Control the amount of time to leave an unused socket idle before closing it.

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"
@@ skipping 232 matching lines @@
   MockClientSocketFactory* const client_socket_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory);
 };
 
 class TestClientSocketPool : public ClientSocketPool {
  public:
   TestClientSocketPool(
       int max_sockets,
       int max_sockets_per_group,
+      base::TimeDelta unused_idle_socket_timeout,
+      base::TimeDelta used_idle_socket_timeout,
       TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory)
-      : base_(max_sockets, max_sockets_per_group, connect_job_factory) {}
+      : base_(max_sockets, max_sockets_per_group,
+              unused_idle_socket_timeout, used_idle_socket_timeout,
+              connect_job_factory) {}
 
   virtual int RequestSocket(
       const std::string& group_name,
       const void* params,
       int priority,
       ClientSocketHandle* handle,
       CompletionCallback* callback,
       LoadLog* load_log) {
     return base_.RequestSocket(
         group_name, params, priority, handle, callback, load_log);
@@ skipping 25 matching lines @@
                                  const ClientSocketHandle* handle) const {
     return base_.GetLoadState(group_name, handle);
   }
 
   const TestClientSocketPoolBase* base() const { return &base_; }
 
   int NumConnectJobsInGroup(const std::string& group_name) const {
     return base_.NumConnectJobsInGroup(group_name);
   }
 
+  void CleanupTimedOutIdleSockets() { base_.CleanupIdleSockets(false); }
+
  private:
   TestClientSocketPoolBase base_;
 
   DISALLOW_COPY_AND_ASSIGN(TestClientSocketPool);
 };
 
 }  // namespace
 
 REGISTER_SOCKET_PARAMS_FOR_POOL(TestClientSocketPool, const void*);
 
@@ skipping 42 matching lines @@
   bool have_result_;
   bool waiting_for_result_;
   int result_;
 };
 
 class ClientSocketPoolBaseTest : public ClientSocketPoolTest {
  protected:
   ClientSocketPoolBaseTest() {}
 
   void CreatePool(int max_sockets, int max_sockets_per_group) {
+    CreatePoolWithIdleTimeouts(
+        max_sockets,
+        max_sockets_per_group,
+        base::TimeDelta::FromSeconds(kUnusedIdleSocketTimeout),
+        base::TimeDelta::FromSeconds(kUsedIdleSocketTimeout));
+  }
+
+  void CreatePoolWithIdleTimeouts(
+      int max_sockets, int max_sockets_per_group,
+      base::TimeDelta unused_idle_socket_timeout,
+      base::TimeDelta used_idle_socket_timeout) {
     DCHECK(!pool_.get());
     connect_job_factory_ = new TestConnectJobFactory(&client_socket_factory_);
     pool_ = new TestClientSocketPool(max_sockets,
                                      max_sockets_per_group,
+                                     unused_idle_socket_timeout,
+                                     used_idle_socket_timeout,
                                      connect_job_factory_);
   }
 
   int StartRequest(const std::string& group_name, int priority) {
     return StartRequestUsingPool<TestClientSocketPool, const void*>(
         pool_.get(), group_name, priority, NULL);
   }
 
   virtual void TearDown() {
     // Need to delete |pool_| before we turn late binding back off. We also need
@@ skipping 1377 matching lines @@
   EXPECT_TRUE(ReleaseOneConnection(KEEP_ALIVE));
   EXPECT_TRUE(ReleaseOneConnection(KEEP_ALIVE));
 
   // 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"));
 }
 
+TEST_F(ClientSocketPoolBaseTest_LateBinding, 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", 0, &req, pool_.get(), NULL);
+  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", 0, &req2, pool_.get(), NULL);
+  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());
+  req2.handle()->Reset();
+  MessageLoop::current()->RunAllPending();
+
+  ASSERT_EQ(2, pool_->IdleSocketCount());
+  
+  // Invoke the idle socket cleanup check.  Only one socket should be left, the
+  // used socket.  Request it to make sure that it's used.
+
+  pool_->CleanupTimedOutIdleSockets();
+  rv = InitHandle(req.handle(), "a", 0, &req, pool_.get(), NULL);
+  EXPECT_EQ(OK, rv);
+  EXPECT_TRUE(req.handle()->is_reused());
+}
+
 }  // namespace
 
 }  // namespace net