Refactoring in client_socket_pool_base_unittest.cc.

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 "net/base/host_resolver_unittest.h"
 #include "net/base/net_errors.h"
@@ skipping 12 matching lines @@
 // Note that the first and the last are the same, the first should be handled
 // before the last, since it was inserted first.
 const int kPriorities[] = { 1, 3, 4, 2, 1 };
 
 // This is the number of extra requests beyond the first few that use up all
 // available sockets in the socket group.
 const int kNumPendingRequests = arraysize(kPriorities);
 
 const int kNumRequests = kMaxSocketsPerGroup + kNumPendingRequests;
 
+const int kDefaultPriority = 5;
+
 class MockClientSocket : public ClientSocket {
  public:
   MockClientSocket() : connected_(false) {}
 
   // Socket methods:
   virtual int Read(
       IOBuffer* /* buf */, int /* len */, CompletionCallback* /* callback */) {
     return ERR_UNEXPECTED;
   }
 
   virtual int Write(
       IOBuffer* /* buf */, int /* len */, CompletionCallback* /* callback */) {
     return ERR_UNEXPECTED;
   }
 
   // ClientSocket methods:
 
   virtual int Connect(CompletionCallback* callback) {
     connected_ = true;
     return OK;
   }
 
   virtual void Disconnect() { connected_ = false; }
   virtual bool IsConnected() const { return connected_; }
   virtual bool IsConnectedAndIdle() const { return connected_; }
-  
+
 #if defined(OS_LINUX)
   virtual int GetPeerName(struct sockaddr* /* name */,
                           socklen_t* /* namelen */) {
     return 0;
   }
 #endif
 
  private:
   bool connected_;
 
@@ skipping 216 matching lines @@
   virtual void SetUp() {
     TestSocketRequest::completion_count = 0;
   }
 
   virtual void TearDown() {
     // The tests often call Reset() on handles at the end which may post
     // DoReleaseSocket() tasks.
     MessageLoop::current()->RunAllPending();
   }
 
+  void CreateConnections(scoped_ptr<TestSocketRequest>* reqs, size_t count) {

[willchan no longer on Chromium, 2009/07/06 17:11:03]

It strikes me as odd that you have |count| as a variable, since you don't seem
to use it everywhere.  Notably, this code does not seem to handle the case when
count < kMaxSocketsPerGroup, or count != (kMaxSocketsPerGroup +
kNumPendingRequests).

+    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_,
+                                    kDefaultPriority, 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);
+    }
+  }
+
+  enum KeepAlive {
+    KEEP_ALIVE,
+    NO_KEEP_ALIVE,
+  };
+
+  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 < 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());
-  int rv = handle.Init("a", ignored_request_info_, 0, &callback);
-  EXPECT_EQ(OK, rv);
+  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_, 5, &req));
+            req.handle.Init("a", ignored_request_info_,
+                            kDefaultPriority, &req));
 }
 
 TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
   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.Reset();
-        MessageLoop::current()->RunAllPending();
-        released_one = true;
-      }
-    }
-  } while (released_one);
+  CreateConnections(reqs, arraysize(reqs));
+  ReleaseAllConnections(reqs, arraysize(reqs), KEEP_ALIVE);
 
   EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count());
   EXPECT_EQ(kNumPendingRequests, TestSocketRequest::completion_count);
 
   for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
     EXPECT_EQ(request_order_[i], reqs[i].get()) <<
         "Request " << i << " was not in order.";
   }
 
   for (int i = 0; i < kNumPendingRequests - 1; ++i) {
     int index_in_queue = (kNumPendingRequests - 1) - kPriorities[i];
     EXPECT_EQ(request_order_[kMaxSocketsPerGroup + index_in_queue],
               reqs[kMaxSocketsPerGroup + i].get()) <<
         "Request " << kMaxSocketsPerGroup + i << " was not in order.";
   }
 
   EXPECT_EQ(request_order_[arraysize(reqs) - 1],
             reqs[arraysize(reqs) - 1].get()) <<
       "The last request with priority 1 should not have been inserted "
       "earlier into the queue.";
 }
 
 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());
 
   EXPECT_EQ(kNumRequests, client_socket_factory_.allocation_count());
   EXPECT_EQ(kNumPendingRequests, TestSocketRequest::completion_count);
 }
 
 // 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) {
   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();
 }
 
 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(pool_.get(), &request_order_);
   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();
 
   EXPECT_EQ(OK, req2.WaitForResult());
   req2.handle.Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle(pool_.get());
   TestCompletionCallback callback;
   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());
 
   handle.Reset();
 }
 
 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);
 
   for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
     EXPECT_EQ(request_order_[i], reqs[i].get()) <<
         "Request " << i << " was not in order.";
   }
 
   for (int i = 0; i < kNumPendingRequests - 1; ++i) {
@@ skipping 24 matching lines @@
 
   virtual void RunWithParams(const Tuple1<int>& params) {
     callback_.RunWithParams(params);
     ASSERT_EQ(OK, params.a);
 
     if (!within_callback_) {
       test_connect_job_factory_->set_job_type(next_job_type_);
       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);
           break;
         case TestConnectJob::kMockPendingJob:
           EXPECT_EQ(ERR_IO_PENDING, rv);
           break;
         default:
           FAIL() << "Unexpected job type: " << next_job_type_;
           break;
       }
     }
   }
 
   int WaitForResult() {
     return callback_.WaitForResult();
   }
 
  private:
   ClientSocketHandle* const handle_;
   bool within_callback_;
   TestConnectJobFactory* const test_connect_job_factory_;
   TestConnectJob::JobType next_job_type_;
   TestCompletionCallback callback_;
 };
 
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle(pool_.get());
   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());
   handle.Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle(pool_.get());
   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());
   handle.Reset();
 }
 
 // Make sure that pending requests get serviced after active requests get
 // cancelled.
 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   scoped_ptr<TestSocketRequest> reqs[kNumRequests];
 
   // 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);
   }
 
   // Now, kMaxSocketsPerGroup requests should be active.  Let's cancel them.
   for (int i = 0; i < kMaxSocketsPerGroup; ++i)
     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();
   }
 
   EXPECT_EQ(kNumPendingRequests, TestSocketRequest::completion_count);
 }
 
 // Make sure that pending requests get serviced after active requests fail.
 TEST_F(ClientSocketPoolBaseTest, FailingActiveRequestWithPendingRequests) {
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   scoped_ptr<TestSocketRequest> reqs[kMaxSocketsPerGroup * 2 + 1];
 
   // 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);
   }
 
   for (size_t i = 0; i < arraysize(reqs); ++i)
     EXPECT_EQ(ERR_CONNECTION_FAILED, reqs[i]->WaitForResult());
 }
 
 // A pending asynchronous job completes, which will free up a socket slot.  The
 // next job finishes synchronously.  The callback for the asynchronous job
 // should be first though.
 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
   // First two jobs are async.
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   // 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.
-  connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 
+  connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   // 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());
   EXPECT_EQ(ERR_CONNECTION_FAILED, req2.WaitForResult());
   EXPECT_EQ(OK, req3.WaitForResult());
 
   ASSERT_EQ(3U, request_order_.size());
 
   // After job 1 finishes unsuccessfully, it will try to process the pending
   // requests queue, so it starts up job 3 for request 3.  This job
   // synchronously succeeds, so the request order is 1, 3, 2.
   EXPECT_EQ(&req1, request_order_[0]);
   EXPECT_EQ(&req2, request_order_[2]);
   EXPECT_EQ(&req3, request_order_[1]);
 }
 
 }  // namespace
 
 }  // namespace net