Get rid of websocket_over_spdy_enabled global.

net/websockets/websocket_job_test.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/websockets/websocket_job.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 256 matching lines @@
   }
 
   virtual ~MockURLRequestContext() {}
 
  private:
   TransportSecurityState transport_security_state_;
 };
 
 class MockHttpTransactionFactory : public HttpTransactionFactory {
  public:
-  MockHttpTransactionFactory(NextProto next_proto, OrderedSocketData* data) {
+  MockHttpTransactionFactory(NextProto next_proto, OrderedSocketData* data,

[Ryan Hamilton, 2014/05/29 19:26:50]

nit: 1 per line, since it no longer fits on one line.

[mmenke, 2014/05/29 19:54:16]

Did this one, too, just forgot to response.

+                             bool enable_websocket_over_spdy) {
     data_ = data;
     MockConnect connect_data(SYNCHRONOUS, OK);
     data_->set_connect_data(connect_data);
     session_deps_.reset(new SpdySessionDependencies(next_proto));
+    session_deps_->enable_websocket_over_spdy = enable_websocket_over_spdy;
     session_deps_->socket_factory->AddSocketDataProvider(data_);
     http_session_ =
         SpdySessionDependencies::SpdyCreateSession(session_deps_.get());
     host_port_pair_.set_host("example.com");
     host_port_pair_.set_port(80);
     spdy_session_key_ = SpdySessionKey(host_port_pair_,
                                             ProxyServer::Direct(),
                                             PRIVACY_MODE_DISABLED);
     session_ = CreateInsecureSpdySession(
         http_session_, spdy_session_key_, BoundNetLog());
@@ skipping 90 matching lines @@
  private:
   scoped_refptr<WebSocketJob> job_;
   bool delete_next_;
 };
 
 }  // namespace
 
 class WebSocketJobTest : public PlatformTest,
                          public ::testing::WithParamInterface<NextProto> {
  public:
-  WebSocketJobTest() : spdy_util_(GetParam()) {}
+  WebSocketJobTest() : spdy_util_(GetParam()),

[Ryan Hamilton, 2014/05/29 19:26:50]

I think you need to start the initalizer list on a new line, since it doesn't
fit on a single line.

[mmenke, 2014/05/29 19:53:13]

Done.  Looks like you're right.  Rule is often violated, and few enough
reviewers enforce it so I haven't internalized that one.

+                       enable_websocket_over_spdy_(false) {}
 
   virtual void SetUp() OVERRIDE {
     stream_type_ = STREAM_INVALID;
     cookie_store_ = new MockCookieStore;
     context_.reset(new MockURLRequestContext(cookie_store_.get()));
   }
   virtual void TearDown() OVERRIDE {
     cookie_store_ = NULL;
     context_.reset();
     websocket_ = NULL;
     socket_ = NULL;
   }
   void DoSendRequest() {
     EXPECT_TRUE(websocket_->SendData(kHandshakeRequestWithoutCookie,
                                      kHandshakeRequestWithoutCookieLength));
   }
   void DoSendData() {
     if (received_data().size() == kHandshakeResponseWithoutCookieLength)
       websocket_->SendData(kDataHello, kDataHelloLength);
   }
   void DoSync() {
     sync_test_callback_.callback().Run(OK);
   }
   int WaitForResult() {
     return sync_test_callback_.WaitForResult();
   }
+
  protected:
   enum StreamType {
     STREAM_INVALID,
     STREAM_MOCK_SOCKET,
     STREAM_SOCKET,
     STREAM_SPDY_WEBSOCKET,
   };
   enum ThrottlingOption {
     THROTTLING_OFF,
     THROTTLING_ON,
   };
   enum SpdyOption {
     SPDY_OFF,
     SPDY_ON,
   };
   void InitWebSocketJob(const GURL& url,
                         MockSocketStreamDelegate* delegate,
                         StreamType stream_type) {
     DCHECK_NE(STREAM_INVALID, stream_type);
     stream_type_ = stream_type;
     websocket_ = new WebSocketJob(delegate);
 
     if (stream_type == STREAM_MOCK_SOCKET)
       socket_ = new MockSocketStream(url, websocket_.get(), context_.get(),
                                      NULL);
 
     if (stream_type == STREAM_SOCKET || stream_type == STREAM_SPDY_WEBSOCKET) {
       if (stream_type == STREAM_SPDY_WEBSOCKET) {
-        http_factory_.reset(
-            new MockHttpTransactionFactory(GetParam(), data_.get()));
+        http_factory_.reset(new MockHttpTransactionFactory(
+            GetParam(), data_.get(), enable_websocket_over_spdy_));
         context_->set_http_transaction_factory(http_factory_.get());
       }
 
       ssl_config_service_ = new MockSSLConfigService();
       context_->set_ssl_config_service(ssl_config_service_.get());
       proxy_service_.reset(ProxyService::CreateDirect());
       context_->set_proxy_service(proxy_service_.get());
       host_resolver_.reset(new MockHostResolver);
       context_->set_host_resolver(host_resolver_.get());
 
@@ skipping 64 matching lines @@
   scoped_refptr<WebSocketJob> websocket_;
   scoped_refptr<SocketStream> socket_;
   scoped_ptr<MockClientSocketFactory> socket_factory_;
   scoped_ptr<OrderedSocketData> data_;
   TestCompletionCallback sync_test_callback_;
   scoped_refptr<MockSSLConfigService> ssl_config_service_;
   scoped_ptr<ProxyService> proxy_service_;
   scoped_ptr<MockHostResolver> host_resolver_;
   scoped_ptr<MockHttpTransactionFactory> http_factory_;
 
+  // Must be set before call to enable_websocket_over_spdy, defaults to false.
+  bool enable_websocket_over_spdy_;
+
   static const char kHandshakeRequestWithoutCookie[];
   static const char kHandshakeRequestWithCookie[];
   static const char kHandshakeRequestWithFilteredCookie[];
   static const char kHandshakeResponseWithoutCookie[];
   static const char kHandshakeResponseWithCookie[];
   static const char kDataHello[];
   static const char kDataWorld[];
   static const char* const kHandshakeRequestForSpdy[];
   static const char* const kHandshakeResponseForSpdy[];
   static const size_t kHandshakeRequestWithoutCookieLength;
@@ skipping 161 matching lines @@
   CloseWebSocketJob();
 }
 
 INSTANTIATE_TEST_CASE_P(
     NextProto,
     WebSocketJobTest,
     testing::Values(kProtoDeprecatedSPDY2,
                     kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
 
 TEST_P(WebSocketJobTest, DelayedCookies) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = 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.get());
   cookie_store->SetCookieWithOptionsAsync(cookieUrl,
                                           "CR-test=1",
                                           cookie_options,
                                           CookieMonster::SetCookiesCallback());
   cookie_options.set_include_httponly();
@@ skipping 382 matching lines @@
        iter != jobs.rend();
        ++iter) {
     WebSocketJob* job = (*iter).get();
     job->state_ = WebSocketJob::CLOSED;
     WebSocketThrottle::GetInstance()->RemoveFromQueue(job);
   }
 }
 
 // Execute tests in both spdy-disabled mode and spdy-enabled mode.
 TEST_P(WebSocketJobTest, SimpleHandshake) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestSimpleHandshake();
 }
 
 TEST_P(WebSocketJobTest, SlowHandshake) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestSlowHandshake();
 }
 
 TEST_P(WebSocketJobTest, HandshakeWithCookie) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestHandshakeWithCookie();
 }
 
 TEST_P(WebSocketJobTest, HandshakeWithCookieButNotAllowed) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestHandshakeWithCookieButNotAllowed();
 }
 
 TEST_P(WebSocketJobTest, HSTSUpgrade) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestHSTSUpgrade();
 }
 
 TEST_P(WebSocketJobTest, InvalidSendData) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestInvalidSendData();
 }
 
 TEST_P(WebSocketJobTest, SimpleHandshakeSpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestSimpleHandshake();
 }
 
 TEST_P(WebSocketJobTest, SlowHandshakeSpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestSlowHandshake();
 }
 
 TEST_P(WebSocketJobTest, HandshakeWithCookieSpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestHandshakeWithCookie();
 }
 
 TEST_P(WebSocketJobTest, HandshakeWithCookieButNotAllowedSpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestHandshakeWithCookieButNotAllowed();
 }
 
 TEST_P(WebSocketJobTest, HSTSUpgradeSpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestHSTSUpgrade();
 }
 
 TEST_P(WebSocketJobTest, InvalidSendDataSpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestInvalidSendData();
 }
 
 TEST_P(WebSocketJobTest, ConnectByWebSocket) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
+  enable_websocket_over_spdy_ = true;
   TestConnectByWebSocket(THROTTLING_OFF);
 }
 
 TEST_P(WebSocketJobTest, ConnectByWebSocketSpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestConnectByWebSocket(THROTTLING_OFF);
 }
 
 TEST_P(WebSocketJobTest, ConnectBySpdy) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectBySpdy(SPDY_OFF, THROTTLING_OFF);
 }
 
 TEST_P(WebSocketJobTest, ConnectBySpdySpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestConnectBySpdy(SPDY_ON, THROTTLING_OFF);
 }
 
 TEST_P(WebSocketJobTest, ThrottlingWebSocket) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectByWebSocket(THROTTLING_ON);
 }
 
 TEST_P(WebSocketJobTest, ThrottlingMaxNumberOfThrottledJobLimit) {
   TestThrottlingLimit();
 }
 
 TEST_P(WebSocketJobTest, ThrottlingWebSocketSpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestConnectByWebSocket(THROTTLING_ON);
 }
 
 TEST_P(WebSocketJobTest, ThrottlingSpdy) {
-  WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectBySpdy(SPDY_OFF, THROTTLING_ON);
 }
 
 TEST_P(WebSocketJobTest, ThrottlingSpdySpdyEnabled) {
-  WebSocketJob::set_websocket_over_spdy_enabled(true);
+  enable_websocket_over_spdy_ = true;
   TestConnectBySpdy(SPDY_ON, THROTTLING_ON);
 }
 
 TEST_F(WebSocketJobDeleteTest, OnClose) {
   SetDeleteNext();
   job()->OnClose(socket_.get());
   // OnClose() sets WebSocketJob::_socket to NULL before we can detach it, so
   // socket_->delegate is still set at this point. Clear it to avoid hitting
   // DCHECK(!delegate_) in the SocketStream destructor. SocketStream::Finish()
   // is the only caller of this method in real code, and it also sets delegate_
@@ skipping 56 matching lines @@
   job()->Connect();
   SetDeleteNext();
   job()->OnReceivedData(
       socket_.get(), kMinimalResponse, arraysize(kMinimalResponse) - 1);
   EXPECT_FALSE(job());
 }
 
 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation.
 // TODO(toyoshim,yutak): Add tests to verify closing handshake.
 }  // namespace net