Cleanup: Remove the implicit constructor for BoundNetLog that allowed passing...

net/socket/tcp_client_socket_pool_unittest.cc

 // Copyright (c) 2010 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/tcp_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "net/base/mock_host_resolver.h"
@@ skipping 264 matching lines @@
   scoped_refptr<MockHostResolver> host_resolver_;
   MockClientSocketFactory client_socket_factory_;
   MockNetworkChangeNotifier notifier_;
   scoped_refptr<TCPClientSocketPool> pool_;
 };
 
 TEST_F(TCPClientSocketPoolTest, Basic) {
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   TCPSocketParams dest("www.google.com", 80, LOW, GURL(), false);
-  int rv = handle.Init("a", dest, LOW, &callback, pool_, NULL);
+  int rv = handle.Init("a", dest, LOW, &callback, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 
   handle.Reset();
 }
 
 TEST_F(TCPClientSocketPoolTest, InitHostResolutionFailure) {
   host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
   TestSocketRequest req(&request_order_, &completion_count_);
   TCPSocketParams dest("unresolvable.host.name", 80, kDefaultPriority, GURL(),
                        false);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_, NULL));
+            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_,
+                               BoundNetLog()));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req.WaitForResult());
 }
 
 TEST_F(TCPClientSocketPoolTest, InitConnectionFailure) {
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET);
   TestSocketRequest req(&request_order_, &completion_count_);
   TCPSocketParams dest("a", 80, kDefaultPriority, GURL(), false);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_, NULL));
+            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_,
+                               BoundNetLog()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
 
   // Make the host resolutions complete synchronously this time.
   host_resolver_->set_synchronous_mode(true);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_, NULL));
+            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_,
+                               BoundNetLog()));
 }
 
 TEST_F(TCPClientSocketPoolTest, PendingRequests) {
   // First request finishes asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
 
   // Make all subsequent host resolutions complete synchronously.
   host_resolver_->set_synchronous_mode(true);
 
@@ skipping 85 matching lines @@
   EXPECT_EQ(6U, completion_count_);
 }
 
 // This test will start up a RequestSocket() and then immediately Cancel() it.
 // The pending host resolution will eventually complete, and destroy the
 // ClientSocketPool which will crash if the group was not cleared properly.
 TEST_F(TCPClientSocketPoolTest, CancelRequestClearGroup) {
   TestSocketRequest req(&request_order_, &completion_count_);
   TCPSocketParams dest("www.google.com", 80, kDefaultPriority, GURL(), false);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_, NULL));
+            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_,
+                               BoundNetLog()));
   req.handle()->Reset();
 
   // There is a race condition here.  If the worker pool doesn't post the task
   // before we get here, then this might not run ConnectingSocket::OnIOComplete
   // and therefore leak the canceled ConnectingSocket.  However, other tests
   // after this will call MessageLoop::RunAllPending() which should prevent a
   // leak, unless the worker thread takes longer than all of them.
   PlatformThread::Sleep(10);
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(TCPClientSocketPoolTest, TwoRequestsCancelOne) {
   TestSocketRequest req(&request_order_, &completion_count_);
   TestSocketRequest req2(&request_order_, &completion_count_);
 
   TCPSocketParams dest("www.google.com", 80, kDefaultPriority, GURL(), false);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_, NULL));
+            req.handle()->Init("a", dest, kDefaultPriority, &req, pool_,
+                               BoundNetLog()));
   EXPECT_EQ(ERR_IO_PENDING,
-            req2.handle()->Init("a", dest, kDefaultPriority, &req2, pool_, NULL));
+            req2.handle()->Init("a", dest, kDefaultPriority, &req2, pool_,
+                                BoundNetLog()));
 
   req.handle()->Reset();
 
   EXPECT_EQ(OK, req2.WaitForResult());
   req2.handle()->Reset();
 }
 
 TEST_F(TCPClientSocketPoolTest, ConnectCancelConnect) {
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   TestSocketRequest req(&request_order_, &completion_count_);
 
   TCPSocketParams dest("www.google.com", 80, kDefaultPriority, GURL(), false);
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", dest, kDefaultPriority, &callback, pool_, NULL));
+            handle.Init("a", dest, kDefaultPriority, &callback, pool_,
+                        BoundNetLog()));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", dest, kDefaultPriority, &callback2, pool_, NULL));
+            handle.Init("a", dest, kDefaultPriority, &callback2, pool_,
+                        BoundNetLog()));
 
   host_resolver_->set_synchronous_mode(true);
   // At this point, handle has two ConnectingSockets out for it.  Due to the
   // setting the mock resolver into synchronous mode, the host resolution for
   // both will return in the same loop of the MessageLoop.  The client socket
   // is a pending socket, so the Connect() will asynchronously complete on the
   // next loop of the MessageLoop.  That means that the first
   // ConnectingSocket will enter OnIOComplete, and then the second one will.
   // If the first one is not cancelled, it will advance the load state, and
   // then the second one will crash.
@@ skipping 78 matching lines @@
       // run through the MessageLoop once to get it completely released.
       handle_->socket()->Disconnect();
       handle_->Reset();
       {
         MessageLoop::ScopedNestableTaskAllower nestable(
             MessageLoop::current());
         MessageLoop::current()->RunAllPending();
       }
       within_callback_ = true;
       TCPSocketParams dest("www.google.com", 80, LOWEST, GURL(), false);
-      int rv = handle_->Init("a", dest, LOWEST, this, pool_, NULL);
+      int rv = handle_->Init("a", dest, LOWEST, this, pool_, BoundNetLog());
       EXPECT_EQ(OK, rv);
     }
   }
 
   int WaitForResult() {
     return callback_.WaitForResult();
   }
 
  private:
   ClientSocketHandle* const handle_;
   const scoped_refptr<TCPClientSocketPool> pool_;
   bool within_callback_;
   TestCompletionCallback callback_;
 };
 
 TEST_F(TCPClientSocketPoolTest, RequestTwice) {
   ClientSocketHandle handle;
   RequestSocketCallback callback(&handle, pool_.get());
   TCPSocketParams dest("www.google.com", 80, LOWEST, GURL(), false);
-  int rv = handle.Init("a", dest, LOWEST, &callback, pool_, NULL);
+  int rv = handle.Init("a", dest, LOWEST, &callback, pool_, BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   // The callback is going to request "www.google.com". We want it to complete
   // synchronously this time.
   host_resolver_->set_synchronous_mode(true);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
   handle.Reset();
 }
@@ skipping 42 matching lines @@
     EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
 
   for (int i = 0; i < kNumRequests; i++)
     EXPECT_EQ(ERR_CONNECTION_FAILED, requests_[i]->WaitForResult());
 }
 
 TEST_F(TCPClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) {
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   TCPSocketParams dest("www.google.com", 80, LOW, GURL(), false);
-  int rv = handle.Init("a", dest, LOW, &callback, pool_, NULL);
+  int rv = handle.Init("a", dest, LOW, &callback, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 
   handle.Reset();
 
@@ skipping 33 matching lines @@
   };
 
   for (size_t index = 0; index < arraysize(cases); ++index) {
     client_socket_factory_.set_client_socket_types(cases[index]);
 
     EXPECT_EQ(0, pool_->IdleSocketCount());
 
     TestCompletionCallback callback;
     ClientSocketHandle handle;
     TCPSocketParams dest("www.google.com", 80, LOW, GURL(), false);
-    int rv = handle.Init("b", dest, LOW, &callback, pool_, NULL);
+    int rv = handle.Init("b", dest, LOW, &callback, pool_, BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_FALSE(handle.is_initialized());
     EXPECT_FALSE(handle.socket());
 
     // Create the first socket, set the timer.
     MessageLoop::current()->RunAllPending();
 
     // Wait for the backup socket timer to fire.
     PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs);
 
@@ skipping 17 matching lines @@
       MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET);
 
   enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT };
 
   for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) {
     EXPECT_EQ(0, pool_->IdleSocketCount());
 
     TestCompletionCallback callback;
     ClientSocketHandle handle;
     TCPSocketParams dest("www.google.com", 80, LOW, GURL(), false);
-    int rv = handle.Init("c", dest, LOW, &callback, pool_, NULL);
+    int rv = handle.Init("c", dest, LOW, &callback, pool_, BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_FALSE(handle.is_initialized());
     EXPECT_FALSE(handle.socket());
 
     // Create the first socket, set the timer.
     MessageLoop::current()->RunAllPending();
 
     if (index == CANCEL_AFTER_WAIT) {
       // Wait for the backup socket timer to fire.
       PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs);
@@ skipping 24 matching lines @@
     MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET
   };
 
   client_socket_factory_.set_client_socket_types(case_types);
 
   EXPECT_EQ(0, pool_->IdleSocketCount());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   TCPSocketParams dest("www.google.com", 80, LOW, GURL(), false);
-  int rv = handle.Init("b", dest, LOW, &callback, pool_, NULL);
+  int rv = handle.Init("b", dest, LOW, &callback, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   // Create the first socket, set the timer.
   MessageLoop::current()->RunAllPending();
 
   // Wait for the backup socket timer to fire.
   PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs);
 
@@ skipping 25 matching lines @@
     MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET
   };
 
   client_socket_factory_.set_client_socket_types(case_types);
 
   EXPECT_EQ(0, pool_->IdleSocketCount());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   TCPSocketParams dest("www.google.com", 80, LOW, GURL(), false);
-  int rv = handle.Init("b", dest, LOW, &callback, pool_, NULL);
+  int rv = handle.Init("b", dest, LOW, &callback, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   // Create the first socket, set the timer.
   MessageLoop::current()->RunAllPending();
 
   // Wait for the backup socket timer to fire.
   PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs);
 
   // Let the second connect be synchronous. Otherwise, the emulated
   // host resolution takes an extra trip through the message loop.
   host_resolver_->set_synchronous_mode(true);
 
   // Let the appropriate socket connect.
   MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   handle.Reset();
 
   // Reset for the next case.
   host_resolver_->set_synchronous_mode(false);
 }
 
 }  // namespace
 
 }  // namespace net