Most of the WebSocket code does not need to care about the original

frame boundaries. Move the chunk to frame conversion logic to
WebSocketBasicStream from WebSocketChannel and change all interfaces
except for WebSocketFrameParser to use WebSocketFrame instead of
WebSocketFrameChunk.

BUG=288603
TEST=net_unittests --gtest_filter=WebSocket*

Review URL: https://codereview.chromium.org/23604044

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@225452 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 1208 insertions, 1035 deletions

diff --git a/net/websockets/websocket_basic_stream.cc b/net/websockets/websocket_basic_stream.cc
index 5b02b18..fb8fb0a 100644
--- a/net/websockets/websocket_basic_stream.cc
+++ b/net/websockets/websocket_basic_stream.cc
@@ -12,6 +12,7 @@
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/safe_numerics.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_handle.h"
@@ -23,6 +24,10 @@ namespace net {
 
 namespace {
 
+// This uses type uint64 to match the definition of
+// WebSocketFrameHeader::payload_length in websocket_frame.h.
+const uint64 kMaxControlFramePayload = 125;
+
 // The number of bytes to attempt to read at a time.
 // TODO(ricea): See if there is a better number or algorithm to fulfill our
 // requirements:
@@ -47,10 +52,9 @@ WebSocketBasicStream::WebSocketBasicStream(
 
 WebSocketBasicStream::~WebSocketBasicStream() { Close(); }
 
-int WebSocketBasicStream::ReadFrames(
-    ScopedVector<WebSocketFrameChunk>* frame_chunks,
-    const CompletionCallback& callback) {
-  DCHECK(frame_chunks->empty());
+int WebSocketBasicStream::ReadFrames(ScopedVector<WebSocketFrame>* frames,
+                                     const CompletionCallback& callback) {
+  DCHECK(frames->empty());
   // If there is data left over after parsing the HTTP headers, attempt to parse
   // it as WebSocket frames.
   if (http_read_buffer_) {
@@ -60,80 +64,80 @@ int WebSocketBasicStream::ReadFrames(
     scoped_refptr<GrowableIOBuffer> buffered_data;
     buffered_data.swap(http_read_buffer_);
     DCHECK(http_read_buffer_.get() == NULL);
+    ScopedVector<WebSocketFrameChunk> frame_chunks;
     if (!parser_.Decode(buffered_data->StartOfBuffer(),
                         buffered_data->offset(),
-                        frame_chunks))
+                        &frame_chunks))
       return WebSocketErrorToNetError(parser_.websocket_error());
-    if (!frame_chunks->empty())
-      return OK;
+    if (!frame_chunks.empty()) {
+      int result = ConvertChunksToFrames(&frame_chunks, frames);
+      if (result != ERR_IO_PENDING)
+        return result;
+    }
   }
 
-  // Run until socket stops giving us data or we get some chunks.
+  // Run until socket stops giving us data or we get some frames.
   while (true) {
     // base::Unretained(this) here is safe because net::Socket guarantees not to
     // call any callbacks after Disconnect(), which we call from the
-    // destructor. The caller of ReadFrames() is required to keep |frame_chunks|
+    // destructor. The caller of ReadFrames() is required to keep |frames|
     // valid.
-    int result = connection_->socket()
-                     ->Read(read_buffer_.get(),
-                            read_buffer_->size(),
-                            base::Bind(&WebSocketBasicStream::OnReadComplete,
-                                       base::Unretained(this),
-                                       base::Unretained(frame_chunks),
-                                       callback));
+    int result = connection_->socket()->Read(
+        read_buffer_.get(),
+        read_buffer_->size(),
+        base::Bind(&WebSocketBasicStream::OnReadComplete,
+                   base::Unretained(this),
+                   base::Unretained(frames),
+                   callback));
     if (result == ERR_IO_PENDING)
       return result;
-    result = HandleReadResult(result, frame_chunks);
+    result = HandleReadResult(result, frames);
     if (result != ERR_IO_PENDING)
       return result;
+    DCHECK(frames->empty());
   }
 }
 
-int WebSocketBasicStream::WriteFrames(
-    ScopedVector<WebSocketFrameChunk>* frame_chunks,
-    const CompletionCallback& callback) {
+int WebSocketBasicStream::WriteFrames(ScopedVector<WebSocketFrame>* frames,
+                                      const CompletionCallback& callback) {
   // This function always concatenates all frames into a single buffer.
   // TODO(ricea): Investigate whether it would be better in some cases to
   // perform multiple writes with smaller buffers.
   //
   // First calculate the size of the buffer we need to allocate.
-  typedef ScopedVector<WebSocketFrameChunk>::const_iterator Iterator;
+  typedef ScopedVector<WebSocketFrame>::const_iterator Iterator;
   const int kMaximumTotalSize = std::numeric_limits<int>::max();
   int total_size = 0;
-  for (Iterator it = frame_chunks->begin(); it != frame_chunks->end(); ++it) {
-    WebSocketFrameChunk* chunk = *it;
-    DCHECK(chunk->header)
-        << "Only complete frames are supported by WebSocketBasicStream";
-    DCHECK(chunk->final_chunk)
-        << "Only complete frames are supported by WebSocketBasicStream";
+  for (Iterator it = frames->begin(); it != frames->end(); ++it) {
+    WebSocketFrame* frame = *it;
     // Force the masked bit on.
-    chunk->header->masked = true;
+    frame->header.masked = true;
     // We enforce flow control so the renderer should never be able to force us
     // to cache anywhere near 2GB of frames.
-    int chunk_size =
-        chunk->data->size() + GetWebSocketFrameHeaderSize(*(chunk->header));
-    CHECK_GE(kMaximumTotalSize - total_size, chunk_size)
+    int frame_size = frame->header.payload_length +
+                     GetWebSocketFrameHeaderSize(frame->header);
+    CHECK_GE(kMaximumTotalSize - total_size, frame_size)
         << "Aborting to prevent overflow";
-    total_size += chunk_size;
+    total_size += frame_size;
   }
   scoped_refptr<IOBufferWithSize> combined_buffer(
       new IOBufferWithSize(total_size));
   char* dest = combined_buffer->data();
   int remaining_size = total_size;
-  for (Iterator it = frame_chunks->begin(); it != frame_chunks->end(); ++it) {
-    WebSocketFrameChunk* chunk = *it;
+  for (Iterator it = frames->begin(); it != frames->end(); ++it) {
+    WebSocketFrame* frame = *it;
     WebSocketMaskingKey mask = generate_websocket_masking_key_();
-    int result = WriteWebSocketFrameHeader(
-        *(chunk->header), &mask, dest, remaining_size);
-    DCHECK(result != ERR_INVALID_ARGUMENT)
+    int result =
+        WriteWebSocketFrameHeader(frame->header, &mask, dest, remaining_size);
+    DCHECK_NE(ERR_INVALID_ARGUMENT, result)
         << "WriteWebSocketFrameHeader() says that " << remaining_size
         << " is not enough to write the header in. This should not happen.";
     CHECK_GE(result, 0) << "Potentially security-critical check failed";
     dest += result;
     remaining_size -= result;
 
-    const char* const frame_data = chunk->data->data();
-    const int frame_size = chunk->data->size();
+    const char* const frame_data = frame->data->data();
+    const int frame_size = frame->header.payload_length;
     CHECK_GE(remaining_size, frame_size);
     std::copy(frame_data, frame_data + frame_size, dest);
     MaskWebSocketFramePayload(mask, 0, dest, frame_size);
@@ -196,13 +200,13 @@ int WebSocketBasicStream::WriteEverything(
   while (buffer->BytesRemaining() > 0) {
     // The use of base::Unretained() here is safe because on destruction we
     // disconnect the socket, preventing any further callbacks.
-    int result = connection_->socket()
-                     ->Write(buffer.get(),
-                             buffer->BytesRemaining(),
-                             base::Bind(&WebSocketBasicStream::OnWriteComplete,
-                                        base::Unretained(this),
-                                        buffer,
-                                        callback));
+    int result = connection_->socket()->Write(
+        buffer.get(),
+        buffer->BytesRemaining(),
+        base::Bind(&WebSocketBasicStream::OnWriteComplete,
+                   base::Unretained(this),
+                   buffer,
+                   callback));
     if (result > 0) {
       buffer->DidConsume(result);
     } else {
@@ -217,12 +221,12 @@ void WebSocketBasicStream::OnWriteComplete(
     const CompletionCallback& callback,
     int result) {
   if (result < 0) {
-    DCHECK(result != ERR_IO_PENDING);
+    DCHECK_NE(ERR_IO_PENDING, result);
     callback.Run(result);
     return;
   }
 
-  DCHECK(result != 0);
+  DCHECK_NE(0, result);
   buffer->DidConsume(result);
   result = WriteEverything(buffer, callback);
   if (result != ERR_IO_PENDING)
@@ -231,27 +235,177 @@ void WebSocketBasicStream::OnWriteComplete(
 
 int WebSocketBasicStream::HandleReadResult(
     int result,
-    ScopedVector<WebSocketFrameChunk>* frame_chunks) {
+    ScopedVector<WebSocketFrame>* frames) {
   DCHECK_NE(ERR_IO_PENDING, result);
-  DCHECK(frame_chunks->empty());
+  DCHECK(frames->empty());
   if (result < 0)
     return result;
   if (result == 0)
     return ERR_CONNECTION_CLOSED;
-  if (!parser_.Decode(read_buffer_->data(), result, frame_chunks))
+  ScopedVector<WebSocketFrameChunk> frame_chunks;
+  if (!parser_.Decode(read_buffer_->data(), result, &frame_chunks))
     return WebSocketErrorToNetError(parser_.websocket_error());
-  if (!frame_chunks->empty())
-    return OK;
-  return ERR_IO_PENDING;
+  if (frame_chunks.empty())
+    return ERR_IO_PENDING;
+  return ConvertChunksToFrames(&frame_chunks, frames);
 }
 
-void WebSocketBasicStream::OnReadComplete(
+int WebSocketBasicStream::ConvertChunksToFrames(
     ScopedVector<WebSocketFrameChunk>* frame_chunks,
-    const CompletionCallback& callback,
-    int result) {
-  result = HandleReadResult(result, frame_chunks);
+    ScopedVector<WebSocketFrame>* frames) {
+  for (size_t i = 0; i < frame_chunks->size(); ++i) {
+    scoped_ptr<WebSocketFrame> frame;
+    int result = ConvertChunkToFrame(
+        scoped_ptr<WebSocketFrameChunk>((*frame_chunks)[i]), &frame);
+    (*frame_chunks)[i] = NULL;
+    if (result != OK)
+      return result;
+    if (frame)
+      frames->push_back(frame.release());
+  }
+  // All the elements of |frame_chunks| are now NULL, so there is no point in
+  // calling delete on them all.
+  frame_chunks->weak_clear();
+  if (frames->empty())
+    return ERR_IO_PENDING;
+  return OK;
+}
+
+int WebSocketBasicStream::ConvertChunkToFrame(
+    scoped_ptr<WebSocketFrameChunk> chunk,
+    scoped_ptr<WebSocketFrame>* frame) {
+  DCHECK(frame->get() == NULL);
+  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 (bug in WebSocketFrameParser?)";
+    is_first_chunk = true;
+    current_frame_header_.swap(chunk->header);
+  }
+  const int chunk_size = chunk->data ? chunk->data->size() : 0;
+  DCHECK(current_frame_header_) << "Unexpected header-less chunk received "
+                                << "(final_chunk = " << chunk->final_chunk
+                                << ", data size = " << chunk_size
+                                << ") (bug in WebSocketFrameParser?)";
+  scoped_refptr<IOBufferWithSize> data_buffer;
+  data_buffer.swap(chunk->data);
+  const bool is_final_chunk = chunk->final_chunk;
+  const WebSocketFrameHeader::OpCode opcode = current_frame_header_->opcode;
+  if (WebSocketFrameHeader::IsKnownControlOpCode(opcode)) {
+    bool protocol_error = false;
+    if (!current_frame_header_->final) {
+      DVLOG(1) << "WebSocket protocol error. Control frame, opcode=" << opcode
+               << " received with FIN bit unset.";
+      protocol_error = true;
+    }
+    if (current_frame_header_->payload_length > kMaxControlFramePayload) {
+      DVLOG(1) << "WebSocket protocol error. Control frame, opcode=" << opcode
+               << ", payload_length=" << current_frame_header_->payload_length
+               << " exceeds maximum payload length for a control message.";
+      protocol_error = true;
+    }
+    if (protocol_error) {
+      current_frame_header_.reset();
+      return ERR_WS_PROTOCOL_ERROR;
+    }
+    if (!is_final_chunk) {
+      DVLOG(2) << "Encountered a split control frame, opcode " << opcode;
+      if (incomplete_control_frame_body_) {
+        DVLOG(3) << "Appending to an existing split control frame.";
+        AddToIncompleteControlFrameBody(data_buffer);
+      } else {
+        DVLOG(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 OK;
+    }
+    if (incomplete_control_frame_body_) {
+      DVLOG(2) << "Rejoining a split control frame, opcode " << opcode;
+      AddToIncompleteControlFrameBody(data_buffer);
+      const int body_size = incomplete_control_frame_body_->offset();
+      DCHECK_EQ(body_size,
+                static_cast<int>(current_frame_header_->payload_length));
+      scoped_refptr<IOBufferWithSize> body = new IOBufferWithSize(body_size);
+      memcpy(body->data(),
+             incomplete_control_frame_body_->StartOfBuffer(),
+             body_size);
+      incomplete_control_frame_body_ = NULL;  // Frame now complete.
+      DCHECK(is_final_chunk);
+      *frame = CreateFrame(is_final_chunk, body);
+      return OK;
+    }
+  }
+
+  // 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>(chunk_size));
+  DCHECK(!is_first_chunk || !is_final_chunk ||
+         current_frame_header_->payload_length ==
+             base::checked_numeric_cast<uint64>(chunk_size));
+
+  // Convert the chunk to a complete frame.
+  *frame = CreateFrame(is_final_chunk, data_buffer);
+  return OK;
+}
+
+scoped_ptr<WebSocketFrame> WebSocketBasicStream::CreateFrame(
+    bool is_final_chunk,
+    const scoped_refptr<IOBufferWithSize>& data) {
+  scoped_ptr<WebSocketFrame> result_frame;
+  const bool is_final_chunk_in_message =
+      is_final_chunk && current_frame_header_->final;
+  const int data_size = data ? data->size() : 0;
+  const WebSocketFrameHeader::OpCode opcode = current_frame_header_->opcode;
+  // Empty frames convey no useful information unless they have the "final" bit
+  // set.
+  if (is_final_chunk_in_message || data_size > 0) {
+    result_frame.reset(new WebSocketFrame(opcode));
+    result_frame->header.CopyFrom(*current_frame_header_);
+    result_frame->header.final = is_final_chunk_in_message;
+    result_frame->header.payload_length = data_size;
+    result_frame->data = data;
+    // Ensure that opcodes Text and Binary are only used for the first frame in
+    // the message.
+    if (WebSocketFrameHeader::IsKnownDataOpCode(opcode))
+      current_frame_header_->opcode = WebSocketFrameHeader::kOpCodeContinuation;
+  }
+  // Make sure that a frame header is not applied to any chunks that do not
+  // belong to it.
+  if (is_final_chunk)
+    current_frame_header_.reset();
+  return result_frame.Pass();
+}
+
+void WebSocketBasicStream::AddToIncompleteControlFrameBody(
+    const scoped_refptr<IOBufferWithSize>& data_buffer) {
+  if (!data_buffer)
+    return;
+  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 WebSocketBasicStream::OnReadComplete(ScopedVector<WebSocketFrame>* frames,
+                                          const CompletionCallback& callback,
+                                          int result) {
+  result = HandleReadResult(result, frames);
   if (result == ERR_IO_PENDING)
-    result = ReadFrames(frame_chunks, callback);
+    result = ReadFrames(frames, callback);
   if (result != ERR_IO_PENDING)
     callback.Run(result);
 }
diff --git a/net/websockets/websocket_basic_stream.h b/net/websockets/websocket_basic_stream.h
index 1231da8..45c183c 100644
--- a/net/websockets/websocket_basic_stream.h
+++ b/net/websockets/websocket_basic_stream.h
@@ -22,6 +22,7 @@ class GrowableIOBuffer;
 class HttpRequestHeaders;
 class HttpResponseInfo;
 class IOBufferWithSize;
+struct WebSocketFrame;
 struct WebSocketFrameChunk;
 
 // Implementation of WebSocketStream for non-multiplexed ws:// connections (or
@@ -39,10 +40,10 @@ class NET_EXPORT_PRIVATE WebSocketBasicStream : public WebSocketStream {
   virtual ~WebSocketBasicStream();
 
   // WebSocketStream implementation.
-  virtual int ReadFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) OVERRIDE;
 
-  virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) OVERRIDE;
 
   virtual void Close() OVERRIDE;
@@ -83,13 +84,43 @@ class NET_EXPORT_PRIVATE WebSocketBasicStream : public WebSocketStream {
                        int result);
 
   // Attempts to parse the output of a read as WebSocket frames. On success,
-  // returns OK and places the frame(s) in frame_chunks.
-  int HandleReadResult(int result,
-                       ScopedVector<WebSocketFrameChunk>* frame_chunks);
+  // returns OK and places the frame(s) in |frames|.
+  int HandleReadResult(int result, ScopedVector<WebSocketFrame>* frames);
+
+  // Converts the chunks in |frame_chunks| into frames and writes them to
+  // |frames|. |frame_chunks| is destroyed in the process. Returns
+  // ERR_WS_PROTOCOL_ERROR if an invalid chunk was found. If one or more frames
+  // was added to |frames|, then returns OK, otherwise returns ERR_IO_PENDING.
+  int ConvertChunksToFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+                            ScopedVector<WebSocketFrame>* frames);
+
+  // Converts a |chunk| to a |frame|. |*frame| should be NULL on entry to this
+  // method. If |chunk| is an incomplete control frame, or an empty non-final
+  // frame, then |*frame| may still be NULL on exit. If an invalid control frame
+  // is found, returns ERR_WS_PROTOCOL_ERROR and the stream is no longer
+  // usable. Otherwise returns OK (even if frame is still NULL).
+  int ConvertChunkToFrame(scoped_ptr<WebSocketFrameChunk> chunk,
+                          scoped_ptr<WebSocketFrame>* frame);
+
+  // Creates a frame based on the value of |is_final_chunk|, |data| and
+  // |current_frame_header_|. Clears |current_frame_header_| if |is_final_chunk|
+  // is true. |data| may be NULL if the frame has an empty payload. A frame with
+  // no data and the "final" flag not set is not useful; in this case the
+  // returned frame will be NULL. Otherwise, |current_frame_header_->opcode| is
+  // set to Continuation after use if it was Text or Binary, in accordance with
+  // WebSocket RFC6455 section 5.4.
+  scoped_ptr<WebSocketFrame> CreateFrame(
+      bool is_final_chunk,
+      const scoped_refptr<IOBufferWithSize>& data);
+
+  // Adds |data_buffer| to the end of |incomplete_control_frame_body_|, applying
+  // bounds checks.
+  void AddToIncompleteControlFrameBody(
+      const scoped_refptr<IOBufferWithSize>& data_buffer);
 
   // Called when a read completes. Parses the result and (unless no complete
   // header has been received) calls |callback|.
-  void OnReadComplete(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  void OnReadComplete(ScopedVector<WebSocketFrame>* frames,
                       const CompletionCallback& callback,
                       int result);
 
@@ -102,6 +133,18 @@ class NET_EXPORT_PRIVATE WebSocketBasicStream : public WebSocketStream {
   // from being returned to the pool.
   scoped_ptr<ClientSocketHandle> connection_;
 
+  // Frame header for the frame currently being received. Only non-NULL while we
+  // are processing the frame. If the frame arrives in multiple chunks, it can
+  // remain non-NULL until additional chunks arrive. If the header of the frame
+  // was invalid, this is set to NULL, the channel is failed, and subsequent
+  // chunks of the same frame will be ignored.
+  scoped_ptr<WebSocketFrameHeader> current_frame_header_;
+
+  // Although it should rarely happen in practice, a control frame can arrive
+  // broken into chunks. This variable provides storage for a partial control
+  // frame until the rest arrives. It will be NULL the rest of the time.
+  scoped_refptr<GrowableIOBuffer> incomplete_control_frame_body_;
+
   // Only used during handshake. Some data may be left in this buffer after the
   // handshake, in which case it will be picked up during the first call to
   // ReadFrames(). The type is GrowableIOBuffer for compatibility with
diff --git a/net/websockets/websocket_basic_stream_test.cc b/net/websockets/websocket_basic_stream_test.cc
index ec2e51a..37a49f6 100644
--- a/net/websockets/websocket_basic_stream_test.cc
+++ b/net/websockets/websocket_basic_stream_test.cc
@@ -37,33 +37,21 @@ const size_t kMultipleFramesSize = arraysize(kMultipleFrames) - 1;
 // invalid.
 const char kInvalidFrame[] = "\x81\x7E\x00\x07Invalid";
 const size_t kInvalidFrameSize = arraysize(kInvalidFrame) - 1;
+// Control frames must have the FIN bit set. This one does not.
+const char kPingFrameWithoutFin[] = "\x09\x00";
+const size_t kPingFrameWithoutFinSize = arraysize(kPingFrameWithoutFin) - 1;
+// Control frames must have a payload of 125 bytes or less. This one has
+// a payload of 126 bytes.
+const char k126BytePong[] =
+    "\x8a\x7e\x00\x7eZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ"
+    "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
+const size_t k126BytePongSize = arraysize(k126BytePong) - 1;
+const char kCloseFrame[] = "\x88\x09\x03\xe8occludo";
+const size_t kCloseFrameSize = arraysize(kCloseFrame) - 1;
 const char kWriteFrame[] = "\x81\x85\x00\x00\x00\x00Write";
 const size_t kWriteFrameSize = arraysize(kWriteFrame) - 1;
 const WebSocketMaskingKey kNulMaskingKey = {{'\0', '\0', '\0', '\0'}};
 
-// Generates a ScopedVector<WebSocketFrameChunk> which will have a wire format
-// matching kWriteFrame.
-ScopedVector<WebSocketFrameChunk> GenerateWriteFrame() {
-  scoped_ptr<WebSocketFrameChunk> chunk(new WebSocketFrameChunk);
-  const size_t payload_size =
-      kWriteFrameSize - (WebSocketFrameHeader::kBaseHeaderSize +
-                         WebSocketFrameHeader::kMaskingKeyLength);
-  chunk->data = new IOBufferWithSize(payload_size);
-  memcpy(chunk->data->data(),
-         kWriteFrame + kWriteFrameSize - payload_size,
-         payload_size);
-  chunk->final_chunk = true;
-  scoped_ptr<WebSocketFrameHeader> header(
-      new WebSocketFrameHeader(WebSocketFrameHeader::kOpCodeText));
-  header->final = true;
-  header->masked = true;
-  header->payload_length = payload_size;
-  chunk->header = header.Pass();
-  ScopedVector<WebSocketFrameChunk> chunks;
-  chunks.push_back(chunk.release());
-  return chunks.Pass();
-}
-
 // A masking key generator function which generates the identity mask,
 // ie. "\0\0\0\0".
 WebSocketMaskingKey GenerateNulMaskingKey() { return kNulMaskingKey; }
@@ -131,11 +119,6 @@ class WebSocketBasicStreamSocketTest : public WebSocketBasicStreamTest {
     CreateStream(reads, N, NULL, 0);
   }
 
-  template <size_t N>
-  void CreateWriteOnly(MockWrite (&writes)[N]) {
-    CreateStream(NULL, 0, writes, N);
-  }
-
   void CreateNullStream() { CreateStream(NULL, 0, NULL, 0); }
 
   scoped_ptr<SocketDataProvider> socket_data_;
@@ -143,66 +126,145 @@ class WebSocketBasicStreamSocketTest : public WebSocketBasicStreamTest {
   ClientSocketPoolHistograms histograms_;
   MockTransportClientSocketPool pool_;
   CapturingBoundNetLog(bound_net_log_);
-  ScopedVector<WebSocketFrameChunk> frame_chunks_;
+  ScopedVector<WebSocketFrame> frames_;
   TestCompletionCallback cb_;
   scoped_refptr<GrowableIOBuffer> http_read_buffer_;
   std::string sub_protocol_;
   std::string extensions_;
 };
 
+// A test fixture for the common case of tests that only perform a single read.
+class WebSocketBasicStreamSocketSingleReadTest
+    : public WebSocketBasicStreamSocketTest {
+ protected:
+  void CreateRead(const MockRead& read) {
+    reads_[0] = read;
+    CreateStream(reads_, 1U, NULL, 0);
+  }
+
+  MockRead reads_[1];
+};
+
+// A test fixture for tests that perform chunked reads.
+class WebSocketBasicStreamSocketChunkedReadTest
+    : public WebSocketBasicStreamSocketTest {
+ protected:
+  // Specify the behaviour if there aren't enough chunks to use all the data. If
+  // LAST_FRAME_BIG is specified, then the rest of the data will be
+  // put in the last chunk. If LAST_FRAME_NOT_BIG is specified, then the last
+  // frame will be no bigger than the rest of the frames (but it can be smaller,
+  // if not enough data remains).
+  enum LastFrameBehaviour {
+    LAST_FRAME_BIG,
+    LAST_FRAME_NOT_BIG
+  };
+
+  // Prepares a read from |data| of |data_size|, split into |number_of_chunks|,
+  // each of |chunk_size| (except that the last chunk may be larger or
+  // smaller). All reads must be either SYNCHRONOUS or ASYNC (not a mixture),
+  // and errors cannot be simulated. Once data is exhausted, further reads will
+  // return 0 (ie. connection closed).
+  void CreateChunkedRead(IoMode mode,
+                         const char data[],
+                         size_t data_size,
+                         int chunk_size,
+                         int number_of_chunks,
+                         LastFrameBehaviour last_frame_behaviour) {
+    reads_.reset(new MockRead[number_of_chunks]);
+    const char* start = data;
+    for (int i = 0; i < number_of_chunks; ++i) {
+      int len = chunk_size;
+      const bool is_last_chunk = (i == number_of_chunks - 1);
+      if ((last_frame_behaviour == LAST_FRAME_BIG && is_last_chunk) ||
+          static_cast<int>(data + data_size - start) < len) {
+        len = static_cast<int>(data + data_size - start);
+      }
+      reads_[i] = MockRead(mode, start, len);
+      start += len;
+    }
+    CreateStream(reads_.get(), number_of_chunks, NULL, 0);
+  }
+
+  scoped_ptr<MockRead[]> reads_;
+};
+
+// Test fixture for write tests.
+class WebSocketBasicStreamSocketWriteTest
+    : public WebSocketBasicStreamSocketTest {
+ protected:
+  // All write tests use the same frame, so it is easiest to create it during
+  // test creation.
+  virtual void SetUp() OVERRIDE { PrepareWriteFrame(); }
+
+  // Creates a WebSocketFrame with a wire format matching kWriteFrame and adds
+  // it to |frames_|.
+  void PrepareWriteFrame() {
+    scoped_ptr<WebSocketFrame> frame(
+        new WebSocketFrame(WebSocketFrameHeader::kOpCodeText));
+    const size_t payload_size =
+        kWriteFrameSize - (WebSocketFrameHeader::kBaseHeaderSize +
+                           WebSocketFrameHeader::kMaskingKeyLength);
+    frame->data = new IOBuffer(payload_size);
+    memcpy(frame->data->data(),
+           kWriteFrame + kWriteFrameSize - payload_size,
+           payload_size);
+    WebSocketFrameHeader& header = frame->header;
+    header.final = true;
+    header.masked = true;
+    header.payload_length = payload_size;
+    frames_.push_back(frame.release());
+  }
+
+  // Creates a stream that expects the listed writes.
+  template <size_t N>
+  void CreateWriteOnly(MockWrite (&writes)[N]) {
+    CreateStream(NULL, 0, writes, N);
+  }
+};
+
 TEST_F(WebSocketBasicStreamSocketTest, ConstructionWorks) {
   CreateNullStream();
 }
 
-TEST_F(WebSocketBasicStreamSocketTest, SyncReadWorks) {
-  MockRead reads[] = {MockRead(SYNCHRONOUS, kSampleFrame, kSampleFrameSize)};
-  CreateReadOnly(reads);
-  int result = stream_->ReadFrames(&frame_chunks_, cb_.callback());
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, SyncReadWorks) {
+  CreateRead(MockRead(SYNCHRONOUS, kSampleFrame, kSampleFrameSize));
+  int result = stream_->ReadFrames(&frames_, cb_.callback());
   EXPECT_EQ(OK, result);
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->header);
-  EXPECT_EQ(GG_UINT64_C(6), frame_chunks_[0]->header->payload_length);
-  EXPECT_TRUE(frame_chunks_[0]->header->final);
-  EXPECT_TRUE(frame_chunks_[0]->final_chunk);
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_TRUE(frames_[0]->header.final);
 }
 
-TEST_F(WebSocketBasicStreamSocketTest, AsyncReadWorks) {
-  MockRead reads[] = {MockRead(ASYNC, kSampleFrame, kSampleFrameSize)};
-  CreateReadOnly(reads);
-  int result = stream_->ReadFrames(&frame_chunks_, cb_.callback());
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, AsyncReadWorks) {
+  CreateRead(MockRead(ASYNC, kSampleFrame, kSampleFrameSize));
+  int result = stream_->ReadFrames(&frames_, cb_.callback());
   ASSERT_EQ(ERR_IO_PENDING, result);
   EXPECT_EQ(OK, cb_.WaitForResult());
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->header);
-  EXPECT_EQ(GG_UINT64_C(6), frame_chunks_[0]->header->payload_length);
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
   // Don't repeat all the tests from SyncReadWorks; just enough to be sure the
   // frame was really read.
 }
 
 // ReadFrames will not return a frame whose header has not been wholly received.
-TEST_F(WebSocketBasicStreamSocketTest, HeaderFragmentedSync) {
-  MockRead reads[] = {
-      MockRead(SYNCHRONOUS, kSampleFrame, 1),
-      MockRead(SYNCHRONOUS, kSampleFrame + 1, kSampleFrameSize - 1)};
-  CreateReadOnly(reads);
-  int result = stream_->ReadFrames(&frame_chunks_, cb_.callback());
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, HeaderFragmentedSync) {
+  CreateChunkedRead(
+      SYNCHRONOUS, kSampleFrame, kSampleFrameSize, 1, 2, LAST_FRAME_BIG);
+  int result = stream_->ReadFrames(&frames_, cb_.callback());
   ASSERT_EQ(OK, result);
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->header);
-  EXPECT_EQ(GG_UINT64_C(6), frame_chunks_[0]->header->payload_length);
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
 }
 
 // The same behaviour applies to asynchronous reads.
-TEST_F(WebSocketBasicStreamSocketTest, HeaderFragmentedAsync) {
-  MockRead reads[] = {MockRead(ASYNC, kSampleFrame, 1),
-                      MockRead(ASYNC, kSampleFrame + 1, kSampleFrameSize - 1)};
-  CreateReadOnly(reads);
-  int result = stream_->ReadFrames(&frame_chunks_, cb_.callback());
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, HeaderFragmentedAsync) {
+  CreateChunkedRead(
+      ASYNC, kSampleFrame, kSampleFrameSize, 1, 2, LAST_FRAME_BIG);
+  int result = stream_->ReadFrames(&frames_, cb_.callback());
   ASSERT_EQ(ERR_IO_PENDING, result);
   EXPECT_EQ(OK, cb_.WaitForResult());
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->header);
-  EXPECT_EQ(GG_UINT64_C(6), frame_chunks_[0]->header->payload_length);
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
 }
 
 // If it receives an incomplete header in a synchronous call, then has to wait
@@ -211,12 +273,11 @@ TEST_F(WebSocketBasicStreamSocketTest, HeaderFragmentedSyncAsync) {
   MockRead reads[] = {MockRead(SYNCHRONOUS, kSampleFrame, 1),
                       MockRead(ASYNC, kSampleFrame + 1, kSampleFrameSize - 1)};
   CreateReadOnly(reads);
-  int result = stream_->ReadFrames(&frame_chunks_, cb_.callback());
+  int result = stream_->ReadFrames(&frames_, cb_.callback());
   ASSERT_EQ(ERR_IO_PENDING, result);
   EXPECT_EQ(OK, cb_.WaitForResult());
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->header);
-  EXPECT_EQ(GG_UINT64_C(6), frame_chunks_[0]->header->payload_length);
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
 }
 
 // An extended header should also return ERR_IO_PENDING if it is not completely
@@ -226,112 +287,164 @@ TEST_F(WebSocketBasicStreamSocketTest, FragmentedLargeHeader) {
       MockRead(SYNCHRONOUS, kPartialLargeFrame, kLargeFrameHeaderSize - 1),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
   CreateReadOnly(reads);
-  EXPECT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
 }
 
-// A frame that does not arrive in a single read should arrive in chunks.
-TEST_F(WebSocketBasicStreamSocketTest, LargeFrameFirstChunk) {
-  MockRead reads[] = {
-      MockRead(SYNCHRONOUS, kPartialLargeFrame, kPartialLargeFrameSize)};
-  CreateReadOnly(reads);
-  EXPECT_EQ(OK, stream_->ReadFrames(&frame_chunks_, cb_.callback()));
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->header);
-  EXPECT_EQ(kLargeFrameDeclaredPayloadSize,
-            frame_chunks_[0]->header->payload_length);
-  EXPECT_TRUE(frame_chunks_[0]->header->final);
-  EXPECT_FALSE(frame_chunks_[0]->final_chunk);
+// A frame that does not arrive in a single read should be broken into separate
+// frames.
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, LargeFrameFirstChunk) {
+  CreateRead(MockRead(SYNCHRONOUS, kPartialLargeFrame, kPartialLargeFrameSize));
+  EXPECT_EQ(OK, stream_->ReadFrames(&frames_, cb_.callback()));
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_FALSE(frames_[0]->header.final);
   EXPECT_EQ(kPartialLargeFrameSize - kLargeFrameHeaderSize,
-            static_cast<size_t>(frame_chunks_[0]->data->size()));
+            static_cast<size_t>(frames_[0]->header.payload_length));
 }
 
-// If only the header arrives, we should get a zero-byte chunk.
+// If only the header of a data frame arrives, we should not receive a frame and
+// be told to wait. WebSocketBasicStream does two reads in this case, as after
+// the first read it has no frames to return.
 TEST_F(WebSocketBasicStreamSocketTest, HeaderOnlyChunk) {
   MockRead reads[] = {
-      MockRead(SYNCHRONOUS, kPartialLargeFrame, kLargeFrameHeaderSize)};
+      MockRead(SYNCHRONOUS, kPartialLargeFrame, kLargeFrameHeaderSize),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
   CreateReadOnly(reads);
-  EXPECT_EQ(OK, stream_->ReadFrames(&frame_chunks_, cb_.callback()));
-  ASSERT_EQ(1U, frame_chunks_.size());
-  EXPECT_FALSE(frame_chunks_[0]->final_chunk);
-  EXPECT_TRUE(frame_chunks_[0]->data.get() == NULL);
+  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
+  ASSERT_EQ(0U, frames_.size());
 }
 
-// The second and subsequent chunks of a frame have no header.
-TEST_F(WebSocketBasicStreamSocketTest, LargeFrameTwoChunks) {
-  static const size_t kChunkSize = 16;
+// If the header and the body of a data frame arrive seperately, we should only
+// see one frame.
+TEST_F(WebSocketBasicStreamSocketTest, HeaderBodySeparated) {
   MockRead reads[] = {
-      MockRead(ASYNC, kPartialLargeFrame, kChunkSize),
-      MockRead(ASYNC, kPartialLargeFrame + kChunkSize, kChunkSize)};
+      MockRead(SYNCHRONOUS, kPartialLargeFrame, kLargeFrameHeaderSize),
+      MockRead(ASYNC,
+               kPartialLargeFrame + kLargeFrameHeaderSize,
+               kPartialLargeFrameSize - kLargeFrameHeaderSize)};
   CreateReadOnly(reads);
+  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
+  EXPECT_EQ(OK, cb_.WaitForResult());
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(kPartialLargeFrameSize - kLargeFrameHeaderSize,
+            frames_[0]->header.payload_length);
+}
+
+// If the header and body of a data frame arrive separately, the frame we see
+// should have the opcode from the header (not Continuation).
+TEST_F(WebSocketBasicStreamSocketTest, HeaderBodySeparatedOpCodeNotLost) {
+  MockRead reads[] = {
+      MockRead(ASYNC, kPartialLargeFrame, kLargeFrameHeaderSize),
+      MockRead(ASYNC,
+               kPartialLargeFrame + kLargeFrameHeaderSize,
+               kPartialLargeFrameSize - kLargeFrameHeaderSize)};
+  CreateReadOnly(reads);
+  EXPECT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
+  EXPECT_EQ(OK, cb_.WaitForResult());
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_[0]->header.opcode);
+}
+
+// Every frame has a header with a correct payload_length field.
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, LargeFrameTwoChunks) {
+  const size_t kChunkSize = 16;
+  CreateChunkedRead(ASYNC,
+                    kPartialLargeFrame,
+                    kPartialLargeFrameSize,
+                    kChunkSize,
+                    2,
+                    LAST_FRAME_NOT_BIG);
   TestCompletionCallback cb[2];
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb[0].callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb[0].callback()));
   EXPECT_EQ(OK, cb[0].WaitForResult());
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->header);
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(kChunkSize - kLargeFrameHeaderSize,
+            frames_[0]->header.payload_length);
 
-  frame_chunks_.clear();
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb[1].callback()));
+  frames_.clear();
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb[1].callback()));
   EXPECT_EQ(OK, cb[1].WaitForResult());
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_FALSE(frame_chunks_[0]->header);
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(kChunkSize, frames_[0]->header.payload_length);
 }
 
-// Only the final chunk of a frame has final_chunk set.
-TEST_F(WebSocketBasicStreamSocketTest, OnlyFinalChunkIsFinal) {
+// Only the final frame of a fragmented message has |final| bit set.
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, OnlyFinalChunkIsFinal) {
   static const size_t kFirstChunkSize = 4;
-  MockRead reads[] = {MockRead(ASYNC, kSampleFrame, kFirstChunkSize),
-                      MockRead(ASYNC,
-                               kSampleFrame + kFirstChunkSize,
-                               kSampleFrameSize - kFirstChunkSize)};
-  CreateReadOnly(reads);
+  CreateChunkedRead(ASYNC,
+                    kSampleFrame,
+                    kSampleFrameSize,
+                    kFirstChunkSize,
+                    2,
+                    LAST_FRAME_BIG);
   TestCompletionCallback cb[2];
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb[0].callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb[0].callback()));
   EXPECT_EQ(OK, cb[0].WaitForResult());
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_FALSE(frame_chunks_[0]->final_chunk);
+  ASSERT_EQ(1U, frames_.size());
+  ASSERT_FALSE(frames_[0]->header.final);
 
-  frame_chunks_.clear();
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb[1].callback()));
+  frames_.clear();
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb[1].callback()));
   EXPECT_EQ(OK, cb[1].WaitForResult());
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->final_chunk);
+  ASSERT_EQ(1U, frames_.size());
+  ASSERT_TRUE(frames_[0]->header.final);
 }
 
-// Multiple frames that arrive together should be parsed correctly.
-TEST_F(WebSocketBasicStreamSocketTest, ThreeFramesTogether) {
-  MockRead reads[] = {
-      MockRead(SYNCHRONOUS, kMultipleFrames, kMultipleFramesSize)};
-  CreateReadOnly(reads);
+// All frames after the first have their opcode changed to Continuation.
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, ContinuationOpCodeUsed) {
+  const size_t kFirstChunkSize = 3;
+  const int kChunkCount = 3;
+  // The input data is one frame with opcode Text, which arrives in three
+  // separate chunks.
+  CreateChunkedRead(ASYNC,
+                    kSampleFrame,
+                    kSampleFrameSize,
+                    kFirstChunkSize,
+                    kChunkCount,
+                    LAST_FRAME_BIG);
+  TestCompletionCallback cb[kChunkCount];
+
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb[0].callback()));
+  EXPECT_EQ(OK, cb[0].WaitForResult());
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_[0]->header.opcode);
+
+  // This test uses a loop to verify that the opcode for every frames generated
+  // after the first is converted to Continuation.
+  for (int i = 1; i < kChunkCount; ++i) {
+    frames_.clear();
+    ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb[i].callback()));
+    EXPECT_EQ(OK, cb[i].WaitForResult());
+    ASSERT_EQ(1U, frames_.size());
+    EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
+              frames_[0]->header.opcode);
+  }
+}
 
-  ASSERT_EQ(OK, stream_->ReadFrames(&frame_chunks_, cb_.callback()));
-  ASSERT_EQ(3U, frame_chunks_.size());
-  EXPECT_TRUE(frame_chunks_[0]->final_chunk);
-  EXPECT_TRUE(frame_chunks_[1]->final_chunk);
-  EXPECT_TRUE(frame_chunks_[2]->final_chunk);
+// Multiple frames that arrive together should be parsed correctly.
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, ThreeFramesTogether) {
+  CreateRead(MockRead(SYNCHRONOUS, kMultipleFrames, kMultipleFramesSize));
+
+  ASSERT_EQ(OK, stream_->ReadFrames(&frames_, cb_.callback()));
+  ASSERT_EQ(3U, frames_.size());
+  EXPECT_TRUE(frames_[0]->header.final);
+  EXPECT_TRUE(frames_[1]->header.final);
+  EXPECT_TRUE(frames_[2]->header.final);
 }
 
 // ERR_CONNECTION_CLOSED must be returned on close.
-TEST_F(WebSocketBasicStreamSocketTest, SyncClose) {
-  MockRead reads[] = {MockRead(SYNCHRONOUS, "", 0)};
-  CreateReadOnly(reads);
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, SyncClose) {
+  CreateRead(MockRead(SYNCHRONOUS, "", 0));
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+            stream_->ReadFrames(&frames_, cb_.callback()));
 }
 
-TEST_F(WebSocketBasicStreamSocketTest, AsyncClose) {
-  MockRead reads[] = {MockRead(ASYNC, "", 0)};
-  CreateReadOnly(reads);
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, AsyncClose) {
+  CreateRead(MockRead(ASYNC, "", 0));
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
   EXPECT_EQ(ERR_CONNECTION_CLOSED, cb_.WaitForResult());
 }
 
@@ -339,53 +452,52 @@ TEST_F(WebSocketBasicStreamSocketTest, AsyncClose) {
 // ERR_CONNECTION_CLOSED. This is not expected to happen on an established
 // connection; a Read of size 0 is the expected behaviour. The key point of this
 // test is to confirm that ReadFrames() behaviour is identical in both cases.
-TEST_F(WebSocketBasicStreamSocketTest, SyncCloseWithErr) {
-  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_CONNECTION_CLOSED)};
-  CreateReadOnly(reads);
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, SyncCloseWithErr) {
+  CreateRead(MockRead(SYNCHRONOUS, ERR_CONNECTION_CLOSED));
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+            stream_->ReadFrames(&frames_, cb_.callback()));
 }
 
-TEST_F(WebSocketBasicStreamSocketTest, AsyncCloseWithErr) {
-  MockRead reads[] = {MockRead(ASYNC, ERR_CONNECTION_CLOSED)};
-  CreateReadOnly(reads);
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, AsyncCloseWithErr) {
+  CreateRead(MockRead(ASYNC, ERR_CONNECTION_CLOSED));
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
   EXPECT_EQ(ERR_CONNECTION_CLOSED, cb_.WaitForResult());
 }
 
-TEST_F(WebSocketBasicStreamSocketTest, SyncErrorsPassedThrough) {
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, SyncErrorsPassedThrough) {
   // ERR_INSUFFICIENT_RESOURCES here represents an arbitrary error that
   // WebSocketBasicStream gives no special handling to.
-  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_INSUFFICIENT_RESOURCES)};
-  CreateReadOnly(reads);
+  CreateRead(MockRead(SYNCHRONOUS, ERR_INSUFFICIENT_RESOURCES));
 
   EXPECT_EQ(ERR_INSUFFICIENT_RESOURCES,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+            stream_->ReadFrames(&frames_, cb_.callback()));
 }
 
-TEST_F(WebSocketBasicStreamSocketTest, AsyncErrorsPassedThrough) {
-  MockRead reads[] = {MockRead(ASYNC, ERR_INSUFFICIENT_RESOURCES)};
-  CreateReadOnly(reads);
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, AsyncErrorsPassedThrough) {
+  CreateRead(MockRead(ASYNC, ERR_INSUFFICIENT_RESOURCES));
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
   EXPECT_EQ(ERR_INSUFFICIENT_RESOURCES, cb_.WaitForResult());
 }
 
 // If we get a frame followed by a close, we should receive them separately.
-TEST_F(WebSocketBasicStreamSocketTest, CloseAfterFrame) {
-  MockRead reads[] = {MockRead(SYNCHRONOUS, kSampleFrame, kSampleFrameSize),
-                      MockRead(SYNCHRONOUS, "", 0)};
-  CreateReadOnly(reads);
-
-  EXPECT_EQ(OK, stream_->ReadFrames(&frame_chunks_, cb_.callback()));
-  EXPECT_EQ(1U, frame_chunks_.size());
-  frame_chunks_.clear();
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, CloseAfterFrame) {
+  // The chunk size equals the data size, so the second chunk is 0 size, closing
+  // the connection.
+  CreateChunkedRead(SYNCHRONOUS,
+                    kSampleFrame,
+                    kSampleFrameSize,
+                    kSampleFrameSize,
+                    2,
+                    LAST_FRAME_NOT_BIG);
+
+  EXPECT_EQ(OK, stream_->ReadFrames(&frames_, cb_.callback()));
+  EXPECT_EQ(1U, frames_.size());
+  frames_.clear();
   EXPECT_EQ(ERR_CONNECTION_CLOSED,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+            stream_->ReadFrames(&frames_, cb_.callback()));
 }
 
 // Synchronous close after an async frame header is handled by a different code
@@ -395,8 +507,7 @@ TEST_F(WebSocketBasicStreamSocketTest, AsyncCloseAfterIncompleteHeader) {
                       MockRead(SYNCHRONOUS, "", 0)};
   CreateReadOnly(reads);
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
   ASSERT_EQ(ERR_CONNECTION_CLOSED, cb_.WaitForResult());
 }
 
@@ -407,8 +518,7 @@ TEST_F(WebSocketBasicStreamSocketTest, AsyncErrCloseAfterIncompleteHeader) {
                       MockRead(SYNCHRONOUS, ERR_CONNECTION_CLOSED)};
   CreateReadOnly(reads);
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
   ASSERT_EQ(ERR_CONNECTION_CLOSED, cb_.WaitForResult());
 }
 
@@ -418,80 +528,186 @@ TEST_F(WebSocketBasicStreamSocketTest, HttpReadBufferIsUsed) {
   SetHttpReadBuffer(kSampleFrame, kSampleFrameSize);
   CreateNullStream();
 
-  EXPECT_EQ(OK, stream_->ReadFrames(&frame_chunks_, cb_.callback()));
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->data);
-  EXPECT_EQ(6, frame_chunks_[0]->data->size());
+  EXPECT_EQ(OK, stream_->ReadFrames(&frames_, cb_.callback()));
+  ASSERT_EQ(1U, frames_.size());
+  ASSERT_TRUE(frames_[0]->data);
+  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
 }
 
 // Check that a frame whose header partially arrived at the end of the response
 // headers works correctly.
-TEST_F(WebSocketBasicStreamSocketTest, PartialFrameHeaderInHttpResponse) {
+TEST_F(WebSocketBasicStreamSocketSingleReadTest,
+       PartialFrameHeaderInHttpResponse) {
   SetHttpReadBuffer(kSampleFrame, 1);
-  MockRead reads[] = {MockRead(ASYNC, kSampleFrame + 1, kSampleFrameSize - 1)};
-  CreateReadOnly(reads);
+  CreateRead(MockRead(ASYNC, kSampleFrame + 1, kSampleFrameSize - 1));
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
   EXPECT_EQ(OK, cb_.WaitForResult());
-  ASSERT_EQ(1U, frame_chunks_.size());
-  ASSERT_TRUE(frame_chunks_[0]->data);
-  EXPECT_EQ(6, frame_chunks_[0]->data->size());
-  ASSERT_TRUE(frame_chunks_[0]->header);
-  EXPECT_EQ(WebSocketFrameHeader::kOpCodeText,
-            frame_chunks_[0]->header->opcode);
+  ASSERT_EQ(1U, frames_.size());
+  ASSERT_TRUE(frames_[0]->data);
+  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_[0]->header.opcode);
+}
+
+// Check that a control frame which partially arrives at the end of the response
+// headers works correctly.
+TEST_F(WebSocketBasicStreamSocketSingleReadTest,
+       PartialControlFrameInHttpResponse) {
+  const size_t kPartialFrameBytes = 3;
+  SetHttpReadBuffer(kCloseFrame, kPartialFrameBytes);
+  CreateRead(MockRead(ASYNC,
+                      kCloseFrame + kPartialFrameBytes,
+                      kCloseFrameSize - kPartialFrameBytes));
+
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
+  EXPECT_EQ(OK, cb_.WaitForResult());
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeClose, frames_[0]->header.opcode);
+  EXPECT_EQ(kCloseFrameSize - 2, frames_[0]->header.payload_length);
+  EXPECT_EQ(
+      0,
+      memcmp(frames_[0]->data->data(), kCloseFrame + 2, kCloseFrameSize - 2));
+}
+
+// Check that a control frame which partially arrives at the end of the response
+// headers works correctly. Synchronous version (unlikely in practice).
+TEST_F(WebSocketBasicStreamSocketSingleReadTest,
+       PartialControlFrameInHttpResponseSync) {
+  const size_t kPartialFrameBytes = 3;
+  SetHttpReadBuffer(kCloseFrame, kPartialFrameBytes);
+  CreateRead(MockRead(SYNCHRONOUS,
+                      kCloseFrame + kPartialFrameBytes,
+                      kCloseFrameSize - kPartialFrameBytes));
+
+  ASSERT_EQ(OK, stream_->ReadFrames(&frames_, cb_.callback()));
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeClose, frames_[0]->header.opcode);
 }
 
 // Check that an invalid frame results in an error.
-TEST_F(WebSocketBasicStreamSocketTest, SyncInvalidFrame) {
-  MockRead reads[] = {MockRead(SYNCHRONOUS, kInvalidFrame, kInvalidFrameSize)};
-  CreateReadOnly(reads);
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, SyncInvalidFrame) {
+  CreateRead(MockRead(SYNCHRONOUS, kInvalidFrame, kInvalidFrameSize));
 
   EXPECT_EQ(ERR_WS_PROTOCOL_ERROR,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+            stream_->ReadFrames(&frames_, cb_.callback()));
 }
 
-TEST_F(WebSocketBasicStreamSocketTest, AsyncInvalidFrame) {
-  MockRead reads[] = {MockRead(ASYNC, kInvalidFrame, kInvalidFrameSize)};
-  CreateReadOnly(reads);
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, AsyncInvalidFrame) {
+  CreateRead(MockRead(ASYNC, kInvalidFrame, kInvalidFrameSize));
+
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
+  EXPECT_EQ(ERR_WS_PROTOCOL_ERROR, cb_.WaitForResult());
+}
+
+// A control frame without a FIN flag is invalid and should not be passed
+// through to higher layers. RFC6455 5.5 "All control frames ... MUST NOT be
+// fragmented."
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, ControlFrameWithoutFin) {
+  CreateRead(
+      MockRead(SYNCHRONOUS, kPingFrameWithoutFin, kPingFrameWithoutFinSize));
+
+  ASSERT_EQ(ERR_WS_PROTOCOL_ERROR,
+            stream_->ReadFrames(&frames_, cb_.callback()));
+  EXPECT_TRUE(frames_.empty());
+}
+
+// A control frame over 125 characters is invalid. RFC6455 5.5 "All control
+// frames MUST have a payload length of 125 bytes or less". Since we use a
+// 125-byte buffer to assemble fragmented control frames, we need to detect this
+// error before attempting to assemble the fragments.
+TEST_F(WebSocketBasicStreamSocketSingleReadTest, OverlongControlFrame) {
+  CreateRead(MockRead(SYNCHRONOUS, k126BytePong, k126BytePongSize));
+
+  EXPECT_EQ(ERR_WS_PROTOCOL_ERROR,
+            stream_->ReadFrames(&frames_, cb_.callback()));
+  EXPECT_TRUE(frames_.empty());
+}
+
+// A control frame over 125 characters should still be rejected if it is split
+// into multiple chunks.
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, SplitOverlongControlFrame) {
+  const size_t kFirstChunkSize = 16;
+  CreateChunkedRead(SYNCHRONOUS,
+                    k126BytePong,
+                    k126BytePongSize,
+                    kFirstChunkSize,
+                    2,
+                    LAST_FRAME_BIG);
+
+  EXPECT_EQ(ERR_WS_PROTOCOL_ERROR,
+            stream_->ReadFrames(&frames_, cb_.callback()));
+  EXPECT_TRUE(frames_.empty());
+}
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest,
+       AsyncSplitOverlongControlFrame) {
+  const size_t kFirstChunkSize = 16;
+  CreateChunkedRead(ASYNC,
+                    k126BytePong,
+                    k126BytePongSize,
+                    kFirstChunkSize,
+                    2,
+                    LAST_FRAME_BIG);
+
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
   EXPECT_EQ(ERR_WS_PROTOCOL_ERROR, cb_.WaitForResult());
+  // The caller should not call ReadFrames() again after receiving an error
+  // other than ERR_IO_PENDING.
+  EXPECT_TRUE(frames_.empty());
+}
+
+// In the synchronous case, ReadFrames assembles the whole control frame before
+// returning.
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, SyncControlFrameAssembly) {
+  const size_t kChunkSize = 3;
+  CreateChunkedRead(
+      SYNCHRONOUS, kCloseFrame, kCloseFrameSize, kChunkSize, 3, LAST_FRAME_BIG);
+
+  ASSERT_EQ(OK, stream_->ReadFrames(&frames_, cb_.callback()));
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeClose, frames_[0]->header.opcode);
+}
+
+// In the asynchronous case, the callback is not called until the control frame
+// has been completely assembled.
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, AsyncControlFrameAssembly) {
+  const size_t kChunkSize = 3;
+  CreateChunkedRead(
+      ASYNC, kCloseFrame, kCloseFrameSize, kChunkSize, 3, LAST_FRAME_BIG);
+
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
+  ASSERT_EQ(OK, cb_.WaitForResult());
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeClose, frames_[0]->header.opcode);
 }
 
 // Check that writing a frame all at once works.
-TEST_F(WebSocketBasicStreamSocketTest, WriteAtOnce) {
+TEST_F(WebSocketBasicStreamSocketWriteTest, WriteAtOnce) {
   MockWrite writes[] = {MockWrite(SYNCHRONOUS, kWriteFrame, kWriteFrameSize)};
   CreateWriteOnly(writes);
-  frame_chunks_ = GenerateWriteFrame();
 
-  EXPECT_EQ(OK, stream_->WriteFrames(&frame_chunks_, cb_.callback()));
+  EXPECT_EQ(OK, stream_->WriteFrames(&frames_, cb_.callback()));
 }
 
 // Check that completely async writing works.
-TEST_F(WebSocketBasicStreamSocketTest, AsyncWriteAtOnce) {
+TEST_F(WebSocketBasicStreamSocketWriteTest, AsyncWriteAtOnce) {
   MockWrite writes[] = {MockWrite(ASYNC, kWriteFrame, kWriteFrameSize)};
   CreateWriteOnly(writes);
-  frame_chunks_ = GenerateWriteFrame();
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->WriteFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->WriteFrames(&frames_, cb_.callback()));
   EXPECT_EQ(OK, cb_.WaitForResult());
 }
 
 // Check that writing a frame to an extremely full kernel buffer (so that it
 // ends up being sent in bits) works. The WriteFrames() callback should not be
 // called until all parts have been written.
-TEST_F(WebSocketBasicStreamSocketTest, WriteInBits) {
+TEST_F(WebSocketBasicStreamSocketWriteTest, WriteInBits) {
   MockWrite writes[] = {MockWrite(SYNCHRONOUS, kWriteFrame, 4),
                         MockWrite(ASYNC, kWriteFrame + 4, 4),
                         MockWrite(ASYNC, kWriteFrame + 8, kWriteFrameSize - 8)};
   CreateWriteOnly(writes);
-  frame_chunks_ = GenerateWriteFrame();
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream_->WriteFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream_->WriteFrames(&frames_, cb_.callback()));
   EXPECT_EQ(OK, cb_.WaitForResult());
 }
 
diff --git a/net/websockets/websocket_channel.cc b/net/websockets/websocket_channel.cc
index 3db457c..d2150d4 100644
--- a/net/websockets/websocket_channel.cc
+++ b/net/websockets/websocket_channel.cc
@@ -27,10 +27,6 @@ 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
@@ -39,26 +35,25 @@ class WebSocketChannel::SendBuffer {
  public:
   SendBuffer() : total_bytes_(0) {}
 
-  // Add a WebSocketFrameChunk to the buffer and increase total_bytes_.
-  void AddFrame(scoped_ptr<WebSocketFrameChunk> chunk);
+  // Add a WebSocketFrame to the buffer and increase total_bytes_.
+  void AddFrame(scoped_ptr<WebSocketFrame> chunk);
 
   // Return a pointer to the frames_ for write purposes.
-  ScopedVector<WebSocketFrameChunk>* frames() { return &frames_; }
+  ScopedVector<WebSocketFrame>* frames() { return &frames_; }
 
  private:
   // The frames_ that will be sent in the next call to WriteFrames().
-  ScopedVector<WebSocketFrameChunk> frames_;
+  ScopedVector<WebSocketFrame> frames_;
 
-  // The total size of the buffers in |frames_|. This will be used to measure
-  // the throughput of the link.
+  // The total size of the payload data 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());
+void WebSocketChannel::SendBuffer::AddFrame(scoped_ptr<WebSocketFrame> frame) {
+  total_bytes_ += frame->header.payload_length;
+  frames_.push_back(frame.release());
 }
 
 // Implementation of WebSocketStream::ConnectDelegate that simply forwards the
@@ -98,7 +93,7 @@ WebSocketChannel::WebSocketChannel(
       state_(FRESHLY_CONSTRUCTED) {}
 
 WebSocketChannel::~WebSocketChannel() {
-  // The stream may hold a pointer to read_frame_chunks_, and so it needs to be
+  // The stream may hold a pointer to read_frames_, and so it needs to be
   // destroyed first.
   stream_.reset();
 }
@@ -163,9 +158,9 @@ void WebSocketChannel::SendFrame(bool fin,
   // 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()));
+  scoped_refptr<IOBuffer> buffer(new IOBuffer(data.size()));
   std::copy(data.begin(), data.end(), buffer->data());
-  SendIOBufferWithSize(fin, op_code, buffer);
+  SendIOBuffer(fin, op_code, buffer, data.size());
 }
 
 void WebSocketChannel::SendFlowControl(int64 quota) {
@@ -308,7 +303,7 @@ void WebSocketChannel::ReadFrames() {
     // WebSocketStream, and any pending reads will be cancelled when it is
     // destroyed.
     result = stream_->ReadFrames(
-        &read_frame_chunks_,
+        &read_frames_,
         base::Bind(
             &WebSocketChannel::OnReadDone, base::Unretained(this), false));
     if (result != ERR_IO_PENDING) {
@@ -325,20 +320,27 @@ void WebSocketChannel::OnReadDone(bool synchronous, int 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())
+      DCHECK(!read_frames_.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());
+      for (size_t i = 0; i < read_frames_.size(); ++i) {
+        scoped_ptr<WebSocketFrame> frame(read_frames_[i]);
+        read_frames_[i] = NULL;
+        ProcessFrame(frame.Pass());
       }
-      read_frame_chunks_.clear();
+      read_frames_.clear();
       // There should always be a call to ReadFrames pending.
+      // TODO(ricea): Unless we are out of quota.
       if (!synchronous && state_ != CLOSED) {
         ReadFrames();
       }
       return;
 
+    case ERR_WS_PROTOCOL_ERROR:
+      FailChannel(SEND_REAL_ERROR,
+                  kWebSocketErrorProtocolError,
+                  "WebSocket Protocol Error");
+      return;
+
     default:
       DCHECK_LT(result, 0)
           << "ReadFrames() should only return OK or ERR_ codes";
@@ -357,119 +359,33 @@ void WebSocketChannel::OnReadDone(bool synchronous, int result) {
   }
 }
 
-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()
-                                << ")";
+void WebSocketChannel::ProcessFrame(scoped_ptr<WebSocketFrame> frame) {
+  if (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;
   }
-  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.
-    }
+  const WebSocketFrameHeader::OpCode opcode = frame->header.opcode;
+  if (WebSocketFrameHeader::IsKnownControlOpCode(opcode) &&
+      !frame->header.final) {
+    FailChannel(SEND_REAL_ERROR,
+                kWebSocketErrorProtocolError,
+                "Control message with FIN bit unset received");
+    return;
   }
 
-  // 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);
+  HandleFrame(
+      opcode, frame->header.final, frame->data, frame->header.payload_length);
 }
 
-void WebSocketChannel::HandleFrame(
-    const WebSocketFrameHeader::OpCode opcode,
-    bool is_first_chunk,
-    bool is_final_chunk,
-    const scoped_refptr<IOBufferWithSize>& data_buffer) {
+void WebSocketChannel::HandleFrame(const WebSocketFrameHeader::OpCode opcode,
+                                   bool final,
+                                   const scoped_refptr<IOBuffer>& data_buffer,
+                                   size_t size) {
   DCHECK_NE(RECV_CLOSED, state_)
       << "HandleFrame() does not support being called re-entrantly from within "
          "SendClose()";
@@ -513,12 +429,11 @@ void WebSocketChannel::HandleFrame(
     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 char* const data_end = data_begin + 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
@@ -526,34 +441,31 @@ void WebSocketChannel::HandleFrame(
         // 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);
+        event_interface_->OnDataFrame(final, opcode, data);
       } else {
         VLOG(3) << "Ignored data packet received in state " << state_;
       }
       return;
 
     case WebSocketFrameHeader::kOpCodePing:
-      VLOG(1) << "Got Ping of size " << data_buffer->size();
+      VLOG(1) << "Got Ping of size " << size;
       if (state_ == CONNECTED) {
-        SendIOBufferWithSize(
-            true, WebSocketFrameHeader::kOpCodePong, data_buffer);
+        SendIOBuffer(
+            true, WebSocketFrameHeader::kOpCodePong, data_buffer, size);
       } else {
         VLOG(3) << "Ignored ping in state " << state_;
       }
       return;
 
     case WebSocketFrameHeader::kOpCodePong:
-      VLOG(1) << "Got Pong of size " << data_buffer->size();
+      VLOG(1) << "Got Pong of size " << 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);
+      ParseClose(data_buffer, size, &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;
@@ -589,20 +501,18 @@ void WebSocketChannel::HandleFrame(
   }
 }
 
-void WebSocketChannel::SendIOBufferWithSize(
-    bool fin,
-    WebSocketFrameHeader::OpCode op_code,
-    const scoped_refptr<IOBufferWithSize>& buffer) {
+void WebSocketChannel::SendIOBuffer(bool fin,
+                                    WebSocketFrameHeader::OpCode op_code,
+                                    const scoped_refptr<IOBuffer>& buffer,
+                                    size_t size) {
   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;
+  scoped_ptr<WebSocketFrame> frame(new WebSocketFrame(op_code));
+  WebSocketFrameHeader& header = frame->header;
+  header.final = fin;
+  header.masked = true;
+  header.payload_length = size;
+  frame->data = buffer;
   if (data_being_sent_) {
     // Either the link to the WebSocket server is saturated, or several messages
     // are being sent in a batch.
@@ -610,10 +520,10 @@ void WebSocketChannel::SendIOBufferWithSize(
     // quota appropriately.
     if (!data_to_send_next_)
       data_to_send_next_.reset(new SendBuffer);
-    data_to_send_next_->AddFrame(chunk.Pass());
+    data_to_send_next_->AddFrame(frame.Pass());
   } else {
     data_being_sent_.reset(new SendBuffer);
-    data_being_sent_->AddFrame(chunk.Pass());
+    data_being_sent_->AddFrame(frame.Pass());
     WriteFrames();
   }
 }
@@ -640,9 +550,6 @@ void WebSocketChannel::FailChannel(ExposeError expose,
   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);
   }
@@ -651,29 +558,31 @@ void WebSocketChannel::FailChannel(ExposeError expose,
 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;
+  scoped_refptr<IOBuffer> body;
+  size_t size = 0;
   if (code == kWebSocketErrorNoStatusReceived) {
     // Special case: translate kWebSocketErrorNoStatusReceived into a Close
     // frame with no payload.
-    body = new IOBufferWithSize(0);
+    body = new IOBuffer(0);
   } else {
     const size_t payload_length = kWebSocketCloseCodeLength + reason.length();
-    body = new IOBufferWithSize(payload_length);
+    body = new IOBuffer(payload_length);
+    size = 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);
+  SendIOBuffer(true, WebSocketFrameHeader::kOpCodeClose, body, size);
   state_ = (state_ == CONNECTED) ? SEND_CLOSED : CLOSE_WAIT;
 }
 
-void WebSocketChannel::ParseClose(const scoped_refptr<IOBufferWithSize>& buffer,
+void WebSocketChannel::ParseClose(const scoped_refptr<IOBuffer>& buffer,
+                                  size_t size,
                                   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;
diff --git a/net/websockets/websocket_channel.h b/net/websockets/websocket_channel.h
index c997d6a..dda30cd 100644
--- a/net/websockets/websocket_channel.h
+++ b/net/websockets/websocket_channel.h
@@ -19,10 +19,10 @@
 
 namespace net {
 
-class GrowableIOBuffer;
+class BoundNetLog;
+class IOBuffer;
 class URLRequestContext;
 class WebSocketEventInterface;
-class BoundNetLog;
 
 // Transport-independent implementation of WebSockets. Implements protocol
 // semantics that do not depend on the underlying transport. Provides the
@@ -164,37 +164,33 @@ class NET_EXPORT WebSocketChannel {
   // within the ReadFrames() loop and does not need to call ReadFrames() itself.
   void OnReadDone(bool synchronous, int result);
 
-  // Processes a single chunk that has been read from the stream.
-  void ProcessFrameChunk(scoped_ptr<WebSocketFrameChunk> chunk);
-
-  // Appends |data_buffer| to |incomplete_control_frame_body_|.
-  void AddToIncompleteControlFrameBody(
-      const scoped_refptr<IOBufferWithSize>& data_buffer);
+  // Processes a single frame that has been read from the stream.
+  void ProcessFrame(scoped_ptr<WebSocketFrame> frame);
 
   // Handles a frame that the object has received enough of to process. May call
-  // event_interface_ methods, send responses to the server, and change the
-  // value of state_.
+  // |event_interface_| methods, send responses to the server, and change the
+  // value of |state_|.
   void HandleFrame(const WebSocketFrameHeader::OpCode opcode,
-                   bool is_first_chunk,
-                   bool is_final_chunk,
-                   const scoped_refptr<IOBufferWithSize>& data_buffer);
+                   bool final,
+                   const scoped_refptr<IOBuffer>& data_buffer,
+                   size_t size);
 
   // Low-level method to send a single frame. Used for both data and control
   // frames. Either sends the frame immediately or buffers it to be scheduled
   // when the current write finishes. |fin| and |op_code| are defined as for
   // SendFrame() above, except that |op_code| may also be a control frame
   // opcode.
-  void SendIOBufferWithSize(bool fin,
-                            WebSocketFrameHeader::OpCode op_code,
-                            const scoped_refptr<IOBufferWithSize>& buffer);
+  void SendIOBuffer(bool fin,
+                    WebSocketFrameHeader::OpCode op_code,
+                    const scoped_refptr<IOBuffer>& buffer,
+                    size_t size);
 
   // Performs the "Fail the WebSocket Connection" operation as defined in
   // RFC6455. The supplied code and reason are sent back to the renderer in an
   // OnDropChannel message. If state_ is CONNECTED then a Close message is sent
   // to the remote host. If |expose| is SEND_REAL_ERROR then the remote host is
   // given the same status code passed to the renderer; otherwise it is sent a
-  // fixed "Going Away" code.  Resets current_frame_header_, closes the stream_,
-  // and sets state_ to CLOSED.
+  // fixed "Going Away" code.  Closes the stream_ and sets state_ to CLOSED.
   void FailChannel(ExposeError expose, uint16 code, const std::string& reason);
 
   // Sends a Close frame to Start the WebSocket Closing Handshake, or to respond
@@ -208,7 +204,8 @@ class NET_EXPORT WebSocketChannel {
   // outside the valid range, then 1002 (Protocol error) is set instead. If the
   // reason text is not valid UTF-8, then |reason| is set to an empty string
   // instead.
-  void ParseClose(const scoped_refptr<IOBufferWithSize>& buffer,
+  void ParseClose(const scoped_refptr<IOBuffer>& buffer,
+                  size_t size,
                   uint16* code,
                   std::string* reason);
 
@@ -231,20 +228,12 @@ class NET_EXPORT WebSocketChannel {
   scoped_ptr<SendBuffer> data_to_send_next_;
 
   // Destination for the current call to WebSocketStream::ReadFrames
-  ScopedVector<WebSocketFrameChunk> read_frame_chunks_;
-  // Frame header for the frame currently being received. Only non-NULL while we
-  // are processing the frame. If the frame arrives in multiple chunks, it can
-  // remain non-NULL until additional chunks arrive. If the header of the frame
-  // was invalid, this is set to NULL, the channel is failed, and subsequent
-  // chunks of the same frame will be ignored.
-  scoped_ptr<WebSocketFrameHeader> current_frame_header_;
+  ScopedVector<WebSocketFrame> read_frames_;
+
   // Handle to an in-progress WebSocketStream creation request. Only non-NULL
   // during the connection process.
   scoped_ptr<WebSocketStreamRequest> stream_request_;
-  // Although it should rarely happen in practice, a control frame can arrive
-  // broken into chunks. This variable provides storage for a partial control
-  // frame until the rest arrives. It will be NULL the rest of the time.
-  scoped_refptr<GrowableIOBuffer> incomplete_control_frame_body_;
+
   // If the renderer's send quota reaches this level, it is sent a quota
   // refresh. "quota units" are currently bytes. TODO(ricea): Update the
   // definition of quota units when necessary.
diff --git a/net/websockets/websocket_channel_test.cc b/net/websockets/websocket_channel_test.cc
index 25e9cdc..361f69f 100644
--- a/net/websockets/websocket_channel_test.cc
+++ b/net/websockets/websocket_channel_test.cc
@@ -34,40 +34,37 @@
 #define CLOSE_DATA(code, string) WEBSOCKET_CLOSE_CODE_AS_STRING_##code string
 #define WEBSOCKET_CLOSE_CODE_AS_STRING_NORMAL_CLOSURE "\x03\xe8"
 #define WEBSOCKET_CLOSE_CODE_AS_STRING_GOING_AWAY "\x03\xe9"
+#define WEBSOCKET_CLOSE_CODE_AS_STRING_PROTOCOL_ERROR "\x03\xea"
 #define WEBSOCKET_CLOSE_CODE_AS_STRING_SERVER_ERROR "\x03\xf3"
 
 namespace net {
 
-// Printing helpers to allow GoogleMock to print frame chunks. These are
-// explicitly designed to look like the static initialisation format we use in
-// these tests. They have to live in the net namespace in order to be found by
+// Printing helpers to allow GoogleMock to print frames. These are explicitly
+// designed to look like the static initialisation format we use in these
+// tests. They have to live in the net namespace in order to be found by
 // GoogleMock; a nested anonymous namespace will not work.
 
 std::ostream& operator<<(std::ostream& os, const WebSocketFrameHeader& header) {
-  return os << "{" << (header.final ? "FINAL_FRAME" : "NOT_FINAL_FRAME") << ", "
+  return os << (header.final ? "FINAL_FRAME" : "NOT_FINAL_FRAME") << ", "
             << header.opcode << ", "
-            << (header.masked ? "MASKED" : "NOT_MASKED") << ", "
-            << header.payload_length << "}";
+            << (header.masked ? "MASKED" : "NOT_MASKED");
 }
 
-std::ostream& operator<<(std::ostream& os, const WebSocketFrameChunk& chunk) {
-  os << "{";
-  if (chunk.header) {
-    os << *chunk.header;
-  } else {
-    os << "{NO_HEADER}";
+std::ostream& operator<<(std::ostream& os, const WebSocketFrame& frame) {
+  os << "{" << frame.header << ", ";
+  if (frame.data) {
+    return os << "\"" << base::StringPiece(frame.data->data(),
+                                           frame.header.payload_length)
+              << "\"}";
   }
-  return os << ", " << (chunk.final_chunk ? "FINAL_CHUNK" : "NOT_FINAL_CHUNK")
-            << ", \""
-            << base::StringPiece(chunk.data->data(), chunk.data->size())
-            << "\"}";
+  return os << "NULL}";
 }
 
 std::ostream& operator<<(std::ostream& os,
-                         const ScopedVector<WebSocketFrameChunk>& vector) {
+                         const ScopedVector<WebSocketFrame>& vector) {
   os << "{";
   bool first = true;
-  for (ScopedVector<WebSocketFrameChunk>::const_iterator it = vector.begin();
+  for (ScopedVector<WebSocketFrame>::const_iterator it = vector.begin();
        it != vector.end();
        ++it) {
     if (!first) {
@@ -81,7 +78,7 @@ std::ostream& operator<<(std::ostream& os,
 }
 
 std::ostream& operator<<(std::ostream& os,
-                         const ScopedVector<WebSocketFrameChunk>* vector) {
+                         const ScopedVector<WebSocketFrame>* vector) {
   return os << '&' << *vector;
 }
 
@@ -97,7 +94,7 @@ using ::testing::_;
 
 // A selection of characters that have traditionally been mangled in some
 // environment or other, for testing 8-bit cleanliness.
-const char kBinaryBlob[] = {'\n', '\r',      // BACKWARDS CRNL
+const char kBinaryBlob[] = {'\n',   '\r',    // BACKWARDS CRNL
                             '\0',            // nul
                             '\x7F',          // DEL
                             '\x80', '\xFF',  // NOT VALID UTF-8
@@ -170,12 +167,12 @@ class FakeWebSocketStream : public WebSocketStream {
     return ERR_IO_PENDING;
   }
 
-  virtual int ReadFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) OVERRIDE {
     return ERR_IO_PENDING;
   }
 
-  virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) OVERRIDE {
     return ERR_IO_PENDING;
   }
@@ -198,12 +195,7 @@ class FakeWebSocketStream : public WebSocketStream {
 
 // To make the static initialisers easier to read, we use enums rather than
 // bools.
-
-// NO_HEADER means there shouldn't be a header included in the generated
-// WebSocketFrameChunk. The static initialiser always has a header, but we can
-// avoid specifying the rest of the fields.
 enum IsFinal {
-  NO_HEADER,
   NOT_FINAL_FRAME,
   FINAL_FRAME
 };
@@ -213,54 +205,33 @@ enum IsMasked {
   MASKED
 };
 
-enum IsFinalChunk {
-  NOT_FINAL_CHUNK,
-  FINAL_CHUNK
-};
-
-// This is used to initialise a WebSocketFrameChunk but is statically
-// initialisable.
-struct InitFrameChunk {
-  struct FrameHeader {
-    IsFinal final;
-    // Reserved fields omitted for now. Add them if you need them.
-    WebSocketFrameHeader::OpCode opcode;
-    IsMasked masked;
-    // payload_length is the length of the whole frame. The length of the data
-    // members from every chunk in the frame must add up to the payload_length.
-    uint64 payload_length;
-  };
-  FrameHeader header;
-
-  // Directly equivalent to WebSocketFrameChunk::final_chunk
-  IsFinalChunk final_chunk;
+// This is used to initialise a WebSocketFrame but is statically initialisable.
+struct InitFrame {
+  IsFinal final;
+  // Reserved fields omitted for now. Add them if you need them.
+  WebSocketFrameHeader::OpCode opcode;
+  IsMasked masked;
 
   // Will be used to create the IOBuffer member. Can be NULL for NULL data. Is a
-  // nul-terminated string for ease-of-use. This means it is not 8-bit clean,
-  // but this is not an issue for test data.
+  // nul-terminated string for ease-of-use. |header.payload_length| is
+  // initialised from |strlen(data)|. This means it is not 8-bit clean, but this
+  // is not an issue for test data.
   const char* const data;
 };
 
 // For GoogleMock
-std::ostream& operator<<(std::ostream& os, const InitFrameChunk& chunk) {
-  os << "{";
-  if (chunk.header.final != NO_HEADER) {
-    os << "{" << (chunk.header.final == FINAL_FRAME ? "FINAL_FRAME"
-                                                    : "NOT_FINAL_FRAME") << ", "
-       << chunk.header.opcode << ", "
-       << (chunk.header.masked == MASKED ? "MASKED" : "NOT_MASKED") << ", "
-       << chunk.header.payload_length << "}";
-
-  } else {
-    os << "{NO_HEADER}";
+std::ostream& operator<<(std::ostream& os, const InitFrame& frame) {
+  os << "{" << (frame.final == FINAL_FRAME ? "FINAL_FRAME" : "NOT_FINAL_FRAME")
+     << ", " << frame.opcode << ", "
+     << (frame.masked == MASKED ? "MASKED" : "NOT_MASKED") << ", ";
+  if (frame.data) {
+    return os << "\"" << frame.data << "\"}";
   }
-  return os << ", " << (chunk.final_chunk == FINAL_CHUNK ? "FINAL_CHUNK"
-                                                         : "NOT_FINAL_CHUNK")
-            << ", \"" << chunk.data << "\"}";
+  return os << "NULL}";
 }
 
 template <size_t N>
-std::ostream& operator<<(std::ostream& os, const InitFrameChunk (&chunks)[N]) {
+std::ostream& operator<<(std::ostream& os, const InitFrame (&frames)[N]) {
   os << "{";
   bool first = true;
   for (size_t i = 0; i < N; ++i) {
@@ -269,119 +240,92 @@ std::ostream& operator<<(std::ostream& os, const InitFrameChunk (&chunks)[N]) {
     } else {
       first = false;
     }
-    os << chunks[i];
+    os << frames[i];
   }
   return os << "}";
 }
 
-// Convert a const array of InitFrameChunks to the format used at
+// Convert a const array of InitFrame structs to the format used at
 // runtime. Templated on the size of the array to save typing.
 template <size_t N>
-ScopedVector<WebSocketFrameChunk> CreateFrameChunkVector(
-    const InitFrameChunk (&source_chunks)[N]) {
-  ScopedVector<WebSocketFrameChunk> result_chunks;
-  result_chunks.reserve(N);
+ScopedVector<WebSocketFrame> CreateFrameVector(
+    const InitFrame (&source_frames)[N]) {
+  ScopedVector<WebSocketFrame> result_frames;
+  result_frames.reserve(N);
   for (size_t i = 0; i < N; ++i) {
-    scoped_ptr<WebSocketFrameChunk> result_chunk(new WebSocketFrameChunk);
-    size_t chunk_length =
-        source_chunks[i].data ? strlen(source_chunks[i].data) : 0;
-    if (source_chunks[i].header.final != NO_HEADER) {
-      const InitFrameChunk::FrameHeader& source_header =
-          source_chunks[i].header;
-      scoped_ptr<WebSocketFrameHeader> result_header(
-          new WebSocketFrameHeader(source_header.opcode));
-      result_header->final = (source_header.final == FINAL_FRAME);
-      result_header->masked = (source_header.masked == MASKED);
-      result_header->payload_length = source_header.payload_length;
-      DCHECK(chunk_length <= source_header.payload_length);
-      result_chunk->header.swap(result_header);
-    }
-    result_chunk->final_chunk = (source_chunks[i].final_chunk == FINAL_CHUNK);
-    if (source_chunks[i].data) {
-      result_chunk->data = new IOBufferWithSize(chunk_length);
-      memcpy(result_chunk->data->data(), source_chunks[i].data, chunk_length);
+    const InitFrame& source_frame = source_frames[i];
+    scoped_ptr<WebSocketFrame> result_frame(
+        new WebSocketFrame(source_frame.opcode));
+    size_t frame_length = source_frame.data ? strlen(source_frame.data) : 0;
+    WebSocketFrameHeader& result_header = result_frame->header;
+    result_header.final = (source_frame.final == FINAL_FRAME);
+    result_header.masked = (source_frame.masked == MASKED);
+    result_header.payload_length = frame_length;
+    if (source_frame.data) {
+      result_frame->data = new IOBuffer(frame_length);
+      memcpy(result_frame->data->data(), source_frame.data, frame_length);
     }
-    result_chunks.push_back(result_chunk.release());
+    result_frames.push_back(result_frame.release());
   }
-  return result_chunks.Pass();
+  return result_frames.Pass();
 }
 
 // A GoogleMock action which can be used to respond to call to ReadFrames with
-// some frames. Use like ReadFrames(_, _).WillOnce(ReturnChunks(&chunks));
-// |chunks| is an array of InitFrameChunks needs to be passed by pointer because
-// otherwise it will be reduced to a pointer and lose the array size
-// information.
-ACTION_P(ReturnChunks, source_chunks) {
-  *arg0 = CreateFrameChunkVector(*source_chunks);
+// some frames. Use like ReadFrames(_, _).WillOnce(ReturnFrames(&frames));
+// |frames| is an array of InitFrame. |frames| needs to be passed by pointer
+// because otherwise it will be treated as a pointer and the array size
+// information will be lost.
+ACTION_P(ReturnFrames, source_frames) {
+  *arg0 = CreateFrameVector(*source_frames);
   return OK;
 }
 
 // The implementation of a GoogleMock matcher which can be used to compare a
-// ScopedVector<WebSocketFrameChunk>* against an expectation defined as an array
-// of InitFrameChunks. Although it is possible to compose built-in GoogleMock
-// matchers to check the contents of a WebSocketFrameChunk, the results are so
+// ScopedVector<WebSocketFrame>* against an expectation defined as an array of
+// InitFrame objects. Although it is possible to compose built-in GoogleMock
+// matchers to check the contents of a WebSocketFrame, the results are so
 // unreadable that it is better to use this matcher.
 template <size_t N>
-class EqualsChunksMatcher
-    : public ::testing::MatcherInterface<ScopedVector<WebSocketFrameChunk>*> {
+class EqualsFramesMatcher
+    : public ::testing::MatcherInterface<ScopedVector<WebSocketFrame>*> {
  public:
-  EqualsChunksMatcher(const InitFrameChunk (*expect_chunks)[N])
-      : expect_chunks_(expect_chunks) {}
+  EqualsFramesMatcher(const InitFrame (*expect_frames)[N])
+      : expect_frames_(expect_frames) {}
 
-  virtual bool MatchAndExplain(ScopedVector<WebSocketFrameChunk>* actual_chunks,
+  virtual bool MatchAndExplain(ScopedVector<WebSocketFrame>* actual_frames,
                                ::testing::MatchResultListener* listener) const {
-    if (actual_chunks->size() != N) {
-      *listener << "the vector size is " << actual_chunks->size();
+    if (actual_frames->size() != N) {
+      *listener << "the vector size is " << actual_frames->size();
       return false;
     }
     for (size_t i = 0; i < N; ++i) {
-      const WebSocketFrameChunk& actual_chunk = *(*actual_chunks)[i];
-      const InitFrameChunk& expected_chunk = (*expect_chunks_)[i];
-      // Testing that the absence or presence of a header is the same for both.
-      if ((!actual_chunk.header) !=
-          (expected_chunk.header.final == NO_HEADER)) {
-        *listener << "the header is "
-                  << (actual_chunk.header ? "present" : "absent");
+      const WebSocketFrame& actual_frame = *(*actual_frames)[i];
+      const InitFrame& expected_frame = (*expect_frames_)[i];
+      if (actual_frame.header.final != (expected_frame.final == FINAL_FRAME)) {
+        *listener << "the frame is marked as "
+                  << (actual_frame.header.final ? "" : "not ") << "final";
         return false;
       }
-      if (actual_chunk.header) {
-        if (actual_chunk.header->final !=
-            (expected_chunk.header.final == FINAL_FRAME)) {
-          *listener << "the frame is marked as "
-                    << (actual_chunk.header->final ? "" : "not ") << "final";
-          return false;
-        }
-        if (actual_chunk.header->opcode != expected_chunk.header.opcode) {
-          *listener << "the opcode is " << actual_chunk.header->opcode;
-          return false;
-        }
-        if (actual_chunk.header->masked !=
-            (expected_chunk.header.masked == MASKED)) {
-          *listener << "the frame is "
-                    << (actual_chunk.header->masked ? "masked" : "not masked");
-          return false;
-        }
-        if (actual_chunk.header->payload_length !=
-            expected_chunk.header.payload_length) {
-          *listener << "the payload length is "
-                    << actual_chunk.header->payload_length;
-          return false;
-        }
+      if (actual_frame.header.opcode != expected_frame.opcode) {
+        *listener << "the opcode is " << actual_frame.header.opcode;
+        return false;
       }
-      if (actual_chunk.final_chunk !=
-          (expected_chunk.final_chunk == FINAL_CHUNK)) {
-        *listener << "the chunk is marked as "
-                  << (actual_chunk.final_chunk ? "" : "not ") << "final";
+      if (actual_frame.header.masked != (expected_frame.masked == MASKED)) {
+        *listener << "the frame is "
+                  << (actual_frame.header.masked ? "masked" : "not masked");
         return false;
       }
-      if (actual_chunk.data->size() !=
-          base::checked_numeric_cast<int>(strlen(expected_chunk.data))) {
-        *listener << "the data size is " << actual_chunk.data->size();
+      const size_t expected_length =
+          expected_frame.data ? strlen(expected_frame.data) : 0;
+      if (actual_frame.header.payload_length != expected_length) {
+        *listener << "the payload length is "
+                  << actual_frame.header.payload_length;
         return false;
       }
-      if (memcmp(actual_chunk.data->data(),
-                 expected_chunk.data,
-                 actual_chunk.data->size()) != 0) {
+      if (expected_length != 0 &&
+          memcmp(actual_frame.data->data(),
+                 expected_frame.data,
+                 actual_frame.header.payload_length) != 0) {
         *listener << "the data content differs";
         return false;
       }
@@ -390,23 +334,23 @@ class EqualsChunksMatcher
   }
 
   virtual void DescribeTo(std::ostream* os) const {
-    *os << "matches " << *expect_chunks_;
+    *os << "matches " << *expect_frames_;
   }
 
   virtual void DescribeNegationTo(std::ostream* os) const {
-    *os << "does not match " << *expect_chunks_;
+    *os << "does not match " << *expect_frames_;
   }
 
  private:
-  const InitFrameChunk (*expect_chunks_)[N];
+  const InitFrame (*expect_frames_)[N];
 };
 
-// The definition of EqualsChunks GoogleMock matcher. Unlike the ReturnChunks
+// The definition of EqualsFrames GoogleMock matcher. Unlike the ReturnFrames
 // action, this can take the array by reference.
 template <size_t N>
-::testing::Matcher<ScopedVector<WebSocketFrameChunk>*> EqualsChunks(
-    const InitFrameChunk (&chunks)[N]) {
-  return ::testing::MakeMatcher(new EqualsChunksMatcher<N>(&chunks));
+::testing::Matcher<ScopedVector<WebSocketFrame>*> EqualsFrames(
+    const InitFrame (&frames)[N]) {
+  return ::testing::MakeMatcher(new EqualsFramesMatcher<N>(&frames));
 }
 
 // A FakeWebSocketStream whose ReadFrames() function returns data.
@@ -427,39 +371,38 @@ class ReadableFakeWebSocketStream : public FakeWebSocketStream {
     CHECK(!read_frames_pending_);
   }
 
-  // Prepares a fake responses. Fake responses will be returned from
-  // ReadFrames() in the same order they were prepared with PrepareReadFrames()
-  // and PrepareReadFramesError(). If |async| is ASYNC, then ReadFrames() will
+  // Prepares a fake response. Fake responses will be returned from ReadFrames()
+  // in the same order they were prepared with PrepareReadFrames() and
+  // PrepareReadFramesError(). If |async| is ASYNC, then ReadFrames() will
   // return ERR_IO_PENDING and the callback will be scheduled to run on the
   // message loop. This requires the test case to run the message loop. If
   // |async| is SYNC, the response will be returned synchronously. |error| is
   // returned directly from ReadFrames() in the synchronous case, or passed to
-  // the callback in the asynchronous case. |chunks| will be converted to a
-  // ScopedVector<WebSocketFrameChunks> and copied to the pointer that was
-  // passed to ReadFrames().
+  // the callback in the asynchronous case. |frames| will be converted to a
+  // ScopedVector<WebSocketFrame> and copied to the pointer that was passed to
+  // ReadFrames().
   template <size_t N>
   void PrepareReadFrames(IsSync async,
                          int error,
-                         const InitFrameChunk (&chunks)[N]) {
-    responses_.push_back(
-        new Response(async, error, CreateFrameChunkVector(chunks)));
+                         const InitFrame (&frames)[N]) {
+    responses_.push_back(new Response(async, error, CreateFrameVector(frames)));
   }
 
   // An alternate version of PrepareReadFrames for when we need to construct
   // the frames manually.
   void PrepareRawReadFrames(IsSync async,
                             int error,
-                            ScopedVector<WebSocketFrameChunk> chunks) {
-    responses_.push_back(new Response(async, error, chunks.Pass()));
+                            ScopedVector<WebSocketFrame> frames) {
+    responses_.push_back(new Response(async, error, frames.Pass()));
   }
 
   // Prepares a fake error response (ie. there is no data).
   void PrepareReadFramesError(IsSync async, int error) {
     responses_.push_back(
-        new Response(async, error, ScopedVector<WebSocketFrameChunk>()));
+        new Response(async, error, ScopedVector<WebSocketFrame>()));
   }
 
-  virtual int ReadFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) OVERRIDE {
     CHECK(!read_frames_pending_);
     if (index_ >= responses_.size())
@@ -470,34 +413,34 @@ class ReadableFakeWebSocketStream : public FakeWebSocketStream {
           FROM_HERE,
           base::Bind(&ReadableFakeWebSocketStream::DoCallback,
                      base::Unretained(this),
-                     frame_chunks,
+                     frames,
                      callback));
       return ERR_IO_PENDING;
     } else {
-      frame_chunks->swap(responses_[index_]->chunks);
+      frames->swap(responses_[index_]->frames);
       return responses_[index_++]->error;
     }
   }
 
  private:
-  void DoCallback(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  void DoCallback(ScopedVector<WebSocketFrame>* frames,
                   const CompletionCallback& callback) {
     read_frames_pending_ = false;
-    frame_chunks->swap(responses_[index_]->chunks);
+    frames->swap(responses_[index_]->frames);
     callback.Run(responses_[index_++]->error);
     return;
   }
 
   struct Response {
-    Response(IsSync async, int error, ScopedVector<WebSocketFrameChunk> chunks)
-        : async(async), error(error), chunks(chunks.Pass()) {}
+    Response(IsSync async, int error, ScopedVector<WebSocketFrame> frames)
+        : async(async), error(error), frames(frames.Pass()) {}
 
     IsSync async;
     int error;
-    ScopedVector<WebSocketFrameChunk> chunks;
+    ScopedVector<WebSocketFrame> frames;
 
    private:
-    // Bad things will happen if we attempt to copy or assign "chunks".
+    // Bad things will happen if we attempt to copy or assign |frames|.
     DISALLOW_COPY_AND_ASSIGN(Response);
   };
   ScopedVector<Response> responses_;
@@ -516,7 +459,7 @@ class ReadableFakeWebSocketStream : public FakeWebSocketStream {
 // synchronously.
 class WriteableFakeWebSocketStream : public FakeWebSocketStream {
  public:
-  virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) OVERRIDE {
     return OK;
   }
@@ -525,7 +468,7 @@ class WriteableFakeWebSocketStream : public FakeWebSocketStream {
 // A FakeWebSocketStream where writes always fail.
 class UnWriteableFakeWebSocketStream : public FakeWebSocketStream {
  public:
-  virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) OVERRIDE {
     return ERR_CONNECTION_RESET;
   }
@@ -539,23 +482,22 @@ class UnWriteableFakeWebSocketStream : public FakeWebSocketStream {
 // otherwise the ReadFrames() callback will never be called.
 class EchoeyFakeWebSocketStream : public FakeWebSocketStream {
  public:
-  EchoeyFakeWebSocketStream() : read_frame_chunks_(NULL), done_(false) {}
+  EchoeyFakeWebSocketStream() : read_frames_(NULL), done_(false) {}
 
-  virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) OVERRIDE {
     // Users of WebSocketStream will not expect the ReadFrames() callback to be
     // called from within WriteFrames(), so post it to the message loop instead.
-    stored_frame_chunks_.insert(
-        stored_frame_chunks_.end(), frame_chunks->begin(), frame_chunks->end());
-    frame_chunks->weak_clear();
+    stored_frames_.insert(stored_frames_.end(), frames->begin(), frames->end());
+    frames->weak_clear();
     PostCallback();
     return OK;
   }
 
-  virtual int ReadFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) OVERRIDE {
     read_callback_ = callback;
-    read_frame_chunks_ = frame_chunks;
+    read_frames_ = frames;
     if (done_)
       PostCallback();
     return ERR_IO_PENDING;
@@ -572,36 +514,34 @@ class EchoeyFakeWebSocketStream : public FakeWebSocketStream {
   void DoCallback() {
     if (done_) {
       read_callback_.Run(ERR_CONNECTION_CLOSED);
-    } else if (!stored_frame_chunks_.empty()) {
-      done_ = MoveFrameChunks(read_frame_chunks_);
-      read_frame_chunks_ = NULL;
+    } else if (!stored_frames_.empty()) {
+      done_ = MoveFrames(read_frames_);
+      read_frames_ = NULL;
       read_callback_.Run(OK);
     }
   }
 
-  // Copy the chunks stored in stored_frame_chunks_ to |out|, while clearing the
+  // Copy the frames stored in stored_frames_ to |out|, while clearing the
   // "masked" header bit. Returns true if a Close Frame was seen, false
   // otherwise.
-  bool MoveFrameChunks(ScopedVector<WebSocketFrameChunk>* out) {
+  bool MoveFrames(ScopedVector<WebSocketFrame>* out) {
     bool seen_close = false;
-    *out = stored_frame_chunks_.Pass();
-    for (ScopedVector<WebSocketFrameChunk>::iterator it = out->begin();
+    *out = stored_frames_.Pass();
+    for (ScopedVector<WebSocketFrame>::iterator it = out->begin();
          it != out->end();
          ++it) {
-      WebSocketFrameHeader* header = (*it)->header.get();
-      if (header) {
-        header->masked = false;
-        if (header->opcode == WebSocketFrameHeader::kOpCodeClose)
-          seen_close = true;
-      }
+      WebSocketFrameHeader& header = (*it)->header;
+      header.masked = false;
+      if (header.opcode == WebSocketFrameHeader::kOpCodeClose)
+        seen_close = true;
     }
     return seen_close;
   }
 
-  ScopedVector<WebSocketFrameChunk> stored_frame_chunks_;
+  ScopedVector<WebSocketFrame> stored_frames_;
   CompletionCallback read_callback_;
   // Owned by the caller of ReadFrames().
-  ScopedVector<WebSocketFrameChunk>* read_frame_chunks_;
+  ScopedVector<WebSocketFrame>* read_frames_;
   // True if we should close the connection.
   bool done_;
 };
@@ -612,7 +552,7 @@ class EchoeyFakeWebSocketStream : public FakeWebSocketStream {
 // run the message loop.
 class ResetOnWriteFakeWebSocketStream : public FakeWebSocketStream {
  public:
-  virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) OVERRIDE {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERR_CONNECTION_RESET));
@@ -621,7 +561,7 @@ class ResetOnWriteFakeWebSocketStream : public FakeWebSocketStream {
     return ERR_IO_PENDING;
   }
 
-  virtual int ReadFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) OVERRIDE {
     read_callback_ = callback;
     return ERR_IO_PENDING;
@@ -636,10 +576,10 @@ class ResetOnWriteFakeWebSocketStream : public FakeWebSocketStream {
 class MockWebSocketStream : public WebSocketStream {
  public:
   MOCK_METHOD2(ReadFrames,
-               int(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+               int(ScopedVector<WebSocketFrame>* frames,
                    const CompletionCallback& callback));
   MOCK_METHOD2(WriteFrames,
-               int(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+               int(ScopedVector<WebSocketFrame>* frames,
                    const CompletionCallback& callback));
   MOCK_METHOD0(Close, void());
   MOCK_CONST_METHOD0(GetSubProtocol, std::string());
@@ -846,8 +786,8 @@ TEST_F(WebSocketChannelTest, EverythingIsPassedToTheFactoryFunction) {
 // AddressSanitizer.
 TEST_F(WebSocketChannelDeletingTest, DeletingFromOnAddChannelResponseWorks) {
   CreateChannelAndConnect();
-  connect_data_.factory.connect_delegate
-      ->OnFailure(kWebSocketErrorNoStatusReceived);
+  connect_data_.factory.connect_delegate->OnFailure(
+      kWebSocketErrorNoStatusReceived);
   EXPECT_EQ(NULL, channel_.get());
 }
 
@@ -869,8 +809,8 @@ TEST_F(WebSocketChannelEventInterfaceTest, ConnectFailureReported) {
 
   CreateChannelAndConnect();
 
-  connect_data_.factory.connect_delegate
-      ->OnFailure(kWebSocketErrorNoStatusReceived);
+  connect_data_.factory.connect_delegate->OnFailure(
+      kWebSocketErrorNoStatusReceived);
 }
 
 TEST_F(WebSocketChannelEventInterfaceTest, ProtocolPassed) {
@@ -889,10 +829,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, ProtocolPassed) {
 TEST_F(WebSocketChannelEventInterfaceTest, DataLeftFromHandshake) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, 5},
-       FINAL_CHUNK, "HELLO"}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, chunks);
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "HELLO"}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -912,10 +851,10 @@ TEST_F(WebSocketChannelEventInterfaceTest, DataLeftFromHandshake) {
 TEST_F(WebSocketChannelEventInterfaceTest, CloseAfterHandshake) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, 23},
-       FINAL_CHUNK, CLOSE_DATA(SERVER_ERROR, "Internal Server Error")}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, chunks);
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       NOT_MASKED,  CLOSE_DATA(SERVER_ERROR, "Internal Server Error")}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   stream->PrepareReadFramesError(ReadableFakeWebSocketStream::SYNC,
                                  ERR_CONNECTION_CLOSED);
   set_stream(stream.Pass());
@@ -954,13 +893,12 @@ TEST_F(WebSocketChannelEventInterfaceTest, ConnectionCloseAfterHandshake) {
 TEST_F(WebSocketChannelEventInterfaceTest, NormalAsyncRead) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, 5},
-       FINAL_CHUNK, "HELLO"}};
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "HELLO"}};
   // We use this checkpoint object to verify that the callback isn't called
   // until we expect it to be.
   MockFunction<void(int)> checkpoint;
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -985,14 +923,12 @@ TEST_F(WebSocketChannelEventInterfaceTest, NormalAsyncRead) {
 TEST_F(WebSocketChannelEventInterfaceTest, AsyncThenSyncRead) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks1[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, 5},
-       FINAL_CHUNK, "HELLO"}};
-  static const InitFrameChunk chunks2[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, 5},
-       FINAL_CHUNK, "WORLD"}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks1);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, chunks2);
+  static const InitFrame frames1[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "HELLO"}};
+  static const InitFrame frames2[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "WORLD"}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames1);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames2);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -1012,31 +948,29 @@ TEST_F(WebSocketChannelEventInterfaceTest, AsyncThenSyncRead) {
   base::MessageLoop::current()->RunUntilIdle();
 }
 
-// Data frames that arrive in fragments are turned into individual frames
-TEST_F(WebSocketChannelEventInterfaceTest, FragmentedFrames) {
+// Data frames are delivered the same regardless of how many reads they arrive
+// as.
+TEST_F(WebSocketChannelEventInterfaceTest, FragmentedMessage) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  // Here we have one message split into 3 frames which arrive in 3 chunks. The
-  // first frame is entirely in the first chunk, the second frame is split
-  // across all the chunks, and the final frame is entirely in the final
-  // chunk. The frame fragments are converted to separate frames so that they
-  // can be delivered immediatedly. So the EventInterface should see a Text
-  // message with 5 frames.
-  static const InitFrameChunk chunks1[] = {
-      {{NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, 5},
-       FINAL_CHUNK, "THREE"},
-      {{NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
-        7},
-       NOT_FINAL_CHUNK, " "}};
-  static const InitFrameChunk chunks2[] = {
-      {{NO_HEADER}, NOT_FINAL_CHUNK, "SMALL"}};
-  static const InitFrameChunk chunks3[] = {
-      {{NO_HEADER}, FINAL_CHUNK, " "},
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED, 6},
-       FINAL_CHUNK, "FRAMES"}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks1);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks2);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks3);
+  // Here we have one message which arrived in five frames split across three
+  // reads. It may have been reframed on arrival, but this class doesn't care
+  // about that.
+  static const InitFrame frames1[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "THREE"},
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
+       NOT_MASKED,      " "}};
+  static const InitFrame frames2[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
+       NOT_MASKED,      "SMALL"}};
+  static const InitFrame frames3[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
+       NOT_MASKED,      " "},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
+       NOT_MASKED,  "FRAMES"}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames1);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames2);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames3);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -1068,112 +1002,16 @@ TEST_F(WebSocketChannelEventInterfaceTest, FragmentedFrames) {
   base::MessageLoop::current()->RunUntilIdle();
 }
 
-// In the case when a single-frame message because fragmented, it must be
-// correctly transformed to multiple frames.
-TEST_F(WebSocketChannelEventInterfaceTest, MessageFragmentation) {
-  scoped_ptr<ReadableFakeWebSocketStream> stream(
-      new ReadableFakeWebSocketStream);
-  // A single-frame Text message arrives in three chunks. This should be
-  // delivered as three frames.
-  static const InitFrameChunk chunks1[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, 12},
-       NOT_FINAL_CHUNK, "TIME"}};
-  static const InitFrameChunk chunks2[] = {
-      {{NO_HEADER}, NOT_FINAL_CHUNK, " FOR "}};
-  static const InitFrameChunk chunks3[] = {{{NO_HEADER}, FINAL_CHUNK, "TEA"}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks1);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks2);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks3);
-  set_stream(stream.Pass());
-  {
-    InSequence s;
-    EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
-    EXPECT_CALL(*event_interface_, OnFlowControl(_));
-    EXPECT_CALL(
-        *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeText, AsVector("TIME")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector(" FOR ")));
-    EXPECT_CALL(
-        *event_interface_,
-        OnDataFrame(
-            true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("TEA")));
-  }
-
-  CreateChannelAndConnectSuccessfully();
-  base::MessageLoop::current()->RunUntilIdle();
-}
-
-// If a control message is fragmented, it must be re-assembled before being
-// delivered. A control message can only be fragmented at the network level; it
-// is not permitted to be split into multiple frames.
-TEST_F(WebSocketChannelEventInterfaceTest, FragmentedControlMessage) {
-  scoped_ptr<ReadableFakeWebSocketStream> stream(
-      new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks1[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, 7},
-       NOT_FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "")}};
-  static const InitFrameChunk chunks2[] = {
-      {{NO_HEADER}, NOT_FINAL_CHUNK, "Clo"}};
-  static const InitFrameChunk chunks3[] = {{{NO_HEADER}, FINAL_CHUNK, "se"}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks1);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks2);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks3);
-  stream->PrepareReadFramesError(ReadableFakeWebSocketStream::ASYNC,
-                                 ERR_CONNECTION_CLOSED);
-  set_stream(stream.Pass());
-  {
-    InSequence s;
-    EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
-    EXPECT_CALL(*event_interface_, OnFlowControl(_));
-    EXPECT_CALL(*event_interface_, OnClosingHandshake());
-    EXPECT_CALL(*event_interface_,
-                OnDropChannel(kWebSocketNormalClosure, "Close"));
-  }
-
-  CreateChannelAndConnectSuccessfully();
-  base::MessageLoop::current()->RunUntilIdle();
-}
-
-// The payload of a control frame is not permitted to exceed 125 bytes.  RFC6455
-// 5.5 "All control frames MUST have a payload length of 125 bytes or less"
-TEST_F(WebSocketChannelEventInterfaceTest, OversizeControlMessageIsRejected) {
-  scoped_ptr<ReadableFakeWebSocketStream> stream(
-      new ReadableFakeWebSocketStream);
-  static const size_t kPayloadLen = 126;
-  char payload[kPayloadLen + 1];  // allow space for trailing NUL
-  std::fill(payload, payload + kPayloadLen, 'A');
-  payload[kPayloadLen] = '\0';
-  // Not static because "payload" is constructed at runtime.
-  const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodePing, NOT_MASKED,
-        kPayloadLen},
-       FINAL_CHUNK, payload}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, chunks);
-  set_stream(stream.Pass());
-
-  EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
-  EXPECT_CALL(*event_interface_, OnFlowControl(_));
-  EXPECT_CALL(*event_interface_,
-              OnDropChannel(kWebSocketErrorProtocolError, _));
-
-  CreateChannelAndConnectSuccessfully();
-}
-
 // A control frame is not permitted to be split into multiple frames. RFC6455
 // 5.5 "All control frames ... MUST NOT be fragmented."
 TEST_F(WebSocketChannelEventInterfaceTest, MultiFrameControlMessageIsRejected) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodePing, NOT_MASKED, 2},
-       FINAL_CHUNK, "Pi"},
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED, 2},
-       FINAL_CHUNK, "ng"}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks);
+  static const InitFrame frames[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodePing, NOT_MASKED, "Pi"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
+       NOT_MASKED,  "ng"}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -1225,39 +1063,14 @@ TEST_F(WebSocketChannelEventInterfaceTest, ConnectionReset) {
   base::MessageLoop::current()->RunUntilIdle();
 }
 
-// Connection closed in the middle of a Close message (server bug, etc.)
-TEST_F(WebSocketChannelEventInterfaceTest, ConnectionClosedInMessage) {
-  scoped_ptr<ReadableFakeWebSocketStream> stream(
-      new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, 7},
-       NOT_FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "")}};
-
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks);
-  stream->PrepareReadFramesError(ReadableFakeWebSocketStream::ASYNC,
-                                 ERR_CONNECTION_CLOSED);
-  set_stream(stream.Pass());
-  {
-    InSequence s;
-    EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
-    EXPECT_CALL(*event_interface_, OnFlowControl(_));
-    EXPECT_CALL(*event_interface_,
-                OnDropChannel(kWebSocketErrorAbnormalClosure, _));
-  }
-
-  CreateChannelAndConnectSuccessfully();
-  base::MessageLoop::current()->RunUntilIdle();
-}
-
 // RFC6455 5.1 "A client MUST close a connection if it detects a masked frame."
 TEST_F(WebSocketChannelEventInterfaceTest, MaskedFramesAreRejected) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 5}, FINAL_CHUNK,
-       "HELLO"}};
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "HELLO"}};
 
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -1276,10 +1089,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, MaskedFramesAreRejected) {
 TEST_F(WebSocketChannelEventInterfaceTest, UnknownOpCodeIsRejected) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, 4, NOT_MASKED, 5}, FINAL_CHUNK, "HELLO"}};
+  static const InitFrame frames[] = {{FINAL_FRAME, 4, NOT_MASKED, "HELLO"}};
 
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -1300,18 +1112,17 @@ TEST_F(WebSocketChannelEventInterfaceTest, ControlFrameInDataMessage) {
       new ReadableFakeWebSocketStream);
   // We have one message of type Text split into two frames. In the middle is a
   // control message of type Pong.
-  static const InitFrameChunk chunks1[] = {
-      {{NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, 6},
-       FINAL_CHUNK, "SPLIT "}};
-  static const InitFrameChunk chunks2[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodePong, NOT_MASKED, 0},
-       FINAL_CHUNK, ""}};
-  static const InitFrameChunk chunks3[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED, 7},
-       FINAL_CHUNK, "MESSAGE"}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks1);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks2);
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks3);
+  static const InitFrame frames1[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
+       NOT_MASKED,      "SPLIT "}};
+  static const InitFrame frames2[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePong, NOT_MASKED, ""}};
+  static const InitFrame frames3[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
+       NOT_MASKED,  "MESSAGE"}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames1);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames2);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames3);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -1331,17 +1142,16 @@ TEST_F(WebSocketChannelEventInterfaceTest, ControlFrameInDataMessage) {
   base::MessageLoop::current()->RunUntilIdle();
 }
 
-// If a chunk has an invalid header, then the connection is closed and
-// subsequent chunks must not trigger events.
-TEST_F(WebSocketChannelEventInterfaceTest, HeaderlessChunkAfterInvalidChunk) {
+// If a frame has an invalid header, then the connection is closed and
+// subsequent frames must not trigger events.
+TEST_F(WebSocketChannelEventInterfaceTest, FrameAfterInvalidFrame) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 11},
-       NOT_FINAL_CHUNK, "HELLO"},
-      {{NO_HEADER}, FINAL_CHUNK, " WORLD"}};
+  static const InitFrame frames[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "HELLO"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, " WORLD"}};
 
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, chunks);
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
@@ -1501,10 +1311,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, OnDropChannelCalledOnce) {
 TEST_F(WebSocketChannelEventInterfaceTest, CloseWithNoPayloadGivesStatus1005) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, 0},
-       FINAL_CHUNK, ""}};
-  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, chunks);
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, ""}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   stream->PrepareReadFramesError(ReadableFakeWebSocketStream::SYNC,
                                  ERR_CONNECTION_CLOSED);
   set_stream(stream.Pass());
@@ -1517,16 +1326,50 @@ TEST_F(WebSocketChannelEventInterfaceTest, CloseWithNoPayloadGivesStatus1005) {
   CreateChannelAndConnectSuccessfully();
 }
 
+// If ReadFrames() returns ERR_WS_PROTOCOL_ERROR, then
+// kWebSocketErrorProtocolError must be sent to the renderer.
+TEST_F(WebSocketChannelEventInterfaceTest, SyncProtocolErrorGivesStatus1002) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  stream->PrepareReadFramesError(ReadableFakeWebSocketStream::SYNC,
+                                 ERR_WS_PROTOCOL_ERROR);
+  set_stream(stream.Pass());
+  EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
+  EXPECT_CALL(*event_interface_, OnFlowControl(_));
+
+  EXPECT_CALL(*event_interface_,
+              OnDropChannel(kWebSocketErrorProtocolError, _));
+
+  CreateChannelAndConnectSuccessfully();
+}
+
+// Async version of above test.
+TEST_F(WebSocketChannelEventInterfaceTest, AsyncProtocolErrorGivesStatus1002) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  stream->PrepareReadFramesError(ReadableFakeWebSocketStream::ASYNC,
+                                 ERR_WS_PROTOCOL_ERROR);
+  set_stream(stream.Pass());
+  EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
+  EXPECT_CALL(*event_interface_, OnFlowControl(_));
+
+  EXPECT_CALL(*event_interface_,
+              OnDropChannel(kWebSocketErrorProtocolError, _));
+
+  CreateChannelAndConnectSuccessfully();
+  base::MessageLoop::current()->RunUntilIdle();
+}
+
 // RFC6455 5.1 "a client MUST mask all frames that it sends to the server".
 // WebSocketChannel actually only sets the mask bit in the header, it doesn't
 // perform masking itself (not all transports actually use masking).
 TEST_F(WebSocketChannelStreamTest, SentFramesAreMasked) {
-  static const InitFrameChunk expected[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 13},
-       FINAL_CHUNK, "NEEDS MASKING"}};
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
+       MASKED,      "NEEDS MASKING"}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
-  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected), _))
+  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
@@ -1537,12 +1380,12 @@ TEST_F(WebSocketChannelStreamTest, SentFramesAreMasked) {
 // RFC6455 5.5.1 "The application MUST NOT send any more data frames after
 // sending a Close frame."
 TEST_F(WebSocketChannelStreamTest, NothingIsSentAfterClose) {
-  static const InitFrameChunk expected[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED, 9},
-       FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
-  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected), _))
+  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
@@ -1554,17 +1397,17 @@ TEST_F(WebSocketChannelStreamTest, NothingIsSentAfterClose) {
 // RFC6455 5.5.1 "If an endpoint receives a Close frame and did not previously
 // send a Close frame, the endpoint MUST send a Close frame in response."
 TEST_F(WebSocketChannelStreamTest, CloseIsEchoedBack) {
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, 7},
-       FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
-  static const InitFrameChunk expected[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED, 7},
-       FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-      .WillOnce(ReturnChunks(&chunks))
+      .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
-  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected), _))
+  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
@@ -1573,17 +1416,17 @@ TEST_F(WebSocketChannelStreamTest, CloseIsEchoedBack) {
 // The converse of the above case; after sending a Close frame, we should not
 // send another one.
 TEST_F(WebSocketChannelStreamTest, CloseOnlySentOnce) {
-  static const InitFrameChunk expected[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED, 7},
-       FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, 7},
-       FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
+  static const InitFrame frames_init[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
 
   // We store the parameters that were passed to ReadFrames() so that we can
   // call them explicitly later.
   CompletionCallback read_callback;
-  ScopedVector<WebSocketFrameChunk>* frame_chunks = NULL;
+  ScopedVector<WebSocketFrame>* frames = NULL;
 
   // Use a checkpoint to make the ordering of events clearer.
   MockFunction<void(int)> checkpoint;
@@ -1591,11 +1434,11 @@ TEST_F(WebSocketChannelStreamTest, CloseOnlySentOnce) {
     InSequence s;
     EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-        .WillOnce(DoAll(SaveArg<0>(&frame_chunks),
+        .WillOnce(DoAll(SaveArg<0>(&frames),
                         SaveArg<1>(&read_callback),
                         Return(ERR_IO_PENDING)));
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
         .WillOnce(Return(OK));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
@@ -1610,7 +1453,7 @@ TEST_F(WebSocketChannelStreamTest, CloseOnlySentOnce) {
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "Close");
   checkpoint.Call(2);
 
-  *frame_chunks = CreateFrameChunkVector(chunks);
+  *frames = CreateFrameVector(frames_init);
   read_callback.Run(OK);
   checkpoint.Call(3);
 }
@@ -1621,17 +1464,15 @@ TEST_F(WebSocketChannelStreamTest, CloseOnlySentOnce) {
 // CloseWithNoPayloadGivesStatus1005, above, for confirmation that code 1005 is
 // correctly generated internally.
 TEST_F(WebSocketChannelStreamTest, Code1005IsNotEchoed) {
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, 0},
-       FINAL_CHUNK, ""}};
-  static const InitFrameChunk expected[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED, 0},
-       FINAL_CHUNK, ""}};
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, ""}};
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED, ""}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-      .WillOnce(ReturnChunks(&chunks))
+      .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
-  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected), _))
+  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
@@ -1643,58 +1484,57 @@ TEST_F(WebSocketChannelStreamTest, Code1005IsNotEchoed) {
 // "Application data" as found in the message body of the Ping frame being
 // replied to."
 TEST_F(WebSocketChannelStreamTest, PingRepliedWithPong) {
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodePing, NOT_MASKED, 16},
-       FINAL_CHUNK, "Application data"}};
-  static const InitFrameChunk expected[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodePong, MASKED, 16},
-       FINAL_CHUNK, "Application data"}};
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePing,
+       NOT_MASKED,  "Application data"}};
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePong,
+       MASKED,      "Application data"}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-      .WillOnce(ReturnChunks(&chunks))
+      .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
-  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected), _))
+  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 TEST_F(WebSocketChannelStreamTest, PongInTheMiddleOfDataMessage) {
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodePing, NOT_MASKED, 16},
-       FINAL_CHUNK, "Application data"}};
-  static const InitFrameChunk expected1[] = {
-      {{NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 6},
-       FINAL_CHUNK, "Hello "}};
-  static const InitFrameChunk expected2[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodePong, MASKED, 16},
-       FINAL_CHUNK, "Application data"}};
-  static const InitFrameChunk expected3[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, MASKED, 5},
-       FINAL_CHUNK, "World"}};
-  ScopedVector<WebSocketFrameChunk>* read_chunks;
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePing,
+       NOT_MASKED,  "Application data"}};
+  static const InitFrame expected1[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "Hello "}};
+  static const InitFrame expected2[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePong,
+       MASKED,      "Application data"}};
+  static const InitFrame expected3[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
+       MASKED,      "World"}};
+  ScopedVector<WebSocketFrame>* read_frames;
   CompletionCallback read_callback;
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-      .WillOnce(DoAll(SaveArg<0>(&read_chunks),
+      .WillOnce(DoAll(SaveArg<0>(&read_frames),
                       SaveArg<1>(&read_callback),
                       Return(ERR_IO_PENDING)))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   {
     InSequence s;
 
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected1), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected1), _))
         .WillOnce(Return(OK));
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected2), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected2), _))
         .WillOnce(Return(OK));
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected3), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected3), _))
         .WillOnce(Return(OK));
   }
 
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(
       false, WebSocketFrameHeader::kOpCodeText, AsVector("Hello "));
-  *read_chunks = CreateFrameChunkVector(chunks);
+  *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   channel_->SendFrame(
       true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("World"));
@@ -1703,12 +1543,10 @@ TEST_F(WebSocketChannelStreamTest, PongInTheMiddleOfDataMessage) {
 // WriteFrames() may not be called until the previous write has completed.
 // WebSocketChannel must buffer writes that happen in the meantime.
 TEST_F(WebSocketChannelStreamTest, WriteFramesOneAtATime) {
-  static const InitFrameChunk expected1[] = {
-      {{NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 6},
-       FINAL_CHUNK, "Hello "}};
-  static const InitFrameChunk expected2[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 5}, FINAL_CHUNK,
-       "World"}};
+  static const InitFrame expected1[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "Hello "}};
+  static const InitFrame expected2[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "World"}};
   CompletionCallback write_callback;
   MockFunction<void(int)> checkpoint;
 
@@ -1717,10 +1555,10 @@ TEST_F(WebSocketChannelStreamTest, WriteFramesOneAtATime) {
   {
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected1), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected1), _))
         .WillOnce(DoAll(SaveArg<1>(&write_callback), Return(ERR_IO_PENDING)));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected2), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected2), _))
         .WillOnce(Return(ERR_IO_PENDING));
     EXPECT_CALL(checkpoint, Call(3));
   }
@@ -1741,27 +1579,22 @@ TEST_F(WebSocketChannelStreamTest, WriteFramesOneAtATime) {
 // important to get good throughput in the "many small messages" case.
 TEST_F(WebSocketChannelStreamTest, WaitingMessagesAreBatched) {
   static const char input_letters[] = "Hello";
-  static const InitFrameChunk expected1[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 1}, FINAL_CHUNK,
-       "H"}};
-  static const InitFrameChunk expected2[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 1}, FINAL_CHUNK,
-       "e"},
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 1}, FINAL_CHUNK,
-       "l"},
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 1}, FINAL_CHUNK,
-       "l"},
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, 1}, FINAL_CHUNK,
-       "o"}};
+  static const InitFrame expected1[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "H"}};
+  static const InitFrame expected2[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "e"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "l"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "l"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "o"}};
   CompletionCallback write_callback;
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
   {
     InSequence s;
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected1), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected1), _))
         .WillOnce(DoAll(SaveArg<1>(&write_callback), Return(ERR_IO_PENDING)));
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected2), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected2), _))
         .WillOnce(Return(ERR_IO_PENDING));
   }
 
@@ -1781,12 +1614,12 @@ TEST_F(WebSocketChannelStreamTest, WaitingMessagesAreBatched) {
 // even be using a different extension which uses that code to mean something
 // else.
 TEST_F(WebSocketChannelStreamTest, MuxErrorIsNotSentToStream) {
-  static const InitFrameChunk expected[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED, 16},
-       FINAL_CHUNK, CLOSE_DATA(GOING_AWAY, "Internal Error")}};
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       MASKED,      CLOSE_DATA(GOING_AWAY, "Internal Error")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
-  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected), _))
+  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
   EXPECT_CALL(*mock_stream_, Close());
 
@@ -1800,45 +1633,41 @@ TEST_F(WebSocketChannelStreamTest, MuxErrorIsNotSentToStream) {
 // protocol also has Binary frames and those need to be 8-bit clean. For the
 // sake of completeness, this test verifies that they are.
 TEST_F(WebSocketChannelStreamTest, WrittenBinaryFramesAre8BitClean) {
-  ScopedVector<WebSocketFrameChunk>* frame_chunks = NULL;
+  ScopedVector<WebSocketFrame>* frames = NULL;
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
-      .WillOnce(DoAll(SaveArg<0>(&frame_chunks), Return(ERR_IO_PENDING)));
+      .WillOnce(DoAll(SaveArg<0>(&frames), Return(ERR_IO_PENDING)));
 
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(
       true,
       WebSocketFrameHeader::kOpCodeBinary,
       std::vector<char>(kBinaryBlob, kBinaryBlob + kBinaryBlobSize));
-  ASSERT_TRUE(frame_chunks != NULL);
-  ASSERT_EQ(1U, frame_chunks->size());
-  const WebSocketFrameChunk* out_chunk = (*frame_chunks)[0];
-  ASSERT_TRUE(out_chunk->header);
-  EXPECT_EQ(kBinaryBlobSize, out_chunk->header->payload_length);
-  ASSERT_TRUE(out_chunk->data);
-  EXPECT_EQ(kBinaryBlobSize, static_cast<size_t>(out_chunk->data->size()));
-  EXPECT_EQ(0, memcmp(kBinaryBlob, out_chunk->data->data(), kBinaryBlobSize));
+  ASSERT_TRUE(frames != NULL);
+  ASSERT_EQ(1U, frames->size());
+  const WebSocketFrame* out_frame = (*frames)[0];
+  EXPECT_EQ(kBinaryBlobSize, out_frame->header.payload_length);
+  ASSERT_TRUE(out_frame->data);
+  EXPECT_EQ(0, memcmp(kBinaryBlob, out_frame->data->data(), kBinaryBlobSize));
 }
 
 // Test the read path for 8-bit cleanliness as well.
 TEST_F(WebSocketChannelEventInterfaceTest, ReadBinaryFramesAre8BitClean) {
-  scoped_ptr<WebSocketFrameHeader> frame_header(
-      new WebSocketFrameHeader(WebSocketFrameHeader::kOpCodeBinary));
-  frame_header->final = true;
-  frame_header->payload_length = kBinaryBlobSize;
-  scoped_ptr<WebSocketFrameChunk> frame_chunk(new WebSocketFrameChunk);
-  frame_chunk->header = frame_header.Pass();
-  frame_chunk->final_chunk = true;
-  frame_chunk->data = new IOBufferWithSize(kBinaryBlobSize);
-  memcpy(frame_chunk->data->data(), kBinaryBlob, kBinaryBlobSize);
-  ScopedVector<WebSocketFrameChunk> chunks;
-  chunks.push_back(frame_chunk.release());
+  scoped_ptr<WebSocketFrame> frame(
+      new WebSocketFrame(WebSocketFrameHeader::kOpCodeBinary));
+  WebSocketFrameHeader& frame_header = frame->header;
+  frame_header.final = true;
+  frame_header.payload_length = kBinaryBlobSize;
+  frame->data = new IOBuffer(kBinaryBlobSize);
+  memcpy(frame->data->data(), kBinaryBlob, kBinaryBlobSize);
+  ScopedVector<WebSocketFrame> frames;
+  frames.push_back(frame.release());
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   stream->PrepareRawReadFrames(
-      ReadableFakeWebSocketStream::SYNC, OK, chunks.Pass());
+      ReadableFakeWebSocketStream::SYNC, OK, frames.Pass());
   set_stream(stream.Pass());
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
@@ -1856,17 +1685,17 @@ TEST_F(WebSocketChannelEventInterfaceTest, ReadBinaryFramesAre8BitClean) {
 // but the current implementation fails the connection. Since a Close has
 // already been sent, this just means closing the connection.
 TEST_F(WebSocketChannelStreamTest, PingAfterCloseIsRejected) {
-  static const InitFrameChunk chunks[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, 4},
-       FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "OK")},
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodePing, NOT_MASKED, 9},
-       FINAL_CHUNK, "Ping body"}};
-  static const InitFrameChunk expected[] = {
-      {{FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED, 4},
-       FINAL_CHUNK, CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "OK")},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePing,
+       NOT_MASKED,  "Ping body"}};
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-      .WillOnce(ReturnChunks(&chunks))
+      .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   {
     // We only need to verify the relative order of WriteFrames() and
@@ -1874,7 +1703,7 @@ TEST_F(WebSocketChannelStreamTest, PingAfterCloseIsRejected) {
     // frame before calling ReadFrames() again, but that is an implementation
     // detail and better not to consider required behaviour.
     InSequence s;
-    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsChunks(expected), _))
+    EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
         .WillOnce(Return(OK));
     EXPECT_CALL(*mock_stream_, Close()).Times(1);
   }
@@ -1882,5 +1711,21 @@ TEST_F(WebSocketChannelStreamTest, PingAfterCloseIsRejected) {
   CreateChannelAndConnectSuccessfully();
 }
 
+// A protocol error from the remote server should result in a close frame with
+// status 1002, followed by the connection closing.
+TEST_F(WebSocketChannelStreamTest, ProtocolError) {
+  static const InitFrame expected[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       MASKED,      CLOSE_DATA(PROTOCOL_ERROR, "WebSocket Protocol Error")}};
+  EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
+  EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
+      .WillOnce(Return(ERR_WS_PROTOCOL_ERROR));
+  EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
+      .WillOnce(Return(OK));
+  EXPECT_CALL(*mock_stream_, Close());
+
+  CreateChannelAndConnectSuccessfully();
+}
+
 }  // namespace
 }  // namespace net
diff --git a/net/websockets/websocket_frame.cc b/net/websockets/websocket_frame.cc
index f05b5b7..763712a 100644
--- a/net/websockets/websocket_frame.cc
+++ b/net/websockets/websocket_frame.cc
@@ -41,18 +41,27 @@ inline void MaskWebSocketFramePayloadByBytes(
 
 namespace net {
 
-scoped_ptr<WebSocketFrameHeader> WebSocketFrameHeader::Clone() {
+scoped_ptr<WebSocketFrameHeader> WebSocketFrameHeader::Clone() const {
   scoped_ptr<WebSocketFrameHeader> ret(new WebSocketFrameHeader(opcode));
-  ret->final = final;
-  ret->reserved1 = reserved1;
-  ret->reserved2 = reserved2;
-  ret->reserved3 = reserved3;
-  ret->opcode = opcode;
-  ret->masked = masked;
-  ret->payload_length = payload_length;
+  ret->CopyFrom(*this);
   return ret.Pass();
 }
 
+void WebSocketFrameHeader::CopyFrom(const WebSocketFrameHeader& source) {
+  final = source.final;
+  reserved1 = source.reserved1;
+  reserved2 = source.reserved2;
+  reserved3 = source.reserved3;
+  opcode = source.opcode;
+  masked = source.masked;
+  payload_length = source.payload_length;
+}
+
+WebSocketFrame::WebSocketFrame(WebSocketFrameHeader::OpCode opcode)
+    : header(opcode) {}
+
+WebSocketFrame::~WebSocketFrame() {}
+
 WebSocketFrameChunk::WebSocketFrameChunk() : final_chunk(false) {}
 
 WebSocketFrameChunk::~WebSocketFrameChunk() {}
@@ -195,7 +204,7 @@ void MaskWebSocketFramePayload(const WebSocketMaskingKey& masking_key,
   // Create a version of the mask which is rotated by the appropriate offset
   // for our alignment. The "trick" here is that 0 XORed with the mask will
   // give the value of the mask for the appropriate byte.
-  char realigned_mask[kMaskingKeyLength] = { 0 };
+  char realigned_mask[kMaskingKeyLength] = {};
   MaskWebSocketFramePayloadByBytes(
       masking_key,
       (frame_offset + aligned_begin - data) % kMaskingKeyLength,
diff --git a/net/websockets/websocket_frame.h b/net/websockets/websocket_frame.h
index 8c04f7d..c9d8b97 100644
--- a/net/websockets/websocket_frame.h
+++ b/net/websockets/websocket_frame.h
@@ -14,6 +14,7 @@
 
 namespace net {
 
+class IOBuffer;
 class IOBufferWithSize;
 
 // Represents a WebSocket frame header.
@@ -69,7 +70,10 @@ struct NET_EXPORT WebSocketFrameHeader {
         payload_length(0) {}
 
   // Create a clone of this object on the heap.
-  scoped_ptr<WebSocketFrameHeader> Clone();
+  scoped_ptr<WebSocketFrameHeader> Clone() const;
+
+  // Overwrite this object with the fields from |source|.
+  void CopyFrom(const WebSocketFrameHeader& source);
 
   // Members below correspond to each item in WebSocket frame header.
   // See <http://tools.ietf.org/html/rfc6455#section-5.2> for details.
@@ -85,16 +89,32 @@ struct NET_EXPORT WebSocketFrameHeader {
   DISALLOW_COPY_AND_ASSIGN(WebSocketFrameHeader);
 };
 
-// Contains payload data of part of a WebSocket frame.
+// Contains an entire WebSocket frame including payload. This is used by APIs
+// that are not concerned about retaining the original frame boundaries (because
+// frames may need to be split in order for the data to fit in memory).
+struct NET_EXPORT_PRIVATE WebSocketFrame {
+  // A frame must always have an opcode, so this parameter is compulsory.
+  explicit WebSocketFrame(WebSocketFrameHeader::OpCode opcode);
+  ~WebSocketFrame();
+
+  // |header| is always present.
+  WebSocketFrameHeader header;
+
+  // |data| is always unmasked even if the frame is masked. The size of |data|
+  // is given by |header.payload_length|.
+  scoped_refptr<IOBuffer> data;
+};
+
+// Structure describing one chunk of a WebSocket frame.
 //
-// Payload of a WebSocket frame may be divided into multiple chunks.
+// The payload of a WebSocket frame may be divided into multiple chunks.
 // You need to look at |final_chunk| member variable to detect the end of a
 // series of chunk objects of a WebSocket frame.
 //
-// Frame dissection is necessary to handle WebSocket frame stream containing
-// abritrarily large frames in the browser process. Because the server may send
-// a huge frame that doesn't fit in the memory, we cannot store the entire
-// payload data in the memory.
+// Frame dissection is necessary to handle frames that are too large to store in
+// the browser memory without losing information about the frame boundaries. In
+// practice, most code does not need to worry about the original frame
+// boundaries and can use the WebSocketFrame type declared above.
 //
 // Users of this struct should treat WebSocket frames as a data stream; it's
 // important to keep the frame data flowing, especially in the browser process.
diff --git a/net/websockets/websocket_stream.h b/net/websockets/websocket_stream.h
index 4885bbe..ca29f57 100644
--- a/net/websockets/websocket_stream.h
+++ b/net/websockets/websocket_stream.h
@@ -24,7 +24,7 @@ class BoundNetLog;
 class HttpRequestHeaders;
 class HttpResponseInfo;
 class URLRequestContext;
-struct WebSocketFrameChunk;
+struct WebSocketFrame;
 
 // WebSocketStreamRequest is the caller's handle to the process of creation of a
 // WebSocketStream. Deleting the object before the OnSuccess or OnFailure
@@ -91,10 +91,10 @@ class NET_EXPORT_PRIVATE WebSocketStream : public WebSocketStreamBase {
   virtual ~WebSocketStream();
 
   // Reads WebSocket frame data. This operation finishes when new frame data
-  // becomes available. Each frame message might be chopped off in the middle
-  // as specified in the description of the WebSocketFrameChunk struct.
-  // |frame_chunks| remains owned by the caller and must be valid until the
-  // operation completes or Close() is called. |frame_chunks| must be empty on
+  // becomes available.
+  //
+  // |frames| remains owned by the caller and must be valid until the
+  // operation completes or Close() is called. |frames| must be empty on
   // calling.
   //
   // This function should not be called while the previous call of ReadFrames()
@@ -102,20 +102,18 @@ class NET_EXPORT_PRIVATE WebSocketStream : public WebSocketStreamBase {
   //
   // Returns net::OK or one of the net::ERR_* codes.
   //
-  // frame_chunks->size() >= 1 if the result is OK.
+  // frames->size() >= 1 if the result is OK.
   //
-  // A frame with an incomplete header will never be inserted into
-  // |frame_chunks|. If the currently available bytes of a new frame do not form
-  // a complete frame header, then the implementation will buffer them until all
-  // the fields in the WebSocketFrameHeader object can be filled. If
-  // ReadFrames() is freshly called in this situation, it will return
-  // ERR_IO_PENDING exactly as if no data was available.
+  // Only frames with complete header information are inserted into |frames|. If
+  // the currently available bytes of a new frame do not form a complete frame
+  // header, then the implementation will buffer them until all the fields in
+  // the WebSocketFrameHeader object can be filled. If ReadFrames() is freshly
+  // called in this situation, it will return ERR_IO_PENDING exactly as if no
+  // data was available.
   //
-  // Every WebSocketFrameChunk in the vector except the first and last is
-  // guaranteed to be a complete frame. The first chunk may be the final part
-  // of the previous frame. The last chunk may be the first part of a new
-  // frame. If there is only one chunk, then it may consist of data from the
-  // middle part of a frame.
+  // Original frame boundaries are not preserved. In particular, if only part of
+  // a frame is available, then the frame will be split, and the available data
+  // will be returned immediately.
   //
   // When the socket is closed on the remote side, this method will return
   // ERR_CONNECTION_CLOSED. It will not return OK with an empty vector.
@@ -124,33 +122,23 @@ class NET_EXPORT_PRIVATE WebSocketStream : public WebSocketStreamBase {
   // ReadFrames may discard the incomplete frame. Since the renderer will
   // discard any incomplete messages when the connection is closed, this makes
   // no difference to the overall semantics.
-  virtual int ReadFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) = 0;
 
-  // Writes WebSocket frame data. |frame_chunks| must only contain complete
-  // frames. Every chunk must have a non-NULL |header| and the |final_chunk|
-  // boolean set to true.
-  //
-  // The |frame_chunks| pointer must remain valid until the operation completes
-  // or Close() is called. WriteFrames() will modify the contents of
-  // |frame_chunks| in the process of sending the message. After WriteFrames()
-  // has completed it is safe to clear and then re-use the vector, but other
-  // than that the caller should make no assumptions about its contents.
+  // Writes WebSocket frame data.
   //
-  // This function should not be called while a previous call to WriteFrames()
-  // on the same stream is pending.
+  // |frames| must be valid until the operation completes or Close() is called.
   //
-  // Frame boundaries may not be preserved. Frames may be split or
-  // coalesced. Message boundaries are preserved (as required by WebSocket API
-  // semantics).
+  // This function must not be called while a previous call of WriteFrames() is
+  // still pending.
   //
   // This method will only return OK if all frames were written completely.
   // Otherwise it will return an appropriate net error code.
-  virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) = 0;
 
   // Closes the stream. All pending I/O operations (if any) are cancelled
-  // at this point, so |frame_chunks| can be freed.
+  // at this point, so |frames| can be freed.
   virtual void Close() = 0;
 
   // The subprotocol that was negotiated for the stream. If no protocol was