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

trunk/src/net/socket_stream/socket_stream_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/socket_stream/socket_stream.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 300 matching lines @@
       frame.push_back('\xff');
       EXPECT_TRUE(event->socket->SendData(&frame[0], frame.size()));
     }
     // Actual StreamSocket close must happen after all frames queued by
     // SendData above are sent out.
     event->socket->Close();
   }
 
   virtual void DoCloseFlushPendingWriteTestWithSetContextNull(
       SocketStreamEvent* event) {
-    event->socket->DetachContext();
+    event->socket->set_context(NULL);
     // handshake response received.
     for (size_t i = 0; i < messages_.size(); i++) {
       std::vector<char> frame;
       frame.push_back('\0');
       frame.insert(frame.end(), messages_[i].begin(), messages_[i].end());
       frame.push_back('\xff');
       EXPECT_TRUE(event->socket->SendData(&frame[0], frame.size()));
     }
     // Actual StreamSocket close must happen after all frames queued by
     // SendData above are sent out.
@@ skipping 61 matching lines @@
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnConnected(base::Bind(
       &SocketStreamTest::DoSendWebSocketHandshake, base::Unretained(this)));
   delegate->SetOnReceivedData(base::Bind(
       &SocketStreamTest::DoCloseFlushPendingWriteTest,
       base::Unretained(this)));
 
   TestURLRequestContext context;
 
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
+  socket_stream->set_context(&context);
 
   MockWrite data_writes[] = {
     MockWrite(SocketStreamTest::kWebSocketHandshakeRequest),
     MockWrite(ASYNC, "\0message1\xff", 10),
     MockWrite(ASYNC, "\0message2\xff", 10)
   };
   MockRead data_reads[] = {
     MockRead(SocketStreamTest::kWebSocketHandshakeResponse),
     // Server doesn't close the connection after handshake.
     MockRead(ASYNC, ERR_IO_PENDING)
@@ skipping 30 matching lines @@
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[5].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[6].event_type);
 }
 
 TEST_F(SocketStreamTest, ResolveFailure) {
   TestCompletionCallback test_callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
 
+  scoped_refptr<SocketStream> socket_stream(
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
   // Make resolver fail.
   TestURLRequestContext context;
   scoped_ptr<MockHostResolver> mock_host_resolver(
       new MockHostResolver());
   mock_host_resolver->rules()->AddSimulatedFailure("example.com");
   context.set_host_resolver(mock_host_resolver.get());
-
-  scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+  socket_stream->set_context(&context);
 
   // No read/write on socket is expected.
   StaticSocketDataProvider data_provider(NULL, 0, NULL, 0);
   MockClientSocketFactory* mock_socket_factory =
       GetMockClientSocketFactory();
   mock_socket_factory->AddSocketDataProvider(&data_provider);
   socket_stream->SetClientSocketFactory(mock_socket_factory);
 
   socket_stream->Connect();
 
@@ skipping 10 matching lines @@
   TestCompletionCallback test_callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnConnected(base::Bind(
       &SocketStreamTest::DoFailByTooBigDataAndClose, base::Unretained(this)));
 
   TestURLRequestContext context;
 
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
+  socket_stream->set_context(&context);
 
   DelayedSocketData data_provider(1, NULL, 0, NULL, 0);
 
   MockClientSocketFactory* mock_socket_factory =
       GetMockClientSocketFactory();
   mock_socket_factory->AddSocketDataProvider(&data_provider);
 
   socket_stream->SetClientSocketFactory(mock_socket_factory);
 
   socket_stream->Connect();
@@ skipping 50 matching lines @@
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
                                       base::Unretained(delegate.get())));
   delegate->SetAuthInfo(AuthCredentials(ASCIIToUTF16("foo"),
                                         ASCIIToUTF16("bar")));
   delegate->SetOnAuthRequired(base::Bind(
       &SocketStreamEventRecorder::DoRestartWithAuth,
       base::Unretained(delegate.get())));
 
+  scoped_refptr<SocketStream> socket_stream(
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
   TestURLRequestContextWithProxy context("myproxy:70");
 
-  scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
-
+  socket_stream->set_context(&context);
   socket_stream->SetClientSocketFactory(&mock_socket_factory);
 
   socket_stream->Connect();
 
   test_callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(5U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
@@ skipping 26 matching lines @@
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                  data_writes, arraysize(data_writes));
   mock_socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback test_callback;
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
                                       base::Unretained(delegate.get())));
 
+  scoped_refptr<SocketStream> socket_stream(
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
   TestURLRequestContextWithProxy context("myproxy:70");
   HttpAuthCache* auth_cache =
       context.http_transaction_factory()->GetSession()->http_auth_cache();
   auth_cache->Add(GURL("http://myproxy:70"),
                   "MyRealm1",
                   HttpAuth::AUTH_SCHEME_BASIC,
                   "Basic realm=MyRealm1",
                   AuthCredentials(ASCIIToUTF16("foo"),
                                   ASCIIToUTF16("bar")),
                   "/");
 
-  scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
-
+  socket_stream->set_context(&context);
   socket_stream->SetClientSocketFactory(&mock_socket_factory);
 
   socket_stream->Connect();
 
   test_callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(4U, events.size());
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
@@ skipping 22 matching lines @@
 
   SSLSocketDataProvider data2(ASYNC, OK);
   mock_socket_factory.AddSSLSocketDataProvider(&data2);
 
   TestCompletionCallback test_callback;
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
                                       base::Unretained(delegate.get())));
 
+  scoped_refptr<SocketStream> socket_stream(
+      new SocketStream(GURL("wss://example.com/demo"), delegate.get()));
+
   TestURLRequestContextWithProxy context("myproxy:70");
   HttpAuthCache* auth_cache =
       context.http_transaction_factory()->GetSession()->http_auth_cache();
   auth_cache->Add(GURL("http://myproxy:70"),
                   "MyRealm1",
                   HttpAuth::AUTH_SCHEME_BASIC,
                   "Basic realm=MyRealm1",
                   AuthCredentials(ASCIIToUTF16("foo"),
                                   ASCIIToUTF16("bar")),
                   "/");
 
-  scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("wss://example.com/demo"), delegate.get(),
-                       &context, NULL));
-
+  socket_stream->set_context(&context);
   socket_stream->SetClientSocketFactory(&mock_socket_factory);
 
   socket_stream->Connect();
 
   test_callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(4U, events.size());
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
@@ skipping 11 matching lines @@
       &SocketStreamTest::DoIOPending, base::Unretained(this)));
   delegate->SetOnConnected(base::Bind(
       &SocketStreamTest::DoSendWebSocketHandshake, base::Unretained(this)));
   delegate->SetOnReceivedData(base::Bind(
       &SocketStreamTest::DoCloseFlushPendingWriteTest,
       base::Unretained(this)));
 
   TestURLRequestContext context;
 
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
+  socket_stream->set_context(&context);
 
   MockWrite data_writes[] = {
     MockWrite(SocketStreamTest::kWebSocketHandshakeRequest),
     MockWrite(ASYNC, "\0message1\xff", 10),
     MockWrite(ASYNC, "\0message2\xff", 10)
   };
   MockRead data_reads[] = {
     MockRead(SocketStreamTest::kWebSocketHandshakeResponse),
     // Server doesn't close the connection after handshake.
     MockRead(ASYNC, ERR_IO_PENDING)
@@ skipping 39 matching lines @@
   TestCompletionCallback test_callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnStartOpenConnection(base::Bind(
       &SocketStreamTest::DoSwitchToSpdyTest, base::Unretained(this)));
 
   TestURLRequestContext context;
 
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
+  socket_stream->set_context(&context);
 
   socket_stream->Connect();
 
   EXPECT_EQ(ERR_PROTOCOL_SWITCHED, test_callback.WaitForResult());
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(2U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[1].event_type);
   EXPECT_EQ(ERR_PROTOCOL_SWITCHED, events[1].error_code);
 }
 
 TEST_F(SocketStreamTest, SwitchAfterPending) {
   TestCompletionCallback test_callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnStartOpenConnection(base::Bind(
       &SocketStreamTest::DoIOPending, base::Unretained(this)));
 
   TestURLRequestContext context;
 
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
+  socket_stream->set_context(&context);
 
   socket_stream->Connect();
   io_test_callback_.WaitForResult();
 
   EXPECT_EQ(SocketStream::STATE_RESOLVE_PROTOCOL_COMPLETE,
             socket_stream->next_state_);
   delegate->CompleteConnection(ERR_PROTOCOL_SWITCHED);
 
   EXPECT_EQ(ERR_PROTOCOL_SWITCHED, test_callback.WaitForResult());
 
@@ skipping 31 matching lines @@
 
   TestCompletionCallback test_callback;
   TestURLRequestContextWithProxy context("https://myproxy:70");
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
                                       base::Unretained(delegate.get())));
 
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
 
+  socket_stream->set_context(&context);
   socket_stream->SetClientSocketFactory(&mock_socket_factory);
 
   socket_stream->Connect();
 
   test_callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(3U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
@@ skipping 28 matching lines @@
 
   TestCompletionCallback test_callback;
   TestURLRequestContextWithProxy context("https://myproxy:70");
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
                                       base::Unretained(delegate.get())));
 
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
 
+  socket_stream->set_context(&context);
   socket_stream->SetClientSocketFactory(&mock_socket_factory);
 
   socket_stream->Connect();
 
   test_callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(4U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[2].event_type);
   EXPECT_EQ(ERR_ABORTED, events[2].error_code);
   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[3].event_type);
 }
 
 TEST_F(SocketStreamTest, BeforeConnectFailed) {
   TestCompletionCallback test_callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
 
   TestURLRequestContext context;
   TestSocketStreamNetworkDelegate network_delegate;
   network_delegate.SetBeforeConnectResult(ERR_ACCESS_DENIED);
   context.set_network_delegate(&network_delegate);
 
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
+
+  socket_stream->set_context(&context);
 
   socket_stream->Connect();
 
   test_callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(2U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[0].event_type);
   EXPECT_EQ(ERR_ACCESS_DENIED, events[0].error_code);
@@ skipping 10 matching lines @@
   // connect it and the SocketStream.
   SelfDeletingDelegate* delegate =
       new SelfDeletingDelegate(test_callback.callback());
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider data;
   data.set_connect_data(mock_connect);
   mock_socket_factory.AddSocketDataProvider(&data);
 
   TestURLRequestContext context;
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://localhost:9998/echo"), delegate,
-                       &context, NULL));
+      new SocketStream(GURL("ws://localhost:9998/echo"), delegate));
+  socket_stream->set_context(&context);
   socket_stream->SetClientSocketFactory(&mock_socket_factory);
   delegate->set_socket_stream(socket_stream);
   // The delegate pointer will become invalid during the test. Set it to NULL to
   // avoid holding a dangling pointer.
   delegate = NULL;
 
   socket_stream->Connect();
 
   EXPECT_EQ(OK, test_callback.WaitForResult());
 }
 
 TEST_F(SocketStreamTest, NullContextSocketStreamShouldNotCrash) {
   TestCompletionCallback test_callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(test_callback.callback()));
   TestURLRequestContext context;
   scoped_refptr<SocketStream> socket_stream(
-      new SocketStream(GURL("ws://example.com/demo"), delegate.get(),
-                       &context, NULL));
+      new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
   delegate->SetOnStartOpenConnection(base::Bind(
       &SocketStreamTest::DoIOPending, base::Unretained(this)));
   delegate->SetOnConnected(base::Bind(
       &SocketStreamTest::DoSendWebSocketHandshake, base::Unretained(this)));
   delegate->SetOnReceivedData(base::Bind(
       &SocketStreamTest::DoCloseFlushPendingWriteTestWithSetContextNull,
       base::Unretained(this)));
 
+  socket_stream->set_context(&context);
+
   MockWrite data_writes[] = {
     MockWrite(SocketStreamTest::kWebSocketHandshakeRequest),
   };
   MockRead data_reads[] = {
     MockRead(SocketStreamTest::kWebSocketHandshakeResponse),
   };
   AddWebSocketMessage("message1");
   AddWebSocketMessage("message2");
 
   DelayedSocketData data_provider(
@@ skipping 17 matching lines @@
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[2].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_RECEIVED_DATA, events[3].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[4].event_type);
 }
 
 }  // namespace net