Revert 256579 "Allow the content browser client to specify a spe..."

trunk/src/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 23 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 class MockSocketStream : public SocketStream {
  public:
-  MockSocketStream(const GURL& url, SocketStream::Delegate* delegate,
-                   URLRequestContext* context, CookieStore* cookie_store)
-      : SocketStream(url, delegate, context, cookie_store) {}
+  MockSocketStream(const GURL& url, SocketStream::Delegate* delegate)
+      : SocketStream(url, delegate) {}
 
   virtual void Connect() OVERRIDE {}
   virtual bool SendData(const char* data, int len) OVERRIDE {
     sent_data_ += std::string(data, len);
     return true;
   }
 
   virtual void Close() OVERRIDE {}
   virtual void RestartWithAuth(
       const AuthCredentials& credentials) OVERRIDE {
@@ skipping 301 matching lines @@
     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);
+      socket_ = new MockSocketStream(url, websocket_.get());
 
     if (stream_type == STREAM_SOCKET || stream_type == STREAM_SPDY_WEBSOCKET) {
       if (stream_type == STREAM_SPDY_WEBSOCKET) {
         http_factory_.reset(
             new MockHttpTransactionFactory(GetParam(), data_.get()));
         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());
 
-      socket_ = new SocketStream(url, websocket_.get(), context_.get(), NULL);
+      socket_ = new SocketStream(url, websocket_.get());
       socket_factory_.reset(new MockClientSocketFactory);
       DCHECK(data_.get());
       socket_factory_->AddSocketDataProvider(data_.get());
       socket_->SetClientSocketFactory(socket_factory_.get());
     }
 
     websocket_->InitSocketStream(socket_.get());
+    websocket_->set_context(context_.get());
     // MockHostResolver resolves all hosts to 127.0.0.1; however, when we create
     // a WebSocketJob purely to block another one in a throttling test, we don't
     // perform a real connect. In that case, the following address is used
     // instead.
     IPAddressNumber ip;
     ParseIPLiteralToNumber("127.0.0.1", &ip);
     websocket_->addresses_ = AddressList::CreateFromIPAddress(ip, 80);
   }
   void SkipToConnecting() {
     websocket_->state_ = WebSocketJob::CONNECTING;
@@ skipping 329 matching lines @@
 
   CloseWebSocketJob();
 }
 
 void WebSocketJobTest::TestHSTSUpgrade() {
   GURL url("ws://upgrademe.com/");
   MockSocketStreamDelegate delegate;
   scoped_refptr<SocketStreamJob> job =
       SocketStreamJob::CreateSocketStreamJob(
           url, &delegate, context_->transport_security_state(),
-          context_->ssl_config_service(), NULL, NULL);
+          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(), NULL, NULL);
+      context_->ssl_config_service());
   EXPECT_FALSE(GetSocket(job.get())->is_secure());
   job->DetachDelegate();
 }
 
 void WebSocketJobTest::TestInvalidSendData() {
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
   SkipToConnecting();
 
@@ skipping 352 matching lines @@
 }
 
 TEST_P(WebSocketJobTest, 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