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

net/websockets/websocket_job_spdy2_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/websockets/websocket_job.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/transport_security_state.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket_stream/socket_stream.h"
 #include "net/spdy/spdy_session.h"
-#include "net/spdy/spdy_test_util.h"
-#include "net/spdy/spdy_websocket_test_util.h"
+#include "net/spdy/spdy_test_util_spdy2.h"
+#include "net/spdy/spdy_websocket_test_util_spdy2.h"
 #include "net/url_request/url_request_context.h"
 #include "net/websockets/websocket_throttle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
+using namespace net::test_spdy2;
+
 namespace {
 
 class MockSocketStream : public net::SocketStream {
  public:
   MockSocketStream(const GURL& url, net::SocketStream::Delegate* delegate)
       : SocketStream(url, delegate) {}
   virtual ~MockSocketStream() {}
 
   virtual void Connect() OVERRIDE {}
   virtual bool SendData(const char* data, int len) OVERRIDE {
@@ skipping 204 matching lines @@
 
   net::TransportSecurityState transport_security_state_;
 };
 
 class MockHttpTransactionFactory : public net::HttpTransactionFactory {
  public:
   MockHttpTransactionFactory(net::OrderedSocketData* data) {
     data_ = data;
     net::MockConnect connect_data(net::SYNCHRONOUS, net::OK);
     data_->set_connect_data(connect_data);
-    session_deps_.reset(new net::SpdySessionDependencies);
+    session_deps_.reset(new SpdySessionDependencies);
     session_deps_->socket_factory->AddSocketDataProvider(data_);
     http_session_ =
-        net::SpdySessionDependencies::SpdyCreateSession(session_deps_.get());
+        SpdySessionDependencies::SpdyCreateSession(session_deps_.get());
     host_port_pair_.set_host("example.com");
     host_port_pair_.set_port(80);
     host_port_proxy_pair_.first = host_port_pair_;
     host_port_proxy_pair_.second = net::ProxyServer::Direct();
     net::SpdySessionPool* spdy_session_pool =
         http_session_->spdy_session_pool();
     DCHECK(spdy_session_pool);
     EXPECT_FALSE(spdy_session_pool->HasSession(host_port_proxy_pair_));
     session_ =
         spdy_session_pool->Get(host_port_proxy_pair_, net::BoundNetLog());
@@ skipping 18 matching lines @@
   }
   virtual net::HttpCache* GetCache() {
     NOTREACHED();
     return NULL;
   }
   virtual net::HttpNetworkSession* GetSession() {
     return http_session_.get();
   }
  private:
   net::OrderedSocketData* data_;
-  scoped_ptr<net::SpdySessionDependencies> session_deps_;
+  scoped_ptr<SpdySessionDependencies> session_deps_;
   scoped_refptr<net::HttpNetworkSession> http_session_;
   scoped_refptr<net::TransportSocketParams> transport_params_;
   scoped_refptr<net::SpdySession> session_;
   net::HostPortPair host_port_pair_;
   net::HostPortProxyPair host_port_proxy_pair_;
 };
-}
+}  // namespace
 
 namespace net {
 
-class WebSocketJobTest : public PlatformTest {
+class WebSocketJobSpdy2Test : public PlatformTest {
  public:
   virtual void SetUp() {
     spdy::SpdyFramer::set_enable_compression_default(false);
     stream_type_ = STREAM_INVALID;
     cookie_store_ = new MockCookieStore;
     context_ = new MockURLRequestContext(cookie_store_.get());
   }
   virtual void TearDown() {
     cookie_store_ = NULL;
     context_ = NULL;
@@ skipping 139 matching lines @@
   static const char* const kHandshakeResponseForSpdy[];
   static const size_t kHandshakeRequestWithoutCookieLength;
   static const size_t kHandshakeRequestWithCookieLength;
   static const size_t kHandshakeRequestWithFilteredCookieLength;
   static const size_t kHandshakeResponseWithoutCookieLength;
   static const size_t kHandshakeResponseWithCookieLength;
   static const size_t kDataHelloLength;
   static const size_t kDataWorldLength;
 };
 
-const char WebSocketJobTest::kHandshakeRequestWithoutCookie[] =
+const char WebSocketJobSpdy2Test::kHandshakeRequestWithoutCookie[] =
     "GET /demo HTTP/1.1\r\n"
     "Host: example.com\r\n"
     "Connection: Upgrade\r\n"
     "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
     "Sec-WebSocket-Protocol: sample\r\n"
     "Upgrade: WebSocket\r\n"
     "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
     "Origin: http://example.com\r\n"
     "\r\n"
     "^n:ds[4U";
 
-const char WebSocketJobTest::kHandshakeRequestWithCookie[] =
+const char WebSocketJobSpdy2Test::kHandshakeRequestWithCookie[] =
     "GET /demo HTTP/1.1\r\n"
     "Host: example.com\r\n"
     "Connection: Upgrade\r\n"
     "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
     "Sec-WebSocket-Protocol: sample\r\n"
     "Upgrade: WebSocket\r\n"
     "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
     "Origin: http://example.com\r\n"
     "Cookie: WK-test=1\r\n"
     "\r\n"
     "^n:ds[4U";
 
-const char WebSocketJobTest::kHandshakeRequestWithFilteredCookie[] =
+const char WebSocketJobSpdy2Test::kHandshakeRequestWithFilteredCookie[] =
     "GET /demo HTTP/1.1\r\n"
     "Host: example.com\r\n"
     "Connection: Upgrade\r\n"
     "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
     "Sec-WebSocket-Protocol: sample\r\n"
     "Upgrade: WebSocket\r\n"
     "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
     "Origin: http://example.com\r\n"
     "Cookie: CR-test=1; CR-test-httponly=1\r\n"
     "\r\n"
     "^n:ds[4U";
 
-const char WebSocketJobTest::kHandshakeResponseWithoutCookie[] =
+const char WebSocketJobSpdy2Test::kHandshakeResponseWithoutCookie[] =
     "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
     "Upgrade: WebSocket\r\n"
     "Connection: Upgrade\r\n"
     "Sec-WebSocket-Origin: http://example.com\r\n"
     "Sec-WebSocket-Location: ws://example.com/demo\r\n"
     "Sec-WebSocket-Protocol: sample\r\n"
     "\r\n"
     "8jKS'y:G*Co,Wxa-";
 
-const char WebSocketJobTest::kHandshakeResponseWithCookie[] =
+const char WebSocketJobSpdy2Test::kHandshakeResponseWithCookie[] =
     "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
     "Upgrade: WebSocket\r\n"
     "Connection: Upgrade\r\n"
     "Sec-WebSocket-Origin: http://example.com\r\n"
     "Sec-WebSocket-Location: ws://example.com/demo\r\n"
     "Sec-WebSocket-Protocol: sample\r\n"
     "Set-Cookie: CR-set-test=1\r\n"
     "\r\n"
     "8jKS'y:G*Co,Wxa-";
 
-const char WebSocketJobTest::kDataHello[] = "Hello, ";
+const char WebSocketJobSpdy2Test::kDataHello[] = "Hello, ";
 
-const char WebSocketJobTest::kDataWorld[] = "World!\n";
+const char WebSocketJobSpdy2Test::kDataWorld[] = "World!\n";
 
 // TODO(toyoshim): I should clarify which WebSocket headers for handshake must
 // be exported to SPDY SYN_STREAM and SYN_REPLY.
 // Because it depends on HyBi versions, just define it as follow for now.
-const char* const WebSocketJobTest::kHandshakeRequestForSpdy[] = {
+const char* const WebSocketJobSpdy2Test::kHandshakeRequestForSpdy[] = {
   "host", "example.com",
   "origin", "http://example.com",
   "sec-websocket-protocol", "sample",
   "url", "ws://example.com/demo"
 };
 
-const char* const WebSocketJobTest::kHandshakeResponseForSpdy[] = {
+const char* const WebSocketJobSpdy2Test::kHandshakeResponseForSpdy[] = {
   "sec-websocket-origin", "http://example.com",
   "sec-websocket-location", "ws://example.com/demo",
   "sec-websocket-protocol", "sample",
 };
 
-const size_t WebSocketJobTest::kHandshakeRequestWithoutCookieLength =
+const size_t WebSocketJobSpdy2Test::kHandshakeRequestWithoutCookieLength =
     arraysize(kHandshakeRequestWithoutCookie) - 1;
-const size_t WebSocketJobTest::kHandshakeRequestWithCookieLength =
+const size_t WebSocketJobSpdy2Test::kHandshakeRequestWithCookieLength =
     arraysize(kHandshakeRequestWithCookie) - 1;
-const size_t WebSocketJobTest::kHandshakeRequestWithFilteredCookieLength =
+const size_t WebSocketJobSpdy2Test::kHandshakeRequestWithFilteredCookieLength =
     arraysize(kHandshakeRequestWithFilteredCookie) - 1;
-const size_t WebSocketJobTest::kHandshakeResponseWithoutCookieLength =
+const size_t WebSocketJobSpdy2Test::kHandshakeResponseWithoutCookieLength =
     arraysize(kHandshakeResponseWithoutCookie) - 1;
-const size_t WebSocketJobTest::kHandshakeResponseWithCookieLength =
+const size_t WebSocketJobSpdy2Test::kHandshakeResponseWithCookieLength =
     arraysize(kHandshakeResponseWithCookie) - 1;
-const size_t WebSocketJobTest::kDataHelloLength =
+const size_t WebSocketJobSpdy2Test::kDataHelloLength =
     arraysize(kDataHello) - 1;
-const size_t WebSocketJobTest::kDataWorldLength =
+const size_t WebSocketJobSpdy2Test::kDataWorldLength =
     arraysize(kDataWorld) - 1;
 
-void WebSocketJobTest::TestSimpleHandshake() {
+void WebSocketJobSpdy2Test::TestSimpleHandshake() {
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
   SkipToConnecting();
 
   DoSendRequest();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
   websocket_->OnSentData(socket_.get(),
                          kHandshakeRequestWithoutCookieLength);
   EXPECT_EQ(kHandshakeRequestWithoutCookieLength, delegate.amount_sent());
 
   websocket_->OnReceivedData(socket_.get(),
                              kHandshakeResponseWithoutCookie,
                              kHandshakeResponseWithoutCookieLength);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
   CloseWebSocketJob();
 }
 
-void WebSocketJobTest::TestSlowHandshake() {
+void WebSocketJobSpdy2Test::TestSlowHandshake() {
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
   SkipToConnecting();
 
   DoSendRequest();
   // We assume request is sent in one data chunk (from WebKit)
   // We don't support streaming request.
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
@@ skipping 17 matching lines @@
   websocket_->OnReceivedData(socket_.get(), "\r\n", 2);
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(delegate.received_data().empty());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
   websocket_->OnReceivedData(socket_.get(), "8jKS'y:G*Co,Wxa-", 16);
   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
   CloseWebSocketJob();
 }
 
-TEST_F(WebSocketJobTest, DelayedCookies) {
+TEST_F(WebSocketJobSpdy2Test, DelayedCookies) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   GURL url("ws://example.com/demo");
   GURL cookieUrl("http://example.com/demo");
   CookieOptions cookie_options;
   scoped_refptr<DelayedCookieMonster> cookie_store = new DelayedCookieMonster();
   context_->set_cookie_store(cookie_store);
   cookie_store->SetCookieWithOptionsAsync(
       cookieUrl, "CR-test=1", cookie_options,
       net::CookieMonster::SetCookiesCallback());
   cookie_options.set_include_httponly();
@@ skipping 19 matching lines @@
   websocket_->OnReceivedData(socket_.get(),
                              kHandshakeResponseWithCookie,
                              kHandshakeResponseWithCookieLength);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
 
   CloseWebSocketJob();
 }
 
-void WebSocketJobTest::TestHandshakeWithCookie() {
+void WebSocketJobSpdy2Test::TestHandshakeWithCookie() {
   GURL url("ws://example.com/demo");
   GURL cookieUrl("http://example.com/demo");
   CookieOptions cookie_options;
   cookie_store_->SetCookieWithOptions(
       cookieUrl, "CR-test=1", cookie_options);
   cookie_options.set_include_httponly();
   cookie_store_->SetCookieWithOptions(
       cookieUrl, "CR-test-httponly=1", cookie_options);
 
   MockSocketStreamDelegate delegate;
@@ skipping 22 matching lines @@
   EXPECT_EQ(cookieUrl, cookie_store_->entries()[0].url);
   EXPECT_EQ("CR-test=1", cookie_store_->entries()[0].cookie_line);
   EXPECT_EQ(cookieUrl, cookie_store_->entries()[1].url);
   EXPECT_EQ("CR-test-httponly=1", cookie_store_->entries()[1].cookie_line);
   EXPECT_EQ(cookieUrl, cookie_store_->entries()[2].url);
   EXPECT_EQ("CR-set-test=1", cookie_store_->entries()[2].cookie_line);
 
   CloseWebSocketJob();
 }
 
-void WebSocketJobTest::TestHandshakeWithCookieButNotAllowed() {
+void WebSocketJobSpdy2Test::TestHandshakeWithCookieButNotAllowed() {
   GURL url("ws://example.com/demo");
   GURL cookieUrl("http://example.com/demo");
   CookieOptions cookie_options;
   cookie_store_->SetCookieWithOptions(
       cookieUrl, "CR-test=1", cookie_options);
   cookie_options.set_include_httponly();
   cookie_store_->SetCookieWithOptions(
       cookieUrl, "CR-test-httponly=1", cookie_options);
 
   MockSocketStreamDelegate delegate;
@@ skipping 20 matching lines @@
 
   EXPECT_EQ(2U, cookie_store_->entries().size());
   EXPECT_EQ(cookieUrl, cookie_store_->entries()[0].url);
   EXPECT_EQ("CR-test=1", cookie_store_->entries()[0].cookie_line);
   EXPECT_EQ(cookieUrl, cookie_store_->entries()[1].url);
   EXPECT_EQ("CR-test-httponly=1", cookie_store_->entries()[1].cookie_line);
 
   CloseWebSocketJob();
 }
 
-void WebSocketJobTest::TestHSTSUpgrade() {
+void WebSocketJobSpdy2Test::TestHSTSUpgrade() {
   GURL url("ws://upgrademe.com/");
   MockSocketStreamDelegate delegate;
   scoped_refptr<SocketStreamJob> job =
       SocketStreamJob::CreateSocketStreamJob(
           url, &delegate, context_->transport_security_state(),
           context_->ssl_config_service());
   EXPECT_TRUE(GetSocket(job.get())->is_secure());
   job->DetachDelegate();
 
   url = GURL("ws://donotupgrademe.com/");
   job = SocketStreamJob::CreateSocketStreamJob(
       url, &delegate, context_->transport_security_state(),
       context_->ssl_config_service());
   EXPECT_FALSE(GetSocket(job.get())->is_secure());
   job->DetachDelegate();
 }
 
-void WebSocketJobTest::TestInvalidSendData() {
+void WebSocketJobSpdy2Test::TestInvalidSendData() {
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
   SkipToConnecting();
 
   DoSendRequest();
   // We assume request is sent in one data chunk (from WebKit)
   // We don't support streaming request.
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
@@ skipping 10 matching lines @@
   CloseWebSocketJob();
 }
 
 // Following tests verify cooperation between WebSocketJob and SocketStream.
 // Other former tests use MockSocketStream as SocketStream, so we could not
 // check SocketStream behavior.
 // OrderedSocketData provide socket level verifiation by checking out-going
 // packets in comparison with the MockWrite array and emulating in-coming
 // packets with MockRead array.
 
-void WebSocketJobTest::TestConnectByWebSocket(ThrottlingOption throttling) {
+void WebSocketJobSpdy2Test::TestConnectByWebSocket(
+    ThrottlingOption throttling) {
   // This is a test for verifying cooperation between WebSocketJob and
   // SocketStream. If |throttling| was |THROTTLING_OFF|, it test basic
   // situation. If |throttling| was |THROTTLING_ON|, throttling limits the
   // latter connection.
   MockWrite writes[] = {
     MockWrite(ASYNC,
               kHandshakeRequestWithoutCookie,
               kHandshakeRequestWithoutCookieLength,
               1),
     MockWrite(ASYNC,
@@ skipping 10 matching lines @@
              kDataWorld,
              kDataWorldLength,
              4),
     MockRead(SYNCHRONOUS, 0, 5)  // EOF
   };
   data_.reset(new OrderedSocketData(
       reads, arraysize(reads), writes, arraysize(writes)));
 
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
-  WebSocketJobTest* test = this;
+  WebSocketJobSpdy2Test* test = this;
   if (throttling == THROTTLING_ON)
     delegate.SetOnStartOpenConnection(
-        base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
+        base::Bind(&WebSocketJobSpdy2Test::DoSync, base::Unretained(test)));
   delegate.SetOnConnected(
-      base::Bind(&WebSocketJobTest::DoSendRequest, base::Unretained(test)));
+      base::Bind(&WebSocketJobSpdy2Test::DoSendRequest,
+                 base::Unretained(test)));
   delegate.SetOnReceivedData(
-      base::Bind(&WebSocketJobTest::DoSendData, base::Unretained(test)));
+      base::Bind(&WebSocketJobSpdy2Test::DoSendData, base::Unretained(test)));
   delegate.SetOnClose(
-      base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
+      base::Bind(&WebSocketJobSpdy2Test::DoSync, base::Unretained(test)));
   InitWebSocketJob(url, &delegate, STREAM_SOCKET);
 
   scoped_refptr<WebSocketJob> block_websocket;
   if (throttling == THROTTLING_ON) {
     // Create former WebSocket object which obstructs the latter one.
     block_websocket = new WebSocketJob(NULL);
     block_websocket->addresses_ = AddressList(websocket_->address_list());
     WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get());
   }
 
@@ skipping 10 matching lines @@
     block_websocket = NULL;
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
   }
 
   EXPECT_EQ(OK, WaitForResult());
   EXPECT_TRUE(data_->at_read_eof());
   EXPECT_TRUE(data_->at_write_eof());
   EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState());
 }
 
-void WebSocketJobTest::TestConnectBySpdy(
+void WebSocketJobSpdy2Test::TestConnectBySpdy(
     SpdyOption spdy, ThrottlingOption throttling) {
   // This is a test for verifying cooperation between WebSocketJob and
   // SocketStream in the situation we have SPDY session to the server. If
   // |throttling| was |THROTTLING_ON|, throttling limits the latter connection.
   // If you enabled spdy, you should specify |spdy| as |SPDY_ON|. Expected
   // results depend on its configuration.
   MockWrite writes_websocket[] = {
     MockWrite(ASYNC,
               kHandshakeRequestWithoutCookie,
               kHandshakeRequestWithoutCookieLength,
@@ skipping 54 matching lines @@
     data_.reset(new OrderedSocketData(
         reads_spdy, arraysize(reads_spdy),
         writes_spdy, arraysize(writes_spdy)));
   else
     data_.reset(new OrderedSocketData(
         reads_websocket, arraysize(reads_websocket),
         writes_websocket, arraysize(writes_websocket)));
 
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
-  WebSocketJobTest* test = this;
+  WebSocketJobSpdy2Test* test = this;
   if (throttling == THROTTLING_ON)
     delegate.SetOnStartOpenConnection(
-        base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
+        base::Bind(&WebSocketJobSpdy2Test::DoSync, base::Unretained(test)));
   delegate.SetOnConnected(
-      base::Bind(&WebSocketJobTest::DoSendRequest, base::Unretained(test)));
+      base::Bind(&WebSocketJobSpdy2Test::DoSendRequest,
+                 base::Unretained(test)));
   delegate.SetOnReceivedData(
-      base::Bind(&WebSocketJobTest::DoSendData, base::Unretained(test)));
+      base::Bind(&WebSocketJobSpdy2Test::DoSendData, base::Unretained(test)));
   delegate.SetOnClose(
-      base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
+      base::Bind(&WebSocketJobSpdy2Test::DoSync, base::Unretained(test)));
   InitWebSocketJob(url, &delegate, STREAM_SPDY_WEBSOCKET);
 
   scoped_refptr<WebSocketJob> block_websocket;
   if (throttling == THROTTLING_ON) {
     // Create former WebSocket object which obstructs the latter one.
     block_websocket = new WebSocketJob(NULL);
     block_websocket->addresses_ = AddressList(websocket_->address_list());
     WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get());
   }
 
@@ skipping 11 matching lines @@
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
   }
 
   EXPECT_EQ(OK, WaitForResult());
   EXPECT_TRUE(data_->at_read_eof());
   EXPECT_TRUE(data_->at_write_eof());
   EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState());
 }
 
 // Execute tests in both spdy-disabled mode and spdy-enabled mode.
-TEST_F(WebSocketJobTest, SimpleHandshake) {
+TEST_F(WebSocketJobSpdy2Test, SimpleHandshake) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestSimpleHandshake();
 }
 
-TEST_F(WebSocketJobTest, SlowHandshake) {
+TEST_F(WebSocketJobSpdy2Test, SlowHandshake) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestSlowHandshake();
 }
 
-TEST_F(WebSocketJobTest, HandshakeWithCookie) {
+TEST_F(WebSocketJobSpdy2Test, HandshakeWithCookie) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestHandshakeWithCookie();
 }
 
-TEST_F(WebSocketJobTest, HandshakeWithCookieButNotAllowed) {
+TEST_F(WebSocketJobSpdy2Test, HandshakeWithCookieButNotAllowed) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestHandshakeWithCookieButNotAllowed();
 }
 
-TEST_F(WebSocketJobTest, HSTSUpgrade) {
+TEST_F(WebSocketJobSpdy2Test, HSTSUpgrade) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestHSTSUpgrade();
 }
 
-TEST_F(WebSocketJobTest, InvalidSendData) {
+TEST_F(WebSocketJobSpdy2Test, InvalidSendData) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestInvalidSendData();
 }
 
-TEST_F(WebSocketJobTest, SimpleHandshakeSpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, SimpleHandshakeSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestSimpleHandshake();
 }
 
-TEST_F(WebSocketJobTest, SlowHandshakeSpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, SlowHandshakeSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestSlowHandshake();
 }
 
-TEST_F(WebSocketJobTest, HandshakeWithCookieSpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, HandshakeWithCookieSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestHandshakeWithCookie();
 }
 
-TEST_F(WebSocketJobTest, HandshakeWithCookieButNotAllowedSpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, HandshakeWithCookieButNotAllowedSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestHandshakeWithCookieButNotAllowed();
 }
 
-TEST_F(WebSocketJobTest, HSTSUpgradeSpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, HSTSUpgradeSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestHSTSUpgrade();
 }
 
-TEST_F(WebSocketJobTest, InvalidSendDataSpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, InvalidSendDataSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestInvalidSendData();
 }
 
-TEST_F(WebSocketJobTest, ConnectByWebSocket) {
+TEST_F(WebSocketJobSpdy2Test, ConnectByWebSocket) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectByWebSocket(THROTTLING_OFF);
 }
 
-TEST_F(WebSocketJobTest, ConnectByWebSocketSpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, ConnectByWebSocketSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectByWebSocket(THROTTLING_OFF);
 }
 
-TEST_F(WebSocketJobTest, ConnectBySpdy) {
+TEST_F(WebSocketJobSpdy2Test, ConnectBySpdy) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectBySpdy(SPDY_OFF, THROTTLING_OFF);
 }
 
-TEST_F(WebSocketJobTest, ConnectBySpdySpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, ConnectBySpdySpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectBySpdy(SPDY_ON, THROTTLING_OFF);
 }
 
-TEST_F(WebSocketJobTest, ThrottlingWebSocket) {
+TEST_F(WebSocketJobSpdy2Test, ThrottlingWebSocket) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectByWebSocket(THROTTLING_ON);
 }
 
-TEST_F(WebSocketJobTest, ThrottlingWebSocketSpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, ThrottlingWebSocketSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectByWebSocket(THROTTLING_ON);
 }
 
-TEST_F(WebSocketJobTest, ThrottlingSpdy) {
+TEST_F(WebSocketJobSpdy2Test, ThrottlingSpdy) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectBySpdy(SPDY_OFF, THROTTLING_ON);
 }
 
-TEST_F(WebSocketJobTest, ThrottlingSpdySpdyEnabled) {
+TEST_F(WebSocketJobSpdy2Test, ThrottlingSpdySpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectBySpdy(SPDY_ON, THROTTLING_ON);
 }
 
 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation.
 // TODO(toyoshim,yutak): Add tests to verify closing handshake.
 
 }  // namespace net