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

net/socket/client_socket_pool_base_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/client_socket_pool_base.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
@@ skipping 453 matching lines @@
   return handle->Init<TestSocketParams, TestClientSocketPool>(
       group_name, NULL, priority, callback, pool, net_log);
 }
 
 // Even though a timeout is specified, it doesn't time out on a synchronous
 // completion.
 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
   TestConnectJobDelegate delegate;
   ClientSocketHandle ignored;
   TestClientSocketPoolBase::Request request(
-      &ignored, NULL, kDefaultPriority, NULL, NULL);
+      &ignored, NULL, kDefaultPriority, NULL, BoundNetLog());
   scoped_ptr<TestConnectJob> job(
       new TestConnectJob(TestConnectJob::kMockJob,
                          "a",
                          request,
                          base::TimeDelta::FromMicroseconds(1),
                          &delegate,
                          &client_socket_factory_,
-                         NULL));
+                         BoundNetLog()));
   EXPECT_EQ(OK, job->Connect());
 }
 
 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
   TestConnectJobDelegate delegate;
   ClientSocketHandle ignored;
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
 
   TestClientSocketPoolBase::Request request(
-      &ignored, NULL, kDefaultPriority, NULL, NULL);
+      &ignored, NULL, kDefaultPriority, NULL, BoundNetLog());
   // Deleted by TestConnectJobDelegate.
   TestConnectJob* job =
       new TestConnectJob(TestConnectJob::kMockPendingJob,
                          "a",
                          request,
                          base::TimeDelta::FromMicroseconds(1),
                          &delegate,
                          &client_socket_factory_,
                          log.bound());
   ASSERT_EQ(ERR_IO_PENDING, job->Connect());
@@ skipping 46 matching lines @@
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
 
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
             InitHandle(req.handle(), "a", kDefaultPriority, &req, pool_,
                        log.bound()));
 
   EXPECT_EQ(6u, log.entries().size());
-  EXPECT_TRUE(LogContainsBeginEvent(log.entries(), 0, NetLog::TYPE_SOCKET_POOL));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      log.entries(), 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsBeginEvent(
       log.entries(), 2, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
   EXPECT_TRUE(LogContainsEndEvent(
       log.entries(), 3, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
   EXPECT_TRUE(LogContainsEndEvent(log.entries(), 5, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
@@ skipping 311 matching lines @@
 
 // This test will start up a RequestSocket() and then immediately Cancel() it.
 // The pending connect job will be cancelled and should not call back into
 // ClientSocketPoolBase.
 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            InitHandle(req.handle(), "a", kDefaultPriority, &req, pool_, NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req, pool_,
+                       BoundNetLog()));
   req.handle()->Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   TestSocketRequest req(&request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            InitHandle(&handle, "a", kDefaultPriority, &callback, pool_, NULL));
+            InitHandle(&handle, "a", kDefaultPriority, &callback, pool_,
+            BoundNetLog()));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, InitHandle(&handle, "a", kDefaultPriority,
-                                       &callback2, pool_, NULL));
+                                       &callback2, pool_, BoundNetLog()));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
 
   handle.Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
@@ skipping 53 matching lines @@
       handle_->socket()->Disconnect();
       handle_->Reset();
       {
         MessageLoop::ScopedNestableTaskAllower nestable(
             MessageLoop::current());
         MessageLoop::current()->RunAllPending();
       }
       within_callback_ = true;
       TestCompletionCallback next_job_callback;
       int rv = InitHandle(handle_, "a", kDefaultPriority, &next_job_callback,
-                          pool_, NULL);
+                          pool_, BoundNetLog());
       switch (next_job_type_) {
         case TestConnectJob::kMockJob:
           EXPECT_EQ(OK, rv);
           break;
         case TestConnectJob::kMockPendingJob:
           EXPECT_EQ(ERR_IO_PENDING, rv);
 
           // For pending jobs, wait for new socket to be created. This makes
           // sure there are no more pending operations nor any unclosed sockets
           // when the test finishes.
@@ skipping 28 matching lines @@
 };
 
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_,
       TestConnectJob::kMockPendingJob);
-  int rv = InitHandle(&handle, "a", kDefaultPriority, &callback, pool_, NULL);
+  int rv = InitHandle(&handle, "a", kDefaultPriority, &callback, pool_,
+                      BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob);
-  int rv = InitHandle(&handle, "a", kDefaultPriority, &callback, pool_, NULL);
+  int rv = InitHandle(&handle, "a", kDefaultPriority, &callback, pool_,
+                      BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Make sure that pending requests get serviced after active requests get
 // cancelled.
 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
@@ skipping 40 matching lines @@
   for (size_t i = 0; i < kNumberOfRequests; ++i)
     EXPECT_EQ(ERR_CONNECTION_FAILED, requests_[i]->WaitForResult());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req(&request_order_, &completion_count_);
-  int rv = InitHandle(req.handle(), "a", kDefaultPriority, &req, pool_, NULL);
+  int rv = InitHandle(req.handle(), "a", kDefaultPriority, &req, pool_,
+                      BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the active request.
   req.handle()->Reset();
 
-  rv = InitHandle(req.handle(), "a", kDefaultPriority, &req, pool_, NULL);
+  rv = InitHandle(req.handle(), "a", kDefaultPriority, &req, pool_,
+                  BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req.WaitForResult());
 
   EXPECT_FALSE(req.handle()->is_reused());
   EXPECT_EQ(1U, completion_count_);
   EXPECT_EQ(2, client_socket_factory_.allocation_count());
 }
 
 // Regression test for http://crbug.com/17985.
 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) {
@@ skipping 132 matching lines @@
 
 // When requests and ConnectJobs are not coupled, the request will get serviced
 // by whatever comes first.
 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   // Start job 1 (async OK)
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req1(&request_order_, &completion_count_);
-  int rv = InitHandle(req1.handle(), "a", kDefaultPriority, &req1, pool_, NULL);
+  int rv = InitHandle(req1.handle(), "a", kDefaultPriority, &req1, pool_,
+                      BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req1.WaitForResult());
 
   // Job 1 finished OK.  Start job 2 (also async OK).  Request 3 is pending
   // without a job.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, pool_, NULL);
+  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, pool_,
+                  BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   TestSocketRequest req3(&request_order_, &completion_count_);
-  rv = InitHandle(req3.handle(), "a", kDefaultPriority, &req3, pool_, NULL);
+  rv = InitHandle(req3.handle(), "a", kDefaultPriority, &req3, pool_,
+                  BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Both Requests 2 and 3 are pending.  We release socket 1 which should
   // service request 2.  Request 3 should still be waiting.
   req1.handle()->Reset();
   MessageLoop::current()->RunAllPending();  // Run the DoReleaseSocket()
   ASSERT_TRUE(req2.handle()->socket());
   EXPECT_EQ(OK, req2.WaitForResult());
   EXPECT_FALSE(req3.handle()->socket());
 
@@ skipping 10 matching lines @@
 }
 
 // The requests are not coupled to the jobs.  So, the requests should finish in
 // their priority / insertion order.
 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   // First two jobs are async.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   TestSocketRequest req1(&request_order_, &completion_count_);
-  int rv = InitHandle(req1.handle(), "a", kDefaultPriority, &req1, pool_, NULL);
+  int rv = InitHandle(req1.handle(), "a", kDefaultPriority, &req1, pool_,
+                      BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, pool_, NULL);
+  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, pool_,
+                  BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   TestSocketRequest req3(&request_order_, &completion_count_);
-  rv = InitHandle(req3.handle(), "a", kDefaultPriority, &req3, pool_, NULL);
+  rv = InitHandle(req3.handle(), "a", kDefaultPriority, &req3, pool_,
+                  BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
   EXPECT_EQ(OK, req2.WaitForResult());
   EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult());
 
   ASSERT_EQ(3U, request_order_.size());
   EXPECT_EQ(&req1, request_order_[0]);
   EXPECT_EQ(&req2, request_order_[1]);
   EXPECT_EQ(&req3, request_order_[2]);
 }
 
 TEST_F(ClientSocketPoolBaseTest, DISABLED_LoadState) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockAdvancingLoadStateJob);
 
   TestSocketRequest req1(&request_order_, &completion_count_);
-  int rv = InitHandle(req1.handle(), "a", kDefaultPriority, &req1, pool_, NULL);
+  int rv = InitHandle(req1.handle(), "a", kDefaultPriority, &req1, pool_,
+                      BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_IDLE, req1.handle()->GetLoadState());
 
   MessageLoop::current()->RunAllPending();
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, pool_, NULL);
+  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, pool_,
+                  BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, req1.handle()->GetLoadState());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, req2.handle()->GetLoadState());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   // Startup two mock pending connect jobs, which will sit in the MessageLoop.
 
   TestSocketRequest req(&request_order_, &completion_count_);
-  int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_, NULL);
+  int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = InitHandle(req2.handle(), "a", LOWEST, &req2, pool_, NULL);
+  rv = InitHandle(req2.handle(), "a", LOWEST, &req2, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req2.handle()));
 
   // Cancel one of the requests.  Wait for the other, which will get the first
   // job.  Release the socket.  Run the loop again to make sure the second
   // socket is sitting idle and the first one is released (since ReleaseSocket()
   // just posts a DoReleaseSocket() task).
 
   req.handle()->Reset();
   EXPECT_EQ(OK, req2.WaitForResult());
@@ skipping 26 matching lines @@
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   // Startup 4 connect jobs.  Two of them will be pending.
 
   TestSocketRequest req(&request_order_, &completion_count_);
-  int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_, NULL);
+  int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = InitHandle(req2.handle(), "a", LOWEST, &req2, pool_, NULL);
+  rv = InitHandle(req2.handle(), "a", LOWEST, &req2, pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   TestSocketRequest req3(&request_order_, &completion_count_);
-  rv = InitHandle(req3.handle(), "a", LOWEST, &req3, pool_, NULL);
+  rv = InitHandle(req3.handle(), "a", LOWEST, &req3, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestSocketRequest req4(&request_order_, &completion_count_);
-  rv = InitHandle(req4.handle(), "a", LOWEST, &req4, pool_, NULL);
+  rv = InitHandle(req4.handle(), "a", LOWEST, &req4, pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Release two disconnected sockets.
 
   req.handle()->socket()->Disconnect();
   req.handle()->Reset();
   req2.handle()->socket()->Disconnect();
   req2.handle()->Reset();
 
   EXPECT_EQ(OK, req3.WaitForResult());
@@ skipping 42 matching lines @@
   ClientSocketHandle* handle() { return &handle_; }
 
   int WaitForResult() {
     return callback_.WaitForResult();
   }
 
   virtual void RunWithParams(const Tuple1<int>& params) {
     callback_.RunWithParams(params);
     handle_.Reset();
     EXPECT_EQ(ERR_IO_PENDING, InitHandle(&handle2_, "a", kDefaultPriority,
-                                         &callback2_, pool_, NULL));
+                                         &callback2_, pool_, BoundNetLog()));
   }
 
  private:
   TestClientSocketPool* const pool_;
   ClientSocketHandle handle_;
   ClientSocketHandle handle2_;
   TestCompletionCallback callback_;
   TestCompletionCallback callback2_;
 };
 
 // This test covers the case where, within the same DoReleaseSocket() callback,
 // we release the just acquired socket and start up a new request.  See bug
 // 36871 for details.
 TEST_F(ClientSocketPoolBaseTest, ReleasedSocketReleasesToo) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   // Complete one request and release the socket.
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(OK, InitHandle(&handle, "a", kDefaultPriority, &callback, pool_,
-                           NULL));
+                           BoundNetLog()));
   handle.Reset();
 
   // Before the DoReleaseSocket() task has run, start up a
   // TestReleasingSocketRequest.  This one will be ERR_IO_PENDING since
   // num_releasing_sockets > 0 and there was no idle socket to use yet.
   TestReleasingSocketRequest request(pool_.get());
   EXPECT_EQ(ERR_IO_PENDING, InitHandle(request.handle(), "a", kDefaultPriority,
-                                       &request, pool_, NULL));
+                                       &request, pool_, BoundNetLog()));
 
   EXPECT_EQ(OK, request.WaitForResult());
 }
 
 }  // namespace
 
 }  // namespace net