Delete the old WebSocket implementation from net/

The removal of NetworkDelegate::OnBeforeSocketStreamConnect() is in http://crrev.com/652363005 so not too many reviewers will need to review this more-complex CL.

BUG=423201
TEST=net_unittests, browser_tests

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

Cr-Commit-Position: refs/heads/master@{#303387}

8 files changed, 0 insertions, 1100 deletions

diff --git a/net/spdy/spdy_framer.h b/net/spdy/spdy_framer.h
index 1421b55..1bbafe5 100644
--- a/net/spdy/spdy_framer.h
+++ b/net/spdy/spdy_framer.h
@@ -37,8 +37,6 @@ class SpdyNetworkTransactionTest;
 class SpdyProxyClientSocketTest;
 class SpdySessionTest;
 class SpdyStreamTest;
-class SpdyWebSocketStreamTest;
-class WebSocketJobTest;
 
 class SpdyFramer;
 class SpdyFrameBuilder;
@@ -624,8 +622,6 @@ class NET_EXPORT_PRIVATE SpdyFramer {
   friend class net::SpdyProxyClientSocketTest;
   friend class net::SpdySessionTest;
   friend class net::SpdyStreamTest;
-  friend class net::SpdyWebSocketStreamTest;
-  friend class net::WebSocketJobTest;
   friend class test::TestSpdyVisitor;
 
  private:
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 0faab29..7a5060b 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -373,7 +373,6 @@ SpdySessionDependencies::SpdySessionDependencies(NextProto protocol)
       force_spdy_over_ssl(false),
       force_spdy_always(false),
       use_alternate_protocols(false),
-      enable_websocket_over_spdy(false),
       net_log(NULL) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 
@@ -407,7 +406,6 @@ SpdySessionDependencies::SpdySessionDependencies(
       force_spdy_over_ssl(false),
       force_spdy_always(false),
       use_alternate_protocols(false),
-      enable_websocket_over_spdy(false),
       net_log(NULL) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 }
@@ -467,7 +465,6 @@ net::HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
   params.force_spdy_over_ssl = session_deps->force_spdy_over_ssl;
   params.force_spdy_always = session_deps->force_spdy_always;
   params.use_alternate_protocols = session_deps->use_alternate_protocols;
-  params.enable_websocket_over_spdy = session_deps->enable_websocket_over_spdy;
   params.net_log = session_deps->net_log;
   return params;
 }
diff --git a/net/spdy/spdy_test_util_common.h b/net/spdy/spdy_test_util_common.h
index e91800d..178d2e1 100644
--- a/net/spdy/spdy_test_util_common.h
+++ b/net/spdy/spdy_test_util_common.h
@@ -222,7 +222,6 @@ struct SpdySessionDependencies {
   bool force_spdy_over_ssl;
   bool force_spdy_always;
   bool use_alternate_protocols;
-  bool enable_websocket_over_spdy;
   NetLog* net_log;
 };
 
diff --git a/net/spdy/spdy_websocket_stream.cc b/net/spdy/spdy_websocket_stream.cc
deleted file mode 100644
index 54e668c..0000000
--- a/net/spdy/spdy_websocket_stream.cc
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "net/spdy/spdy_websocket_stream.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/compiler_specific.h"
-#include "net/base/io_buffer.h"
-#include "net/base/net_errors.h"
-#include "net/spdy/spdy_framer.h"
-#include "net/spdy/spdy_protocol.h"
-#include "net/spdy/spdy_session.h"
-#include "net/spdy/spdy_stream.h"
-#include "url/gurl.h"
-
-namespace net {
-
-SpdyWebSocketStream::SpdyWebSocketStream(
-    const base::WeakPtr<SpdySession>& spdy_session, Delegate* delegate)
-    : spdy_session_(spdy_session),
-      pending_send_data_length_(0),
-      delegate_(delegate),
-      weak_ptr_factory_(this) {
-  DCHECK(spdy_session_.get());
-  DCHECK(delegate_);
-}
-
-SpdyWebSocketStream::~SpdyWebSocketStream() {
-  delegate_ = NULL;
-  Close();
-}
-
-int SpdyWebSocketStream::InitializeStream(const GURL& url,
-                                          RequestPriority request_priority,
-                                          const BoundNetLog& net_log) {
-  if (!spdy_session_)
-    return ERR_SOCKET_NOT_CONNECTED;
-
-  int rv = stream_request_.StartRequest(
-      SPDY_BIDIRECTIONAL_STREAM, spdy_session_, url, request_priority, net_log,
-      base::Bind(&SpdyWebSocketStream::OnSpdyStreamCreated,
-                 weak_ptr_factory_.GetWeakPtr()));
-
-  if (rv == OK) {
-    stream_ = stream_request_.ReleaseStream();
-    DCHECK(stream_.get());
-    stream_->SetDelegate(this);
-  }
-  return rv;
-}
-
-int SpdyWebSocketStream::SendRequest(scoped_ptr<SpdyHeaderBlock> headers) {
-  if (!stream_.get()) {
-    NOTREACHED();
-    return ERR_UNEXPECTED;
-  }
-  int result = stream_->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND);
-  if (result < OK && result != ERR_IO_PENDING)
-    Close();
-  return result;
-}
-
-int SpdyWebSocketStream::SendData(const char* data, int length) {
-  if (!stream_.get()) {
-    NOTREACHED();
-    return ERR_UNEXPECTED;
-  }
-  DCHECK_GE(length, 0);
-  pending_send_data_length_ = static_cast<size_t>(length);
-  scoped_refptr<IOBuffer> buf(new IOBuffer(length));
-  memcpy(buf->data(), data, length);
-  stream_->SendData(buf.get(), length, MORE_DATA_TO_SEND);
-  return ERR_IO_PENDING;
-}
-
-void SpdyWebSocketStream::Close() {
-  if (stream_.get()) {
-    stream_->Close();
-    DCHECK(!stream_.get());
-  }
-}
-
-void SpdyWebSocketStream::OnRequestHeadersSent() {
-  DCHECK(delegate_);
-  delegate_->OnSentSpdyHeaders();
-}
-
-SpdyResponseHeadersStatus SpdyWebSocketStream::OnResponseHeadersUpdated(
-    const SpdyHeaderBlock& response_headers) {
-  DCHECK(delegate_);
-  delegate_->OnSpdyResponseHeadersUpdated(response_headers);
-  return RESPONSE_HEADERS_ARE_COMPLETE;
-}
-
-void SpdyWebSocketStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
-  DCHECK(delegate_);
-  delegate_->OnReceivedSpdyData(buffer.Pass());
-}
-
-void SpdyWebSocketStream::OnDataSent() {
-  DCHECK(delegate_);
-  delegate_->OnSentSpdyData(pending_send_data_length_);
-  pending_send_data_length_ = 0;
-}
-
-void SpdyWebSocketStream::OnClose(int status) {
-  stream_.reset();
-
-  // Destruction without Close() call OnClose() with delegate_ being NULL.
-  if (!delegate_)
-    return;
-  Delegate* delegate = delegate_;
-  delegate_ = NULL;
-  delegate->OnCloseSpdyStream();
-}
-
-void SpdyWebSocketStream::OnSpdyStreamCreated(int result) {
-  DCHECK_NE(ERR_IO_PENDING, result);
-  if (result == OK) {
-    stream_ = stream_request_.ReleaseStream();
-    DCHECK(stream_.get());
-    stream_->SetDelegate(this);
-  }
-  DCHECK(delegate_);
-  delegate_->OnCreatedSpdyStream(result);
-}
-
-}  // namespace net
diff --git a/net/spdy/spdy_websocket_stream.h b/net/spdy/spdy_websocket_stream.h
deleted file mode 100644
index 854afbf..0000000
--- a/net/spdy/spdy_websocket_stream.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright (c) 2012 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.
-
-#ifndef NET_SPDY_SPDY_WEBSOCKET_STREAM_H_
-#define NET_SPDY_SPDY_WEBSOCKET_STREAM_H_
-
-#include "base/basictypes.h"
-#include "base/gtest_prod_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
-#include "base/time/time.h"
-#include "net/base/completion_callback.h"
-#include "net/base/request_priority.h"
-#include "net/spdy/spdy_framer.h"
-#include "net/spdy/spdy_header_block.h"
-#include "net/spdy/spdy_session.h"
-#include "net/spdy/spdy_stream.h"
-
-namespace net {
-
-// The SpdyWebSocketStream is a WebSocket-specific type of stream known to a
-// SpdySession. WebSocket's opening handshake is converted to SPDY's
-// SYN_STREAM/SYN_REPLY. WebSocket frames are encapsulated as SPDY data frames.
-class NET_EXPORT_PRIVATE SpdyWebSocketStream
-    : public SpdyStream::Delegate {
- public:
-  // Delegate handles asynchronous events.
-  class NET_EXPORT_PRIVATE Delegate {
-   public:
-    // Called when InitializeStream() finishes asynchronously. This delegate is
-    // called if InitializeStream() returns ERR_IO_PENDING. |status| indicates
-    // network error.
-    virtual void OnCreatedSpdyStream(int status) = 0;
-
-    // Called on corresponding to OnSendHeadersComplete() or SPDY's SYN frame
-    // has been sent.
-    virtual void OnSentSpdyHeaders() = 0;
-
-    // Called on corresponding to OnResponseHeadersUpdated() or
-    // SPDY's SYN_STREAM, SYN_REPLY, or HEADERS frames are
-    // received. This callback may be called multiple times as SPDY's
-    // delegate does.
-    virtual void OnSpdyResponseHeadersUpdated(
-        const SpdyHeaderBlock& response_headers) = 0;
-
-    // Called when data is sent.
-    virtual void OnSentSpdyData(size_t bytes_sent) = 0;
-
-    // Called when data is received.
-    virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) = 0;
-
-    // Called when SpdyStream is closed.
-    virtual void OnCloseSpdyStream() = 0;
-
-   protected:
-    virtual ~Delegate() {}
-  };
-
-  SpdyWebSocketStream(const base::WeakPtr<SpdySession>& spdy_session,
-                      Delegate* delegate);
-  ~SpdyWebSocketStream() override;
-
-  // Initializes SPDY stream for the WebSocket.
-  // It might create SPDY stream asynchronously.  In this case, this method
-  // returns ERR_IO_PENDING and call OnCreatedSpdyStream delegate with result
-  // after completion. In other cases, delegate does not be called.
-  int InitializeStream(const GURL& url,
-                       RequestPriority request_priority,
-                       const BoundNetLog& stream_net_log);
-
-  int SendRequest(scoped_ptr<SpdyHeaderBlock> headers);
-  int SendData(const char* data, int length);
-  void Close();
-
-  // SpdyStream::Delegate
-  void OnRequestHeadersSent() override;
-  SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) override;
-  void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override;
-  void OnDataSent() override;
-  void OnClose(int status) override;
-
- private:
-  friend class SpdyWebSocketStreamTest;
-  FRIEND_TEST_ALL_PREFIXES(SpdyWebSocketStreamTest, Basic);
-
-  void OnSpdyStreamCreated(int status);
-
-  SpdyStreamRequest stream_request_;
-  base::WeakPtr<SpdyStream> stream_;
-  const base::WeakPtr<SpdySession> spdy_session_;
-  size_t pending_send_data_length_;
-  Delegate* delegate_;
-
-  base::WeakPtrFactory<SpdyWebSocketStream> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(SpdyWebSocketStream);
-};
-
-}  // namespace net
-
-#endif  // NET_SPDY_SPDY_WEBSOCKET_STREAM_H_
diff --git a/net/spdy/spdy_websocket_stream_unittest.cc b/net/spdy/spdy_websocket_stream_unittest.cc
deleted file mode 100644
index fc54884..0000000
--- a/net/spdy/spdy_websocket_stream_unittest.cc
+++ /dev/null
@@ -1,669 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "net/spdy/spdy_websocket_stream.h"
-
-#include <string>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "net/base/completion_callback.h"
-#include "net/proxy/proxy_server.h"
-#include "net/socket/next_proto.h"
-#include "net/socket/ssl_client_socket.h"
-#include "net/spdy/spdy_http_utils.h"
-#include "net/spdy/spdy_protocol.h"
-#include "net/spdy/spdy_session.h"
-#include "net/spdy/spdy_websocket_test_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace net {
-
-namespace {
-
-struct SpdyWebSocketStreamEvent {
-  enum EventType {
-    EVENT_CREATED,
-    EVENT_SENT_HEADERS,
-    EVENT_RECEIVED_HEADER,
-    EVENT_SENT_DATA,
-    EVENT_RECEIVED_DATA,
-    EVENT_CLOSE,
-  };
-  SpdyWebSocketStreamEvent(EventType type,
-                           const SpdyHeaderBlock& headers,
-                           int result,
-                           const std::string& data)
-      : event_type(type),
-        headers(headers),
-        result(result),
-        data(data) {}
-
-  EventType event_type;
-  SpdyHeaderBlock headers;
-  int result;
-  std::string data;
-};
-
-class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
- public:
-  explicit SpdyWebSocketStreamEventRecorder(const CompletionCallback& callback)
-      : callback_(callback) {}
-  ~SpdyWebSocketStreamEventRecorder() override {}
-
-  typedef base::Callback<void(SpdyWebSocketStreamEvent*)> StreamEventCallback;
-
-  void SetOnCreated(const StreamEventCallback& callback) {
-    on_created_ = callback;
-  }
-  void SetOnSentHeaders(const StreamEventCallback& callback) {
-    on_sent_headers_ = callback;
-  }
-  void SetOnReceivedHeader(const StreamEventCallback& callback) {
-    on_received_header_ = callback;
-  }
-  void SetOnSentData(const StreamEventCallback& callback) {
-    on_sent_data_ = callback;
-  }
-  void SetOnReceivedData(const StreamEventCallback& callback) {
-    on_received_data_ = callback;
-  }
-  void SetOnClose(const StreamEventCallback& callback) {
-    on_close_ = callback;
-  }
-
-  void OnCreatedSpdyStream(int result) override {
-    events_.push_back(
-        SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_CREATED,
-                                 SpdyHeaderBlock(),
-                                 result,
-                                 std::string()));
-    if (!on_created_.is_null())
-      on_created_.Run(&events_.back());
-  }
-  void OnSentSpdyHeaders() override {
-    events_.push_back(
-        SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
-                                 SpdyHeaderBlock(),
-                                 OK,
-                                 std::string()));
-    if (!on_sent_data_.is_null())
-      on_sent_data_.Run(&events_.back());
-  }
-  void OnSpdyResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) override {
-    events_.push_back(
-        SpdyWebSocketStreamEvent(
-            SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
-            response_headers,
-            OK,
-            std::string()));
-    if (!on_received_header_.is_null())
-      on_received_header_.Run(&events_.back());
-  }
-  void OnSentSpdyData(size_t bytes_sent) override {
-    events_.push_back(
-        SpdyWebSocketStreamEvent(
-            SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
-            SpdyHeaderBlock(),
-            static_cast<int>(bytes_sent),
-            std::string()));
-    if (!on_sent_data_.is_null())
-      on_sent_data_.Run(&events_.back());
-  }
-  void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) override {
-    std::string buffer_data;
-    size_t buffer_len = 0;
-    if (buffer) {
-      buffer_len = buffer->GetRemainingSize();
-      buffer_data.append(buffer->GetRemainingData(), buffer_len);
-    }
-    events_.push_back(
-        SpdyWebSocketStreamEvent(
-            SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
-            SpdyHeaderBlock(),
-            buffer_len,
-            buffer_data));
-    if (!on_received_data_.is_null())
-      on_received_data_.Run(&events_.back());
-  }
-  void OnCloseSpdyStream() override {
-    events_.push_back(
-        SpdyWebSocketStreamEvent(
-            SpdyWebSocketStreamEvent::EVENT_CLOSE,
-            SpdyHeaderBlock(),
-            OK,
-            std::string()));
-    if (!on_close_.is_null())
-      on_close_.Run(&events_.back());
-    if (!callback_.is_null())
-      callback_.Run(OK);
-  }
-
-  const std::vector<SpdyWebSocketStreamEvent>& GetSeenEvents() const {
-    return events_;
-  }
-
- private:
-  std::vector<SpdyWebSocketStreamEvent> events_;
-  StreamEventCallback on_created_;
-  StreamEventCallback on_sent_headers_;
-  StreamEventCallback on_received_header_;
-  StreamEventCallback on_sent_data_;
-  StreamEventCallback on_received_data_;
-  StreamEventCallback on_close_;
-  CompletionCallback callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(SpdyWebSocketStreamEventRecorder);
-};
-
-}  // namespace
-
-class SpdyWebSocketStreamTest
-    : public ::testing::Test,
-      public ::testing::WithParamInterface<NextProto> {
- public:
-  OrderedSocketData* data() { return data_.get(); }
-
-  void DoSendHelloFrame(SpdyWebSocketStreamEvent* event) {
-    // Record the actual stream_id.
-    created_stream_id_ = websocket_stream_->stream_->stream_id();
-    websocket_stream_->SendData(kMessageFrame, kMessageFrameLength);
-  }
-
-  void DoSendClosingFrame(SpdyWebSocketStreamEvent* event) {
-    websocket_stream_->SendData(kClosingFrame, kClosingFrameLength);
-  }
-
-  void DoClose(SpdyWebSocketStreamEvent* event) {
-    websocket_stream_->Close();
-  }
-
-  void DoSync(SpdyWebSocketStreamEvent* event) {
-    sync_callback_.callback().Run(OK);
-  }
-
- protected:
-  SpdyWebSocketStreamTest()
-      : spdy_util_(GetParam()),
-        spdy_settings_id_to_set_(SETTINGS_MAX_CONCURRENT_STREAMS),
-        spdy_settings_flags_to_set_(SETTINGS_FLAG_PLEASE_PERSIST),
-        spdy_settings_value_to_set_(1),
-        session_deps_(GetParam()),
-        stream_id_(0),
-        created_stream_id_(0) {}
-  virtual ~SpdyWebSocketStreamTest() {}
-
-  void SetUp() override {
-    host_port_pair_.set_host("example.com");
-    host_port_pair_.set_port(80);
-    spdy_session_key_ = SpdySessionKey(host_port_pair_,
-                                       ProxyServer::Direct(),
-                                       PRIVACY_MODE_DISABLED);
-
-    spdy_settings_to_send_[spdy_settings_id_to_set_] =
-        SettingsFlagsAndValue(
-            SETTINGS_FLAG_PERSISTED, spdy_settings_value_to_set_);
-  }
-
-  void TearDown() override { base::MessageLoop::current()->RunUntilIdle(); }
-
-  void Prepare(SpdyStreamId stream_id) {
-    stream_id_ = stream_id;
-
-    request_frame_.reset(spdy_util_.ConstructSpdyWebSocketSynStream(
-        stream_id_,
-        "/echo",
-        "example.com",
-        "http://example.com/wsdemo"));
-
-    response_frame_.reset(
-        spdy_util_.ConstructSpdyWebSocketSynReply(stream_id_));
-
-    message_frame_.reset(spdy_util_.ConstructSpdyWebSocketDataFrame(
-        kMessageFrame,
-        kMessageFrameLength,
-        stream_id_,
-        false));
-
-    closing_frame_.reset(spdy_util_.ConstructSpdyWebSocketDataFrame(
-        kClosingFrame,
-        kClosingFrameLength,
-        stream_id_,
-        false));
-
-    closing_frame_fin_.reset(spdy_util_.ConstructSpdyWebSocketDataFrame(
-        kClosingFrame,
-        kClosingFrameLength,
-        stream_id_,
-        true));
-  }
-
-  void InitSession(MockRead* reads, size_t reads_count,
-                   MockWrite* writes, size_t writes_count) {
-    data_.reset(new OrderedSocketData(reads, reads_count,
-                                      writes, writes_count));
-    session_deps_.socket_factory->AddSocketDataProvider(data_.get());
-    http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
-    session_ = CreateInsecureSpdySession(
-        http_session_, spdy_session_key_, BoundNetLog());
-  }
-
-  void SendRequest() {
-    scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
-    spdy_util_.SetHeader("path", "/echo", headers.get());
-    spdy_util_.SetHeader("host", "example.com", headers.get());
-    spdy_util_.SetHeader("version", "WebSocket/13", headers.get());
-    spdy_util_.SetHeader("scheme", "ws", headers.get());
-    spdy_util_.SetHeader("origin", "http://example.com/wsdemo", headers.get());
-    websocket_stream_->SendRequest(headers.Pass());
-  }
-
-  SpdyWebSocketTestUtil spdy_util_;
-  SpdySettingsIds spdy_settings_id_to_set_;
-  SpdySettingsFlags spdy_settings_flags_to_set_;
-  uint32 spdy_settings_value_to_set_;
-  SettingsMap spdy_settings_to_send_;
-  SpdySessionDependencies session_deps_;
-  scoped_ptr<OrderedSocketData> data_;
-  scoped_refptr<HttpNetworkSession> http_session_;
-  base::WeakPtr<SpdySession> session_;
-  scoped_ptr<SpdyWebSocketStream> websocket_stream_;
-  SpdyStreamId stream_id_;
-  SpdyStreamId created_stream_id_;
-  scoped_ptr<SpdyFrame> request_frame_;
-  scoped_ptr<SpdyFrame> response_frame_;
-  scoped_ptr<SpdyFrame> message_frame_;
-  scoped_ptr<SpdyFrame> closing_frame_;
-  scoped_ptr<SpdyFrame> closing_frame_fin_;
-  HostPortPair host_port_pair_;
-  SpdySessionKey spdy_session_key_;
-  TestCompletionCallback completion_callback_;
-  TestCompletionCallback sync_callback_;
-
-  static const char kMessageFrame[];
-  static const char kClosingFrame[];
-  static const size_t kMessageFrameLength;
-  static const size_t kClosingFrameLength;
-};
-
-INSTANTIATE_TEST_CASE_P(
-    NextProto,
-    SpdyWebSocketStreamTest,
-    testing::Values(kProtoDeprecatedSPDY2,
-                    kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
-
-// TODO(toyoshim): Replace old framing data to new one, then use HEADERS and
-// data frames.
-const char SpdyWebSocketStreamTest::kMessageFrame[] = "\x81\x05hello";
-const char SpdyWebSocketStreamTest::kClosingFrame[] = "\x88\0";
-const size_t SpdyWebSocketStreamTest::kMessageFrameLength =
-    arraysize(SpdyWebSocketStreamTest::kMessageFrame) - 1;
-const size_t SpdyWebSocketStreamTest::kClosingFrameLength =
-    arraysize(SpdyWebSocketStreamTest::kClosingFrame) - 1;
-
-TEST_P(SpdyWebSocketStreamTest, Basic) {
-  Prepare(1);
-  MockWrite writes[] = {
-    CreateMockWrite(*request_frame_.get(), 1),
-    CreateMockWrite(*message_frame_.get(), 3),
-    CreateMockWrite(*closing_frame_.get(), 5)
-  };
-
-  MockRead reads[] = {
-    CreateMockRead(*response_frame_.get(), 2),
-    CreateMockRead(*message_frame_.get(), 4),
-    // Skip sequence 6 to notify closing has been sent.
-    CreateMockRead(*closing_frame_.get(), 7),
-    MockRead(SYNCHRONOUS, 0, 8)  // EOF cause OnCloseSpdyStream event.
-  };
-
-  InitSession(reads, arraysize(reads), writes, arraysize(writes));
-
-  SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
-  delegate.SetOnReceivedHeader(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
-                 base::Unretained(this)));
-  delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendClosingFrame,
-                 base::Unretained(this)));
-
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
-
-  BoundNetLog net_log;
-  GURL url("ws://example.com/echo");
-  ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
-
-  ASSERT_TRUE(websocket_stream_->stream_.get());
-
-  SendRequest();
-
-  completion_callback_.WaitForResult();
-
-  EXPECT_EQ(stream_id_, created_stream_id_);
-
-  websocket_stream_.reset();
-
-  const std::vector<SpdyWebSocketStreamEvent>& events =
-      delegate.GetSeenEvents();
-  ASSERT_EQ(7U, events.size());
-
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
-            events[0].event_type);
-  EXPECT_EQ(OK, events[0].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
-            events[1].event_type);
-  EXPECT_EQ(OK, events[1].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
-            events[2].event_type);
-  EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
-            events[3].event_type);
-  EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
-            events[4].event_type);
-  EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[4].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
-            events[5].event_type);
-  EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[5].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
-            events[6].event_type);
-  EXPECT_EQ(OK, events[6].result);
-
-  // EOF close SPDY session.
-  EXPECT_FALSE(
-      HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
-  EXPECT_TRUE(data()->at_read_eof());
-  EXPECT_TRUE(data()->at_write_eof());
-}
-
-// A SPDY websocket may still send it's close frame after
-// recieving a close with SPDY stream FIN.
-TEST_P(SpdyWebSocketStreamTest, RemoteCloseWithFin) {
-  Prepare(1);
-  MockWrite writes[] = {
-    CreateMockWrite(*request_frame_.get(), 1),
-    CreateMockWrite(*closing_frame_.get(), 4),
-  };
-  MockRead reads[] = {
-    CreateMockRead(*response_frame_.get(), 2),
-    CreateMockRead(*closing_frame_fin_.get(), 3),
-    MockRead(SYNCHRONOUS, 0, 5)  // EOF cause OnCloseSpdyStream event.
-  };
-  InitSession(reads, arraysize(reads), writes, arraysize(writes));
-
-  SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
-  delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendClosingFrame,
-                 base::Unretained(this)));
-
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
-  BoundNetLog net_log;
-  GURL url("ws://example.com/echo");
-  ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
-
-  SendRequest();
-  completion_callback_.WaitForResult();
-  websocket_stream_.reset();
-
-  const std::vector<SpdyWebSocketStreamEvent>& events =
-      delegate.GetSeenEvents();
-  EXPECT_EQ(5U, events.size());
-
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
-            events[0].event_type);
-  EXPECT_EQ(OK, events[0].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
-            events[1].event_type);
-  EXPECT_EQ(OK, events[1].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
-            events[2].event_type);
-  EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[2].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
-            events[3].event_type);
-  EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[3].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
-            events[4].event_type);
-  EXPECT_EQ(OK, events[4].result);
-
-  // EOF closes SPDY session.
-  EXPECT_FALSE(
-      HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
-  EXPECT_TRUE(data()->at_read_eof());
-  EXPECT_TRUE(data()->at_write_eof());
-}
-
-TEST_P(SpdyWebSocketStreamTest, DestructionBeforeClose) {
-  Prepare(1);
-  MockWrite writes[] = {
-    CreateMockWrite(*request_frame_.get(), 1),
-    CreateMockWrite(*message_frame_.get(), 3)
-  };
-
-  MockRead reads[] = {
-    CreateMockRead(*response_frame_.get(), 2),
-    CreateMockRead(*message_frame_.get(), 4),
-    MockRead(ASYNC, ERR_IO_PENDING, 5)
-  };
-
-  InitSession(reads, arraysize(reads), writes, arraysize(writes));
-
-  SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
-  delegate.SetOnReceivedHeader(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
-                 base::Unretained(this)));
-  delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoSync,
-                 base::Unretained(this)));
-
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
-
-  BoundNetLog net_log;
-  GURL url("ws://example.com/echo");
-  ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
-
-  SendRequest();
-
-  sync_callback_.WaitForResult();
-
-  // WebSocketStream destruction remove its SPDY stream from the session.
-  EXPECT_TRUE(session_->IsStreamActive(stream_id_));
-  websocket_stream_.reset();
-  EXPECT_FALSE(session_->IsStreamActive(stream_id_));
-
-  const std::vector<SpdyWebSocketStreamEvent>& events =
-      delegate.GetSeenEvents();
-  ASSERT_GE(4U, events.size());
-
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
-            events[0].event_type);
-  EXPECT_EQ(OK, events[0].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
-            events[1].event_type);
-  EXPECT_EQ(OK, events[1].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
-            events[2].event_type);
-  EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
-            events[3].event_type);
-  EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
-
-  EXPECT_TRUE(
-      HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
-  EXPECT_TRUE(data()->at_read_eof());
-  EXPECT_TRUE(data()->at_write_eof());
-}
-
-TEST_P(SpdyWebSocketStreamTest, DestructionAfterExplicitClose) {
-  Prepare(1);
-  MockWrite writes[] = {
-    CreateMockWrite(*request_frame_.get(), 1),
-    CreateMockWrite(*message_frame_.get(), 3),
-    CreateMockWrite(*closing_frame_.get(), 5)
-  };
-
-  MockRead reads[] = {
-    CreateMockRead(*response_frame_.get(), 2),
-    CreateMockRead(*message_frame_.get(), 4),
-    MockRead(ASYNC, ERR_IO_PENDING, 6)
-  };
-
-  InitSession(reads, arraysize(reads), writes, arraysize(writes));
-
-  SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
-  delegate.SetOnReceivedHeader(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
-                 base::Unretained(this)));
-  delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoClose,
-                 base::Unretained(this)));
-
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
-
-  BoundNetLog net_log;
-  GURL url("ws://example.com/echo");
-  ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
-
-  SendRequest();
-
-  completion_callback_.WaitForResult();
-
-  // SPDY stream has already been removed from the session by Close().
-  EXPECT_FALSE(session_->IsStreamActive(stream_id_));
-  websocket_stream_.reset();
-
-  const std::vector<SpdyWebSocketStreamEvent>& events =
-      delegate.GetSeenEvents();
-  ASSERT_EQ(5U, events.size());
-
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
-            events[0].event_type);
-  EXPECT_EQ(OK, events[0].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
-            events[1].event_type);
-  EXPECT_EQ(OK, events[1].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
-            events[2].event_type);
-  EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
-            events[3].event_type);
-  EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE, events[4].event_type);
-
-  EXPECT_TRUE(
-      HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
-}
-
-TEST_P(SpdyWebSocketStreamTest, IOPending) {
-  Prepare(1);
-  scoped_ptr<SpdyFrame> settings_frame(
-      spdy_util_.ConstructSpdySettings(spdy_settings_to_send_));
-  scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
-  MockWrite writes[] = {
-    CreateMockWrite(*settings_ack, 1),
-    CreateMockWrite(*request_frame_.get(), 2),
-    CreateMockWrite(*message_frame_.get(), 4),
-    CreateMockWrite(*closing_frame_.get(), 6)
-  };
-
-  MockRead reads[] = {
-    CreateMockRead(*settings_frame.get(), 0),
-    CreateMockRead(*response_frame_.get(), 3),
-    CreateMockRead(*message_frame_.get(), 5),
-    CreateMockRead(*closing_frame_.get(), 7),
-    MockRead(SYNCHRONOUS, 0, 8)  // EOF cause OnCloseSpdyStream event.
-  };
-
-  DeterministicSocketData data(reads, arraysize(reads),
-                               writes, arraysize(writes));
-  session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
-  http_session_ =
-      SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
-
-  session_ = CreateInsecureSpdySession(
-      http_session_, spdy_session_key_, BoundNetLog());
-
-  // Create a dummy WebSocketStream which cause ERR_IO_PENDING to another
-  // WebSocketStream under test.
-  SpdyWebSocketStreamEventRecorder block_delegate((CompletionCallback()));
-
-  scoped_ptr<SpdyWebSocketStream> block_stream(
-      new SpdyWebSocketStream(session_, &block_delegate));
-  BoundNetLog block_net_log;
-  GURL block_url("ws://example.com/block");
-  ASSERT_EQ(OK,
-            block_stream->InitializeStream(block_url, HIGHEST, block_net_log));
-
-  data.RunFor(1);
-
-  // Create a WebSocketStream under test.
-  SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
-  delegate.SetOnCreated(
-      base::Bind(&SpdyWebSocketStreamTest::DoSync,
-                 base::Unretained(this)));
-  delegate.SetOnReceivedHeader(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
-                 base::Unretained(this)));
-  delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendClosingFrame,
-                 base::Unretained(this)));
-
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
-  BoundNetLog net_log;
-  GURL url("ws://example.com/echo");
-  ASSERT_EQ(ERR_IO_PENDING, websocket_stream_->InitializeStream(
-      url, HIGHEST, net_log));
-
-  // Delete the fist stream to allow create the second stream.
-  block_stream.reset();
-  ASSERT_EQ(OK, sync_callback_.WaitForResult());
-
-  SendRequest();
-
-  data.RunFor(8);
-  completion_callback_.WaitForResult();
-
-  websocket_stream_.reset();
-
-  const std::vector<SpdyWebSocketStreamEvent>& block_events =
-      block_delegate.GetSeenEvents();
-  ASSERT_EQ(0U, block_events.size());
-
-  const std::vector<SpdyWebSocketStreamEvent>& events =
-      delegate.GetSeenEvents();
-  ASSERT_EQ(8U, events.size());
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CREATED,
-            events[0].event_type);
-  EXPECT_EQ(0, events[0].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
-            events[1].event_type);
-  EXPECT_EQ(OK, events[1].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
-            events[2].event_type);
-  EXPECT_EQ(OK, events[2].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
-            events[3].event_type);
-  EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
-            events[4].event_type);
-  EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[4].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
-            events[5].event_type);
-  EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[5].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
-            events[6].event_type);
-  EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[6].result);
-  EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
-            events[7].event_type);
-  EXPECT_EQ(OK, events[7].result);
-
-  // EOF close SPDY session.
-  EXPECT_FALSE(
-      HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
-  EXPECT_TRUE(data.at_read_eof());
-  EXPECT_TRUE(data.at_write_eof());
-}
-
-}  // namespace net
diff --git a/net/spdy/spdy_websocket_test_util.cc b/net/spdy/spdy_websocket_test_util.cc
deleted file mode 100644
index b1ef81b..0000000
--- a/net/spdy/spdy_websocket_test_util.cc
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "net/spdy/spdy_websocket_test_util.h"
-
-#include "net/spdy/buffered_spdy_framer.h"
-#include "net/spdy/spdy_http_utils.h"
-
-namespace net {
-
-const bool kDefaultCompressed = false;
-
-SpdyWebSocketTestUtil::SpdyWebSocketTestUtil(
-    NextProto protocol) : spdy_util_(protocol) {}
-
-std::string SpdyWebSocketTestUtil::GetHeader(const SpdyHeaderBlock& headers,
-                                             const std::string& key) const {
-  SpdyHeaderBlock::const_iterator it = headers.find(GetHeaderKey(key));
-  return (it == headers.end()) ? "" : it->second;
-}
-
-void SpdyWebSocketTestUtil::SetHeader(
-    const std::string& key,
-    const std::string& value,
-    SpdyHeaderBlock* headers) const {
-  (*headers)[GetHeaderKey(key)] = value;
-}
-
-SpdyFrame* SpdyWebSocketTestUtil::ConstructSpdyWebSocketSynStream(
-    int stream_id,
-    const char* path,
-    const char* host,
-    const char* origin) {
-  scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
-  SetHeader("path", path, headers.get());
-  SetHeader("host", host, headers.get());
-  SetHeader("version", "WebSocket/13", headers.get());
-  SetHeader("scheme", "ws", headers.get());
-  SetHeader("origin", origin, headers.get());
-  return spdy_util_.ConstructSpdySyn(
-      stream_id, *headers, HIGHEST, false, false);
-}
-
-SpdyFrame* SpdyWebSocketTestUtil::ConstructSpdyWebSocketSynReply(
-    int stream_id) {
-  SpdyHeaderBlock block;
-  SetHeader("status", "101", &block);
-  return spdy_util_.ConstructSpdyReply(stream_id, block);
-}
-
-SpdyFrame* SpdyWebSocketTestUtil::ConstructSpdyWebSocketHandshakeRequestFrame(
-    scoped_ptr<SpdyHeaderBlock> headers,
-    SpdyStreamId stream_id,
-    RequestPriority request_priority) {
-  return spdy_util_.ConstructSpdySyn(
-      stream_id, *headers, request_priority, kDefaultCompressed, false);
-}
-
-SpdyFrame* SpdyWebSocketTestUtil::ConstructSpdyWebSocketHandshakeResponseFrame(
-    scoped_ptr<SpdyHeaderBlock> headers,
-    SpdyStreamId stream_id,
-    RequestPriority request_priority) {
-  return spdy_util_.ConstructSpdyReply(stream_id, *headers);
-}
-
-SpdyFrame* SpdyWebSocketTestUtil::ConstructSpdyWebSocketHeadersFrame(
-    int stream_id,
-    const char* length,
-    bool fin) {
-  scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
-  SetHeader("opcode", "1", headers.get());  // text frame
-  SetHeader("length", length, headers.get());
-  SetHeader("fin", fin ? "1" : "0", headers.get());
-  return spdy_util_.ConstructSpdySyn(stream_id, *headers, LOWEST, false, false);
-}
-
-SpdyFrame* SpdyWebSocketTestUtil::ConstructSpdyWebSocketDataFrame(
-    const char* data,
-    int len,
-    SpdyStreamId stream_id,
-    bool fin) {
-
-  // Construct SPDY data frame.
-  BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
-  return framer.CreateDataFrame(
-      stream_id,
-      data,
-      len,
-      fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
-}
-
-SpdyFrame* SpdyWebSocketTestUtil::ConstructSpdySettings(
-    const SettingsMap& settings) const {
-  return spdy_util_.ConstructSpdySettings(settings);
-}
-
-SpdyFrame* SpdyWebSocketTestUtil::ConstructSpdySettingsAck() const {
-  return spdy_util_.ConstructSpdySettingsAck();
-}
-
-SpdyMajorVersion SpdyWebSocketTestUtil::spdy_version() const {
-  return spdy_util_.spdy_version();
-}
-
-std::string SpdyWebSocketTestUtil::GetHeaderKey(
-    const std::string& key) const {
-  return (spdy_util_.is_spdy2() ? "" : ":") + key;
-}
-
-}  // namespace net
diff --git a/net/spdy/spdy_websocket_test_util.h b/net/spdy/spdy_websocket_test_util.h
deleted file mode 100644
index 14c8c02..0000000
--- a/net/spdy/spdy_websocket_test_util.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 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.
-
-#ifndef NET_SPDY_SPDY_WEBSOCKET_TEST_UTIL_H_
-#define NET_SPDY_SPDY_WEBSOCKET_TEST_UTIL_H_
-
-#include "net/base/request_priority.h"
-#include "net/spdy/spdy_header_block.h"
-#include "net/spdy/spdy_protocol.h"
-#include "net/spdy/spdy_test_util_common.h"
-
-namespace net {
-
-class SpdyWebSocketTestUtil {
- public:
-  explicit SpdyWebSocketTestUtil(NextProto protocol);
-
-  // Returns the value corresponding to the given key (passed through
-  // GetHeaderKey()), or the empty string if none exists.
-  std::string GetHeader(const SpdyHeaderBlock& headers,
-                        const std::string& key) const;
-
-  // Adds the given key/value pair to |headers|, passing the key
-  // through GetHeaderKey().
-  void SetHeader(const std::string& key,
-                 const std::string& value,
-                 SpdyHeaderBlock* headers) const;
-
-  // Constructs a standard SPDY SYN_STREAM frame for WebSocket over
-  // SPDY opening handshake.
-  SpdyFrame* ConstructSpdyWebSocketSynStream(int stream_id,
-                                             const char* path,
-                                             const char* host,
-                                             const char* origin);
-
-  // Constructs a standard SPDY SYN_REPLY packet to match the
-  // WebSocket over SPDY opening handshake.
-  SpdyFrame* ConstructSpdyWebSocketSynReply(int stream_id);
-
-  // Constructs a WebSocket over SPDY handshake request packet.
-  SpdyFrame* ConstructSpdyWebSocketHandshakeRequestFrame(
-      scoped_ptr<SpdyHeaderBlock> headers,
-      SpdyStreamId stream_id,
-      RequestPriority request_priority);
-
-  // Constructs a WebSocket over SPDY handshake response packet.
-  SpdyFrame* ConstructSpdyWebSocketHandshakeResponseFrame(
-      scoped_ptr<SpdyHeaderBlock> headers,
-      SpdyStreamId stream_id,
-      RequestPriority request_priority);
-
-  // Constructs a SPDY HEADERS frame for a WebSocket frame over SPDY.
-  SpdyFrame* ConstructSpdyWebSocketHeadersFrame(int stream_id,
-                                                const char* length,
-                                                bool fin);
-
-  // Constructs a WebSocket over SPDY data packet.
-  SpdyFrame* ConstructSpdyWebSocketDataFrame(const char* data,
-                                             int len,
-                                             SpdyStreamId stream_id,
-                                             bool fin);
-
-  // Forwards to |spdy_util_|.
-  SpdyFrame* ConstructSpdySettings(const SettingsMap& settings) const;
-  SpdyFrame* ConstructSpdySettingsAck() const;
-  SpdyMajorVersion spdy_version() const;
-
- private:
-  // Modify the header key based on the SPDY version and return it.
-  std::string GetHeaderKey(const std::string& key) const;
-
-  SpdyTestUtil spdy_util_;
-};
-
-}  // namespace net
-
-#endif  // NET_SPDY_SPDY_WEBSOCKET_TEST_UTIL_H_