base::Bind: Convert proxy_resolving_client_socket.[cc,h] and deps.

net/spdy/spdy_session_unittest.cc

 // Copyright (c) 2011 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_session.h"
 
 #include "net/base/ip_endpoint.h"
 #include "net/spdy/spdy_io_buffer.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
@@ skipping 124 matching lines @@
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   EXPECT_TRUE(spdy_session_pool->HasSession(pair));
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
                                 MEDIUM,
                                 false,
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-  EXPECT_EQ(OK,
-            connection->Init(test_host_port_pair.ToString(),
-                             transport_params, MEDIUM,
-                             NULL, http_session->GetTransportSocketPool(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
+                                 transport_params, MEDIUM, CompletionCallback(),
+                                 http_session->GetTransportSocketPool(),
+                                 BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   // Flush the SpdySession::OnReadComplete() task.
   MessageLoop::current()->RunAllPending();
 
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
 
   scoped_refptr<SpdySession> session2 =
       spdy_session_pool->Get(pair, BoundNetLog());
 
@@ skipping 46 matching lines @@
       spdy_session_pool->Get(pair, BoundNetLog());
   EXPECT_TRUE(spdy_session_pool->HasSession(pair));
 
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
                                 MEDIUM,
                                 false,
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-  EXPECT_EQ(OK,
-            connection->Init(test_host_port_pair.ToString(),
-                             transport_params,
-                             MEDIUM,
-                             NULL,
-                             http_session->GetTransportSocketPool(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
+                                 transport_params, MEDIUM, CompletionCallback(),
+                                 http_session->GetTransportSocketPool(),
+                                 BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   scoped_refptr<SpdyStream> spdy_stream1;
   TestOldCompletionCallback callback1;
   EXPECT_EQ(OK, session->CreateStream(url,
                                       MEDIUM,
                                       &spdy_stream1,
                                       BoundNetLog(),
                                       &callback1));
   scoped_ptr<TestSpdyStreamDelegate> delegate(
@@ skipping 64 matching lines @@
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   EXPECT_TRUE(spdy_session_pool->HasSession(pair));
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
                                 MEDIUM,
                                 false,
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-  EXPECT_EQ(OK,
-            connection->Init(test_host_port_pair.ToString(),
-                             transport_params,
-                             MEDIUM,
-                             NULL,
-                             http_session->GetTransportSocketPool(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
+                                 transport_params, MEDIUM, CompletionCallback(),
+                                 http_session->GetTransportSocketPool(),
+                                 BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   scoped_refptr<SpdyStream> spdy_stream1;
   TestOldCompletionCallback callback1;
   EXPECT_EQ(OK, session->CreateStream(url,
                                       MEDIUM,
                                       &spdy_stream1,
                                       BoundNetLog(),
                                       &callback1));
   scoped_ptr<TestSpdyStreamDelegate> delegate(
@@ skipping 219 matching lines @@
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   ASSERT_TRUE(spdy_session_pool->HasSession(pair));
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
                                 MEDIUM,
                                 false,
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-  EXPECT_EQ(OK,
-            connection->Init(test_host_port_pair.ToString(),
-                             transport_params, MEDIUM,
-                             NULL, http_session->GetTransportSocketPool(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
+                                 transport_params, MEDIUM, CompletionCallback(),
+                                 http_session->GetTransportSocketPool(),
+                                 BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   // Create 2 streams.  First will succeed.  Second will be pending.
   scoped_refptr<SpdyStream> spdy_stream1;
   TestOldCompletionCallback callback1;
   GURL url("http://www.google.com");
   EXPECT_EQ(OK,
             session->CreateStream(url,
                                   MEDIUM, /* priority, not important */
                                   &spdy_stream1,
@@ skipping 60 matching lines @@
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   ASSERT_TRUE(spdy_session_pool->HasSession(pair));
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
                                 MEDIUM,
                                 false,
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-  EXPECT_EQ(OK,
-            connection->Init(test_host_port_pair.ToString(),
-                             transport_params, MEDIUM,
-                             NULL, http_session->GetTransportSocketPool(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
+                                 transport_params, MEDIUM, CompletionCallback(),
+                                 http_session->GetTransportSocketPool(),
+                                 BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   // Use scoped_ptr to let us invalidate the memory when we want to, to trigger
   // a valgrind error if the callback is invoked when it's not supposed to be.
   scoped_ptr<TestOldCompletionCallback> callback(new TestOldCompletionCallback);
 
   // Create 2 streams.  First will succeed.  Second will be pending.
   scoped_refptr<SpdyStream> spdy_stream1;
   GURL url("http://www.google.com");
   ASSERT_EQ(OK,
@@ skipping 74 matching lines @@
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   EXPECT_TRUE(spdy_session_pool->HasSession(pair));
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
                                 MEDIUM,
                                 false,
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-  EXPECT_EQ(OK,
-            connection->Init(test_host_port_pair.ToString(),
-                             transport_params, MEDIUM,
-                             NULL, http_session->GetTransportSocketPool(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
+                                 transport_params, MEDIUM, CompletionCallback(),
+                                 http_session->GetTransportSocketPool(),
+                                 BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(data.at_write_eof());
 }
 
 // This test has two variants, one for each style of closing the connection.
 // If |clean_via_close_current_sessions| is false, the sessions are closed
 // manually, calling SpdySessionPool::Remove() directly.  If it is true,
 // sessions are closed with SpdySessionPool::CloseCurrentSessions().
 void IPPoolingTest(bool clean_via_close_current_sessions) {
@@ skipping 49 matching lines @@
       spdy_session_pool->Get(test_hosts[0].pair, BoundNetLog());
   EXPECT_TRUE(spdy_session_pool->HasSession(test_hosts[0].pair));
 
   HostPortPair test_host_port_pair(test_hosts[0].name, kTestPort);
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
                           MEDIUM,
                           false,
                           false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-  EXPECT_EQ(OK,
-            connection->Init(test_host_port_pair.ToString(),
-                             transport_params, MEDIUM,
-                             NULL, http_session->GetTransportSocketPool(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
+                                 transport_params, MEDIUM, CompletionCallback(),
+                                 http_session->GetTransportSocketPool(),
+                                 BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   // TODO(rtenneti): MockClientSocket::GetPeerAddress return's 0 as the port
   // number. Fix it to return port 80 and then use GetPeerAddress to AddAlias.
   const addrinfo* address = test_hosts[0].addresses.head();
   SpdySessionPoolPeer pool_peer(spdy_session_pool);
   pool_peer.AddAlias(address, test_hosts[0].pair);
 
   // Flush the SpdySession::OnReadComplete() task.
   MessageLoop::current()->RunAllPending();
@@ skipping 85 matching lines @@
   test_http_server_properties->SetSpdySettings(test_host_port_pair,
                                                test_settings);
   EXPECT_NE(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair).size());
   spdy_session_pool->OnIPAddressChanged();
   EXPECT_EQ(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair).size());
 }
 
 }  // namespace net