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

net/spdy/spdy_proxy_client_socket_spdy3_unittest.cc

Index: net/spdy/spdy_proxy_client_socket_spdy3_unittest.cc
===================================================================
--- net/spdy/spdy_proxy_client_socket_spdy3_unittest.cc	(revision 124690)
+++ net/spdy/spdy_proxy_client_socket_spdy3_unittest.cc	(working copy)
@@ -21,10 +21,12 @@
 #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_spdy3.h"
 #include "testing/platform_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using namespace net::test_spdy3;
+
 //-----------------------------------------------------------------------------
 
 namespace {
@@ -55,9 +57,9 @@
 
 namespace net {
 
-class SpdyProxyClientSocketTest : public PlatformTest {
+class SpdyProxyClientSocketSpdy3Test : public PlatformTest {
  public:
-  SpdyProxyClientSocketTest();
+  SpdyProxyClientSocketSpdy3Test();
 
   virtual void TearDown();
 
@@ -122,10 +124,10 @@
   HostPortProxyPair endpoint_host_port_proxy_pair_;
   scoped_refptr<TransportSocketParams> transport_params_;
 
-  DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest);
+  DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketSpdy3Test);
 };
 
-SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
+SpdyProxyClientSocketSpdy3Test::SpdyProxyClientSocketSpdy3Test()
     : sock_(NULL),
       data_(NULL),
       session_(NULL),
@@ -147,7 +149,7 @@
                                             false)) {
 }
 
-void SpdyProxyClientSocketTest::TearDown() {
+void SpdyProxyClientSocketSpdy3Test::TearDown() {
   sock_.reset(NULL);
   if (session_ != NULL)
     session_->spdy_session_pool()->CloseAllSessions();
@@ -158,7 +160,7 @@
   PlatformTest::TearDown();
 }
 
-void SpdyProxyClientSocketTest::Initialize(MockRead* reads,
+void SpdyProxyClientSocketSpdy3Test::Initialize(MockRead* reads,
                                            size_t reads_count,
                                            MockWrite* writes,
                                            size_t writes_count) {
@@ -203,42 +205,42 @@
                                 session_->http_auth_handler_factory()));
 }
 
-scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer(
+scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketSpdy3Test::CreateBuffer(
     const char* data, int size) {
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(size));
   memcpy(buf->data(), data, size);
   return buf;
 }
 
-void SpdyProxyClientSocketTest::AssertConnectSucceeds() {
+void SpdyProxyClientSocketSpdy3Test::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 SpdyProxyClientSocketSpdy3Test::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 SpdyProxyClientSocketSpdy3Test::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,
-                                                     int len) {
+void SpdyProxyClientSocketSpdy3Test::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 SpdyProxyClientSocketSpdy3Test::AssertAsyncReadEquals(const char* data,
+                                                           int len) {
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
@@ -253,7 +255,8 @@
   ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
 }
 
-void SpdyProxyClientSocketTest::AssertReadStarts(const char* data, int len) {
+void SpdyProxyClientSocketSpdy3Test::AssertReadStarts(const char* data,
+                                                      int len) {
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
   read_buf_ = new IOBuffer(len);
@@ -262,7 +265,8 @@
   EXPECT_TRUE(sock_->IsConnected());
 }
 
-void SpdyProxyClientSocketTest::AssertReadReturns(const char* data, int len) {
+void SpdyProxyClientSocketSpdy3Test::AssertReadReturns(const char* data,
+                                                       int len) {
   EXPECT_TRUE(sock_->IsConnected());
 
   // Now the read will return
@@ -270,24 +274,25 @@
   ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
 }
 
-void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data,
-                                                        int len) {
+void SpdyProxyClientSocketSpdy3Test::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 SpdyProxyClientSocketSpdy3Test::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 SpdyProxyClientSocketSpdy3Test::AssertWriteLength(int len) {
   EXPECT_EQ(len, write_callback_.WaitForResult());
 }
 
-void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds(
+void SpdyProxyClientSocketSpdy3Test::AssertAsyncWriteWithReadsSucceeds(
     const char* data, int len, int num_reads) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
 
@@ -303,7 +308,8 @@
 }
 
 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectRequestFrame() {
+spdy::SpdyFrame*
+SpdyProxyClientSocketSpdy3Test::ConstructConnectRequestFrame() {
   const SpdyHeaderInfo kSynStartHeader = {
     spdy::SYN_STREAM,
     kStreamId,
@@ -329,7 +335,8 @@
 
 // Constructs a SPDY SYN_STREAM frame for a CONNECT request which includes
 // Proxy-Authorization headers.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthRequestFrame() {
+spdy::SpdyFrame*
+SpdyProxyClientSocketSpdy3Test::ConstructConnectAuthRequestFrame() {
   const SpdyHeaderInfo kSynStartHeader = {
     spdy::SYN_STREAM,
     kStreamId,
@@ -355,7 +362,7 @@
 }
 
 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectReplyFrame() {
+spdy::SpdyFrame* SpdyProxyClientSocketSpdy3Test::ConstructConnectReplyFrame() {
   const char* const kStandardReplyHeaders[] = {
       "status", "200 Connection Established",
       "version", "HTTP/1.1"
@@ -372,7 +379,8 @@
 }
 
 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthReplyFrame() {
+spdy::SpdyFrame*
+SpdyProxyClientSocketSpdy3Test::ConstructConnectAuthReplyFrame() {
   const char* const kStandardReplyHeaders[] = {
       "status", "407 Proxy Authentication Required",
       "version", "HTTP/1.1",
@@ -391,7 +399,8 @@
 }
 
 // Constructs a SPDY SYN_REPLY frame with an HTTP 500 error.
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectErrorReplyFrame() {
+spdy::SpdyFrame*
+SpdyProxyClientSocketSpdy3Test::ConstructConnectErrorReplyFrame() {
   const char* const kStandardReplyHeaders[] = {
       "status", "500 Internal Server Error",
       "version", "HTTP/1.1",
@@ -408,14 +417,15 @@
                                    arraysize(kStandardReplyHeaders));
 }
 
-spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructBodyFrame(const char* data,
-                                                               int length) {
+spdy::SpdyFrame* SpdyProxyClientSocketSpdy3Test::ConstructBodyFrame(
+    const char* data,
+    int length) {
   return framer_.CreateDataFrame(kStreamId, data, length, spdy::DATA_FLAG_NONE);
 }
 
 // ----------- Connect
 
-TEST_F(SpdyProxyClientSocketTest, ConnectSendsCorrectRequest) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ConnectSendsCorrectRequest) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -436,7 +446,7 @@
   AssertConnectionEstablished();
 }
 
-TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthRequested) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ConnectWithAuthRequested) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -459,7 +469,7 @@
             response->headers->GetStatusText());
 }
 
-TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ConnectWithAuthCredentials) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectAuthRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -479,7 +489,7 @@
   AssertConnectionEstablished();
 }
 
-TEST_F(SpdyProxyClientSocketTest, ConnectFails) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ConnectFails) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -501,7 +511,7 @@
 
 // ----------- WasEverUsed
 
-TEST_F(SpdyProxyClientSocketTest, WasEverUsedReturnsCorrectValues) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, WasEverUsedReturnsCorrectValues) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -524,7 +534,7 @@
 
 // ----------- GetPeerAddress
 
-TEST_F(SpdyProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, GetPeerAddressReturnsCorrectValues) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -557,7 +567,7 @@
 
 // ----------- Write
 
-TEST_F(SpdyProxyClientSocketTest, WriteSendsDataInDataFrame) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, WriteSendsDataInDataFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
@@ -581,7 +591,7 @@
   AssertAsyncWriteSucceeds(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, WriteSplitsLargeDataIntoMultipleFrames) {
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> chunk(ConstructBodyFrame(chunk_data.data(),
@@ -616,7 +626,7 @@
 
 // ----------- Read
 
-TEST_F(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ReadReadsDataInDataFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -639,7 +649,7 @@
   AssertSyncReadEquals(kMsg1, kLen1);
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadDataFromBufferedFrames) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ReadDataFromBufferedFrames) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -667,7 +677,7 @@
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ReadDataMultipleBufferedFrames) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -693,7 +703,8 @@
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, LargeReadWillMergeDataFromDifferentFrames) {
+TEST_F(SpdyProxyClientSocketSpdy3Test,
+       LargeReadWillMergeDataFromDifferentFrames) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -720,7 +731,7 @@
   AssertSyncReadEquals(kMsg33, kLen33);
 }
 
-TEST_F(SpdyProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, MultipleShortReadsThenMoreRead) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -752,7 +763,7 @@
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ReadWillSplitDataFromLargeFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -782,7 +793,7 @@
   AssertSyncReadEquals(kMsg3, kLen3);
 }
 
-TEST_F(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, MultipleReadsFromSameLargeFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -813,7 +824,7 @@
   ASSERT_TRUE(sock_->IsConnected());
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadAuthResponseBody) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ReadAuthResponseBody) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -839,7 +850,7 @@
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketTest, ReadErrorResponseBody) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ReadErrorResponseBody) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -870,7 +881,7 @@
 
 // ----------- Reads and Writes
 
-TEST_F(SpdyProxyClientSocketTest, AsyncReadAroundWrite) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, AsyncReadAroundWrite) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
@@ -906,7 +917,7 @@
   AssertReadReturns(kMsg3, kLen3);
 }
 
-TEST_F(SpdyProxyClientSocketTest, AsyncWriteAroundReads) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, AsyncWriteAroundReads) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
@@ -945,7 +956,7 @@
 // ----------- Reading/Writing on Closed socket
 
 // Reading from an already closed socket should return 0
-TEST_F(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ReadOnClosedSocketReturnsZero) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -971,7 +982,7 @@
 }
 
 // Read pending when socket is closed should return 0
-TEST_F(SpdyProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, PendingReadOnCloseReturnsZero) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -995,7 +1006,8 @@
 }
 
 // Reading from a disconnected socket is an error
-TEST_F(SpdyProxyClientSocketTest, ReadOnDisconnectSocketReturnsNotConnected) {
+TEST_F(SpdyProxyClientSocketSpdy3Test,
+       ReadOnDisconnectSocketReturnsNotConnected) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1019,7 +1031,7 @@
 
 // Reading buffered data from an already closed socket should return
 // buffered data, then 0.
-TEST_F(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, ReadOnClosedSocketReturnsBufferedData) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1052,7 +1064,7 @@
 }
 
 // Calling Write() on a closed socket is an error
-TEST_F(SpdyProxyClientSocketTest, WriteOnClosedStream) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, WriteOnClosedStream) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1076,7 +1088,7 @@
 }
 
 // Calling Write() on a disconnected socket is an error
-TEST_F(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, WriteOnDisconnectedSocket) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1102,7 +1114,7 @@
 
 // If the socket is closed with a pending Write(), the callback
 // should be called with ERR_CONNECTION_CLOSED.
-TEST_F(SpdyProxyClientSocketTest, WritePendingOnClose) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, WritePendingOnClose) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1132,7 +1144,7 @@
 
 // If the socket is Disconnected with a pending Write(), the callback
 // should not be called.
-TEST_F(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, DisconnectWithWritePending) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1163,7 +1175,7 @@
 
 // If the socket is Disconnected with a pending Read(), the callback
 // should not be called.
-TEST_F(SpdyProxyClientSocketTest, DisconnectWithReadPending) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, DisconnectWithReadPending) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1193,7 +1205,7 @@
 
 // If the socket is Reset when both a read and write are pending,
 // both should be called back.
-TEST_F(SpdyProxyClientSocketTest, RstWithReadAndWritePending) {
+TEST_F(SpdyProxyClientSocketSpdy3Test, RstWithReadAndWritePending) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1260,7 +1272,7 @@
 // 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(SpdyProxyClientSocketSpdy3Test, RstWithReadAndWritePendingDelete) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),