Fork SPDY/2 and SPDY/3 versions of our SPDY tests, in preparation for landing

net/spdy/spdy_proxy_client_socket_spdy2_unittest.cc

 // 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_proxy_client_socket.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/address_list.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/winsock_init.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session_pool.h"
-#include "net/spdy/spdy_test_util.h"
+#include "net/spdy/spdy_test_util_spdy2.h"
 #include "testing/platform_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using namespace net::test_spdy2;
+
 //-----------------------------------------------------------------------------
 
 namespace {
 
 static const char kUrl[] = "https://www.google.com/";
 static const char kOriginHost[] = "www.google.com";
 static const int kOriginPort = 443;
 static const char kOriginHostPort[] = "www.google.com:443";
 static const char kProxyUrl[] = "https://myproxy:6121/";
 static const char kProxyHost[] = "myproxy";
@@ skipping 10 matching lines @@
 static const int kLen3 = 4;
 static const char kMsg33[] = "bye!bye!";
 static const int kLen33 = kLen3 + kLen3;
 static const char kMsg333[] = "bye!bye!bye!";
 static const int kLen333 = kLen3 + kLen3 + kLen3;
 
 }  // anonymous namespace
 
 namespace net {
 
-class SpdyProxyClientSocketTest : public PlatformTest {
+class SpdyProxyClientSocketSpdy2Test : public PlatformTest {
  public:
-  SpdyProxyClientSocketTest();
+  SpdyProxyClientSocketSpdy2Test();
 
   virtual void TearDown();
 
  protected:
   void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
                   size_t writes_count);
   spdy::SpdyFrame* ConstructConnectRequestFrame();
   spdy::SpdyFrame* ConstructConnectAuthRequestFrame();
   spdy::SpdyFrame* ConstructConnectReplyFrame();
   spdy::SpdyFrame* ConstructConnectAuthReplyFrame();
@@ skipping 44 matching lines @@
   spdy::SpdyFramer framer_;
 
   std::string user_agent_;
   GURL url_;
   HostPortPair proxy_host_port_;
   HostPortPair endpoint_host_port_pair_;
   ProxyServer proxy_;
   HostPortProxyPair endpoint_host_port_proxy_pair_;
   scoped_refptr<TransportSocketParams> transport_params_;
 
-  DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest);
+  DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketSpdy2Test);
 };
 
-SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
+SpdyProxyClientSocketSpdy2Test::SpdyProxyClientSocketSpdy2Test()
     : sock_(NULL),
       data_(NULL),
       session_(NULL),
       read_buf_(NULL),
       session_deps_(),
       connect_data_(SYNCHRONOUS, OK),
       spdy_session_(NULL),
       spdy_stream_(NULL),
       framer_(),
       user_agent_(kUserAgent),
       url_(kUrl),
       proxy_host_port_(kProxyHost, kProxyPort),
       endpoint_host_port_pair_(kOriginHost, kOriginPort),
       proxy_(ProxyServer::SCHEME_HTTPS, proxy_host_port_),
       endpoint_host_port_proxy_pair_(endpoint_host_port_pair_, proxy_),
       transport_params_(new TransportSocketParams(proxy_host_port_,
                                             LOWEST,
                                             false,
                                             false)) {
 }
 
-void SpdyProxyClientSocketTest::TearDown() {
+void SpdyProxyClientSocketSpdy2Test::TearDown() {
   sock_.reset(NULL);
   if (session_ != NULL)
     session_->spdy_session_pool()->CloseAllSessions();
 
   spdy::SpdyFramer::set_enable_compression_default(true);
   // Empty the current queue.
   MessageLoop::current()->RunAllPending();
   PlatformTest::TearDown();
 }
 
-void SpdyProxyClientSocketTest::Initialize(MockRead* reads,
+void SpdyProxyClientSocketSpdy2Test::Initialize(MockRead* reads,
                                            size_t reads_count,
                                            MockWrite* writes,
                                            size_t writes_count) {
   data_ = new DeterministicSocketData(reads, reads_count, writes, writes_count);
   data_->set_connect_data(connect_data_);
   data_->SetStop(2);
 
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(
       data_.get());
   session_deps_.host_resolver->set_synchronous_mode(true);
@@ skipping 24 matching lines @@
                                   CompletionCallback()));
 
   // Create the SpdyProxyClientSocket
   sock_.reset(
       new SpdyProxyClientSocket(spdy_stream_, user_agent_,
                                 endpoint_host_port_pair_, url_,
                                 proxy_host_port_, session_->http_auth_cache(),
                                 session_->http_auth_handler_factory()));
 }
 
-scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer(
+scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketSpdy2Test::CreateBuffer(
     const char* data, int size) {
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(size));
   memcpy(buf->data(), data, size);
   return buf;
 }
 
-void SpdyProxyClientSocketTest::AssertConnectSucceeds() {
+void SpdyProxyClientSocketSpdy2Test::AssertConnectSucceeds() {
   ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback()));
   data_->Run();
   ASSERT_EQ(OK, read_callback_.WaitForResult());
 }
 
-void SpdyProxyClientSocketTest::AssertConnectFails(int result) {
+void SpdyProxyClientSocketSpdy2Test::AssertConnectFails(int result) {
   ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback()));
   data_->Run();
   ASSERT_EQ(result, read_callback_.WaitForResult());
 }
 
-void SpdyProxyClientSocketTest::AssertConnectionEstablished() {
+void SpdyProxyClientSocketSpdy2Test::AssertConnectionEstablished() {
   const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_EQ(200, response->headers->response_code());
   ASSERT_EQ("Connection Established", response->headers->GetStatusText());
 }
 
-void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data,
+void SpdyProxyClientSocketSpdy2Test::AssertSyncReadEquals(const char* data,
                                                      int len) {
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
   ASSERT_EQ(len, sock_->Read(buf, len, CompletionCallback()));
   ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
   ASSERT_TRUE(sock_->IsConnected());
 }
 
-void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data,
-                                                     int len) {
+void SpdyProxyClientSocketSpdy2Test::AssertAsyncReadEquals(const char* data,
+                                                           int len) {
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
   ASSERT_EQ(ERR_IO_PENDING, sock_->Read(buf, len, read_callback_.callback()));
   EXPECT_TRUE(sock_->IsConnected());
   data_->Run();
 
   EXPECT_TRUE(sock_->IsConnected());
 
   // Now the read will return
   EXPECT_EQ(len, read_callback_.WaitForResult());
   ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
 }
 
-void SpdyProxyClientSocketTest::AssertReadStarts(const char* data, int len) {
+void SpdyProxyClientSocketSpdy2Test::AssertReadStarts(const char* data,
+                                                      int len) {
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
   read_buf_ = new IOBuffer(len);
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(read_buf_, len, read_callback_.callback()));
   EXPECT_TRUE(sock_->IsConnected());
 }
 
-void SpdyProxyClientSocketTest::AssertReadReturns(const char* data, int len) {
+void SpdyProxyClientSocketSpdy2Test::AssertReadReturns(const char* data,
+                                                       int len) {
   EXPECT_TRUE(sock_->IsConnected());
 
   // Now the read will return
   EXPECT_EQ(len, read_callback_.WaitForResult());
   ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
 }
 
-void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data,
-                                                        int len) {
+void SpdyProxyClientSocketSpdy2Test::AssertAsyncWriteSucceeds(const char* data,
+                                                              int len) {
   AssertWriteReturns(data, len, ERR_IO_PENDING);
   data_->RunFor(1);
   AssertWriteLength(len);
 }
 
-void SpdyProxyClientSocketTest::AssertWriteReturns(const char* data, int len,
-                                                   int rv) {
+void SpdyProxyClientSocketSpdy2Test::AssertWriteReturns(const char* data,
+                                                        int len,
+                                                        int rv) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
   EXPECT_EQ(rv, sock_->Write(buf, buf->size(), write_callback_.callback()));
 }
 
-void SpdyProxyClientSocketTest::AssertWriteLength(int len) {
+void SpdyProxyClientSocketSpdy2Test::AssertWriteLength(int len) {
   EXPECT_EQ(len, write_callback_.WaitForResult());
 }
 
-void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds(
+void SpdyProxyClientSocketSpdy2Test::AssertAsyncWriteWithReadsSucceeds(
     const char* data, int len, int num_reads) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
 
   EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(),
                                          write_callback_.callback()));
 
   for (int i = 0; i < num_reads; i++) {
     Run(1);
     AssertSyncReadEquals(kMsg2, kLen2);
   }
 
   write_callback_.WaitForResult();
 }
 
 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectRequestFrame() {
+spdy::SpdyFrame*
+SpdyProxyClientSocketSpdy2Test::ConstructConnectRequestFrame() {
   const SpdyHeaderInfo kSynStartHeader = {
     spdy::SYN_STREAM,
     kStreamId,
     0,
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),
     spdy::CONTROL_FLAG_NONE,
     false,
     spdy::INVALID,
     NULL,
     0,
     spdy::DATA_FLAG_NONE
   };
   const char* const kConnectHeaders[] = {
     "method", "CONNECT",
     "url", kOriginHostPort,
     "host", kOriginHost,
     "user-agent", kUserAgent,
     "version", "HTTP/1.1",
   };
   return ConstructSpdyPacket(
       kSynStartHeader, NULL, 0, kConnectHeaders, arraysize(kConnectHeaders)/2);
 }
 
 // Constructs a SPDY SYN_STREAM frame for a CONNECT request which includes
 // Proxy-Authorization headers.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthRequestFrame() {
+spdy::SpdyFrame*
+SpdyProxyClientSocketSpdy2Test::ConstructConnectAuthRequestFrame() {
   const SpdyHeaderInfo kSynStartHeader = {
     spdy::SYN_STREAM,
     kStreamId,
     0,
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),
     spdy::CONTROL_FLAG_NONE,
     false,
     spdy::INVALID,
     NULL,
     0,
     spdy::DATA_FLAG_NONE
   };
   const char* const kConnectHeaders[] = {
     "method", "CONNECT",
     "url", kOriginHostPort,
     "host", kOriginHost,
     "user-agent", kUserAgent,
     "version", "HTTP/1.1",
     "proxy-authorization", "Basic Zm9vOmJhcg==",
   };
   return ConstructSpdyPacket(
       kSynStartHeader, NULL, 0, kConnectHeaders, arraysize(kConnectHeaders)/2);
 }
 
 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectReplyFrame() {
+spdy::SpdyFrame* SpdyProxyClientSocketSpdy2Test::ConstructConnectReplyFrame() {
   const char* const kStandardReplyHeaders[] = {
       "status", "200 Connection Established",
       "version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(NULL,
                                    0,
                                    false,
                                    kStreamId,
                                    LOWEST,
                                    spdy::SYN_REPLY,
                                    spdy::CONTROL_FLAG_NONE,
                                    kStandardReplyHeaders,
                                    arraysize(kStandardReplyHeaders));
 }
 
 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthReplyFrame() {
+spdy::SpdyFrame*
+SpdyProxyClientSocketSpdy2Test::ConstructConnectAuthReplyFrame() {
   const char* const kStandardReplyHeaders[] = {
       "status", "407 Proxy Authentication Required",
       "version", "HTTP/1.1",
       "proxy-authenticate", "Basic realm=\"MyRealm1\"",
   };
 
   return ConstructSpdyControlFrame(NULL,
                                    0,
                                    false,
                                    kStreamId,
                                    LOWEST,
                                    spdy::SYN_REPLY,
                                    spdy::CONTROL_FLAG_NONE,
                                    kStandardReplyHeaders,
                                    arraysize(kStandardReplyHeaders));
 }
 
 // Constructs a SPDY SYN_REPLY frame with an HTTP 500 error.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectErrorReplyFrame() {
+spdy::SpdyFrame*
+SpdyProxyClientSocketSpdy2Test::ConstructConnectErrorReplyFrame() {
   const char* const kStandardReplyHeaders[] = {
       "status", "500 Internal Server Error",
       "version", "HTTP/1.1",
   };
 
   return ConstructSpdyControlFrame(NULL,
                                    0,
                                    false,
                                    kStreamId,
                                    LOWEST,
                                    spdy::SYN_REPLY,
                                    spdy::CONTROL_FLAG_NONE,
                                    kStandardReplyHeaders,
                                    arraysize(kStandardReplyHeaders));
 }
 
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructBodyFrame(const char* data,
-                                                               int length) {
+spdy::SpdyFrame* SpdyProxyClientSocketSpdy2Test::ConstructBodyFrame(
+    const char* data,  int length) {
   return framer_.CreateDataFrame(kStreamId, data, length, spdy::DATA_FLAG_NONE);
 }
 
 // ----------- Connect
 
-TEST_F(SpdyProxyClientSocketTest, ConnectSendsCorrectRequest) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectSendsCorrectRequest) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   ASSERT_FALSE(sock_->IsConnected());
 
   AssertConnectSucceeds();
 
   AssertConnectionEstablished();
 }
 
-TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthRequested) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectWithAuthRequested) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectAuthReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectFails(ERR_PROXY_AUTH_REQUESTED);
 
   const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_EQ(407, response->headers->response_code());
   ASSERT_EQ("Proxy Authentication Required",
             response->headers->GetStatusText());
 }
 
-TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectWithAuthCredentials) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectAuthRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
   AddAuthToCache();
 
   AssertConnectSucceeds();
 
   AssertConnectionEstablished();
 }
 
-TEST_F(SpdyProxyClientSocketTest, ConnectFails) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectFails) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     MockRead(ASYNC, 0, 1),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   ASSERT_FALSE(sock_->IsConnected());
 
   AssertConnectFails(ERR_CONNECTION_CLOSED);
 
   ASSERT_FALSE(sock_->IsConnected());
 }
 
 // ----------- WasEverUsed
 
-TEST_F(SpdyProxyClientSocketTest, WasEverUsedReturnsCorrectValues) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, WasEverUsedReturnsCorrectValues) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   EXPECT_FALSE(sock_->WasEverUsed());
   AssertConnectSucceeds();
   EXPECT_TRUE(sock_->WasEverUsed());
   sock_->Disconnect();
   EXPECT_TRUE(sock_->WasEverUsed());
 }
 
 // ----------- GetPeerAddress
 
-TEST_F(SpdyProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, GetPeerAddressReturnsCorrectValues) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),  // EOF
   };
@@ skipping 12 matching lines @@
   EXPECT_FALSE(sock_->IsConnected());
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr));
 
   sock_->Disconnect();
 
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr));
 }
 
 // ----------- Write
 
-TEST_F(SpdyProxyClientSocketTest, WriteSendsDataInDataFrame) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, WriteSendsDataInDataFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
     CreateMockWrite(*msg1, 2, SYNCHRONOUS),
     CreateMockWrite(*msg2, 3, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 4),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   AssertAsyncWriteSucceeds(kMsg1, kLen1);
   AssertAsyncWriteSucceeds(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, WriteSplitsLargeDataIntoMultipleFrames) {
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> chunk(ConstructBodyFrame(chunk_data.data(),
                                                        chunk_data.length()));
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
     CreateMockWrite(*chunk, 2, SYNCHRONOUS),
     CreateMockWrite(*chunk, 3, SYNCHRONOUS),
     CreateMockWrite(*chunk, 4, SYNCHRONOUS)
   };
@@ skipping 14 matching lines @@
 
   EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(),
                                          write_callback_.callback()));
   data_->RunFor(3);
 
   EXPECT_EQ(buf->size(), write_callback_.WaitForResult());
 }
 
 // ----------- Read
 
-TEST_F(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ReadReadsDataInDataFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     CreateMockRead(*msg1, 2, ASYNC),
     MockRead(ASYNC, 0, 3),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(1);  // SpdySession consumes the next read and sends it to
            // sock_ to be buffered.
   AssertSyncReadEquals(kMsg1, kLen1);
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadDataFromBufferedFrames) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ReadDataFromBufferedFrames) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     CreateMockRead(*msg1, 2, ASYNC),
     CreateMockRead(*msg2, 3, ASYNC),
     MockRead(ASYNC, 0, 4),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(1);  // SpdySession consumes the next read and sends it to
            // sock_ to be buffered.
   AssertSyncReadEquals(kMsg1, kLen1);
   Run(1);  // SpdySession consumes the next read and sends it to
            // sock_ to be buffered.
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ReadDataMultipleBufferedFrames) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     CreateMockRead(*msg1, 2, ASYNC),
     CreateMockRead(*msg2, 3, ASYNC),
     MockRead(ASYNC, 0, 4),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(2);  // SpdySession consumes the next two reads and sends then to
            // sock_ to be buffered.
   AssertSyncReadEquals(kMsg1, kLen1);
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, LargeReadWillMergeDataFromDifferentFrames) {
+TEST_F(SpdyProxyClientSocketSpdy2Test,
+       LargeReadWillMergeDataFromDifferentFrames) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     CreateMockRead(*msg3, 2, ASYNC),
     CreateMockRead(*msg3, 3, ASYNC),
     MockRead(ASYNC, 0, 4),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(2);  // SpdySession consumes the next two reads and sends then to
            // sock_ to be buffered.
   // The payload from two data frames, each with kMsg3 will be combined
   // together into a single read().
   AssertSyncReadEquals(kMsg33, kLen33);
 }
 
-TEST_F(SpdyProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, MultipleShortReadsThenMoreRead) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockRead reads[] = {
@@ skipping 11 matching lines @@
 
   Run(4);  // SpdySession consumes the next four reads and sends then to
            // sock_ to be buffered.
   AssertSyncReadEquals(kMsg1, kLen1);
   // The payload from two data frames, each with kMsg3 will be combined
   // together into a single read().
   AssertSyncReadEquals(kMsg33, kLen33);
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ReadWillSplitDataFromLargeFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg33(ConstructBodyFrame(kMsg33, kLen33));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     CreateMockRead(*msg1, 2, ASYNC),
     CreateMockRead(*msg33, 3, ASYNC),
     MockRead(ASYNC, 0, 4),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(2);  // SpdySession consumes the next two reads and sends then to
            // sock_ to be buffered.
   AssertSyncReadEquals(kMsg1, kLen1);
   // The payload from the single large data frame will be read across
   // two different reads.
   AssertSyncReadEquals(kMsg3, kLen3);
   AssertSyncReadEquals(kMsg3, kLen3);
 }
 
-TEST_F(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, MultipleReadsFromSameLargeFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg333(ConstructBodyFrame(kMsg333, kLen333));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     CreateMockRead(*msg333, 2, ASYNC),
@@ skipping 10 matching lines @@
   // two different reads.
   AssertSyncReadEquals(kMsg33, kLen33);
 
   // Now attempt to do a read of more data than remains buffered
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33));
   ASSERT_EQ(kLen3, sock_->Read(buf, kLen33, read_callback_.callback()));
   ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3));
   ASSERT_TRUE(sock_->IsConnected());
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadAuthResponseBody) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ReadAuthResponseBody) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectAuthReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     CreateMockRead(*msg1, 2, ASYNC),
     CreateMockRead(*msg2, 3, ASYNC),
     MockRead(ASYNC, 0, 4),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectFails(ERR_PROXY_AUTH_REQUESTED);
 
   Run(2);  // SpdySession consumes the next two reads and sends then to
            // sock_ to be buffered.
   AssertSyncReadEquals(kMsg1, kLen1);
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadErrorResponseBody) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ReadErrorResponseBody) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectErrorReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
@@ skipping 10 matching lines @@
            // sock_ to be buffered.
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
             sock_->Read(NULL, 1, CompletionCallback()));
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1 + kLen2));
   scoped_ptr<HttpStream> stream(sock_->CreateConnectResponseStream());
   stream->ReadResponseBody(buf, kLen1 + kLen2, read_callback_.callback());
 }
 
 // ----------- Reads and Writes
 
-TEST_F(SpdyProxyClientSocketTest, AsyncReadAroundWrite) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, AsyncReadAroundWrite) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
     CreateMockWrite(*msg2, 3, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
@@ skipping 15 matching lines @@
   // Read should block until after the write succeeds
 
   AssertAsyncWriteSucceeds(kMsg2, kLen2);  // Runs 1 step
 
   ASSERT_FALSE(read_callback_.have_result());
   Run(1);
   // Now the read will return
   AssertReadReturns(kMsg3, kLen3);
 }
 
-TEST_F(SpdyProxyClientSocketTest, AsyncWriteAroundReads) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, AsyncWriteAroundReads) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
     CreateMockWrite(*msg2, 4, ASYNC),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
@@ skipping 18 matching lines @@
   ASSERT_FALSE(write_callback_.have_result());
 
   // Now the write will complete
   Run(1);
   AssertWriteLength(kLen2);
 }
 
 // ----------- Reading/Writing on Closed socket
 
 // Reading from an already closed socket should return 0
-TEST_F(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ReadOnClosedSocketReturnsZero) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(1);
 
   ASSERT_FALSE(sock_->IsConnected());
   ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   ASSERT_FALSE(sock_->IsConnectedAndIdle());
 }
 
 // Read pending when socket is closed should return 0
-TEST_F(SpdyProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, PendingReadOnCloseReturnsZero) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   AssertReadStarts(kMsg1, kLen1);
 
   Run(1);
 
   ASSERT_EQ(0, read_callback_.WaitForResult());
 }
 
 // Reading from a disconnected socket is an error
-TEST_F(SpdyProxyClientSocketTest, ReadOnDisconnectSocketReturnsNotConnected) {
+TEST_F(SpdyProxyClientSocketSpdy2Test,
+       ReadOnDisconnectSocketReturnsNotConnected) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   sock_->Disconnect();
 
   ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
             sock_->Read(NULL, 1, CompletionCallback()));
 }
 
 // Reading buffered data from an already closed socket should return
 // buffered data, then 0.
-TEST_F(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, ReadOnClosedSocketReturnsBufferedData) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     CreateMockRead(*msg1, 2, ASYNC),
@@ skipping 12 matching lines @@
   ASSERT_EQ(std::string(kMsg1, kLen1), std::string(buf->data(), kLen1));
 
   ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   sock_->Disconnect();
   ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
             sock_->Read(NULL, 1, CompletionCallback()));
 }
 
 // Calling Write() on a closed socket is an error
-TEST_F(SpdyProxyClientSocketTest, WriteOnClosedStream) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, WriteOnClosedStream) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(1);  // Read EOF which will close the stream
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
             sock_->Write(buf, buf->size(), CompletionCallback()));
 }
 
 // Calling Write() on a disconnected socket is an error
-TEST_F(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, WriteOnDisconnectedSocket) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   sock_->Disconnect();
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
             sock_->Write(buf, buf->size(), CompletionCallback()));
 }
 
 // If the socket is closed with a pending Write(), the callback
 // should be called with ERR_CONNECTION_CLOSED.
-TEST_F(SpdyProxyClientSocketTest, WritePendingOnClose) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, WritePendingOnClose) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
     MockWrite(ASYNC, ERR_IO_PENDING, 2),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_IO_PENDING,
             sock_->Write(buf, buf->size(), write_callback_.callback()));
 
   Run(1);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, write_callback_.WaitForResult());
 }
 
 // If the socket is Disconnected with a pending Write(), the callback
 // should not be called.
-TEST_F(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, DisconnectWithWritePending) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
     MockWrite(SYNCHRONOUS, 0, 2),  // EOF
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3),  // EOF
@@ skipping 10 matching lines @@
             sock_->Write(buf, buf->size(), write_callback_.callback()));
 
   sock_->Disconnect();
 
   EXPECT_FALSE(sock_->IsConnected());
   EXPECT_FALSE(write_callback_.have_result());
 }
 
 // If the socket is Disconnected with a pending Read(), the callback
 // should not be called.
-TEST_F(SpdyProxyClientSocketTest, DisconnectWithReadPending) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, DisconnectWithReadPending) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1));
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(buf, kLen1, read_callback_.callback()));
 
   sock_->Disconnect();
 
   EXPECT_FALSE(sock_->IsConnected());
   EXPECT_FALSE(read_callback_.have_result());
 }
 
 // If the socket is Reset when both a read and write are pending,
 // both should be called back.
-TEST_F(SpdyProxyClientSocketTest, RstWithReadAndWritePending) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, RstWithReadAndWritePending) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
     MockWrite(ASYNC, ERR_IO_PENDING, 2),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(1, spdy::CANCEL));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
@@ skipping 46 matching lines @@
 
   scoped_ptr<SpdyProxyClientSocket>* sock_;
   CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteSockCallback);
 };
 
 // If the socket is Reset when both a read and write are pending, and the
 // read callback causes the socket to be deleted, the write callback should
 // not be called.
-TEST_F(SpdyProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
+TEST_F(SpdyProxyClientSocketSpdy2Test, RstWithReadAndWritePendingDelete) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
     MockWrite(ASYNC, ERR_IO_PENDING, 2),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(1, spdy::CANCEL));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
@@ skipping 17 matching lines @@
                                          write_callback_.callback()));
 
   Run(2);
 
   EXPECT_FALSE(sock_.get());
   EXPECT_TRUE(read_callback.have_result());
   EXPECT_FALSE(write_callback_.have_result());
 }
 
 }  // namespace net