WebSocketBasicStream framing logic

net/websockets/websocket_basic_stream_test.cc

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Tests for WebSocketBasicStream. Note that we do not attempt to verify that
+// frame parsing itself functions correctly, as that is covered by the
+// WebSocketFrameParser tests.
+
+#include "net/websockets/websocket_basic_stream.h"
+
+#include "base/basictypes.h"
+#include "base/port.h"
+#include "net/base/capturing_net_log.h"
+#include "net/base/test_completion_callback.h"
+#include "net/socket/socket_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace {
+
+// TODO(ricea): Add tests for
+// - Empty frames (data & control)
+// - Non-NULL masking key
+// - A frame larger than kReadBufferSize;
+
+const char kSampleFrame[] = "\x81\x06Sample";
+const size_t kSampleFrameSize = arraysize(kSampleFrame) - 1;
+const char kPartialLargeFrame[] =
+    "\x81\x7F\x00\x00\x00\x00\x7F\xFF\xFF\xFF"
+    "chromiunum ad pasco per loca insanis pullum manducat frumenti";
+const size_t kPartialLargeFrameSize = arraysize(kPartialLargeFrame) - 1;
+const size_t kLargeFrameHeaderSize = 10;
+const size_t kLargeFrameDeclaredPayloadSize = 0x7FFFFFFF;
+const char kMultipleFrames[] = "\x81\x01X\x81\x01Y\x81\x01Z";
+const size_t kMultipleFramesSize = arraysize(kMultipleFrames) - 1;
+// This frame encodes a payload length of 7 in two bytes, which is always
+// invalid.
+const char kInvalidFrame[] = "\x81\x7E\x00\x07Invalid";
+const size_t kInvalidFrameSize = arraysize(kInvalidFrame) - 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; }
+
+// Base class for WebSocketBasicStream test fixtures.
+class WebSocketBasicStreamTest : public ::testing::Test {
+ protected:
+  scoped_ptr<WebSocketBasicStream> stream_;
+  CapturingNetLog net_log_;
+};
+
+// A fixture for tests which only perform normal socket operations.
+class WebSocketBasicStreamSocketTest : public WebSocketBasicStreamTest {
+ protected:
+  WebSocketBasicStreamSocketTest()
+      : histograms_("a"), pool_(1, 1, &histograms_, &factory_) {}
+
+  virtual ~WebSocketBasicStreamSocketTest() {
+    // stream_ has a reference to socket_data_ (via MockTCPClientSocket) and so
+    // should be destroyed first.
+    stream_.reset();
+  }
+
+  scoped_ptr<ClientSocketHandle> MakeTransportSocket(MockRead reads[],
+                                                     size_t reads_count,
+                                                     MockWrite writes[],
+                                                     size_t writes_count) {
+    socket_data_.reset(
+        new StaticSocketDataProvider(reads, reads_count, writes, writes_count));
+    socket_data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
+    factory_.AddSocketDataProvider(socket_data_.get());
+
+    scoped_ptr<ClientSocketHandle> transport_socket(new ClientSocketHandle);
+    scoped_refptr<MockTransportSocketParams> params;
+    transport_socket->Init("a",
+                           params,
+                           MEDIUM,
+                           CompletionCallback(),
+                           &pool_,
+                           bound_net_log_.bound());
+    return transport_socket.Pass();
+  }
+
+  void SetHttpReadBuffer(const char* data, size_t size) {
+    http_read_buffer_ = new GrowableIOBuffer;
+    http_read_buffer_->SetCapacity(size);
+    memcpy(http_read_buffer_->data(), data, size);
+    http_read_buffer_->set_offset(size);
+  }
+
+  void CreateStream(MockRead reads[],
+                    size_t reads_count,
+                    MockWrite writes[],
+                    size_t writes_count) {
+    stream_ = WebSocketBasicStream::CreateWebSocketBasicStreamForTesting(
+        MakeTransportSocket(reads, reads_count, writes, writes_count),
+        http_read_buffer_,
+        sub_protocol_,
+        extensions_,
+        &GenerateNulMaskingKey);
+  }
+
+  template <size_t N>
+  void CreateReadOnly(MockRead (&reads)[N]) {
+    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_;
+  MockClientSocketFactory factory_;
+  ClientSocketPoolHistograms histograms_;
+  MockTransportClientSocketPool pool_;
+  CapturingBoundNetLog(bound_net_log_);
+  ScopedVector<WebSocketFrameChunk> frame_chunks_;
+  TestCompletionCallback cb_;
+  scoped_refptr<GrowableIOBuffer> http_read_buffer_;
+  std::string sub_protocol_;
+  std::string extensions_;
+};
+
+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());
+  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);
+}
+
+TEST_F(WebSocketBasicStreamSocketTest, AsyncReadWorks) {
+  MockRead reads[] = {MockRead(ASYNC, kSampleFrame, kSampleFrameSize)};
+  CreateReadOnly(reads);
+  int result = stream_->ReadFrames(&frame_chunks_, 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);
+  // 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());
+  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);
+}
+
+// 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());
+  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);
+}
+
+// If it receives an incomplete header in a synchronous call, then has to wait
+// for the rest of the frame, ReadFrames will return ERR_IO_PENDING.
+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());
+  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);
+}
+
+// An extended header should also return ERR_IO_PENDING if it is not completely
+// received.
+TEST_F(WebSocketBasicStreamSocketTest, FragmentedLargeHeader) {
+  MockRead reads[] = {
+      MockRead(SYNCHRONOUS, kPartialLargeFrame, kLargeFrameHeaderSize - 1),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
+  CreateReadOnly(reads);
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, 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);
+  EXPECT_EQ(kPartialLargeFrameSize - kLargeFrameHeaderSize,
+            static_cast<size_t>(frame_chunks_[0]->data->size()));
+}
+
+// If only the header arrives, we should get a zero-byte chunk.
+TEST_F(WebSocketBasicStreamSocketTest, HeaderOnlyChunk) {
+  MockRead reads[] = {
+      MockRead(SYNCHRONOUS, kPartialLargeFrame, kLargeFrameHeaderSize)};
+  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);
+}
+
+// The second and subsequent chunks of a frame have no header.
+TEST_F(WebSocketBasicStreamSocketTest, LargeFrameTwoChunks) {
+  static const size_t kChunkSize = 16;
+  MockRead reads[] = {
+      MockRead(ASYNC, kPartialLargeFrame, kChunkSize),
+      MockRead(ASYNC, kPartialLargeFrame + kChunkSize, kChunkSize)};
+  CreateReadOnly(reads);
+  TestCompletionCallback cb[2];
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb[0].callback()));
+  EXPECT_EQ(OK, cb[0].WaitForResult());
+  ASSERT_EQ(1U, frame_chunks_.size());
+  ASSERT_TRUE(frame_chunks_[0]->header);
+
+  frame_chunks_.clear();
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb[1].callback()));
+  EXPECT_EQ(OK, cb[1].WaitForResult());
+  ASSERT_EQ(1U, frame_chunks_.size());
+  ASSERT_FALSE(frame_chunks_[0]->header);
+}
+
+// Only the final chunk of a frame has final_chunk set.
+TEST_F(WebSocketBasicStreamSocketTest, OnlyFinalChunkIsFinal) {
+  static const size_t kFirstChunkSize = 4;
+  MockRead reads[] = {MockRead(ASYNC, kSampleFrame, kFirstChunkSize),
+                      MockRead(ASYNC,
+                               kSampleFrame + kFirstChunkSize,
+                               kSampleFrameSize - kFirstChunkSize)};
+  CreateReadOnly(reads);
+  TestCompletionCallback cb[2];
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb[0].callback()));
+  EXPECT_EQ(OK, cb[0].WaitForResult());
+  ASSERT_EQ(1U, frame_chunks_.size());
+  ASSERT_FALSE(frame_chunks_[0]->final_chunk);
+
+  frame_chunks_.clear();
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb[1].callback()));
+  EXPECT_EQ(OK, cb[1].WaitForResult());
+  ASSERT_EQ(1U, frame_chunks_.size());
+  ASSERT_TRUE(frame_chunks_[0]->final_chunk);
+}
+
+// Multiple frames that arrive together should be parsed correctly.
+TEST_F(WebSocketBasicStreamSocketTest, ThreeFramesTogether) {
+  MockRead reads[] = {
+      MockRead(SYNCHRONOUS, kMultipleFrames, kMultipleFramesSize)};
+  CreateReadOnly(reads);
+
+  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);
+}
+
+// ERR_CONNECTION_CLOSED must be returned on close.
+TEST_F(WebSocketBasicStreamSocketTest, SyncClose) {
+  MockRead reads[] = {MockRead(SYNCHRONOUS, "", 0)};
+  CreateReadOnly(reads);
+
+  EXPECT_EQ(ERR_CONNECTION_CLOSED,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+}
+
+TEST_F(WebSocketBasicStreamSocketTest, AsyncClose) {
+  MockRead reads[] = {MockRead(ASYNC, "", 0)};
+  CreateReadOnly(reads);
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, cb_.WaitForResult());
+}
+
+// The result should be the same if the socket returns ERR_CONNECTION_CLOSED

[szym, 2013/08/29 16:42:01]

I think Socket implementations only return this during connection handshake, but
maybe I'm missing some cases. What should ReadFrames return if the Socket fails
with some other error?

[Adam Rice, 2013/08/30 10:05:35]

I added a comment clarifying that we are not actually expecting to see this
error in practice.

I also added two tests verifying that other Socket errors are passed through
unchanged.

+TEST_F(WebSocketBasicStreamSocketTest, SyncCloseWithErr) {
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_CONNECTION_CLOSED)};
+  CreateReadOnly(reads);
+
+  EXPECT_EQ(ERR_CONNECTION_CLOSED,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+}
+
+TEST_F(WebSocketBasicStreamSocketTest, AsyncCloseWithErr) {
+  MockRead reads[] = {MockRead(ASYNC, ERR_CONNECTION_CLOSED)};
+  CreateReadOnly(reads);
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, 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();
+  EXPECT_EQ(ERR_CONNECTION_CLOSED,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+}
+
+// Synchronous close after an async frame header is handled by a different code
+// path.
+TEST_F(WebSocketBasicStreamSocketTest, AsyncCloseAfterIncompleteHeader) {
+  MockRead reads[] = {MockRead(ASYNC, kSampleFrame, 1U),
+                      MockRead(SYNCHRONOUS, "", 0)};
+  CreateReadOnly(reads);
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_CONNECTION_CLOSED, cb_.WaitForResult());
+}
+
+// When Stream::Read returns ERR_CONNECTION_CLOSED we get the same result via a
+// slightly different code path.
+TEST_F(WebSocketBasicStreamSocketTest, AsyncErrCloseAfterIncompleteHeader) {
+  MockRead reads[] = {MockRead(ASYNC, kSampleFrame, 1U),
+                      MockRead(SYNCHRONOUS, ERR_CONNECTION_CLOSED)};
+  CreateReadOnly(reads);
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  ASSERT_EQ(ERR_CONNECTION_CLOSED, cb_.WaitForResult());
+}
+
+// If there was a frame read at the same time as the response headers (and the
+// handshake succeeded), then we should parse it.
+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());
+}
+
+// Check that a frame whose header partially arrived at the end of the response
+// headers works correctly.
+TEST_F(WebSocketBasicStreamSocketTest, PartialFrameHeaderInHttpResponse) {
+  SetHttpReadBuffer(kSampleFrame, 1);
+  MockRead reads[] = {MockRead(ASYNC, kSampleFrame + 1, kSampleFrameSize - 1)};
+  CreateReadOnly(reads);
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, 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);
+}
+
+// Check that an invalid frame results in an error.
+TEST_F(WebSocketBasicStreamSocketTest, SyncInvalidFrame) {
+  MockRead reads[] = {MockRead(SYNCHRONOUS, kInvalidFrame, kInvalidFrameSize)};
+  CreateReadOnly(reads);
+
+  EXPECT_EQ(ERR_WS_PROTOCOL_ERROR,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+}
+
+TEST_F(WebSocketBasicStreamSocketTest, AsyncInvalidFrame) {
+  MockRead reads[] = {MockRead(ASYNC, kInvalidFrame, kInvalidFrameSize)};
+  CreateReadOnly(reads);
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->ReadFrames(&frame_chunks_, cb_.callback()));
+  EXPECT_EQ(ERR_WS_PROTOCOL_ERROR, cb_.WaitForResult());
+}
+
+// Check that writing a frame all at once works.
+TEST_F(WebSocketBasicStreamSocketTest, WriteAtOnce) {
+  MockWrite writes[] = {MockWrite(SYNCHRONOUS, kWriteFrame, kWriteFrameSize)};
+  CreateWriteOnly(writes);
+  frame_chunks_ = GenerateWriteFrame();
+
+  EXPECT_EQ(OK, stream_->WriteFrames(&frame_chunks_, cb_.callback()));
+}
+
+// Check that completely async writing works.
+TEST_F(WebSocketBasicStreamSocketTest, AsyncWriteAtOnce) {
+  MockWrite writes[] = {MockWrite(ASYNC, kWriteFrame, kWriteFrameSize)};
+  CreateWriteOnly(writes);
+  frame_chunks_ = GenerateWriteFrame();
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream_->WriteFrames(&frame_chunks_, 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) {
+  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()));
+  EXPECT_EQ(OK, cb_.WaitForResult());
+}
+
+TEST_F(WebSocketBasicStreamSocketTest, GetExtensionsWorks) {
+  extensions_ = "inflate-uuencode";
+  CreateNullStream();
+
+  EXPECT_EQ("inflate-uuencode", stream_->GetExtensions());
+}
+
+TEST_F(WebSocketBasicStreamSocketTest, GetSubProtocolWorks) {
+  sub_protocol_ = "cyberchat";
+  CreateNullStream();
+
+  EXPECT_EQ("cyberchat", stream_->GetSubProtocol());
+}
+
+}  // namespace
+}  // namespace net