src/net/websockets/websocket_channel.cc

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