Add timeouts for ConnectJobs. Limit ConnectJobs per group to number of Requests per group + 1.

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/platform_thread.h"
 #include "base/scoped_vector.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 "net/socket/socket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ skipping 81 matching lines @@
     kMockFailingJob,
     kMockPendingJob,
     kMockPendingFailingJob,
     kMockWaitingJob,
     kMockAdvancingLoadStateJob,
   };
 
   TestConnectJob(JobType job_type,
                  const std::string& group_name,
                  const ClientSocketPoolBase::Request& request,
+                 base::TimeDelta timeout_duration,
                  ConnectJob::Delegate* delegate,
                  MockClientSocketFactory* client_socket_factory)
-      : ConnectJob(group_name, request.handle, delegate),
+      : ConnectJob(group_name, request.handle, timeout_duration, delegate),
         job_type_(job_type),
         client_socket_factory_(client_socket_factory),
         method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
+  void Signal() {
+    DoConnect(waiting_success_, true /* async */);
+  }
+
+ private:
   // ConnectJob methods:
 
-  virtual int Connect() {
+  virtual int ConnectInternal() {
     AddressList ignored;
     client_socket_factory_->CreateTCPClientSocket(ignored);
     switch (job_type_) {
       case kMockJob:
         return DoConnect(true /* successful */, false /* sync */);
       case kMockFailingJob:
         return DoConnect(false /* error */, false /* sync */);
       case kMockPendingJob:
         set_load_state(LOAD_STATE_CONNECTING);
         MessageLoop::current()->PostTask(
@@ skipping 21 matching lines @@
             FROM_HERE,
             method_factory_.NewRunnableMethod(
                 &TestConnectJob::AdvanceLoadState, load_state()));
         return ERR_IO_PENDING;
       default:
         NOTREACHED();
         return ERR_FAILED;
     }
   }
 
-  void Signal() {
-    DoConnect(waiting_success_, true /* async */);
-  }
-
- private:
   int DoConnect(bool succeed, bool was_async) {
     int result = ERR_CONNECTION_FAILED;
     if (succeed) {
       result = OK;
       set_socket(new MockClientSocket());
       socket()->Connect(NULL);
     }
 
     if (was_async)
       delegate()->OnConnectJobComplete(result, this);
@@ skipping 24 matching lines @@
 class TestConnectJobFactory : public ClientSocketPoolBase::ConnectJobFactory {
  public:
   explicit TestConnectJobFactory(MockClientSocketFactory* client_socket_factory)
       : job_type_(TestConnectJob::kMockJob),
         client_socket_factory_(client_socket_factory) {}
 
   virtual ~TestConnectJobFactory() {}
 
   void set_job_type(TestConnectJob::JobType job_type) { job_type_ = job_type; }
 
+  void set_timeout_duration(base::TimeDelta timeout_duration) {
+    timeout_duration_ = timeout_duration;
+  }
+
   // ConnectJobFactory methods:
 
   virtual ConnectJob* NewConnectJob(
       const std::string& group_name,
       const ClientSocketPoolBase::Request& request,
       ConnectJob::Delegate* delegate) const {
     return new TestConnectJob(job_type_,
                               group_name,
                               request,
+                              timeout_duration_,
                               delegate,
                               client_socket_factory_);
   }
 
  private:
   TestConnectJob::JobType job_type_;
+  base::TimeDelta timeout_duration_;
   MockClientSocketFactory* const client_socket_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory);
 };
 
 class TestClientSocketPool : public ClientSocketPool {
  public:
   TestClientSocketPool(
       int max_sockets,
       int max_sockets_per_group,
@@ skipping 33 matching lines @@
     return base_->IdleSocketCountInGroup(group_name);
   }
 
   virtual LoadState GetLoadState(const std::string& group_name,
                                  const ClientSocketHandle* handle) const {
     return base_->GetLoadState(group_name, handle);
   }
 
   const ClientSocketPoolBase* base() const { return base_.get(); }
 
+  int NumConnectJobsInGroup(const std::string& group_name) const {
+    return base_->NumConnectJobsInGroup(group_name);
+  }
+
  private:
   const scoped_refptr<ClientSocketPoolBase> base_;
 
   DISALLOW_COPY_AND_ASSIGN(TestClientSocketPool);
 };
 
 void MockClientSocketFactory::SignalJobs() {
   for (std::vector<TestConnectJob*>::iterator it = waiting_jobs_.begin();
        it != waiting_jobs_.end(); ++it) {
     (*it)->Signal();
   }
   waiting_jobs_.clear();
 }
 
+class TestConnectJobDelegate : public ConnectJob::Delegate {
+ public:
+  TestConnectJobDelegate()
+      : have_result_(false), waiting_for_result_(false), result_(OK) {}
+  virtual ~TestConnectJobDelegate() {}
+
+  virtual void OnConnectJobComplete(int result, ConnectJob* job) {
+    result_ = result;
+    delete job;
+    have_result_ = true;
+    if (waiting_for_result_)
+      MessageLoop::current()->Quit();
+  }
+
+  int WaitForResult() {
+    DCHECK(!waiting_for_result_);
+    while (!have_result_) {
+      waiting_for_result_ = true;
+      MessageLoop::current()->Run();
+      waiting_for_result_ = false;
+    }
+    have_result_ = false;  // auto-reset for next callback
+    return result_;
+  }
+
+ private:
+  bool have_result_;
+  bool waiting_for_result_;
+  int result_;
+};
+
 class ClientSocketPoolBaseTest : public ClientSocketPoolTest {
  protected:
   ClientSocketPoolBaseTest()
       : connect_job_factory_(
             new TestConnectJobFactory(&client_socket_factory_)) {}
 
   void CreatePool(int max_sockets, int max_sockets_per_group) {
     DCHECK(!pool_.get());
     pool_ = new TestClientSocketPool(max_sockets,
                                      max_sockets_per_group,
@@ skipping 15 matching lines @@
     ClientSocketPoolBase::EnableLateBindingOfSockets(false);
 
     ClientSocketPoolTest::TearDown();
   }
 
   MockClientSocketFactory client_socket_factory_;
   TestConnectJobFactory* const connect_job_factory_;
   scoped_refptr<TestClientSocketPool> pool_;
 };
 
+// Even though a timeout is specified, it doesn't time out on a synchronous
+// completion.
+TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
+  TestConnectJobDelegate delegate;
+  ClientSocketPoolBase::Request request;
+  ClientSocketHandle ignored(pool_.get());
+  request.handle = &ignored;
+  scoped_ptr<TestConnectJob> job(
+      new TestConnectJob(TestConnectJob::kMockJob,
+                         "a", 
+                         request,
+                         base::TimeDelta::FromMicroseconds(1),
+                         &delegate,
+                         &client_socket_factory_));
+  EXPECT_EQ(OK, job->Connect());
+}
+
+TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
+  TestConnectJobDelegate delegate;
+  ClientSocketPoolBase::Request request;
+  ClientSocketHandle ignored(pool_.get());
+  request.handle = &ignored;
+  // Deleted by TestConnectJobDelegate.
+  TestConnectJob* job =
+      new TestConnectJob(TestConnectJob::kMockPendingJob,
+                         "a", 
+                         request,
+                         base::TimeDelta::FromMicroseconds(1),
+                         &delegate,
+                         &client_socket_factory_);
+  ASSERT_EQ(ERR_IO_PENDING, job->Connect());
+  PlatformThread::Sleep(1);
+  EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult());
+}
+
 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   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();
@@ skipping 866 matching lines @@
   EXPECT_EQ(5, GetOrderOfRequest(3));
   EXPECT_EQ(3, GetOrderOfRequest(4));
   EXPECT_EQ(kRequestNotFound, GetOrderOfRequest(5));  // Canceled request.
   EXPECT_EQ(4, GetOrderOfRequest(6));
   EXPECT_EQ(6, GetOrderOfRequest(7));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(8));
 }
 
+TEST_F(ClientSocketPoolBaseTest_LateBinding, CancelRequestLimitsJobs) {
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
+
+  CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
+
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", 1));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", 2));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", 3));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", 4));
+
+  EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
+  requests_[2]->handle()->Reset();
+  requests_[3]->handle()->Reset();
+  EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
+
+  requests_[1]->handle()->Reset();
+  EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
+
+  requests_[0]->handle()->Reset();
+  EXPECT_EQ(kDefaultMaxSocketsPerGroup - 1, pool_->NumConnectJobsInGroup("a"));
+}
+
 TEST_F(ClientSocketPoolBaseTest_LateBinding, RequestPendingJobTwice) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   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_, kDefaultPriority, &callback);
   ASSERT_EQ(ERR_IO_PENDING, rv);
@@ skipping 220 matching lines @@
   // Closing idle sockets should not get us into trouble, but in the bug
   // we were hitting a CHECK here.
   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
   pool_->CloseIdleSockets();
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 }
 
 }  // namespace
 
 }  // namespace net