path: root/net/websockets/websocket_channel.cc

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/websockets/websocket_channel.h"

#include <algorithm>

#include "base/basictypes.h"  // for size_t
#include "base/bind.h"
#include "base/safe_numerics.h"
#include "base/strings/string_util.h"
#include "net/base/big_endian.h"
#include "net/base/io_buffer.h"
#include "net/base/net_log.h"
#include "net/websockets/websocket_errors.h"
#include "net/websockets/websocket_event_interface.h"
#include "net/websockets/websocket_frame.h"
#include "net/websockets/websocket_mux.h"
#include "net/websockets/websocket_stream.h"

namespace net {

namespace {

const int kDefaultSendQuotaLowWaterMark = 1 << 16;
const int kDefaultSendQuotaHighWaterMark = 1 << 17;
const size_t kWebSocketCloseCodeLength = 2;

// This uses type uint64 to match the definition of
// WebSocketFrameHeader::payload_length in websocket_frame.h.
const uint64 kMaxControlFramePayload = 125;

}  // namespace

// A class to encapsulate a set of frames and information about the size of
// those frames.
class WebSocketChannel::SendBuffer {
 public:
  SendBuffer() : total_bytes_(0) {}

  // Add a WebSocketFrameChunk to the buffer and increase total_bytes_.
  void AddFrame(scoped_ptr<WebSocketFrameChunk> chunk);

  // Return a pointer to the frames_ for write purposes.
  ScopedVector<WebSocketFrameChunk>* frames() { return &frames_; }

 private:
  // The frames_ that will be sent in the next call to WriteFrames().
  ScopedVector<WebSocketFrameChunk> frames_;

  // The total size of the buffers in |frames_|. This will be used to measure
  // the throughput of the link.
  // TODO(ricea): Measure the throughput of the link.
  size_t total_bytes_;
};

void WebSocketChannel::SendBuffer::AddFrame(
    scoped_ptr<WebSocketFrameChunk> chunk) {
  total_bytes_ += chunk->data->size();
  frames_.push_back(chunk.release());
}

// Implementation of WebSocketStream::ConnectDelegate that simply forwards the
// calls on to the WebSocketChannel that created it.
class WebSocketChannel::ConnectDelegate
    : public WebSocketStream::ConnectDelegate {
 public:
  explicit ConnectDelegate(WebSocketChannel* creator) : creator_(creator) {}

  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) OVERRIDE {
    creator_->OnConnectSuccess(stream.Pass());
  }

  virtual void OnFailure(uint16 websocket_error) OVERRIDE {
    creator_->OnConnectFailure(websocket_error);
  }

 private:
  // A pointer to the WebSocketChannel that created this object. There is no
  // danger of this pointer being stale, because deleting the WebSocketChannel
  // cancels the connect process, deleting this object and preventing its
  // callbacks from being called.
  WebSocketChannel* const creator_;

  DISALLOW_COPY_AND_ASSIGN(ConnectDelegate);
};

WebSocketChannel::WebSocketChannel(
    const GURL& socket_url,
    scoped_ptr<WebSocketEventInterface> event_interface)
    : socket_url_(socket_url),
      event_interface_(event_interface.Pass()),
      send_quota_low_water_mark_(kDefaultSendQuotaLowWaterMark),
      send_quota_high_water_mark_(kDefaultSendQuotaHighWaterMark),
      current_send_quota_(0),
      closing_code_(0),
      state_(FRESHLY_CONSTRUCTED) {}

WebSocketChannel::~WebSocketChannel() {
  // The stream may hold a pointer to read_frame_chunks_, and so it needs to be
  // destroyed first.
  stream_.reset();
}

void WebSocketChannel::SendAddChannelRequest(
    const std::vector<std::string>& requested_subprotocols,
    const GURL& origin,
    URLRequestContext* url_request_context) {
  // Delegate to the tested version.
  SendAddChannelRequestWithFactory(
      requested_subprotocols,
      origin,
      url_request_context,
      base::Bind(&WebSocketStream::CreateAndConnectStream));
}

bool WebSocketChannel::InClosingState() const {
  // The state RECV_CLOSED is not supported here, because it is only used in one
  // code path and should not leak into the code in general.
  DCHECK_NE(RECV_CLOSED, state_)
      << "InClosingState called with state_ == RECV_CLOSED";
  return state_ == SEND_CLOSED || state_ == CLOSE_WAIT || state_ == CLOSED;
}

void WebSocketChannel::SendFrame(bool fin,
                                 WebSocketFrameHeader::OpCode op_code,
                                 const std::vector<char>& data) {
  if (data.size() > INT_MAX) {
    NOTREACHED() << "Frame size sanity check failed";
    return;
  }
  if (stream_ == NULL) {
    LOG(DFATAL) << "Got SendFrame without a connection established; "
                << "misbehaving renderer? fin=" << fin << " op_code=" << op_code
                << " data.size()=" << data.size();
    return;
  }
  if (InClosingState()) {
    VLOG(1) << "SendFrame called in state " << state_
            << ". This may be a bug, or a harmless race.";
    return;
  }
  if (state_ != CONNECTED) {
    NOTREACHED() << "SendFrame() called in state " << state_;
    return;
  }
  if (data.size() > base::checked_numeric_cast<size_t>(current_send_quota_)) {
    FailChannel(SEND_GOING_AWAY,
                kWebSocketMuxErrorSendQuotaViolation,
                "Send quota exceeded");
    return;
  }
  if (!WebSocketFrameHeader::IsKnownDataOpCode(op_code)) {
    LOG(DFATAL) << "Got SendFrame with bogus op_code " << op_code
                << "; misbehaving renderer? fin=" << fin
                << " data.size()=" << data.size();
    return;
  }
  current_send_quota_ -= data.size();
  // TODO(ricea): If current_send_quota_ has dropped below
  // send_quota_low_water_mark_, it might be good to increase the "low
  // water mark" and "high water mark", but only if the link to the WebSocket
  // server is not saturated.
  // TODO(ricea): For kOpCodeText, do UTF-8 validation?
  scoped_refptr<IOBufferWithSize> buffer(new IOBufferWithSize(data.size()));
  std::copy(data.begin(), data.end(), buffer->data());
  SendIOBufferWithSize(fin, op_code, buffer);
}

void WebSocketChannel::SendFlowControl(int64 quota) {
  DCHECK_EQ(CONNECTED, state_);
  // TODO(ricea): Add interface to WebSocketStream and implement.
  // stream_->SendFlowControl(quota);
}

void WebSocketChannel::StartClosingHandshake(uint16 code,
                                             const std::string& reason) {
  if (InClosingState()) {
    VLOG(1) << "StartClosingHandshake called in state " << state_
            << ". This may be a bug, or a harmless race.";
    return;
  }
  if (state_ != CONNECTED) {
    NOTREACHED() << "StartClosingHandshake() called in state " << state_;
    return;
  }
  // TODO(ricea): Validate |code|? Check that |reason| is valid UTF-8?
  // TODO(ricea): There should be a timeout for the closing handshake.
  SendClose(code, reason);  // Sets state_ to SEND_CLOSED
}

void WebSocketChannel::SendAddChannelRequestForTesting(
    const std::vector<std::string>& requested_subprotocols,
    const GURL& origin,
    URLRequestContext* url_request_context,
    const WebSocketStreamFactory& factory) {
  SendAddChannelRequestWithFactory(
      requested_subprotocols, origin, url_request_context, factory);
}

void WebSocketChannel::SendAddChannelRequestWithFactory(
    const std::vector<std::string>& requested_subprotocols,
    const GURL& origin,
    URLRequestContext* url_request_context,
    const WebSocketStreamFactory& factory) {
  DCHECK_EQ(FRESHLY_CONSTRUCTED, state_);
  scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate(
      new ConnectDelegate(this));
  stream_request_ = factory.Run(socket_url_,
                                requested_subprotocols,
                                origin,
                                url_request_context,
                                BoundNetLog(),
                                connect_delegate.Pass());
  state_ = CONNECTING;
}

void WebSocketChannel::OnConnectSuccess(scoped_ptr<WebSocketStream> stream) {
  DCHECK(stream);
  DCHECK_EQ(CONNECTING, state_);
  stream_ = stream.Pass();
  state_ = CONNECTED;
  event_interface_->OnAddChannelResponse(false, stream_->GetSubProtocol());

  // TODO(ricea): Get flow control information from the WebSocketStream once we
  // have a multiplexing WebSocketStream.
  current_send_quota_ = send_quota_high_water_mark_;
  event_interface_->OnFlowControl(send_quota_high_water_mark_);

  // |stream_request_| is not used once the connection has succeeded.
  stream_request_.reset();
  ReadFrames();
}

void WebSocketChannel::OnConnectFailure(uint16 websocket_error) {
  DCHECK_EQ(CONNECTING, state_);
  state_ = CLOSED;
  stream_request_.reset();
  event_interface_->OnAddChannelResponse(true, "");
}

void WebSocketChannel::WriteFrames() {
  int result = OK;
  do {
    // This use of base::Unretained is safe because this object owns the
    // WebSocketStream and destroying it cancels all callbacks.
    result = stream_->WriteFrames(
        data_being_sent_->frames(),
        base::Bind(
            &WebSocketChannel::OnWriteDone, base::Unretained(this), false));
    if (result != ERR_IO_PENDING) {
      OnWriteDone(true, result);
    }
  } while (result == OK && data_being_sent_);
}

void WebSocketChannel::OnWriteDone(bool synchronous, int result) {
  DCHECK_NE(FRESHLY_CONSTRUCTED, state_);
  DCHECK_NE(CONNECTING, state_);
  DCHECK_NE(ERR_IO_PENDING, result);
  DCHECK(data_being_sent_);
  switch (result) {
    case OK:
      if (data_to_send_next_) {
        data_being_sent_ = data_to_send_next_.Pass();
        if (!synchronous) {
          WriteFrames();
        }
      } else {
        data_being_sent_.reset();
        if (current_send_quota_ < send_quota_low_water_mark_) {
          // TODO(ricea): Increase low_water_mark and high_water_mark if
          // throughput is high, reduce them if throughput is low.  Low water
          // mark needs to be >= the bandwidth delay product *of the IPC
          // channel*. Because factors like context-switch time, thread wake-up
          // time, and bus speed come into play it is complex and probably needs
          // to be determined empirically.
          DCHECK_LE(send_quota_low_water_mark_, send_quota_high_water_mark_);
          // TODO(ricea): Truncate quota by the quota specified by the remote
          // server, if the protocol in use supports quota.
          int fresh_quota = send_quota_high_water_mark_ - current_send_quota_;
          current_send_quota_ += fresh_quota;
          event_interface_->OnFlowControl(fresh_quota);
        }
      }
      return;

    // If a recoverable error condition existed, it would go here.

    default:
      DCHECK_LT(result, 0)
          << "WriteFrames() should only return OK or ERR_ codes";
      stream_->Close();
      if (state_ != CLOSED) {
        state_ = CLOSED;
        event_interface_->OnDropChannel(kWebSocketErrorAbnormalClosure,
                                        "Abnormal Closure");
      }
      return;
  }
}

void WebSocketChannel::ReadFrames() {
  int result = OK;
  do {
    // This use of base::Unretained is safe because this object owns the
    // WebSocketStream, and any pending reads will be cancelled when it is
    // destroyed.
    result = stream_->ReadFrames(
        &read_frame_chunks_,
        base::Bind(
            &WebSocketChannel::OnReadDone, base::Unretained(this), false));
    if (result != ERR_IO_PENDING) {
      OnReadDone(true, result);
    }
  } while (result == OK && state_ != CLOSED);
}

void WebSocketChannel::OnReadDone(bool synchronous, int result) {
  DCHECK_NE(FRESHLY_CONSTRUCTED, state_);
  DCHECK_NE(CONNECTING, state_);
  DCHECK_NE(ERR_IO_PENDING, result);
  switch (result) {
    case OK:
      // ReadFrames() must use ERR_CONNECTION_CLOSED for a closed connection
      // with no data read, not an empty response.
      DCHECK(!read_frame_chunks_.empty())
          << "ReadFrames() returned OK, but nothing was read.";
      for (size_t i = 0; i < read_frame_chunks_.size(); ++i) {
        scoped_ptr<WebSocketFrameChunk> chunk(read_frame_chunks_[i]);
        read_frame_chunks_[i] = NULL;
        ProcessFrameChunk(chunk.Pass());
      }
      read_frame_chunks_.clear();
      // There should always be a call to ReadFrames pending.
      if (!synchronous && state_ != CLOSED) {
        ReadFrames();
      }
      return;

    default:
      DCHECK_LT(result, 0)
          << "ReadFrames() should only return OK or ERR_ codes";
      stream_->Close();
      if (state_ != CLOSED) {
        state_ = CLOSED;
        uint16 code = kWebSocketErrorAbnormalClosure;
        std::string reason = "Abnormal Closure";
        if (closing_code_ != 0) {
          code = closing_code_;
          reason = closing_reason_;
        }
        event_interface_->OnDropChannel(code, reason);
      }
      return;
  }
}

void WebSocketChannel::ProcessFrameChunk(
    scoped_ptr<WebSocketFrameChunk> chunk) {
  bool is_first_chunk = false;
  if (chunk->header) {
    DCHECK(current_frame_header_ == NULL)
        << "Received the header for a new frame without notification that "
        << "the previous frame was complete.";
    is_first_chunk = true;
    current_frame_header_.swap(chunk->header);
    if (current_frame_header_->masked) {
      // RFC6455 Section 5.1 "A client MUST close a connection if it detects a
      // masked frame."
      FailChannel(SEND_REAL_ERROR,
                  kWebSocketErrorProtocolError,
                  "Masked frame from server");
      return;
    }
  }
  if (!current_frame_header_) {
    // If this channel rejected the previous chunk as invalid, then it will have
    // reset |current_frame_header_| and closed the channel. More chunks of the
    // invalid frame may still arrive, and it is not necessarily a bug for that
    // to happen. However, if this happens when state_ is CONNECTED, it is
    // definitely a bug.
    DCHECK(state_ != CONNECTED) << "Unexpected header-less frame received "
                                << "(final_chunk = " << chunk->final_chunk
                                << ", data size = " << chunk->data->size()
                                << ")";
    return;
  }
  scoped_refptr<IOBufferWithSize> data_buffer;
  data_buffer.swap(chunk->data);
  const bool is_final_chunk = chunk->final_chunk;
  chunk.reset();
  const WebSocketFrameHeader::OpCode opcode = current_frame_header_->opcode;
  if (WebSocketFrameHeader::IsKnownControlOpCode(opcode)) {
    if (!current_frame_header_->final) {
      FailChannel(SEND_REAL_ERROR,
                  kWebSocketErrorProtocolError,
                  "Control message with FIN bit unset received");
      return;
    }
    if (current_frame_header_->payload_length > kMaxControlFramePayload) {
      FailChannel(SEND_REAL_ERROR,
                  kWebSocketErrorProtocolError,
                  "Control message has payload over 125 bytes");
      return;
    }
    if (!is_final_chunk) {
      VLOG(2) << "Encountered a split control frame, opcode " << opcode;
      if (incomplete_control_frame_body_) {
        VLOG(3) << "Appending to an existing split control frame.";
        AddToIncompleteControlFrameBody(data_buffer);
      } else {
        VLOG(3) << "Creating new storage for an incomplete control frame.";
        incomplete_control_frame_body_ = new GrowableIOBuffer();
        // This method checks for oversize control frames above, so as long as
        // the frame parser is working correctly, this won't overflow. If a bug
        // does cause it to overflow, it will CHECK() in
        // AddToIncompleteControlFrameBody() without writing outside the buffer.
        incomplete_control_frame_body_->SetCapacity(kMaxControlFramePayload);
        AddToIncompleteControlFrameBody(data_buffer);
      }
      return;  // Handle when complete.
    }
    if (incomplete_control_frame_body_) {
      VLOG(2) << "Rejoining a split control frame, opcode " << opcode;
      AddToIncompleteControlFrameBody(data_buffer);
      const int body_size = incomplete_control_frame_body_->offset();
      data_buffer = new IOBufferWithSize(body_size);
      memcpy(data_buffer->data(),
             incomplete_control_frame_body_->StartOfBuffer(),
             body_size);
      incomplete_control_frame_body_ = NULL;  // Frame now complete.
    }
  }

  // Apply basic sanity checks to the |payload_length| field from the frame
  // header. A check for exact equality can only be used when the whole frame
  // arrives in one chunk.
  DCHECK_GE(current_frame_header_->payload_length,
            base::checked_numeric_cast<uint64>(data_buffer->size()));
  DCHECK(!is_first_chunk || !is_final_chunk ||
         current_frame_header_->payload_length ==
             base::checked_numeric_cast<uint64>(data_buffer->size()));

  // Respond to the frame appropriately to its type.
  HandleFrame(opcode, is_first_chunk, is_final_chunk, data_buffer);

  if (is_final_chunk) {
    // Make sure that this frame header is not applied to any future chunks.
    current_frame_header_.reset();
  }
}

void WebSocketChannel::AddToIncompleteControlFrameBody(
    const scoped_refptr<IOBufferWithSize>& data_buffer) {
  const int new_offset =
      incomplete_control_frame_body_->offset() + data_buffer->size();
  CHECK_GE(incomplete_control_frame_body_->capacity(), new_offset)
      << "Control frame body larger than frame header indicates; frame parser "
         "bug?";
  memcpy(incomplete_control_frame_body_->data(),
         data_buffer->data(),
         data_buffer->size());
  incomplete_control_frame_body_->set_offset(new_offset);
}

void WebSocketChannel::HandleFrame(
    const WebSocketFrameHeader::OpCode opcode,
    bool is_first_chunk,
    bool is_final_chunk,
    const scoped_refptr<IOBufferWithSize>& data_buffer) {
  DCHECK_NE(RECV_CLOSED, state_)
      << "HandleFrame() does not support being called re-entrantly from within "
         "SendClose()";
  if (state_ == CLOSED || state_ == CLOSE_WAIT) {
    DVLOG_IF(1, state_ == CLOSED) << "A frame was received while in the CLOSED "
                                     "state. This is possible after a channel "
                                     "failed, but should be very rare.";
    std::string frame_name;
    switch (opcode) {
      case WebSocketFrameHeader::kOpCodeText:    // fall-thru
      case WebSocketFrameHeader::kOpCodeBinary:  // fall-thru
      case WebSocketFrameHeader::kOpCodeContinuation:
        frame_name = "Data frame";
        break;

      case WebSocketFrameHeader::kOpCodePing:
        frame_name = "Ping";
        break;

      case WebSocketFrameHeader::kOpCodePong:
        frame_name = "Pong";
        break;

      case WebSocketFrameHeader::kOpCodeClose:
        frame_name = "Close";
        break;

      default:
        frame_name = "Unknown frame type";
        break;
    }
    // SEND_REAL_ERROR makes no difference here, as FailChannel() won't send
    // another Close frame.
    FailChannel(SEND_REAL_ERROR,
                kWebSocketErrorProtocolError,
                frame_name + " received after close");
    return;
  }
  switch (opcode) {
    case WebSocketFrameHeader::kOpCodeText:    // fall-thru
    case WebSocketFrameHeader::kOpCodeBinary:  // fall-thru
    case WebSocketFrameHeader::kOpCodeContinuation:
      if (state_ == CONNECTED) {
        const bool final = is_final_chunk && current_frame_header_->final;
        // TODO(ricea): Need to fail the connection if UTF-8 is invalid
        // post-reassembly. Requires a streaming UTF-8 validator.
        // TODO(ricea): Can this copy be eliminated?
        const char* const data_begin = data_buffer->data();
        const char* const data_end = data_begin + data_buffer->size();
        const std::vector<char> data(data_begin, data_end);
        // TODO(ricea): Handle the case when ReadFrames returns far
        // more data at once than should be sent in a single IPC. This needs to
        // be handled carefully, as an overloaded IO thread is one possible
        // cause of receiving very large chunks.

        // Sends the received frame to the renderer process.
        event_interface_->OnDataFrame(
            final,
            is_first_chunk ? opcode : WebSocketFrameHeader::kOpCodeContinuation,
            data);
      } else {
        VLOG(3) << "Ignored data packet received in state " << state_;
      }
      return;

    case WebSocketFrameHeader::kOpCodePing:
      VLOG(1) << "Got Ping of size " << data_buffer->size();
      if (state_ == CONNECTED) {
        SendIOBufferWithSize(
            true, WebSocketFrameHeader::kOpCodePong, data_buffer);
      } else {
        VLOG(3) << "Ignored ping in state " << state_;
      }
      return;

    case WebSocketFrameHeader::kOpCodePong:
      VLOG(1) << "Got Pong of size " << data_buffer->size();
      // There is no need to do anything with pong messages.
      return;

    case WebSocketFrameHeader::kOpCodeClose: {
      uint16 code = kWebSocketNormalClosure;
      std::string reason;
      ParseClose(data_buffer, &code, &reason);
      // TODO(ricea): Find a way to safely log the message from the close
      // message (escape control codes and so on).
      VLOG(1) << "Got Close with code " << code;
      switch (state_) {
        case CONNECTED:
          state_ = RECV_CLOSED;
          SendClose(code, reason);  // Sets state_ to CLOSE_WAIT
          event_interface_->OnClosingHandshake();
          closing_code_ = code;
          closing_reason_ = reason;
          break;

        case SEND_CLOSED:
          state_ = CLOSE_WAIT;
          // From RFC6455 section 7.1.5: "Each endpoint
          // will see the status code sent by the other end as _The WebSocket
          // Connection Close Code_."
          closing_code_ = code;
          closing_reason_ = reason;
          break;

        default:
          LOG(DFATAL) << "Got Close in unexpected state " << state_;
          break;
      }
      return;
    }

    default:
      FailChannel(
          SEND_REAL_ERROR, kWebSocketErrorProtocolError, "Unknown opcode");
      return;
  }
}

void WebSocketChannel::SendIOBufferWithSize(
    bool fin,
    WebSocketFrameHeader::OpCode op_code,
    const scoped_refptr<IOBufferWithSize>& buffer) {
  DCHECK(state_ == CONNECTED || state_ == RECV_CLOSED);
  DCHECK(stream_);
  scoped_ptr<WebSocketFrameHeader> header(new WebSocketFrameHeader(op_code));
  header->final = fin;
  header->masked = true;
  header->payload_length = buffer->size();
  scoped_ptr<WebSocketFrameChunk> chunk(new WebSocketFrameChunk());
  chunk->header = header.Pass();
  chunk->final_chunk = true;
  chunk->data = buffer;
  if (data_being_sent_) {
    // Either the link to the WebSocket server is saturated, or several messages
    // are being sent in a batch.
    // TODO(ricea): Keep some statistics to work out the situation and adjust
    // quota appropriately.
    if (!data_to_send_next_)
      data_to_send_next_.reset(new SendBuffer);
    data_to_send_next_->AddFrame(chunk.Pass());
  } else {
    data_being_sent_.reset(new SendBuffer);
    data_being_sent_->AddFrame(chunk.Pass());
    WriteFrames();
  }
}

void WebSocketChannel::FailChannel(ExposeError expose,
                                   uint16 code,
                                   const std::string& reason) {
  DCHECK_NE(FRESHLY_CONSTRUCTED, state_);
  DCHECK_NE(CONNECTING, state_);
  // TODO(ricea): Logging.
  State old_state = state_;
  if (state_ == CONNECTED) {
    uint16 send_code = kWebSocketErrorGoingAway;
    std::string send_reason = "Internal Error";
    if (expose == SEND_REAL_ERROR) {
      send_code = code;
      send_reason = reason;
    }
    SendClose(send_code, send_reason);  // Sets state_ to SEND_CLOSED
  }
  // Careful study of RFC6455 section 7.1.7 and 7.1.1 indicates the browser
  // should close the connection itself without waiting for the closing
  // handshake.
  stream_->Close();
  state_ = CLOSED;

  // The channel may be in the middle of processing several chunks. It should
  // not use this frame header for subsequent chunks.
  current_frame_header_.reset();
  if (old_state != CLOSED) {
    event_interface_->OnDropChannel(code, reason);
  }
}

void WebSocketChannel::SendClose(uint16 code, const std::string& reason) {
  DCHECK(state_ == CONNECTED || state_ == RECV_CLOSED);
  // TODO(ricea): Ensure reason.length() <= 123
  scoped_refptr<IOBufferWithSize> body;
  if (code == kWebSocketErrorNoStatusReceived) {
    // Special case: translate kWebSocketErrorNoStatusReceived into a Close
    // frame with no payload.
    body = new IOBufferWithSize(0);
  } else {
    const size_t payload_length = kWebSocketCloseCodeLength + reason.length();
    body = new IOBufferWithSize(payload_length);
    WriteBigEndian(body->data(), code);
    COMPILE_ASSERT(sizeof(code) == kWebSocketCloseCodeLength,
                   they_should_both_be_two);
    std::copy(
        reason.begin(), reason.end(), body->data() + kWebSocketCloseCodeLength);
  }
  SendIOBufferWithSize(true, WebSocketFrameHeader::kOpCodeClose, body);
  state_ = (state_ == CONNECTED) ? SEND_CLOSED : CLOSE_WAIT;
}

void WebSocketChannel::ParseClose(const scoped_refptr<IOBufferWithSize>& buffer,
                                  uint16* code,
                                  std::string* reason) {
  const char* data = buffer->data();
  size_t size = base::checked_numeric_cast<size_t>(buffer->size());
  reason->clear();
  if (size < kWebSocketCloseCodeLength) {
    *code = kWebSocketErrorNoStatusReceived;
    if (size != 0) {
      VLOG(1) << "Close frame with payload size " << size << " received "
              << "(the first byte is " << std::hex << static_cast<int>(data[0])
              << ")";
      return;
    }
    return;
  }
  uint16 unchecked_code = 0;
  ReadBigEndian(data, &unchecked_code);
  COMPILE_ASSERT(sizeof(unchecked_code) == kWebSocketCloseCodeLength,
                 they_should_both_be_two_bytes);
  if (unchecked_code >= static_cast<uint16>(kWebSocketNormalClosure) &&
      unchecked_code <=
          static_cast<uint16>(kWebSocketErrorPrivateReservedMax)) {
    *code = unchecked_code;
  } else {
    VLOG(1) << "Close frame contained code outside of the valid range: "
            << unchecked_code;
    *code = kWebSocketErrorAbnormalClosure;
  }
  std::string text(data + kWebSocketCloseCodeLength, data + size);
  // TODO(ricea): Is this check strict enough? In particular, check the
  // "Security Considerations" from RFC3629.
  if (IsStringUTF8(text)) {
    reason->swap(text);
  }
}

}  // namespace net