Merge SpdyProxyClientSocket unittests.

Now that we've got the proper subset of functions merged into SpdyTestUtil,
merge spdy_proxy_client_socket_spdy[23]_unittest into a single unittest.

BUG=226192

Review URL: https://chromiumcodereview.appspot.com/14772037

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

5 files changed, 119 insertions, 1530 deletions

diff --git a/net/net.gyp b/net/net.gyp
index 656a2b4..41775bd 100644
--- a/net/net.gyp
+++ b/net/net.gyp
@@ -1738,8 +1738,7 @@
         'spdy/spdy_network_transaction_spdy2_unittest.cc',
         'spdy/spdy_priority_forest_test.cc',
         'spdy/spdy_protocol_test.cc',
-        'spdy/spdy_proxy_client_socket_spdy3_unittest.cc',
-        'spdy/spdy_proxy_client_socket_spdy2_unittest.cc',
+        'spdy/spdy_proxy_client_socket_unittest.cc',
         'spdy/spdy_read_queue_unittest.cc',
         'spdy/spdy_session_spdy3_unittest.cc',
         'spdy/spdy_session_spdy2_unittest.cc',
diff --git a/net/spdy/spdy_proxy_client_socket_spdy3_unittest.cc b/net/spdy/spdy_proxy_client_socket_spdy3_unittest.cc
deleted file mode 100644
index d301731..0000000
--- a/net/spdy/spdy_proxy_client_socket_spdy3_unittest.cc
+++ /dev/null
@@ -1,1426 +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_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/capturing_net_log.h"
-#include "net/base/net_log.h"
-#include "net/base/net_log_unittest.h"
-#include "net/base/test_completion_callback.h"
-#include "net/base/winsock_init.h"
-#include "net/dns/mock_host_resolver.h"
-#include "net/http/http_response_headers.h"
-#include "net/http/http_response_info.h"
-#include "net/socket/client_socket_factory.h"
-#include "net/socket/next_proto.h"
-#include "net/socket/socket_test_util.h"
-#include "net/socket/tcp_client_socket.h"
-#include "net/spdy/buffered_spdy_framer.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_common.h"
-#include "net/spdy/spdy_test_util_spdy3.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-using namespace net::test_spdy3;
-
-//-----------------------------------------------------------------------------
-
-namespace {
-
-static const char kRequestUrl[] = "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";
-static const int kProxyPort = 6121;
-static const char kUserAgent[] = "Mozilla/1.0";
-
-static const int kStreamId = 1;
-
-static const char kMsg1[] = "\0hello!\xff";
-static const int kLen1 = 8;
-static const char kMsg2[] = "\00012345678\0";
-static const int kLen2 = 10;
-static const char kMsg3[] = "bye!";
-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;
-
-static const char kRedirectUrl[] = "https://example.com/";
-
-}  // anonymous namespace
-
-namespace net {
-
-class SpdyProxyClientSocketSpdy3Test : public PlatformTest {
- public:
-  SpdyProxyClientSocketSpdy3Test();
-
-  virtual void TearDown();
-
- protected:
-  void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
-                  size_t writes_count);
-  SpdyFrame* ConstructConnectRequestFrame();
-  SpdyFrame* ConstructConnectAuthRequestFrame();
-  SpdyFrame* ConstructConnectReplyFrame();
-  SpdyFrame* ConstructConnectAuthReplyFrame();
-  SpdyFrame* ConstructConnectRedirectReplyFrame();
-  SpdyFrame* ConstructConnectErrorReplyFrame();
-  SpdyFrame* ConstructBodyFrame(const char* data, int length);
-  scoped_refptr<IOBufferWithSize> CreateBuffer(const char* data, int size);
-  void AssertConnectSucceeds();
-  void AssertConnectFails(int result);
-  void AssertConnectionEstablished();
-  void AssertSyncReadEquals(const char* data, int len);
-  void AssertAsyncReadEquals(const char* data, int len);
-  void AssertReadStarts(const char* data, int len);
-  void AssertReadReturns(const char* data, int len);
-  void AssertAsyncWriteSucceeds(const char* data, int len);
-  void AssertWriteReturns(const char* data, int len, int rv);
-  void AssertWriteLength(int len);
-  void AssertAsyncWriteWithReadsSucceeds(const char* data, int len,
-                                        int num_reads);
-
-  void AddAuthToCache() {
-    const base::string16 kFoo(ASCIIToUTF16("foo"));
-    const base::string16 kBar(ASCIIToUTF16("bar"));
-    session_->http_auth_cache()->Add(GURL(kProxyUrl),
-                                     "MyRealm1",
-                                     HttpAuth::AUTH_SCHEME_BASIC,
-                                     "Basic realm=MyRealm1",
-                                     AuthCredentials(kFoo, kBar),
-                                     "/");
-  }
-
-  void Run(int steps) {
-    data_->StopAfter(steps);
-    data_->Run();
-  }
-
-  SpdyTestUtil spdy_util_;
-  scoped_ptr<SpdyProxyClientSocket> sock_;
-  TestCompletionCallback read_callback_;
-  TestCompletionCallback write_callback_;
-  scoped_ptr<DeterministicSocketData> data_;
-  CapturingBoundNetLog net_log_;
-
- private:
-  scoped_refptr<HttpNetworkSession> session_;
-  scoped_refptr<IOBuffer> read_buf_;
-  SpdySessionDependencies session_deps_;
-  MockConnect connect_data_;
-  scoped_refptr<SpdySession> spdy_session_;
-  BufferedSpdyFramer 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(SpdyProxyClientSocketSpdy3Test);
-};
-
-SpdyProxyClientSocketSpdy3Test::SpdyProxyClientSocketSpdy3Test()
-    : spdy_util_(kProtoSPDY3),
-      sock_(NULL),
-      data_(NULL),
-      session_(NULL),
-      read_buf_(NULL),
-      session_deps_(kProtoSPDY3),
-      connect_data_(SYNCHRONOUS, OK),
-      spdy_session_(NULL),
-      framer_(3, false),
-      user_agent_(kUserAgent),
-      url_(kRequestUrl),
-      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,
-                                                  OnHostResolutionCallback())) {
-  session_deps_.net_log = net_log_.bound().net_log();
-}
-
-void SpdyProxyClientSocketSpdy3Test::TearDown() {
-  sock_.reset(NULL);
-  if (session_ != NULL)
-    session_->spdy_session_pool()->CloseAllSessions();
-
-  // Empty the current queue.
-  MessageLoop::current()->RunUntilIdle();
-  PlatformTest::TearDown();
-}
-
-void SpdyProxyClientSocketSpdy3Test::Initialize(MockRead* reads,
-                                                size_t reads_count,
-                                                MockWrite* writes,
-                                                size_t writes_count) {
-  data_.reset(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);
-
-  session_ = SpdySessionDependencies::SpdyCreateSessionDeterministic(
-      &session_deps_);
-
-  // Creates a new spdy session.
-  spdy_session_ =
-      session_->spdy_session_pool()->Get(endpoint_host_port_proxy_pair_,
-                                         net_log_.bound());
-
-  // Perform the TCP connect.
-  scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-  EXPECT_EQ(OK,
-            connection->Init(endpoint_host_port_pair_.ToString(),
-                             transport_params_, LOWEST, CompletionCallback(),
-                             session_->GetTransportSocketPool(
-                                 HttpNetworkSession::NORMAL_SOCKET_POOL),
-                             net_log_.bound()));
-  spdy_session_->InitializeWithSocket(connection.release(), false, OK);
-
-  // Create the SPDY Stream.
-  base::WeakPtr<SpdyStream> spdy_stream(
-      CreateStreamSynchronously(
-          spdy_session_, url_, LOWEST, net_log_.bound()));
-  ASSERT_TRUE(spdy_stream.get() != NULL);
-
-  // Create the SpdyProxyClientSocket.
-  sock_.reset(
-      new SpdyProxyClientSocket(spdy_stream, user_agent_,
-                                endpoint_host_port_pair_, url_,
-                                proxy_host_port_,  net_log_.bound(),
-                                session_->http_auth_cache(),
-                                session_->http_auth_handler_factory()));
-}
-
-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 SpdyProxyClientSocketSpdy3Test::AssertConnectSucceeds() {
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback()));
-  data_->Run();
-  ASSERT_EQ(OK, read_callback_.WaitForResult());
-}
-
-void SpdyProxyClientSocketSpdy3Test::AssertConnectFails(int result) {
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback()));
-  data_->Run();
-  ASSERT_EQ(result, read_callback_.WaitForResult());
-}
-
-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 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 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));
-  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 SpdyProxyClientSocketSpdy3Test::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 SpdyProxyClientSocketSpdy3Test::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 SpdyProxyClientSocketSpdy3Test::AssertAsyncWriteSucceeds(const char* data,
-                                                              int len) {
-  AssertWriteReturns(data, len, ERR_IO_PENDING);
-  data_->RunFor(1);
-  AssertWriteLength(len);
-}
-
-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 SpdyProxyClientSocketSpdy3Test::AssertWriteLength(int len) {
-  EXPECT_EQ(len, write_callback_.WaitForResult());
-}
-
-void SpdyProxyClientSocketSpdy3Test::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.
-SpdyFrame*
-SpdyProxyClientSocketSpdy3Test::ConstructConnectRequestFrame() {
-  const SpdyHeaderInfo kSynStartHeader = {
-    SYN_STREAM,
-    kStreamId,
-    0,
-    net::ConvertRequestPriorityToSpdyPriority(LOWEST, 3),
-    0,
-    CONTROL_FLAG_NONE,
-    false,
-    RST_STREAM_INVALID,
-    NULL,
-    0,
-    DATA_FLAG_NONE
-  };
-  const char* const kConnectHeaders[] = {
-    ":method", "CONNECT",
-    ":path", kOriginHostPort,
-    ":host", kOriginHost,
-    "user-agent", kUserAgent,
-    ":version", "HTTP/1.1",
-  };
-  return spdy_util_.ConstructSpdyFrame(
-      kSynStartHeader, NULL, 0, kConnectHeaders, arraysize(kConnectHeaders)/2);
-}
-
-// Constructs a SPDY SYN_STREAM frame for a CONNECT request which includes
-// Proxy-Authorization headers.
-SpdyFrame*
-SpdyProxyClientSocketSpdy3Test::ConstructConnectAuthRequestFrame() {
-  const SpdyHeaderInfo kSynStartHeader = {
-    SYN_STREAM,
-    kStreamId,
-    0,
-    net::ConvertRequestPriorityToSpdyPriority(LOWEST, 3),
-    0,
-    CONTROL_FLAG_NONE,
-    false,
-    RST_STREAM_INVALID,
-    NULL,
-    0,
-    DATA_FLAG_NONE
-  };
-  const char* const kConnectHeaders[] = {
-    ":method", "CONNECT",
-    ":path", kOriginHostPort,
-    ":host", kOriginHost,
-    "user-agent", kUserAgent,
-    ":version", "HTTP/1.1",
-    "proxy-authorization", "Basic Zm9vOmJhcg==",
-  };
-  return spdy_util_.ConstructSpdyFrame(
-      kSynStartHeader, NULL, 0, kConnectHeaders, arraysize(kConnectHeaders)/2);
-}
-
-// Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
-SpdyFrame* SpdyProxyClientSocketSpdy3Test::ConstructConnectReplyFrame() {
-  const char* const kStandardReplyHeaders[] = {
-      ":status", "200 Connection Established",
-      ":version", "HTTP/1.1"
-  };
-  return spdy_util_.ConstructSpdyControlFrame(NULL,
-                                              0,
-                                              false,
-                                              kStreamId,
-                                              LOWEST,
-                                              SYN_REPLY,
-                                              CONTROL_FLAG_NONE,
-                                              kStandardReplyHeaders,
-                                              arraysize(kStandardReplyHeaders),
-                                              0);
-}
-
-// Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
-SpdyFrame*
-SpdyProxyClientSocketSpdy3Test::ConstructConnectAuthReplyFrame() {
-  const char* const kStandardReplyHeaders[] = {
-      ":status", "407 Proxy Authentication Required",
-      ":version", "HTTP/1.1",
-      "proxy-authenticate", "Basic realm=\"MyRealm1\"",
-  };
-
-  return spdy_util_.ConstructSpdyControlFrame(NULL,
-                                              0,
-                                              false,
-                                              kStreamId,
-                                              LOWEST,
-                                              SYN_REPLY,
-                                              CONTROL_FLAG_NONE,
-                                              kStandardReplyHeaders,
-                                              arraysize(kStandardReplyHeaders),
-                                              0);
-}
-
-// Constructs a SPDY SYN_REPLY frame with an HTTP 302 redirect.
-SpdyFrame*
-SpdyProxyClientSocketSpdy3Test::ConstructConnectRedirectReplyFrame() {
-  const char* const kStandardReplyHeaders[] = {
-      ":status", "302 Found",
-      ":version", "HTTP/1.1",
-      "location", kRedirectUrl,
-      "set-cookie", "foo=bar"
-  };
-
-  return spdy_util_.ConstructSpdyControlFrame(NULL,
-                                              0,
-                                              false,
-                                              kStreamId,
-                                              LOWEST,
-                                              SYN_REPLY,
-                                              CONTROL_FLAG_NONE,
-                                              kStandardReplyHeaders,
-                                              arraysize(kStandardReplyHeaders),
-                                              0);
-}
-
-// Constructs a SPDY SYN_REPLY frame with an HTTP 500 error.
-SpdyFrame*
-SpdyProxyClientSocketSpdy3Test::ConstructConnectErrorReplyFrame() {
-  const char* const kStandardReplyHeaders[] = {
-      ":status", "500 Internal Server Error",
-      ":version", "HTTP/1.1",
-  };
-
-  return spdy_util_.ConstructSpdyControlFrame(NULL,
-                                              0,
-                                              false,
-                                              kStreamId,
-                                              LOWEST,
-                                              SYN_REPLY,
-                                              CONTROL_FLAG_NONE,
-                                              kStandardReplyHeaders,
-                                              arraysize(kStandardReplyHeaders),
-                                              0);
-}
-
-SpdyFrame* SpdyProxyClientSocketSpdy3Test::ConstructBodyFrame(
-    const char* data,
-    int length) {
-  return framer_.CreateDataFrame(kStreamId, data, length, DATA_FLAG_NONE);
-}
-
-// ----------- Connect
-
-TEST_F(SpdyProxyClientSocketSpdy3Test, ConnectSendsCorrectRequest) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    MockRead(ASYNC, 0, 2),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  ASSERT_FALSE(sock_->IsConnected());
-
-  AssertConnectSucceeds();
-
-  AssertConnectionEstablished();
-}
-
-TEST_F(SpdyProxyClientSocketSpdy3Test, ConnectWithAuthRequested) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectAuthReplyFrame());
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    MockRead(ASYNC, 0, 2),  // 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(SpdyProxyClientSocketSpdy3Test, ConnectWithAuthCredentials) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectAuthRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    MockRead(ASYNC, 0, 2),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-  AddAuthToCache();
-
-  AssertConnectSucceeds();
-
-  AssertConnectionEstablished();
-}
-
-TEST_F(SpdyProxyClientSocketSpdy3Test, ConnectRedirects) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectRedirectReplyFrame());
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    MockRead(ASYNC, 0, 2),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  AssertConnectFails(ERR_HTTPS_PROXY_TUNNEL_RESPONSE);
-
-  const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
-  ASSERT_TRUE(response != NULL);
-
-  const HttpResponseHeaders* headers = response->headers;
-  ASSERT_EQ(302, headers->response_code());
-  ASSERT_FALSE(headers->HasHeader("set-cookie"));
-  ASSERT_TRUE(headers->HasHeaderValue("content-length", "0"));
-
-  std::string location;
-  ASSERT_TRUE(headers->IsRedirect(&location));
-  ASSERT_EQ(location, kRedirectUrl);
-}
-
-TEST_F(SpdyProxyClientSocketSpdy3Test, ConnectFails) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, WasEverUsedReturnsCorrectValues) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, GetPeerAddressReturnsCorrectValues) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    MockRead(ASYNC, 0, 2),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  net::IPEndPoint addr;
-  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr));
-
-  AssertConnectSucceeds();
-  EXPECT_TRUE(sock_->IsConnected());
-  EXPECT_EQ(OK, sock_->GetPeerAddress(&addr));
-
-  Run(1);
-
-  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(SpdyProxyClientSocketSpdy3Test, WriteSendsDataInDataFrame) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    CreateMockWrite(*msg1, 2, SYNCHRONOUS),
-    CreateMockWrite(*msg2, 3, SYNCHRONOUS),
-  };
-
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, WriteSplitsLargeDataIntoMultipleFrames) {
-  std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  scoped_ptr<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)
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    MockRead(ASYNC, 0, 5),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  AssertConnectSucceeds();
-
-  std::string big_data(kMaxSpdyFrameChunkSize * 3, 'x');
-  scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(),
-                                                   big_data.length()));
-
-  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(SpdyProxyClientSocketSpdy3Test, ReadReadsDataInDataFrame) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, ReadDataFromBufferedFrames) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, ReadDataMultipleBufferedFrames) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test,
-       LargeReadWillMergeDataFromDifferentFrames) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, MultipleShortReadsThenMoreRead) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
-  scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    CreateMockRead(*msg1, 2, ASYNC),
-    CreateMockRead(*msg3, 3, ASYNC),
-    CreateMockRead(*msg3, 4, ASYNC),
-    CreateMockRead(*msg2, 5, ASYNC),
-    MockRead(ASYNC, 0, 6),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  AssertConnectSucceeds();
-
-  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(SpdyProxyClientSocketSpdy3Test, ReadWillSplitDataFromLargeFrame) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<SpdyFrame> msg33(ConstructBodyFrame(kMsg33, kLen33));
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, MultipleReadsFromSameLargeFrame) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> msg333(ConstructBodyFrame(kMsg333, kLen333));
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    CreateMockRead(*msg333, 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.
-  // The payload from the single large data frame will be read across
-  // 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(SpdyProxyClientSocketSpdy3Test, ReadAuthResponseBody) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectAuthReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, ReadErrorResponseBody) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectErrorReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<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_TUNNEL_CONNECTION_FAILED);
-}
-
-// ----------- Reads and Writes
-
-TEST_F(SpdyProxyClientSocketSpdy3Test, AsyncReadAroundWrite) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    CreateMockWrite(*msg2, 3, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    CreateMockRead(*msg1, 2, ASYNC),  // sync read
-    CreateMockRead(*msg3, 4, ASYNC),  // async read
-    MockRead(ASYNC, 0, 5),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  AssertConnectSucceeds();
-
-  Run(1);
-  AssertSyncReadEquals(kMsg1, kLen1);
-
-  AssertReadStarts(kMsg3, kLen3);
-  // 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(SpdyProxyClientSocketSpdy3Test, AsyncWriteAroundReads) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    CreateMockWrite(*msg2, 4, ASYNC),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
-  scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    CreateMockRead(*msg1, 2, ASYNC),
-    CreateMockRead(*msg3, 3, ASYNC),
-    MockRead(ASYNC, 0, 5),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  AssertConnectSucceeds();
-
-  Run(1);
-  AssertSyncReadEquals(kMsg1, kLen1);
-  // Write should block until the read completes
-  AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
-
-  AssertAsyncReadEquals(kMsg3, kLen3);
-
-  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(SpdyProxyClientSocketSpdy3Test, ReadOnClosedSocketReturnsZero) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, PendingReadOnCloseReturnsZero) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test,
-       ReadOnDisconnectSocketReturnsNotConnected) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, ReadOnClosedSocketReturnsBufferedData) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<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(2);
-
-  ASSERT_FALSE(sock_->IsConnected());
-  scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1));
-  ASSERT_EQ(kLen1, sock_->Read(buf, kLen1, CompletionCallback()));
-  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(SpdyProxyClientSocketSpdy3Test, WriteOnClosedStream) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, WriteOnDisconnectedSocket) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, WritePendingOnClose) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    MockWrite(ASYNC, ERR_IO_PENDING, 2),
-  };
-
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, DisconnectWithWritePending) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    MockWrite(SYNCHRONOUS, 0, 2),  // EOF
-  };
-
-  scoped_ptr<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()));
-
-  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(SpdyProxyClientSocketSpdy3Test, DisconnectWithReadPending) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<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(SpdyProxyClientSocketSpdy3Test, RstWithReadAndWritePending) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    MockWrite(ASYNC, ERR_IO_PENDING, 2),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> rst(
-      spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    CreateMockRead(*rst, 3, ASYNC),
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  AssertConnectSucceeds();
-
-  EXPECT_TRUE(sock_->IsConnected());
-
-  scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
-  ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Read(read_buf, kLen1, read_callback_.callback()));
-
-  scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_IO_PENDING,
-            sock_->Write(write_buf, write_buf->size(),
-                         write_callback_.callback()));
-
-  Run(2);
-
-  EXPECT_TRUE(sock_.get());
-  EXPECT_TRUE(read_callback_.have_result());
-  EXPECT_TRUE(write_callback_.have_result());
-}
-
-// Makes sure the proxy client socket's source gets the expected NetLog events
-// and only the expected NetLog events (No SpdySession events).
-TEST_F(SpdyProxyClientSocketSpdy3Test, NetLog) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<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);
-
-  NetLog::Source sock_source = sock_->NetLog().source();
-  sock_.reset();
-
-  CapturingNetLog::CapturedEntryList entry_list;
-  net_log_.GetEntriesForSource(sock_source, &entry_list);
-
-  ASSERT_EQ(entry_list.size(), 10u);
-  EXPECT_TRUE(LogContainsBeginEvent(entry_list, 0, NetLog::TYPE_SOCKET_ALIVE));
-  EXPECT_TRUE(LogContainsEvent(entry_list, 1,
-                  NetLog::TYPE_SPDY_PROXY_CLIENT_SESSION,
-                  NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsBeginEvent(entry_list, 2,
-                  NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
-  EXPECT_TRUE(LogContainsEvent(entry_list, 3,
-                  NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
-                  NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(entry_list, 4,
-                  NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
-  EXPECT_TRUE(LogContainsBeginEvent(entry_list, 5,
-                  NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
-  EXPECT_TRUE(LogContainsEvent(entry_list, 6,
-                  NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
-                  NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(entry_list, 7,
-                  NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
-  EXPECT_TRUE(LogContainsEvent(entry_list, 8,
-                  NetLog::TYPE_SOCKET_BYTES_RECEIVED,
-                  NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(entry_list, 9, NetLog::TYPE_SOCKET_ALIVE));
-}
-
-// CompletionCallback that causes the SpdyProxyClientSocket to be
-// deleted when Run is invoked.
-class DeleteSockCallback : public TestCompletionCallbackBase {
- public:
-  explicit DeleteSockCallback(scoped_ptr<SpdyProxyClientSocket>* sock)
-      : sock_(sock),
-        callback_(base::Bind(&DeleteSockCallback::OnComplete,
-                             base::Unretained(this))) {
-  }
-
-  virtual ~DeleteSockCallback() {
-  }
-
-  const CompletionCallback& callback() const { return callback_; }
-
- private:
-  void OnComplete(int result) {
-    sock_->reset(NULL);
-    SetResult(result);
-  }
-
-  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(SpdyProxyClientSocketSpdy3Test, RstWithReadAndWritePendingDelete) {
-  scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
-  MockWrite writes[] = {
-    CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    MockWrite(ASYNC, ERR_IO_PENDING, 2),
-  };
-
-  scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
-  scoped_ptr<SpdyFrame> rst(
-      spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
-  MockRead reads[] = {
-    CreateMockRead(*resp, 1, ASYNC),
-    CreateMockRead(*rst, 3, ASYNC),
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  AssertConnectSucceeds();
-
-  EXPECT_TRUE(sock_->IsConnected());
-
-  DeleteSockCallback read_callback(&sock_);
-
-  scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
-  ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Read(read_buf, kLen1, read_callback.callback()));
-
-  scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(write_buf, write_buf->size(),
-                                         write_callback_.callback()));
-
-  Run(2);
-
-  EXPECT_FALSE(sock_.get());
-  EXPECT_TRUE(read_callback.have_result());
-  EXPECT_FALSE(write_callback_.have_result());
-}
-
-}  // namespace net
diff --git a/net/spdy/spdy_proxy_client_socket_spdy2_unittest.cc b/net/spdy/spdy_proxy_client_socket_unittest.cc
index 163f9a1..6e27d47 100644
--- a/net/spdy/spdy_proxy_client_socket_spdy2_unittest.cc
+++ b/net/spdy/spdy_proxy_client_socket_unittest.cc
@@ -25,12 +25,9 @@
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util_common.h"
-#include "net/spdy/spdy_test_util_spdy2.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
-using namespace net::test_spdy2;
-
 //-----------------------------------------------------------------------------
 
 namespace {
@@ -63,9 +60,11 @@ static const char kRedirectUrl[] = "https://example.com/";
 
 namespace net {
 
-class SpdyProxyClientSocketSpdy2Test : public PlatformTest {
+class SpdyProxyClientSocketTest
+    : public PlatformTest,
+      public testing::WithParamInterface<NextProto> {
  public:
-  SpdyProxyClientSocketSpdy2Test();
+  SpdyProxyClientSocketTest();
 
   virtual void TearDown();
 
@@ -132,19 +131,23 @@ class SpdyProxyClientSocketSpdy2Test : public PlatformTest {
   HostPortProxyPair endpoint_host_port_proxy_pair_;
   scoped_refptr<TransportSocketParams> transport_params_;
 
-  DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketSpdy2Test);
+  DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest);
 };
 
-SpdyProxyClientSocketSpdy2Test::SpdyProxyClientSocketSpdy2Test()
-    : spdy_util_(kProtoSPDY2),
+INSTANTIATE_TEST_CASE_P(NextProto,
+                        SpdyProxyClientSocketTest,
+                        testing::Values(kProtoSPDY2, kProtoSPDY3));
+
+SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
+    : spdy_util_(GetParam()),
       sock_(NULL),
       data_(NULL),
       session_(NULL),
       read_buf_(NULL),
-      session_deps_(kProtoSPDY2),
+      session_deps_(GetParam()),
       connect_data_(SYNCHRONOUS, OK),
       spdy_session_(NULL),
-      framer_(2, false),
+      framer_(spdy_util_.spdy_version(), false),
       user_agent_(kUserAgent),
       url_(kRequestUrl),
       proxy_host_port_(kProxyHost, kProxyPort),
@@ -159,7 +162,7 @@ SpdyProxyClientSocketSpdy2Test::SpdyProxyClientSocketSpdy2Test()
   session_deps_.net_log = net_log_.bound().net_log();
 }
 
-void SpdyProxyClientSocketSpdy2Test::TearDown() {
+void SpdyProxyClientSocketTest::TearDown() {
   sock_.reset(NULL);
   if (session_ != NULL)
     session_->spdy_session_pool()->CloseAllSessions();
@@ -169,7 +172,7 @@ void SpdyProxyClientSocketSpdy2Test::TearDown() {
   PlatformTest::TearDown();
 }
 
-void SpdyProxyClientSocketSpdy2Test::Initialize(MockRead* reads,
+void SpdyProxyClientSocketTest::Initialize(MockRead* reads,
                                                 size_t reads_count,
                                                 MockWrite* writes,
                                                 size_t writes_count) {
@@ -215,33 +218,33 @@ void SpdyProxyClientSocketSpdy2Test::Initialize(MockRead* reads,
                                 session_->http_auth_handler_factory()));
 }
 
-scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketSpdy2Test::CreateBuffer(
+scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer(
     const char* data, int size) {
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(size));
   memcpy(buf->data(), data, size);
   return buf;
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertConnectSucceeds() {
+void SpdyProxyClientSocketTest::AssertConnectSucceeds() {
   ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback()));
   data_->Run();
   ASSERT_EQ(OK, read_callback_.WaitForResult());
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertConnectFails(int result) {
+void SpdyProxyClientSocketTest::AssertConnectFails(int result) {
   ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback()));
   data_->Run();
   ASSERT_EQ(result, read_callback_.WaitForResult());
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertConnectionEstablished() {
+void SpdyProxyClientSocketTest::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 SpdyProxyClientSocketSpdy2Test::AssertSyncReadEquals(const char* data,
+void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data,
                                                      int len) {
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
   ASSERT_EQ(len, sock_->Read(buf, len, CompletionCallback()));
@@ -249,7 +252,7 @@ void SpdyProxyClientSocketSpdy2Test::AssertSyncReadEquals(const char* data,
   ASSERT_TRUE(sock_->IsConnected());
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertAsyncReadEquals(const char* data,
+void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data,
                                                            int len) {
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
@@ -265,7 +268,7 @@ void SpdyProxyClientSocketSpdy2Test::AssertAsyncReadEquals(const char* data,
   ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertReadStarts(const char* data,
+void SpdyProxyClientSocketTest::AssertReadStarts(const char* data,
                                                       int len) {
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
@@ -275,7 +278,7 @@ void SpdyProxyClientSocketSpdy2Test::AssertReadStarts(const char* data,
   EXPECT_TRUE(sock_->IsConnected());
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertReadReturns(const char* data,
+void SpdyProxyClientSocketTest::AssertReadReturns(const char* data,
                                                        int len) {
   EXPECT_TRUE(sock_->IsConnected());
 
@@ -284,25 +287,25 @@ void SpdyProxyClientSocketSpdy2Test::AssertReadReturns(const char* data,
   ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertAsyncWriteSucceeds(const char* data,
+void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data,
                                                               int len) {
   AssertWriteReturns(data, len, ERR_IO_PENDING);
   data_->RunFor(1);
   AssertWriteLength(len);
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertWriteReturns(const char* data,
+void SpdyProxyClientSocketTest::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 SpdyProxyClientSocketSpdy2Test::AssertWriteLength(int len) {
+void SpdyProxyClientSocketTest::AssertWriteLength(int len) {
   EXPECT_EQ(len, write_callback_.WaitForResult());
 }
 
-void SpdyProxyClientSocketSpdy2Test::AssertAsyncWriteWithReadsSucceeds(
+void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds(
     const char* data, int len, int num_reads) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
 
@@ -319,13 +322,14 @@ void SpdyProxyClientSocketSpdy2Test::AssertAsyncWriteWithReadsSucceeds(
 
 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
 SpdyFrame*
-SpdyProxyClientSocketSpdy2Test::ConstructConnectRequestFrame() {
+SpdyProxyClientSocketTest::ConstructConnectRequestFrame() {
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_STREAM,
     kStreamId,
     0,
-    net::ConvertRequestPriorityToSpdyPriority(LOWEST, 2),
-    kSpdyCredentialSlotUnused,
+    net::ConvertRequestPriorityToSpdyPriority(
+        LOWEST, spdy_util_.spdy_version()),
+    0,
     CONTROL_FLAG_NONE,
     false,
     RST_STREAM_INVALID,
@@ -333,12 +337,13 @@ SpdyProxyClientSocketSpdy2Test::ConstructConnectRequestFrame() {
     0,
     DATA_FLAG_NONE
   };
+  bool spdy2 = spdy_util_.is_spdy2();
   const char* const kConnectHeaders[] = {
-    "method", "CONNECT",
-    "url", kOriginHostPort,
-    "host", kOriginHost,
+    spdy2 ? "method"  : ":method",  "CONNECT",
+    spdy2 ? "url"     : ":path",    kOriginHostPort,
+    spdy2 ? "host"    : ":host",    kOriginHost,
     "user-agent", kUserAgent,
-    "version", "HTTP/1.1",
+    spdy2 ? "version" : ":version", "HTTP/1.1",
   };
   return spdy_util_.ConstructSpdyFrame(
       kSynStartHeader, NULL, 0, kConnectHeaders, arraysize(kConnectHeaders)/2);
@@ -347,13 +352,14 @@ SpdyProxyClientSocketSpdy2Test::ConstructConnectRequestFrame() {
 // Constructs a SPDY SYN_STREAM frame for a CONNECT request which includes
 // Proxy-Authorization headers.
 SpdyFrame*
-SpdyProxyClientSocketSpdy2Test::ConstructConnectAuthRequestFrame() {
+SpdyProxyClientSocketTest::ConstructConnectAuthRequestFrame() {
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_STREAM,
     kStreamId,
     0,
-    net::ConvertRequestPriorityToSpdyPriority(LOWEST, 2),
-    kSpdyCredentialSlotUnused,
+    net::ConvertRequestPriorityToSpdyPriority(
+        LOWEST, spdy_util_.spdy_version()),
+    0,
     CONTROL_FLAG_NONE,
     false,
     RST_STREAM_INVALID,
@@ -361,12 +367,13 @@ SpdyProxyClientSocketSpdy2Test::ConstructConnectAuthRequestFrame() {
     0,
     DATA_FLAG_NONE
   };
+  bool spdy2 = spdy_util_.is_spdy2();
   const char* const kConnectHeaders[] = {
-    "method", "CONNECT",
-    "url", kOriginHostPort,
-    "host", kOriginHost,
+    spdy2 ? "method"  : ":method",  "CONNECT",
+    spdy2 ? "url"     : ":path",    kOriginHostPort,
+    spdy2 ? "host"    : ":host",    kOriginHost,
     "user-agent", kUserAgent,
-    "version", "HTTP/1.1",
+    spdy2 ? "version" : ":version", "HTTP/1.1",
     "proxy-authorization", "Basic Zm9vOmJhcg==",
   };
   return spdy_util_.ConstructSpdyFrame(
@@ -374,10 +381,11 @@ SpdyProxyClientSocketSpdy2Test::ConstructConnectAuthRequestFrame() {
 }
 
 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
-SpdyFrame* SpdyProxyClientSocketSpdy2Test::ConstructConnectReplyFrame() {
+SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectReplyFrame() {
+  bool spdy2 = spdy_util_.is_spdy2();
   const char* const kStandardReplyHeaders[] = {
-      "status", "200 Connection Established",
-      "version", "HTTP/1.1"
+      spdy2 ? "status"  : ":status",  "200 Connection Established",
+      spdy2 ? "version" : ":version", "HTTP/1.1"
   };
   return spdy_util_.ConstructSpdyControlFrame(NULL,
                                               0,
@@ -393,10 +401,12 @@ SpdyFrame* SpdyProxyClientSocketSpdy2Test::ConstructConnectReplyFrame() {
 
 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
 SpdyFrame*
-SpdyProxyClientSocketSpdy2Test::ConstructConnectAuthReplyFrame() {
+SpdyProxyClientSocketTest::ConstructConnectAuthReplyFrame() {
+  bool spdy2 = spdy_util_.is_spdy2();
+
   const char* const kStandardReplyHeaders[] = {
-      "status", "407 Proxy Authentication Required",
-      "version", "HTTP/1.1",
+      spdy2 ? "status"  : ":status",  "407 Proxy Authentication Required",
+      spdy2 ? "version" : ":version", "HTTP/1.1",
       "proxy-authenticate", "Basic realm=\"MyRealm1\"",
   };
 
@@ -414,10 +424,12 @@ SpdyProxyClientSocketSpdy2Test::ConstructConnectAuthReplyFrame() {
 
 // Constructs a SPDY SYN_REPLY frame with an HTTP 302 redirect.
 SpdyFrame*
-SpdyProxyClientSocketSpdy2Test::ConstructConnectRedirectReplyFrame() {
+SpdyProxyClientSocketTest::ConstructConnectRedirectReplyFrame() {
+  bool spdy2 = spdy_util_.is_spdy2();
+
   const char* const kStandardReplyHeaders[] = {
-      "status", "302 Found",
-      "version", "HTTP/1.1",
+      spdy2 ? "status"  : ":status",  "302 Found",
+      spdy2 ? "version" : ":version", "HTTP/1.1",
       "location", kRedirectUrl,
       "set-cookie", "foo=bar"
   };
@@ -436,10 +448,12 @@ SpdyProxyClientSocketSpdy2Test::ConstructConnectRedirectReplyFrame() {
 
 // Constructs a SPDY SYN_REPLY frame with an HTTP 500 error.
 SpdyFrame*
-SpdyProxyClientSocketSpdy2Test::ConstructConnectErrorReplyFrame() {
+SpdyProxyClientSocketTest::ConstructConnectErrorReplyFrame() {
+  bool spdy2 = spdy_util_.is_spdy2();
+
   const char* const kStandardReplyHeaders[] = {
-      "status", "500 Internal Server Error",
-      "version", "HTTP/1.1",
+      spdy2 ? "status"  : ":status",  "500 Internal Server Error",
+      spdy2 ? "version" : ":version", "HTTP/1.1",
   };
 
   return spdy_util_.ConstructSpdyControlFrame(NULL,
@@ -454,14 +468,15 @@ SpdyProxyClientSocketSpdy2Test::ConstructConnectErrorReplyFrame() {
                                               0);
 }
 
-SpdyFrame* SpdyProxyClientSocketSpdy2Test::ConstructBodyFrame(
-    const char* data,  int length) {
+SpdyFrame* SpdyProxyClientSocketTest::ConstructBodyFrame(
+    const char* data,
+    int length) {
   return framer_.CreateDataFrame(kStreamId, data, length, DATA_FLAG_NONE);
 }
 
 // ----------- Connect
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectSendsCorrectRequest) {
+TEST_P(SpdyProxyClientSocketTest, ConnectSendsCorrectRequest) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -482,7 +497,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectSendsCorrectRequest) {
   AssertConnectionEstablished();
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectWithAuthRequested) {
+TEST_P(SpdyProxyClientSocketTest, ConnectWithAuthRequested) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -505,7 +520,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectWithAuthRequested) {
             response->headers->GetStatusText());
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectWithAuthCredentials) {
+TEST_P(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectAuthRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -525,7 +540,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectWithAuthCredentials) {
   AssertConnectionEstablished();
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectRedirects) {
+TEST_P(SpdyProxyClientSocketTest, ConnectRedirects) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -554,7 +569,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectRedirects) {
   ASSERT_EQ(location, kRedirectUrl);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectFails) {
+TEST_P(SpdyProxyClientSocketTest, ConnectFails) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -576,7 +591,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ConnectFails) {
 
 // ----------- WasEverUsed
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, WasEverUsedReturnsCorrectValues) {
+TEST_P(SpdyProxyClientSocketTest, WasEverUsedReturnsCorrectValues) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -599,7 +614,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, WasEverUsedReturnsCorrectValues) {
 
 // ----------- GetPeerAddress
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, GetPeerAddressReturnsCorrectValues) {
+TEST_P(SpdyProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -632,7 +647,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, GetPeerAddressReturnsCorrectValues) {
 
 // ----------- Write
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, WriteSendsDataInDataFrame) {
+TEST_P(SpdyProxyClientSocketTest, WriteSendsDataInDataFrame) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
@@ -656,7 +671,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, WriteSendsDataInDataFrame) {
   AssertAsyncWriteSucceeds(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, WriteSplitsLargeDataIntoMultipleFrames) {
+TEST_P(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<SpdyFrame> chunk(ConstructBodyFrame(chunk_data.data(),
@@ -691,7 +706,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, WriteSplitsLargeDataIntoMultipleFrames) {
 
 // ----------- Read
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ReadReadsDataInDataFrame) {
+TEST_P(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -714,7 +729,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ReadReadsDataInDataFrame) {
   AssertSyncReadEquals(kMsg1, kLen1);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ReadDataFromBufferedFrames) {
+TEST_P(SpdyProxyClientSocketTest, ReadDataFromBufferedFrames) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -742,7 +757,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ReadDataFromBufferedFrames) {
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ReadDataMultipleBufferedFrames) {
+TEST_P(SpdyProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -768,7 +783,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ReadDataMultipleBufferedFrames) {
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test,
+TEST_P(SpdyProxyClientSocketTest,
        LargeReadWillMergeDataFromDifferentFrames) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
@@ -796,7 +811,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test,
   AssertSyncReadEquals(kMsg33, kLen33);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, MultipleShortReadsThenMoreRead) {
+TEST_P(SpdyProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -828,7 +843,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, MultipleShortReadsThenMoreRead) {
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ReadWillSplitDataFromLargeFrame) {
+TEST_P(SpdyProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -858,7 +873,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ReadWillSplitDataFromLargeFrame) {
   AssertSyncReadEquals(kMsg3, kLen3);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, MultipleReadsFromSameLargeFrame) {
+TEST_P(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -889,7 +904,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, MultipleReadsFromSameLargeFrame) {
   ASSERT_TRUE(sock_->IsConnected());
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ReadAuthResponseBody) {
+TEST_P(SpdyProxyClientSocketTest, ReadAuthResponseBody) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -915,7 +930,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ReadAuthResponseBody) {
   AssertSyncReadEquals(kMsg2, kLen2);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, ReadErrorResponseBody) {
+TEST_P(SpdyProxyClientSocketTest, ReadErrorResponseBody) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -938,7 +953,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ReadErrorResponseBody) {
 
 // ----------- Reads and Writes
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, AsyncReadAroundWrite) {
+TEST_P(SpdyProxyClientSocketTest, AsyncReadAroundWrite) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
@@ -974,7 +989,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, AsyncReadAroundWrite) {
   AssertReadReturns(kMsg3, kLen3);
 }
 
-TEST_F(SpdyProxyClientSocketSpdy2Test, AsyncWriteAroundReads) {
+TEST_P(SpdyProxyClientSocketTest, AsyncWriteAroundReads) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
@@ -1013,7 +1028,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, AsyncWriteAroundReads) {
 // ----------- Reading/Writing on Closed socket
 
 // Reading from an already closed socket should return 0
-TEST_F(SpdyProxyClientSocketSpdy2Test, ReadOnClosedSocketReturnsZero) {
+TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1039,7 +1054,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ReadOnClosedSocketReturnsZero) {
 }
 
 // Read pending when socket is closed should return 0
-TEST_F(SpdyProxyClientSocketSpdy2Test, PendingReadOnCloseReturnsZero) {
+TEST_P(SpdyProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1063,7 +1078,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, PendingReadOnCloseReturnsZero) {
 }
 
 // Reading from a disconnected socket is an error
-TEST_F(SpdyProxyClientSocketSpdy2Test,
+TEST_P(SpdyProxyClientSocketTest,
        ReadOnDisconnectSocketReturnsNotConnected) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
@@ -1088,7 +1103,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test,
 
 // Reading buffered data from an already closed socket should return
 // buffered data, then 0.
-TEST_F(SpdyProxyClientSocketSpdy2Test, ReadOnClosedSocketReturnsBufferedData) {
+TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1121,7 +1136,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, ReadOnClosedSocketReturnsBufferedData) {
 }
 
 // Calling Write() on a closed socket is an error
-TEST_F(SpdyProxyClientSocketSpdy2Test, WriteOnClosedStream) {
+TEST_P(SpdyProxyClientSocketTest, WriteOnClosedStream) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1145,7 +1160,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, WriteOnClosedStream) {
 }
 
 // Calling Write() on a disconnected socket is an error
-TEST_F(SpdyProxyClientSocketSpdy2Test, WriteOnDisconnectedSocket) {
+TEST_P(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1171,7 +1186,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, WriteOnDisconnectedSocket) {
 
 // If the socket is closed with a pending Write(), the callback
 // should be called with ERR_CONNECTION_CLOSED.
-TEST_F(SpdyProxyClientSocketSpdy2Test, WritePendingOnClose) {
+TEST_P(SpdyProxyClientSocketTest, WritePendingOnClose) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1201,7 +1216,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, WritePendingOnClose) {
 
 // If the socket is Disconnected with a pending Write(), the callback
 // should not be called.
-TEST_F(SpdyProxyClientSocketSpdy2Test, DisconnectWithWritePending) {
+TEST_P(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1232,7 +1247,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, DisconnectWithWritePending) {
 
 // If the socket is Disconnected with a pending Read(), the callback
 // should not be called.
-TEST_F(SpdyProxyClientSocketSpdy2Test, DisconnectWithReadPending) {
+TEST_P(SpdyProxyClientSocketTest, DisconnectWithReadPending) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1262,7 +1277,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, DisconnectWithReadPending) {
 
 // If the socket is Reset when both a read and write are pending,
 // both should be called back.
-TEST_F(SpdyProxyClientSocketSpdy2Test, RstWithReadAndWritePending) {
+TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePending) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1301,7 +1316,7 @@ TEST_F(SpdyProxyClientSocketSpdy2Test, RstWithReadAndWritePending) {
 
 // Makes sure the proxy client socket's source gets the expected NetLog events
 // and only the expected NetLog events (No SpdySession events).
-TEST_F(SpdyProxyClientSocketSpdy2Test, NetLog) {
+TEST_P(SpdyProxyClientSocketTest, NetLog) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ -1384,7 +1399,7 @@ class DeleteSockCallback : public TestCompletionCallbackBase {
 // 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(SpdyProxyClientSocketSpdy2Test, RstWithReadAndWritePendingDelete) {
+TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 51fb839..25007aa 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -552,13 +552,12 @@ scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlock(
     base::StringPiece url) const {
   std::string scheme, host, path;
   ParseUrl(url.data(), &scheme, &host, &path);
-  const bool spdy2 = protocol_ < kProtoSPDY3;
   const char* const headers[] = {
-    spdy2 ? "method"  : ":method",  "GET",
-    spdy2 ? "url"     : ":path",    path.c_str(),
-    spdy2 ? "host"    : ":host",    host.c_str(),
-    spdy2 ? "scheme"  : ":scheme",  scheme.c_str(),
-    spdy2 ? "version" : ":version", "HTTP/1.1"
+    is_spdy2() ? "method"  : ":method",  "GET",
+    is_spdy2() ? "url"     : ":path",    path.c_str(),
+    is_spdy2() ? "host"    : ":host",    host.c_str(),
+    is_spdy2() ? "scheme"  : ":scheme",  scheme.c_str(),
+    is_spdy2() ? "version" : ":version", "HTTP/1.1"
   };
   scoped_ptr<SpdyHeaderBlock> header_block(new SpdyHeaderBlock());
   AppendToHeaderBlock(headers, arraysize(headers) / 2, header_block.get());
@@ -571,13 +570,12 @@ scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPostHeaderBlock(
   std::string scheme, host, path;
   ParseUrl(url.data(), &scheme, &host, &path);
   std::string length_str = base::Int64ToString(content_length);
-  const bool spdy2 = protocol_ < kProtoSPDY3;
   const char* const headers[] = {
-    spdy2 ? "method"  : ":method",  "POST",
-    spdy2 ? "url"     : ":path",    path.c_str(),
-    spdy2 ? "host"    : ":host",    host.c_str(),
-    spdy2 ? "scheme"  : ":scheme",  scheme.c_str(),
-    spdy2 ? "version" : ":version", "HTTP/1.1",
+    is_spdy2() ? "method"  : ":method",  "POST",
+    is_spdy2() ? "url"     : ":path",    path.c_str(),
+    is_spdy2() ? "host"    : ":host",    host.c_str(),
+    is_spdy2() ? "scheme"  : ":scheme",  scheme.c_str(),
+    is_spdy2() ? "version" : ":version", "HTTP/1.1",
     "content-length",               length_str.c_str()
   };
   scoped_ptr<SpdyHeaderBlock> header_block(new SpdyHeaderBlock());
@@ -589,7 +587,6 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(
     const SpdyHeaderInfo& header_info,
     scoped_ptr<SpdyHeaderBlock> headers) const {
   BufferedSpdyFramer framer(spdy_version_, header_info.compressed);
-  const bool spdy2 = protocol_ < kProtoSPDY3;
   SpdyFrame* frame = NULL;
   switch (header_info.kind) {
     case DATA:
@@ -598,11 +595,14 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(
                                      header_info.data_flags);
       break;
     case SYN_STREAM:
-      frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
-                                     header_info.priority,
-                                     spdy2 ? 0 : header_info.credential_slot,
-                                     header_info.control_flags,
-                                     header_info.compressed, headers.get());
+      {
+        size_t credential_slot = is_spdy2() ? 0 : header_info.credential_slot;
+        frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
+                                       header_info.priority,
+                                       credential_slot,
+                                       header_info.control_flags,
+                                       header_info.compressed, headers.get());
+      }
       break;
     case SYN_REPLY:
       frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
diff --git a/net/spdy/spdy_test_util_common.h b/net/spdy/spdy_test_util_common.h
index 22c3327..8cbb334 100644
--- a/net/spdy/spdy_test_util_common.h
+++ b/net/spdy/spdy_test_util_common.h
@@ -352,6 +352,7 @@ class SpdyTestUtil {
 
   NextProto protocol() const { return protocol_; }
   int spdy_version() const { return spdy_version_; }
+  bool is_spdy2() const { return protocol_ < kProtoSPDY3; }
   scoped_ptr<SpdyFramer> CreateFramer() const;
 
  private: