Home | History | Annotate | Download | only in websockets 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/websockets/websocket_channel.h"
      6 
      7 #include <limits.h>  // for INT_MAX
      8 
      9 #include <algorithm>
     10 #include <deque>
     11 
     12 #include "base/basictypes.h"  // for size_t
     13 #include "base/big_endian.h"
     14 #include "base/bind.h"
     15 #include "base/compiler_specific.h"
     16 #include "base/memory/ref_counted.h"
     17 #include "base/memory/weak_ptr.h"
     18 #include "base/message_loop/message_loop.h"
     19 #include "base/metrics/histogram.h"
     20 #include "base/numerics/safe_conversions.h"
     21 #include "base/stl_util.h"
     22 #include "base/strings/stringprintf.h"
     23 #include "base/time/time.h"
     24 #include "net/base/io_buffer.h"
     25 #include "net/base/net_log.h"
     26 #include "net/http/http_request_headers.h"
     27 #include "net/http/http_response_headers.h"
     28 #include "net/http/http_util.h"
     29 #include "net/websockets/websocket_errors.h"
     30 #include "net/websockets/websocket_event_interface.h"
     31 #include "net/websockets/websocket_frame.h"
     32 #include "net/websockets/websocket_handshake_request_info.h"
     33 #include "net/websockets/websocket_handshake_response_info.h"
     34 #include "net/websockets/websocket_mux.h"
     35 #include "net/websockets/websocket_stream.h"
     36 #include "url/origin.h"
     37 
     38 namespace net {
     39 
     40 namespace {
     41 
     42 using base::StreamingUtf8Validator;
     43 
     44 const int kDefaultSendQuotaLowWaterMark = 1 << 16;
     45 const int kDefaultSendQuotaHighWaterMark = 1 << 17;
     46 const size_t kWebSocketCloseCodeLength = 2;
     47 // This timeout is based on TCPMaximumSegmentLifetime * 2 from
     48 // MainThreadWebSocketChannel.cpp in Blink.
     49 const int kClosingHandshakeTimeoutSeconds = 2 * 2 * 60;
     50 
     51 typedef WebSocketEventInterface::ChannelState ChannelState;
     52 const ChannelState CHANNEL_ALIVE = WebSocketEventInterface::CHANNEL_ALIVE;
     53 const ChannelState CHANNEL_DELETED = WebSocketEventInterface::CHANNEL_DELETED;
     54 
     55 // Maximum close reason length = max control frame payload -
     56 //                               status code length
     57 //                             = 125 - 2
     58 const size_t kMaximumCloseReasonLength = 125 - kWebSocketCloseCodeLength;
     59 
     60 // Check a close status code for strict compliance with RFC6455. This is only
     61 // used for close codes received from a renderer that we are intending to send
     62 // out over the network. See ParseClose() for the restrictions on incoming close
     63 // codes. The |code| parameter is type int for convenience of implementation;
     64 // the real type is uint16. Code 1005 is treated specially; it cannot be set
     65 // explicitly by Javascript but the renderer uses it to indicate we should send
     66 // a Close frame with no payload.
     67 bool IsStrictlyValidCloseStatusCode(int code) {
     68   static const int kInvalidRanges[] = {
     69       // [BAD, OK)
     70       0,    1000,   // 1000 is the first valid code
     71       1006, 1007,   // 1006 MUST NOT be set.
     72       1014, 3000,   // 1014 unassigned; 1015 up to 2999 are reserved.
     73       5000, 65536,  // Codes above 5000 are invalid.
     74   };
     75   const int* const kInvalidRangesEnd =
     76       kInvalidRanges + arraysize(kInvalidRanges);
     77 
     78   DCHECK_GE(code, 0);
     79   DCHECK_LT(code, 65536);
     80   const int* upper = std::upper_bound(kInvalidRanges, kInvalidRangesEnd, code);
     81   DCHECK_NE(kInvalidRangesEnd, upper);
     82   DCHECK_GT(upper, kInvalidRanges);
     83   DCHECK_GT(*upper, code);
     84   DCHECK_LE(*(upper - 1), code);
     85   return ((upper - kInvalidRanges) % 2) == 0;
     86 }
     87 
     88 // This function avoids a bunch of boilerplate code.
     89 void AllowUnused(ChannelState ALLOW_UNUSED unused) {}
     90 
     91 // Sets |name| to the name of the frame type for the given |opcode|. Note that
     92 // for all of Text, Binary and Continuation opcode, this method returns
     93 // "Data frame".
     94 void GetFrameTypeForOpcode(WebSocketFrameHeader::OpCode opcode,
     95                            std::string* name) {
     96   switch (opcode) {
     97     case WebSocketFrameHeader::kOpCodeText:    // fall-thru
     98     case WebSocketFrameHeader::kOpCodeBinary:  // fall-thru
     99     case WebSocketFrameHeader::kOpCodeContinuation:
    100       *name = "Data frame";
    101       break;
    102 
    103     case WebSocketFrameHeader::kOpCodePing:
    104       *name = "Ping";
    105       break;
    106 
    107     case WebSocketFrameHeader::kOpCodePong:
    108       *name = "Pong";
    109       break;
    110 
    111     case WebSocketFrameHeader::kOpCodeClose:
    112       *name = "Close";
    113       break;
    114 
    115     default:
    116       *name = "Unknown frame type";
    117       break;
    118   }
    119 
    120   return;
    121 }
    122 
    123 }  // namespace
    124 
    125 // A class to encapsulate a set of frames and information about the size of
    126 // those frames.
    127 class WebSocketChannel::SendBuffer {
    128  public:
    129   SendBuffer() : total_bytes_(0) {}
    130 
    131   // Add a WebSocketFrame to the buffer and increase total_bytes_.
    132   void AddFrame(scoped_ptr<WebSocketFrame> chunk);
    133 
    134   // Return a pointer to the frames_ for write purposes.
    135   ScopedVector<WebSocketFrame>* frames() { return &frames_; }
    136 
    137  private:
    138   // The frames_ that will be sent in the next call to WriteFrames().
    139   ScopedVector<WebSocketFrame> frames_;
    140 
    141   // The total size of the payload data in |frames_|. This will be used to
    142   // measure the throughput of the link.
    143   // TODO(ricea): Measure the throughput of the link.
    144   size_t total_bytes_;
    145 };
    146 
    147 void WebSocketChannel::SendBuffer::AddFrame(scoped_ptr<WebSocketFrame> frame) {
    148   total_bytes_ += frame->header.payload_length;
    149   frames_.push_back(frame.release());
    150 }
    151 
    152 // Implementation of WebSocketStream::ConnectDelegate that simply forwards the
    153 // calls on to the WebSocketChannel that created it.
    154 class WebSocketChannel::ConnectDelegate
    155     : public WebSocketStream::ConnectDelegate {
    156  public:
    157   explicit ConnectDelegate(WebSocketChannel* creator) : creator_(creator) {}
    158 
    159   virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) OVERRIDE {
    160     creator_->OnConnectSuccess(stream.Pass());
    161     // |this| may have been deleted.
    162   }
    163 
    164   virtual void OnFailure(const std::string& message) OVERRIDE {
    165     creator_->OnConnectFailure(message);
    166     // |this| has been deleted.
    167   }
    168 
    169   virtual void OnStartOpeningHandshake(
    170       scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
    171     creator_->OnStartOpeningHandshake(request.Pass());
    172   }
    173 
    174   virtual void OnFinishOpeningHandshake(
    175       scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
    176     creator_->OnFinishOpeningHandshake(response.Pass());
    177   }
    178 
    179   virtual void OnSSLCertificateError(
    180       scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
    181           ssl_error_callbacks,
    182       const SSLInfo& ssl_info,
    183       bool fatal) OVERRIDE {
    184     creator_->OnSSLCertificateError(
    185         ssl_error_callbacks.Pass(), ssl_info, fatal);
    186   }
    187 
    188  private:
    189   // A pointer to the WebSocketChannel that created this object. There is no
    190   // danger of this pointer being stale, because deleting the WebSocketChannel
    191   // cancels the connect process, deleting this object and preventing its
    192   // callbacks from being called.
    193   WebSocketChannel* const creator_;
    194 
    195   DISALLOW_COPY_AND_ASSIGN(ConnectDelegate);
    196 };
    197 
    198 class WebSocketChannel::HandshakeNotificationSender
    199     : public base::SupportsWeakPtr<HandshakeNotificationSender> {
    200  public:
    201   explicit HandshakeNotificationSender(WebSocketChannel* channel);
    202   ~HandshakeNotificationSender();
    203 
    204   static void Send(base::WeakPtr<HandshakeNotificationSender> sender);
    205 
    206   ChannelState SendImmediately(WebSocketEventInterface* event_interface);
    207 
    208   const WebSocketHandshakeRequestInfo* handshake_request_info() const {
    209     return handshake_request_info_.get();
    210   }
    211 
    212   void set_handshake_request_info(
    213       scoped_ptr<WebSocketHandshakeRequestInfo> request_info) {
    214     handshake_request_info_ = request_info.Pass();
    215   }
    216 
    217   const WebSocketHandshakeResponseInfo* handshake_response_info() const {
    218     return handshake_response_info_.get();
    219   }
    220 
    221   void set_handshake_response_info(
    222       scoped_ptr<WebSocketHandshakeResponseInfo> response_info) {
    223     handshake_response_info_ = response_info.Pass();
    224   }
    225 
    226  private:
    227   WebSocketChannel* owner_;
    228   scoped_ptr<WebSocketHandshakeRequestInfo> handshake_request_info_;
    229   scoped_ptr<WebSocketHandshakeResponseInfo> handshake_response_info_;
    230 };
    231 
    232 WebSocketChannel::HandshakeNotificationSender::HandshakeNotificationSender(
    233     WebSocketChannel* channel)
    234     : owner_(channel) {}
    235 
    236 WebSocketChannel::HandshakeNotificationSender::~HandshakeNotificationSender() {}
    237 
    238 void WebSocketChannel::HandshakeNotificationSender::Send(
    239     base::WeakPtr<HandshakeNotificationSender> sender) {
    240   // Do nothing if |sender| is already destructed.
    241   if (sender) {
    242     WebSocketChannel* channel = sender->owner_;
    243     AllowUnused(sender->SendImmediately(channel->event_interface_.get()));
    244   }
    245 }
    246 
    247 ChannelState WebSocketChannel::HandshakeNotificationSender::SendImmediately(
    248     WebSocketEventInterface* event_interface) {
    249 
    250   if (handshake_request_info_.get()) {
    251     if (CHANNEL_DELETED == event_interface->OnStartOpeningHandshake(
    252                                handshake_request_info_.Pass()))
    253       return CHANNEL_DELETED;
    254   }
    255 
    256   if (handshake_response_info_.get()) {
    257     if (CHANNEL_DELETED == event_interface->OnFinishOpeningHandshake(
    258                                handshake_response_info_.Pass()))
    259       return CHANNEL_DELETED;
    260 
    261     // TODO(yhirano): We can release |this| to save memory because
    262     // there will be no more opening handshake notification.
    263   }
    264 
    265   return CHANNEL_ALIVE;
    266 }
    267 
    268 WebSocketChannel::PendingReceivedFrame::PendingReceivedFrame(
    269     bool final,
    270     WebSocketFrameHeader::OpCode opcode,
    271     const scoped_refptr<IOBuffer>& data,
    272     size_t offset,
    273     size_t size)
    274     : final_(final),
    275       opcode_(opcode),
    276       data_(data),
    277       offset_(offset),
    278       size_(size) {}
    279 
    280 WebSocketChannel::PendingReceivedFrame::~PendingReceivedFrame() {}
    281 
    282 void WebSocketChannel::PendingReceivedFrame::ResetOpcode() {
    283   DCHECK(WebSocketFrameHeader::IsKnownDataOpCode(opcode_));
    284   opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
    285 }
    286 
    287 void WebSocketChannel::PendingReceivedFrame::DidConsume(size_t bytes) {
    288   DCHECK_LE(offset_, size_);
    289   DCHECK_LE(bytes, size_ - offset_);
    290   offset_ += bytes;
    291 }
    292 
    293 WebSocketChannel::WebSocketChannel(
    294     scoped_ptr<WebSocketEventInterface> event_interface,
    295     URLRequestContext* url_request_context)
    296     : event_interface_(event_interface.Pass()),
    297       url_request_context_(url_request_context),
    298       send_quota_low_water_mark_(kDefaultSendQuotaLowWaterMark),
    299       send_quota_high_water_mark_(kDefaultSendQuotaHighWaterMark),
    300       current_send_quota_(0),
    301       current_receive_quota_(0),
    302       timeout_(base::TimeDelta::FromSeconds(kClosingHandshakeTimeoutSeconds)),
    303       received_close_code_(0),
    304       state_(FRESHLY_CONSTRUCTED),
    305       notification_sender_(new HandshakeNotificationSender(this)),
    306       sending_text_message_(false),
    307       receiving_text_message_(false),
    308       expecting_to_handle_continuation_(false),
    309       initial_frame_forwarded_(false) {}
    310 
    311 WebSocketChannel::~WebSocketChannel() {
    312   // The stream may hold a pointer to read_frames_, and so it needs to be
    313   // destroyed first.
    314   stream_.reset();
    315   // The timer may have a callback pointing back to us, so stop it just in case
    316   // someone decides to run the event loop from their destructor.
    317   timer_.Stop();
    318 }
    319 
    320 void WebSocketChannel::SendAddChannelRequest(
    321     const GURL& socket_url,
    322     const std::vector<std::string>& requested_subprotocols,
    323     const url::Origin& origin) {
    324   // Delegate to the tested version.
    325   SendAddChannelRequestWithSuppliedCreator(
    326       socket_url,
    327       requested_subprotocols,
    328       origin,
    329       base::Bind(&WebSocketStream::CreateAndConnectStream));
    330 }
    331 
    332 void WebSocketChannel::SetState(State new_state) {
    333   DCHECK_NE(state_, new_state);
    334 
    335   if (new_state == CONNECTED)
    336     established_on_ = base::TimeTicks::Now();
    337   if (state_ == CONNECTED && !established_on_.is_null()) {
    338     UMA_HISTOGRAM_LONG_TIMES(
    339         "Net.WebSocket.Duration", base::TimeTicks::Now() - established_on_);
    340   }
    341 
    342   state_ = new_state;
    343 }
    344 
    345 bool WebSocketChannel::InClosingState() const {
    346   // The state RECV_CLOSED is not supported here, because it is only used in one
    347   // code path and should not leak into the code in general.
    348   DCHECK_NE(RECV_CLOSED, state_)
    349       << "InClosingState called with state_ == RECV_CLOSED";
    350   return state_ == SEND_CLOSED || state_ == CLOSE_WAIT || state_ == CLOSED;
    351 }
    352 
    353 void WebSocketChannel::SendFrame(bool fin,
    354                                  WebSocketFrameHeader::OpCode op_code,
    355                                  const std::vector<char>& data) {
    356   if (data.size() > INT_MAX) {
    357     NOTREACHED() << "Frame size sanity check failed";
    358     return;
    359   }
    360   if (stream_ == NULL) {
    361     LOG(DFATAL) << "Got SendFrame without a connection established; "
    362                 << "misbehaving renderer? fin=" << fin << " op_code=" << op_code
    363                 << " data.size()=" << data.size();
    364     return;
    365   }
    366   if (InClosingState()) {
    367     DVLOG(1) << "SendFrame called in state " << state_
    368              << ". This may be a bug, or a harmless race.";
    369     return;
    370   }
    371   if (state_ != CONNECTED) {
    372     NOTREACHED() << "SendFrame() called in state " << state_;
    373     return;
    374   }
    375   if (data.size() > base::checked_cast<size_t>(current_send_quota_)) {
    376     // TODO(ricea): Kill renderer.
    377     AllowUnused(
    378         FailChannel("Send quota exceeded", kWebSocketErrorGoingAway, ""));
    379     // |this| has been deleted.
    380     return;
    381   }
    382   if (!WebSocketFrameHeader::IsKnownDataOpCode(op_code)) {
    383     LOG(DFATAL) << "Got SendFrame with bogus op_code " << op_code
    384                 << "; misbehaving renderer? fin=" << fin
    385                 << " data.size()=" << data.size();
    386     return;
    387   }
    388   if (op_code == WebSocketFrameHeader::kOpCodeText ||
    389       (op_code == WebSocketFrameHeader::kOpCodeContinuation &&
    390        sending_text_message_)) {
    391     StreamingUtf8Validator::State state =
    392         outgoing_utf8_validator_.AddBytes(vector_as_array(&data), data.size());
    393     if (state == StreamingUtf8Validator::INVALID ||
    394         (state == StreamingUtf8Validator::VALID_MIDPOINT && fin)) {
    395       // TODO(ricea): Kill renderer.
    396       AllowUnused(
    397           FailChannel("Browser sent a text frame containing invalid UTF-8",
    398                       kWebSocketErrorGoingAway,
    399                       ""));
    400       // |this| has been deleted.
    401       return;
    402     }
    403     sending_text_message_ = !fin;
    404     DCHECK(!fin || state == StreamingUtf8Validator::VALID_ENDPOINT);
    405   }
    406   current_send_quota_ -= data.size();
    407   // TODO(ricea): If current_send_quota_ has dropped below
    408   // send_quota_low_water_mark_, it might be good to increase the "low
    409   // water mark" and "high water mark", but only if the link to the WebSocket
    410   // server is not saturated.
    411   scoped_refptr<IOBuffer> buffer(new IOBuffer(data.size()));
    412   std::copy(data.begin(), data.end(), buffer->data());
    413   AllowUnused(SendFrameFromIOBuffer(fin, op_code, buffer, data.size()));
    414   // |this| may have been deleted.
    415 }
    416 
    417 void WebSocketChannel::SendFlowControl(int64 quota) {
    418   DCHECK(state_ == CONNECTING || state_ == CONNECTED || state_ == SEND_CLOSED ||
    419          state_ == CLOSE_WAIT);
    420   // TODO(ricea): Kill the renderer if it tries to send us a negative quota
    421   // value or > INT_MAX.
    422   DCHECK_GE(quota, 0);
    423   DCHECK_LE(quota, INT_MAX);
    424   if (!pending_received_frames_.empty()) {
    425     DCHECK_EQ(0, current_receive_quota_);
    426   }
    427   while (!pending_received_frames_.empty() && quota > 0) {
    428     PendingReceivedFrame& front = pending_received_frames_.front();
    429     const size_t data_size = front.size() - front.offset();
    430     const size_t bytes_to_send =
    431         std::min(base::checked_cast<size_t>(quota), data_size);
    432     const bool final = front.final() && data_size == bytes_to_send;
    433     const char* data =
    434         front.data().get() ? front.data()->data() + front.offset() : NULL;
    435     DCHECK(!bytes_to_send || data) << "Non empty data should not be null.";
    436     const std::vector<char> data_vector(data, data + bytes_to_send);
    437     DVLOG(3) << "Sending frame previously split due to quota to the "
    438              << "renderer: quota=" << quota << " data_size=" << data_size
    439              << " bytes_to_send=" << bytes_to_send;
    440     if (event_interface_->OnDataFrame(final, front.opcode(), data_vector) ==
    441         CHANNEL_DELETED)
    442       return;
    443     if (bytes_to_send < data_size) {
    444       front.DidConsume(bytes_to_send);
    445       front.ResetOpcode();
    446       return;
    447     }
    448     const int64 signed_bytes_to_send = base::checked_cast<int64>(bytes_to_send);
    449     DCHECK_GE(quota, signed_bytes_to_send);
    450     quota -= signed_bytes_to_send;
    451 
    452     pending_received_frames_.pop();
    453   }
    454   // If current_receive_quota_ == 0 then there is no pending ReadFrames()
    455   // operation.
    456   const bool start_read =
    457       current_receive_quota_ == 0 && quota > 0 &&
    458       (state_ == CONNECTED || state_ == SEND_CLOSED || state_ == CLOSE_WAIT);
    459   current_receive_quota_ += base::checked_cast<int>(quota);
    460   if (start_read)
    461     AllowUnused(ReadFrames());
    462   // |this| may have been deleted.
    463 }
    464 
    465 void WebSocketChannel::StartClosingHandshake(uint16 code,
    466                                              const std::string& reason) {
    467   if (InClosingState()) {
    468     // When the associated renderer process is killed while the channel is in
    469     // CLOSING state we reach here.
    470     DVLOG(1) << "StartClosingHandshake called in state " << state_
    471              << ". This may be a bug, or a harmless race.";
    472     return;
    473   }
    474   if (state_ == CONNECTING) {
    475     // Abort the in-progress handshake and drop the connection immediately.
    476     stream_request_.reset();
    477     SetState(CLOSED);
    478     AllowUnused(DoDropChannel(false, kWebSocketErrorAbnormalClosure, ""));
    479     return;
    480   }
    481   if (state_ != CONNECTED) {
    482     NOTREACHED() << "StartClosingHandshake() called in state " << state_;
    483     return;
    484   }
    485   // Javascript actually only permits 1000 and 3000-4999, but the implementation
    486   // itself may produce different codes. The length of |reason| is also checked
    487   // by Javascript.
    488   if (!IsStrictlyValidCloseStatusCode(code) ||
    489       reason.size() > kMaximumCloseReasonLength) {
    490     // "InternalServerError" is actually used for errors from any endpoint, per
    491     // errata 3227 to RFC6455. If the renderer is sending us an invalid code or
    492     // reason it must be malfunctioning in some way, and based on that we
    493     // interpret this as an internal error.
    494     if (SendClose(kWebSocketErrorInternalServerError, "") != CHANNEL_DELETED) {
    495       DCHECK_EQ(CONNECTED, state_);
    496       SetState(SEND_CLOSED);
    497     }
    498     return;
    499   }
    500   if (SendClose(
    501           code,
    502           StreamingUtf8Validator::Validate(reason) ? reason : std::string()) ==
    503       CHANNEL_DELETED)
    504     return;
    505   DCHECK_EQ(CONNECTED, state_);
    506   SetState(SEND_CLOSED);
    507 }
    508 
    509 void WebSocketChannel::SendAddChannelRequestForTesting(
    510     const GURL& socket_url,
    511     const std::vector<std::string>& requested_subprotocols,
    512     const url::Origin& origin,
    513     const WebSocketStreamCreator& creator) {
    514   SendAddChannelRequestWithSuppliedCreator(
    515       socket_url, requested_subprotocols, origin, creator);
    516 }
    517 
    518 void WebSocketChannel::SetClosingHandshakeTimeoutForTesting(
    519     base::TimeDelta delay) {
    520   timeout_ = delay;
    521 }
    522 
    523 void WebSocketChannel::SendAddChannelRequestWithSuppliedCreator(
    524     const GURL& socket_url,
    525     const std::vector<std::string>& requested_subprotocols,
    526     const url::Origin& origin,
    527     const WebSocketStreamCreator& creator) {
    528   DCHECK_EQ(FRESHLY_CONSTRUCTED, state_);
    529   if (!socket_url.SchemeIsWSOrWSS()) {
    530     // TODO(ricea): Kill the renderer (this error should have been caught by
    531     // Javascript).
    532     AllowUnused(event_interface_->OnAddChannelResponse(true, "", ""));
    533     // |this| is deleted here.
    534     return;
    535   }
    536   socket_url_ = socket_url;
    537   scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate(
    538       new ConnectDelegate(this));
    539   stream_request_ = creator.Run(socket_url_,
    540                                 requested_subprotocols,
    541                                 origin,
    542                                 url_request_context_,
    543                                 BoundNetLog(),
    544                                 connect_delegate.Pass());
    545   SetState(CONNECTING);
    546 }
    547 
    548 void WebSocketChannel::OnConnectSuccess(scoped_ptr<WebSocketStream> stream) {
    549   DCHECK(stream);
    550   DCHECK_EQ(CONNECTING, state_);
    551 
    552   stream_ = stream.Pass();
    553 
    554   SetState(CONNECTED);
    555 
    556   if (event_interface_->OnAddChannelResponse(
    557           false, stream_->GetSubProtocol(), stream_->GetExtensions()) ==
    558       CHANNEL_DELETED)
    559     return;
    560 
    561   // TODO(ricea): Get flow control information from the WebSocketStream once we
    562   // have a multiplexing WebSocketStream.
    563   current_send_quota_ = send_quota_high_water_mark_;
    564   if (event_interface_->OnFlowControl(send_quota_high_water_mark_) ==
    565       CHANNEL_DELETED)
    566     return;
    567 
    568   // |stream_request_| is not used once the connection has succeeded.
    569   stream_request_.reset();
    570 
    571   AllowUnused(ReadFrames());
    572   // |this| may have been deleted.
    573 }
    574 
    575 void WebSocketChannel::OnConnectFailure(const std::string& message) {
    576   DCHECK_EQ(CONNECTING, state_);
    577 
    578   // Copy the message before we delete its owner.
    579   std::string message_copy = message;
    580 
    581   SetState(CLOSED);
    582   stream_request_.reset();
    583 
    584   if (CHANNEL_DELETED ==
    585       notification_sender_->SendImmediately(event_interface_.get())) {
    586     // |this| has been deleted.
    587     return;
    588   }
    589   AllowUnused(event_interface_->OnFailChannel(message_copy));
    590   // |this| has been deleted.
    591 }
    592 
    593 void WebSocketChannel::OnSSLCertificateError(
    594     scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks> ssl_error_callbacks,
    595     const SSLInfo& ssl_info,
    596     bool fatal) {
    597   AllowUnused(event_interface_->OnSSLCertificateError(
    598       ssl_error_callbacks.Pass(), socket_url_, ssl_info, fatal));
    599 }
    600 
    601 void WebSocketChannel::OnStartOpeningHandshake(
    602     scoped_ptr<WebSocketHandshakeRequestInfo> request) {
    603   DCHECK(!notification_sender_->handshake_request_info());
    604 
    605   // Because it is hard to handle an IPC error synchronously is difficult,
    606   // we asynchronously notify the information.
    607   notification_sender_->set_handshake_request_info(request.Pass());
    608   ScheduleOpeningHandshakeNotification();
    609 }
    610 
    611 void WebSocketChannel::OnFinishOpeningHandshake(
    612     scoped_ptr<WebSocketHandshakeResponseInfo> response) {
    613   DCHECK(!notification_sender_->handshake_response_info());
    614 
    615   // Because it is hard to handle an IPC error synchronously is difficult,
    616   // we asynchronously notify the information.
    617   notification_sender_->set_handshake_response_info(response.Pass());
    618   ScheduleOpeningHandshakeNotification();
    619 }
    620 
    621 void WebSocketChannel::ScheduleOpeningHandshakeNotification() {
    622   base::MessageLoop::current()->PostTask(
    623       FROM_HERE,
    624       base::Bind(HandshakeNotificationSender::Send,
    625                  notification_sender_->AsWeakPtr()));
    626 }
    627 
    628 ChannelState WebSocketChannel::WriteFrames() {
    629   int result = OK;
    630   do {
    631     // This use of base::Unretained is safe because this object owns the
    632     // WebSocketStream and destroying it cancels all callbacks.
    633     result = stream_->WriteFrames(
    634         data_being_sent_->frames(),
    635         base::Bind(base::IgnoreResult(&WebSocketChannel::OnWriteDone),
    636                    base::Unretained(this),
    637                    false));
    638     if (result != ERR_IO_PENDING) {
    639       if (OnWriteDone(true, result) == CHANNEL_DELETED)
    640         return CHANNEL_DELETED;
    641       // OnWriteDone() returns CHANNEL_DELETED on error. Here |state_| is
    642       // guaranteed to be the same as before OnWriteDone() call.
    643     }
    644   } while (result == OK && data_being_sent_);
    645   return CHANNEL_ALIVE;
    646 }
    647 
    648 ChannelState WebSocketChannel::OnWriteDone(bool synchronous, int result) {
    649   DCHECK_NE(FRESHLY_CONSTRUCTED, state_);
    650   DCHECK_NE(CONNECTING, state_);
    651   DCHECK_NE(ERR_IO_PENDING, result);
    652   DCHECK(data_being_sent_);
    653   switch (result) {
    654     case OK:
    655       if (data_to_send_next_) {
    656         data_being_sent_ = data_to_send_next_.Pass();
    657         if (!synchronous)
    658           return WriteFrames();
    659       } else {
    660         data_being_sent_.reset();
    661         if (current_send_quota_ < send_quota_low_water_mark_) {
    662           // TODO(ricea): Increase low_water_mark and high_water_mark if
    663           // throughput is high, reduce them if throughput is low.  Low water
    664           // mark needs to be >= the bandwidth delay product *of the IPC
    665           // channel*. Because factors like context-switch time, thread wake-up
    666           // time, and bus speed come into play it is complex and probably needs
    667           // to be determined empirically.
    668           DCHECK_LE(send_quota_low_water_mark_, send_quota_high_water_mark_);
    669           // TODO(ricea): Truncate quota by the quota specified by the remote
    670           // server, if the protocol in use supports quota.
    671           int fresh_quota = send_quota_high_water_mark_ - current_send_quota_;
    672           current_send_quota_ += fresh_quota;
    673           return event_interface_->OnFlowControl(fresh_quota);
    674         }
    675       }
    676       return CHANNEL_ALIVE;
    677 
    678     // If a recoverable error condition existed, it would go here.
    679 
    680     default:
    681       DCHECK_LT(result, 0)
    682           << "WriteFrames() should only return OK or ERR_ codes";
    683 
    684       stream_->Close();
    685       SetState(CLOSED);
    686       return DoDropChannel(false, kWebSocketErrorAbnormalClosure, "");
    687   }
    688 }
    689 
    690 ChannelState WebSocketChannel::ReadFrames() {
    691   int result = OK;
    692   while (result == OK && current_receive_quota_ > 0) {
    693     // This use of base::Unretained is safe because this object owns the
    694     // WebSocketStream, and any pending reads will be cancelled when it is
    695     // destroyed.
    696     result = stream_->ReadFrames(
    697         &read_frames_,
    698         base::Bind(base::IgnoreResult(&WebSocketChannel::OnReadDone),
    699                    base::Unretained(this),
    700                    false));
    701     if (result != ERR_IO_PENDING) {
    702       if (OnReadDone(true, result) == CHANNEL_DELETED)
    703         return CHANNEL_DELETED;
    704     }
    705     DCHECK_NE(CLOSED, state_);
    706   }
    707   return CHANNEL_ALIVE;
    708 }
    709 
    710 ChannelState WebSocketChannel::OnReadDone(bool synchronous, int result) {
    711   DCHECK_NE(FRESHLY_CONSTRUCTED, state_);
    712   DCHECK_NE(CONNECTING, state_);
    713   DCHECK_NE(ERR_IO_PENDING, result);
    714   switch (result) {
    715     case OK:
    716       // ReadFrames() must use ERR_CONNECTION_CLOSED for a closed connection
    717       // with no data read, not an empty response.
    718       DCHECK(!read_frames_.empty())
    719           << "ReadFrames() returned OK, but nothing was read.";
    720       for (size_t i = 0; i < read_frames_.size(); ++i) {
    721         scoped_ptr<WebSocketFrame> frame(read_frames_[i]);
    722         read_frames_[i] = NULL;
    723         if (HandleFrame(frame.Pass()) == CHANNEL_DELETED)
    724           return CHANNEL_DELETED;
    725       }
    726       read_frames_.clear();
    727       // There should always be a call to ReadFrames pending.
    728       // TODO(ricea): Unless we are out of quota.
    729       DCHECK_NE(CLOSED, state_);
    730       if (!synchronous)
    731         return ReadFrames();
    732       return CHANNEL_ALIVE;
    733 
    734     case ERR_WS_PROTOCOL_ERROR:
    735       // This could be kWebSocketErrorProtocolError (specifically, non-minimal
    736       // encoding of payload length) or kWebSocketErrorMessageTooBig, or an
    737       // extension-specific error.
    738       return FailChannel("Invalid frame header",
    739                          kWebSocketErrorProtocolError,
    740                          "WebSocket Protocol Error");
    741 
    742     default:
    743       DCHECK_LT(result, 0)
    744           << "ReadFrames() should only return OK or ERR_ codes";
    745 
    746       stream_->Close();
    747       SetState(CLOSED);
    748 
    749       uint16 code = kWebSocketErrorAbnormalClosure;
    750       std::string reason = "";
    751       bool was_clean = false;
    752       if (received_close_code_ != 0) {
    753         code = received_close_code_;
    754         reason = received_close_reason_;
    755         was_clean = (result == ERR_CONNECTION_CLOSED);
    756       }
    757 
    758       return DoDropChannel(was_clean, code, reason);
    759   }
    760 }
    761 
    762 ChannelState WebSocketChannel::HandleFrame(scoped_ptr<WebSocketFrame> frame) {
    763   if (frame->header.masked) {
    764     // RFC6455 Section 5.1 "A client MUST close a connection if it detects a
    765     // masked frame."
    766     return FailChannel(
    767         "A server must not mask any frames that it sends to the "
    768         "client.",
    769         kWebSocketErrorProtocolError,
    770         "Masked frame from server");
    771   }
    772   const WebSocketFrameHeader::OpCode opcode = frame->header.opcode;
    773   DCHECK(!WebSocketFrameHeader::IsKnownControlOpCode(opcode) ||
    774          frame->header.final);
    775   if (frame->header.reserved1 || frame->header.reserved2 ||
    776       frame->header.reserved3) {
    777     return FailChannel(base::StringPrintf(
    778                            "One or more reserved bits are on: reserved1 = %d, "
    779                            "reserved2 = %d, reserved3 = %d",
    780                            static_cast<int>(frame->header.reserved1),
    781                            static_cast<int>(frame->header.reserved2),
    782                            static_cast<int>(frame->header.reserved3)),
    783                        kWebSocketErrorProtocolError,
    784                        "Invalid reserved bit");
    785   }
    786 
    787   // Respond to the frame appropriately to its type.
    788   return HandleFrameByState(
    789       opcode, frame->header.final, frame->data, frame->header.payload_length);
    790 }
    791 
    792 ChannelState WebSocketChannel::HandleFrameByState(
    793     const WebSocketFrameHeader::OpCode opcode,
    794     bool final,
    795     const scoped_refptr<IOBuffer>& data_buffer,
    796     size_t size) {
    797   DCHECK_NE(RECV_CLOSED, state_)
    798       << "HandleFrame() does not support being called re-entrantly from within "
    799          "SendClose()";
    800   DCHECK_NE(CLOSED, state_);
    801   if (state_ == CLOSE_WAIT) {
    802     std::string frame_name;
    803     GetFrameTypeForOpcode(opcode, &frame_name);
    804 
    805     // FailChannel() won't send another Close frame.
    806     return FailChannel(
    807         frame_name + " received after close", kWebSocketErrorProtocolError, "");
    808   }
    809   switch (opcode) {
    810     case WebSocketFrameHeader::kOpCodeText:  // fall-thru
    811     case WebSocketFrameHeader::kOpCodeBinary:
    812     case WebSocketFrameHeader::kOpCodeContinuation:
    813       return HandleDataFrame(opcode, final, data_buffer, size);
    814 
    815     case WebSocketFrameHeader::kOpCodePing:
    816       DVLOG(1) << "Got Ping of size " << size;
    817       if (state_ == CONNECTED)
    818         return SendFrameFromIOBuffer(
    819             true, WebSocketFrameHeader::kOpCodePong, data_buffer, size);
    820       DVLOG(3) << "Ignored ping in state " << state_;
    821       return CHANNEL_ALIVE;
    822 
    823     case WebSocketFrameHeader::kOpCodePong:
    824       DVLOG(1) << "Got Pong of size " << size;
    825       // There is no need to do anything with pong messages.
    826       return CHANNEL_ALIVE;
    827 
    828     case WebSocketFrameHeader::kOpCodeClose: {
    829       // TODO(ricea): If there is a message which is queued for transmission to
    830       // the renderer, then the renderer should not receive an
    831       // OnClosingHandshake or OnDropChannel IPC until the queued message has
    832       // been completedly transmitted.
    833       uint16 code = kWebSocketNormalClosure;
    834       std::string reason;
    835       std::string message;
    836       if (!ParseClose(data_buffer, size, &code, &reason, &message)) {
    837         return FailChannel(message, code, reason);
    838       }
    839       // TODO(ricea): Find a way to safely log the message from the close
    840       // message (escape control codes and so on).
    841       DVLOG(1) << "Got Close with code " << code;
    842       switch (state_) {
    843         case CONNECTED:
    844           SetState(RECV_CLOSED);
    845           if (SendClose(code, reason) == CHANNEL_DELETED)
    846             return CHANNEL_DELETED;
    847           DCHECK_EQ(RECV_CLOSED, state_);
    848           SetState(CLOSE_WAIT);
    849 
    850           if (event_interface_->OnClosingHandshake() == CHANNEL_DELETED)
    851             return CHANNEL_DELETED;
    852           received_close_code_ = code;
    853           received_close_reason_ = reason;
    854           break;
    855 
    856         case SEND_CLOSED:
    857           SetState(CLOSE_WAIT);
    858           // From RFC6455 section 7.1.5: "Each endpoint
    859           // will see the status code sent by the other end as _The WebSocket
    860           // Connection Close Code_."
    861           received_close_code_ = code;
    862           received_close_reason_ = reason;
    863           break;
    864 
    865         default:
    866           LOG(DFATAL) << "Got Close in unexpected state " << state_;
    867           break;
    868       }
    869       return CHANNEL_ALIVE;
    870     }
    871 
    872     default:
    873       return FailChannel(
    874           base::StringPrintf("Unrecognized frame opcode: %d", opcode),
    875           kWebSocketErrorProtocolError,
    876           "Unknown opcode");
    877   }
    878 }
    879 
    880 ChannelState WebSocketChannel::HandleDataFrame(
    881     WebSocketFrameHeader::OpCode opcode,
    882     bool final,
    883     const scoped_refptr<IOBuffer>& data_buffer,
    884     size_t size) {
    885   if (state_ != CONNECTED) {
    886     DVLOG(3) << "Ignored data packet received in state " << state_;
    887     return CHANNEL_ALIVE;
    888   }
    889   DCHECK(opcode == WebSocketFrameHeader::kOpCodeContinuation ||
    890          opcode == WebSocketFrameHeader::kOpCodeText ||
    891          opcode == WebSocketFrameHeader::kOpCodeBinary);
    892   const bool got_continuation =
    893       (opcode == WebSocketFrameHeader::kOpCodeContinuation);
    894   if (got_continuation != expecting_to_handle_continuation_) {
    895     const std::string console_log = got_continuation
    896         ? "Received unexpected continuation frame."
    897         : "Received start of new message but previous message is unfinished.";
    898     const std::string reason = got_continuation
    899         ? "Unexpected continuation"
    900         : "Previous data frame unfinished";
    901     return FailChannel(console_log, kWebSocketErrorProtocolError, reason);
    902   }
    903   expecting_to_handle_continuation_ = !final;
    904   WebSocketFrameHeader::OpCode opcode_to_send = opcode;
    905   if (!initial_frame_forwarded_ &&
    906       opcode == WebSocketFrameHeader::kOpCodeContinuation) {
    907     opcode_to_send = receiving_text_message_
    908                          ? WebSocketFrameHeader::kOpCodeText
    909                          : WebSocketFrameHeader::kOpCodeBinary;
    910   }
    911   if (opcode == WebSocketFrameHeader::kOpCodeText ||
    912       (opcode == WebSocketFrameHeader::kOpCodeContinuation &&
    913        receiving_text_message_)) {
    914     // This call is not redundant when size == 0 because it tells us what
    915     // the current state is.
    916     StreamingUtf8Validator::State state = incoming_utf8_validator_.AddBytes(
    917         size ? data_buffer->data() : NULL, size);
    918     if (state == StreamingUtf8Validator::INVALID ||
    919         (state == StreamingUtf8Validator::VALID_MIDPOINT && final)) {
    920       return FailChannel("Could not decode a text frame as UTF-8.",
    921                          kWebSocketErrorProtocolError,
    922                          "Invalid UTF-8 in text frame");
    923     }
    924     receiving_text_message_ = !final;
    925     DCHECK(!final || state == StreamingUtf8Validator::VALID_ENDPOINT);
    926   }
    927   if (size == 0U && !final)
    928     return CHANNEL_ALIVE;
    929 
    930   initial_frame_forwarded_ = !final;
    931   if (size > base::checked_cast<size_t>(current_receive_quota_) ||
    932       !pending_received_frames_.empty()) {
    933     const bool no_quota = (current_receive_quota_ == 0);
    934     DCHECK(no_quota || pending_received_frames_.empty());
    935     DVLOG(3) << "Queueing frame to renderer due to quota. quota="
    936              << current_receive_quota_ << " size=" << size;
    937     WebSocketFrameHeader::OpCode opcode_to_queue =
    938         no_quota ? opcode_to_send : WebSocketFrameHeader::kOpCodeContinuation;
    939     pending_received_frames_.push(PendingReceivedFrame(
    940         final, opcode_to_queue, data_buffer, current_receive_quota_, size));
    941     if (no_quota)
    942       return CHANNEL_ALIVE;
    943     size = current_receive_quota_;
    944     final = false;
    945   }
    946 
    947   // TODO(ricea): Can this copy be eliminated?
    948   const char* const data_begin = size ? data_buffer->data() : NULL;
    949   const char* const data_end = data_begin + size;
    950   const std::vector<char> data(data_begin, data_end);
    951   current_receive_quota_ -= size;
    952   DCHECK_GE(current_receive_quota_, 0);
    953 
    954   // Sends the received frame to the renderer process.
    955   return event_interface_->OnDataFrame(final, opcode_to_send, data);
    956 }
    957 
    958 ChannelState WebSocketChannel::SendFrameFromIOBuffer(
    959     bool fin,
    960     WebSocketFrameHeader::OpCode op_code,
    961     const scoped_refptr<IOBuffer>& buffer,
    962     size_t size) {
    963   DCHECK(state_ == CONNECTED || state_ == RECV_CLOSED);
    964   DCHECK(stream_);
    965 
    966   scoped_ptr<WebSocketFrame> frame(new WebSocketFrame(op_code));
    967   WebSocketFrameHeader& header = frame->header;
    968   header.final = fin;
    969   header.masked = true;
    970   header.payload_length = size;
    971   frame->data = buffer;
    972 
    973   if (data_being_sent_) {
    974     // Either the link to the WebSocket server is saturated, or several messages
    975     // are being sent in a batch.
    976     // TODO(ricea): Keep some statistics to work out the situation and adjust
    977     // quota appropriately.
    978     if (!data_to_send_next_)
    979       data_to_send_next_.reset(new SendBuffer);
    980     data_to_send_next_->AddFrame(frame.Pass());
    981     return CHANNEL_ALIVE;
    982   }
    983 
    984   data_being_sent_.reset(new SendBuffer);
    985   data_being_sent_->AddFrame(frame.Pass());
    986   return WriteFrames();
    987 }
    988 
    989 ChannelState WebSocketChannel::FailChannel(const std::string& message,
    990                                            uint16 code,
    991                                            const std::string& reason) {
    992   DCHECK_NE(FRESHLY_CONSTRUCTED, state_);
    993   DCHECK_NE(CONNECTING, state_);
    994   DCHECK_NE(CLOSED, state_);
    995 
    996   // TODO(ricea): Logging.
    997   if (state_ == CONNECTED) {
    998     if (SendClose(code, reason) == CHANNEL_DELETED)
    999       return CHANNEL_DELETED;
   1000   }
   1001 
   1002   // Careful study of RFC6455 section 7.1.7 and 7.1.1 indicates the browser
   1003   // should close the connection itself without waiting for the closing
   1004   // handshake.
   1005   stream_->Close();
   1006   SetState(CLOSED);
   1007   return event_interface_->OnFailChannel(message);
   1008 }
   1009 
   1010 ChannelState WebSocketChannel::SendClose(uint16 code,
   1011                                          const std::string& reason) {
   1012   DCHECK(state_ == CONNECTED || state_ == RECV_CLOSED);
   1013   DCHECK_LE(reason.size(), kMaximumCloseReasonLength);
   1014   scoped_refptr<IOBuffer> body;
   1015   size_t size = 0;
   1016   if (code == kWebSocketErrorNoStatusReceived) {
   1017     // Special case: translate kWebSocketErrorNoStatusReceived into a Close
   1018     // frame with no payload.
   1019     DCHECK(reason.empty());
   1020     body = new IOBuffer(0);
   1021   } else {
   1022     const size_t payload_length = kWebSocketCloseCodeLength + reason.length();
   1023     body = new IOBuffer(payload_length);
   1024     size = payload_length;
   1025     base::WriteBigEndian(body->data(), code);
   1026     COMPILE_ASSERT(sizeof(code) == kWebSocketCloseCodeLength,
   1027                    they_should_both_be_two);
   1028     std::copy(
   1029         reason.begin(), reason.end(), body->data() + kWebSocketCloseCodeLength);
   1030   }
   1031   // This use of base::Unretained() is safe because we stop the timer in the
   1032   // destructor.
   1033   timer_.Start(
   1034       FROM_HERE,
   1035       timeout_,
   1036       base::Bind(&WebSocketChannel::CloseTimeout, base::Unretained(this)));
   1037   if (SendFrameFromIOBuffer(
   1038           true, WebSocketFrameHeader::kOpCodeClose, body, size) ==
   1039       CHANNEL_DELETED)
   1040     return CHANNEL_DELETED;
   1041   return CHANNEL_ALIVE;
   1042 }
   1043 
   1044 bool WebSocketChannel::ParseClose(const scoped_refptr<IOBuffer>& buffer,
   1045                                   size_t size,
   1046                                   uint16* code,
   1047                                   std::string* reason,
   1048                                   std::string* message) {
   1049   reason->clear();
   1050   if (size < kWebSocketCloseCodeLength) {
   1051     if (size == 0U) {
   1052       *code = kWebSocketErrorNoStatusReceived;
   1053       return true;
   1054     }
   1055 
   1056     DVLOG(1) << "Close frame with payload size " << size << " received "
   1057              << "(the first byte is " << std::hex
   1058              << static_cast<int>(buffer->data()[0]) << ")";
   1059     *code = kWebSocketErrorProtocolError;
   1060     *message =
   1061         "Received a broken close frame containing an invalid size body.";
   1062     return false;
   1063   }
   1064 
   1065   const char* data = buffer->data();
   1066   uint16 unchecked_code = 0;
   1067   base::ReadBigEndian(data, &unchecked_code);
   1068   COMPILE_ASSERT(sizeof(unchecked_code) == kWebSocketCloseCodeLength,
   1069                  they_should_both_be_two_bytes);
   1070 
   1071   switch (unchecked_code) {
   1072     case kWebSocketErrorNoStatusReceived:
   1073     case kWebSocketErrorAbnormalClosure:
   1074     case kWebSocketErrorTlsHandshake:
   1075       *code = kWebSocketErrorProtocolError;
   1076       *message =
   1077           "Received a broken close frame containing a reserved status code.";
   1078       return false;
   1079 
   1080     default:
   1081       *code = unchecked_code;
   1082       break;
   1083   }
   1084 
   1085   std::string text(data + kWebSocketCloseCodeLength, data + size);
   1086   if (StreamingUtf8Validator::Validate(text)) {
   1087     reason->swap(text);
   1088     return true;
   1089   }
   1090 
   1091   *code = kWebSocketErrorProtocolError;
   1092   *reason = "Invalid UTF-8 in Close frame";
   1093   *message = "Received a broken close frame containing invalid UTF-8.";
   1094   return false;
   1095 }
   1096 
   1097 ChannelState WebSocketChannel::DoDropChannel(bool was_clean,
   1098                                              uint16 code,
   1099                                              const std::string& reason) {
   1100   if (CHANNEL_DELETED ==
   1101       notification_sender_->SendImmediately(event_interface_.get()))
   1102     return CHANNEL_DELETED;
   1103   ChannelState result =
   1104       event_interface_->OnDropChannel(was_clean, code, reason);
   1105   DCHECK_EQ(CHANNEL_DELETED, result);
   1106   return result;
   1107 }
   1108 
   1109 void WebSocketChannel::CloseTimeout() {
   1110   stream_->Close();
   1111   SetState(CLOSED);
   1112   AllowUnused(DoDropChannel(false, kWebSocketErrorAbnormalClosure, ""));
   1113   // |this| has been deleted.
   1114 }
   1115 
   1116 }  // namespace net
   1117