Refactorings surrounding HostResolver:...

net/socket/client_socket_pool_base_unittest.cc

 // Copyright (c) 2006-2008 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/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/scoped_vector.h"
-#include "net/base/host_resolver_unittest.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/client_socket.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
@@ skipping 765 matching lines @@
   EXPECT_EQ(&req3, request_order_[1]);
 }
 
 // When a ConnectJob is coupled to a request, even if a free socket becomes
 // available, the request will be serviced by the ConnectJob.
 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
   CreatePool(kDefaultMaxSocketsPerGroup);
   ClientSocketPoolBase::EnableLateBindingOfSockets(false);
 
   // Start job 1 (async OK)
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req1(pool_.get(), &request_order_);
   int rv = req1.handle.Init("a", ignored_request_info_, 5, &req1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req1.WaitForResult());
 
   // Job 1 finished OK.  Start job 2 (also async OK).  Release socket 1.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   TestSocketRequest req2(pool_.get(), &request_order_);
@@ skipping 321 matching lines @@
   EXPECT_EQ(1U, TestSocketRequest::completion_count);
   EXPECT_EQ(2, client_socket_factory_.allocation_count());
 }
 
 // When requests and ConnectJobs are not coupled, the request will get serviced
 // by whatever comes first.
 TEST_F(ClientSocketPoolBaseTest_LateBinding, ReleaseSockets) {
   CreatePool(kDefaultMaxSocketsPerGroup);
 
   // Start job 1 (async OK)
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req1(pool_.get(), &request_order_);
   int rv = req1.handle.Init("a", ignored_request_info_, 5, &req1);
   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);
 
@@ skipping 22 matching lines @@
   EXPECT_EQ(&req2, request_order_[1]);
   EXPECT_EQ(&req3, request_order_[2]);
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 }
 
 // The requests are not coupled to the jobs.  So, the requests should finish in
 // their priority / insertion order.
 TEST_F(ClientSocketPoolBaseTest_LateBinding, PendingJobCompletionOrder) {
   CreatePool(kDefaultMaxSocketsPerGroup);
   // First two jobs are async.
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   TestSocketRequest req1(pool_.get(), &request_order_);
   int rv = req1.handle.Init("a", ignored_request_info_, 5, &req1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestSocketRequest req2(pool_.get(), &request_order_);
   rv = req2.handle.Init("a", ignored_request_info_, 5, &req2);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
-  connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   TestSocketRequest req3(pool_.get(), &request_order_);
   rv = req3.handle.Init("a", ignored_request_info_, 5, &req3);
   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_LateBinding, LoadState) {
   CreatePool(kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(
-      TestConnectJob::kMockAdvancingLoadStateJob); 
+      TestConnectJob::kMockAdvancingLoadStateJob);
 
   TestSocketRequest req1(pool_.get(), &request_order_);
   int rv = req1.handle.Init("a", ignored_request_info_, 5, &req1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_IDLE, req1.handle.GetLoadState());
 
   MessageLoop::current()->RunAllPending();
 
   TestSocketRequest req2(pool_.get(), &request_order_);
   rv = req2.handle.Init("a", ignored_request_info_, 5, &req2);
   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());
 }
 
 }  // namespace
 
 }  // namespace net