Refactoring in client_socket_pool_base_unittest.cc.

This is a preparation to add tests for limiting total number of sockets.

TEST=Covered by net_unittests.

http://crbug.com/15093

Review URL: http://codereview.chromium.org/149159

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@19975 0039d316-1c4b-4281-b951-d872f2087c98

net/socket/client_socket_pool_base_unittest.cc

@@ -30,6 +30,8 @@ const int kNumPendingRequests = arraysize(kPriorities);
 
 const int kNumRequests = kMaxSocketsPerGroup + kNumPendingRequests;
 
+const int kDefaultPriority = 5;
+
 class MockClientSocket : public ClientSocket {
  public:
   MockClientSocket() : connected_(false) {}
@@ -292,40 +294,14 @@ class ClientSocketPoolBaseTest : public testing::Test {
     MessageLoop::current()->RunAllPending();
   }
 
-  HostResolver::RequestInfo ignored_request_info_;
-  MockClientSocketFactory client_socket_factory_;
-  TestConnectJobFactory* const connect_job_factory_;
-  scoped_refptr<ClientSocketPool> pool_;
-  std::vector<TestSocketRequest*> request_order_;
-};
-
-TEST_F(ClientSocketPoolBaseTest, Basic) {
-  TestCompletionCallback callback;
-  ClientSocketHandle handle(pool_.get());
-  int rv = handle.Init("a", ignored_request_info_, 0, &callback);
-  EXPECT_EQ(OK, rv);
-  EXPECT_TRUE(handle.is_initialized());
-  EXPECT_TRUE(handle.socket());
-  handle.Reset();
-}
-
-TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
-  connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
-  TestSocketRequest req(pool_.get(), &request_order_);
-  EXPECT_EQ(ERR_CONNECTION_FAILED,
-            req.handle.Init("a", ignored_request_info_, 5, &req));
-}
-
-TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
-  scoped_ptr<TestSocketRequest> reqs[kNumRequests];
-
-  for (size_t i = 0; i < arraysize(reqs); ++i)
+  void CreateConnections(scoped_ptr<TestSocketRequest>* reqs, size_t count) {
+    for (size_t i = 0; i < count; ++i)
       reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
 
     // Create connections or queue up requests.
-
     for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
-    int rv = reqs[i]->handle.Init("a", ignored_request_info_, 5, reqs[i].get());
+      int rv = reqs[i]->handle.Init("a", ignored_request_info_,
+                                    kDefaultPriority, reqs[i].get());
       EXPECT_EQ(OK, rv);
       request_order_.push_back(reqs[i].get());
     }
@@ -337,19 +313,60 @@ TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
           reqs[kMaxSocketsPerGroup + i].get());
       EXPECT_EQ(ERR_IO_PENDING, rv);
     }
+  }
+
+  enum KeepAlive {
+    KEEP_ALIVE,
+    NO_KEEP_ALIVE,
+  };
 
-  // Release any connections until we have no connections.
+  void ReleaseAllConnections(scoped_ptr<TestSocketRequest>* reqs,
+                             size_t count, KeepAlive keep_alive) {
     bool released_one;
     do {
       released_one = false;
-    for (size_t i = 0; i < arraysize(reqs); ++i) {
+      for (size_t i = 0; i < count; ++i) {
         if (reqs[i]->handle.is_initialized()) {
+          if (keep_alive == NO_KEEP_ALIVE)
+            reqs[i]->handle.socket()->Disconnect();
           reqs[i]->handle.Reset();
           MessageLoop::current()->RunAllPending();
           released_one = true;
         }
       }
     } while (released_one);
+  }
+
+  HostResolver::RequestInfo ignored_request_info_;
+  MockClientSocketFactory client_socket_factory_;
+  TestConnectJobFactory* const connect_job_factory_;
+  scoped_refptr<ClientSocketPool> pool_;
+  std::vector<TestSocketRequest*> request_order_;
+};
+
+TEST_F(ClientSocketPoolBaseTest, Basic) {
+  TestCompletionCallback callback;
+  ClientSocketHandle handle(pool_.get());
+  EXPECT_EQ(OK, handle.Init("a", ignored_request_info_, kDefaultPriority,
+                            &callback));
+  EXPECT_TRUE(handle.is_initialized());
+  EXPECT_TRUE(handle.socket());
+  handle.Reset();
+}
+
+TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
+  connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
+  TestSocketRequest req(pool_.get(), &request_order_);
+  EXPECT_EQ(ERR_CONNECTION_FAILED,
+            req.handle.Init("a", ignored_request_info_,
+                            kDefaultPriority, &req));
+}
+
+TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
+  scoped_ptr<TestSocketRequest> reqs[kNumRequests];
+
+  CreateConnections(reqs, arraysize(reqs));
+  ReleaseAllConnections(reqs, arraysize(reqs), KEEP_ALIVE);
 
   EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count());
   EXPECT_EQ(kNumPendingRequests, TestSocketRequest::completion_count);
@@ -374,37 +391,9 @@ TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
 
 TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) {
   scoped_ptr<TestSocketRequest> reqs[kNumRequests];
-  for (size_t i = 0; i < arraysize(reqs); ++i)
-    reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
-
-  // Create connections or queue up requests.
-  for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
-    int rv = reqs[i]->handle.Init("a", ignored_request_info_, 5, reqs[i].get());
-    EXPECT_EQ(OK, rv);
-    request_order_.push_back(reqs[i].get());
-  }
 
-  // The rest are pending since we've used all active sockets.
-  for (int i = 0; i < kNumPendingRequests; ++i) {
-    int rv = reqs[kMaxSocketsPerGroup + i]->handle.Init(
-        "a", ignored_request_info_, kPriorities[i],
-        reqs[kMaxSocketsPerGroup + i].get());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
-  }
-
-  // Release any connections until we have no connections.
-  bool released_one;
-  do {
-    released_one = false;
-    for (size_t i = 0; i < arraysize(reqs); ++i) {
-      if (reqs[i]->handle.is_initialized()) {
-        reqs[i]->handle.socket()->Disconnect();  // No keep alive.
-        reqs[i]->handle.Reset();
-        MessageLoop::current()->RunAllPending();
-        released_one = true;
-      }
-    }
-  } while (released_one);
+  CreateConnections(reqs, arraysize(reqs));
+  ReleaseAllConnections(reqs, arraysize(reqs), NO_KEEP_ALIVE);
 
   for (int i = kMaxSocketsPerGroup; i < kNumRequests; ++i)
     EXPECT_EQ(OK, reqs[i]->WaitForResult());
@@ -420,7 +409,8 @@ TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(pool_.get(), &request_order_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle.Init("a", ignored_request_info_, 5, &req));
+            req.handle.Init("a", ignored_request_info_,
+                            kDefaultPriority, &req));
   req.handle.Reset();
 }
 
@@ -430,9 +420,11 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
   TestSocketRequest req2(pool_.get(), &request_order_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle.Init("a", ignored_request_info_, 5, &req));
+            req.handle.Init("a", ignored_request_info_,
+                            kDefaultPriority, &req));
   EXPECT_EQ(ERR_IO_PENDING,
-            req2.handle.Init("a", ignored_request_info_, 5, &req2));
+            req2.handle.Init("a", ignored_request_info_,
+                             kDefaultPriority, &req2));
 
   req.handle.Reset();
 
@@ -447,13 +439,15 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
   TestSocketRequest req(pool_.get(), &request_order_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", ignored_request_info_, 5, &callback));
+            handle.Init("a", ignored_request_info_,
+                        kDefaultPriority, &callback));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", ignored_request_info_, 5, &callback2));
+            handle.Init("a", ignored_request_info_,
+                        kDefaultPriority, &callback2));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
@@ -464,40 +458,14 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
 TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
   scoped_ptr<TestSocketRequest> reqs[kNumRequests];
 
-  for (size_t i = 0; i < arraysize(reqs); ++i)
-    reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
-
-  // Create connections or queue up requests.
-  for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
-    int rv = reqs[i]->handle.Init("a", ignored_request_info_, 5, reqs[i].get());
-    EXPECT_EQ(OK, rv);
-    request_order_.push_back(reqs[i].get());
-  }
-
-  // The rest are pending since we've used all active sockets.
-  for (int i = 0; i < kNumPendingRequests; ++i) {
-    EXPECT_EQ(ERR_IO_PENDING, reqs[kMaxSocketsPerGroup + i]->handle.Init(
-        "a", ignored_request_info_, kPriorities[i],
-        reqs[kMaxSocketsPerGroup + i].get()));
-  }
+  CreateConnections(reqs, arraysize(reqs));
 
   // Cancel a request.
   size_t index_to_cancel = kMaxSocketsPerGroup + 2;
   EXPECT_TRUE(!reqs[index_to_cancel]->handle.is_initialized());
   reqs[index_to_cancel]->handle.Reset();
 
-  // Release any connections until we have no connections.
-  bool released_one;
-  do {
-    released_one = false;
-    for (size_t i = 0; i < arraysize(reqs); ++i) {
-      if (reqs[i]->handle.is_initialized()) {
-        reqs[i]->handle.Reset();
-        MessageLoop::current()->RunAllPending();
-        released_one = true;
-      }
-    }
-  } while (released_one);
+  ReleaseAllConnections(reqs, arraysize(reqs), KEEP_ALIVE);
 
   EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count());
   EXPECT_EQ(kNumPendingRequests - 1, TestSocketRequest::completion_count);
@@ -542,7 +510,8 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
       handle_->Reset();
       within_callback_ = true;
       int rv = handle_->Init(
-          "a", HostResolver::RequestInfo("www.google.com", 80), 0, this);
+          "a", HostResolver::RequestInfo("www.google.com", 80),
+          kDefaultPriority, this);
       switch (next_job_type_) {
         case TestConnectJob::kMockJob:
           EXPECT_EQ(OK, rv);
@@ -575,7 +544,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
   RequestSocketCallback callback(
       &handle, connect_job_factory_, TestConnectJob::kMockPendingJob);
   int rv = handle.Init(
-      "a", ignored_request_info_, 0, &callback);
+      "a", ignored_request_info_, kDefaultPriority, &callback);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -588,7 +557,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
   RequestSocketCallback callback(
       &handle, connect_job_factory_, TestConnectJob::kMockJob);
   int rv = handle.Init(
-      "a", ignored_request_info_, 0, &callback);
+      "a", ignored_request_info_, kDefaultPriority, &callback);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -605,7 +574,8 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
   // Queue up all the requests
   for (size_t i = 0; i < arraysize(reqs); ++i) {
     reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
-    int rv = reqs[i]->handle.Init("a", ignored_request_info_, 5, reqs[i].get());
+    int rv = reqs[i]->handle.Init("a", ignored_request_info_,
+                                  kDefaultPriority, reqs[i].get());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
@@ -614,7 +584,6 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
     reqs[i]->handle.Reset();
 
   // Let's wait for the rest to complete now.
-
   for (size_t i = kMaxSocketsPerGroup; i < arraysize(reqs); ++i) {
     EXPECT_EQ(OK, reqs[i]->WaitForResult());
     reqs[i]->handle.Reset();
@@ -632,7 +601,8 @@ TEST_F(ClientSocketPoolBaseTest, FailingActiveRequestWithPendingRequests) {
   // Queue up all the requests
   for (size_t i = 0; i < arraysize(reqs); ++i) {
     reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
-    int rv = reqs[i]->handle.Init("a", ignored_request_info_, 5, reqs[i].get());
+    int rv = reqs[i]->handle.Init("a", ignored_request_info_,
+                                  kDefaultPriority, reqs[i].get());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
@@ -649,12 +619,13 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
 
   // Start job 1 (async error).
   TestSocketRequest req1(pool_.get(), &request_order_);
-  int rv = req1.handle.Init("a", ignored_request_info_, 5, &req1);
+  int rv = req1.handle.Init("a", ignored_request_info_,
+                            kDefaultPriority, &req1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Start job 2 (async error).
   TestSocketRequest req2(pool_.get(), &request_order_);
-  rv = req2.handle.Init("a", ignored_request_info_, 5, &req2);
+  rv = req2.handle.Init("a", ignored_request_info_, kDefaultPriority, &req2);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
@@ -662,7 +633,7 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
 
   // Request 3 does not have a ConnectJob yet.  It's just pending.
   TestSocketRequest req3(pool_.get(), &request_order_);
-  rv = req3.handle.Init("a", ignored_request_info_, 5, &req3);
+  rv = req3.handle.Init("a", ignored_request_info_, kDefaultPriority, &req3);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());