Refactor how ClientSocketPoolBaseHelper avoids re-entrancy.

net/socket/client_socket_pool_base_unittest.cc

 // Copyright (c) 2010 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/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
@@ skipping 352 matching lines @@
       CompletionCallback* callback,
       const BoundNetLog& net_log) {
     const scoped_refptr<TestSocketParams>* casted_socket_params =
         static_cast<const scoped_refptr<TestSocketParams>*>(params);
     return base_.RequestSocket(group_name, *casted_socket_params, priority,
                                handle, callback, net_log);
   }
 
   virtual void CancelRequest(
       const std::string& group_name,
-      const ClientSocketHandle* handle) {
+      ClientSocketHandle* handle) {
     base_.CancelRequest(group_name, handle);
   }
 
   virtual void ReleaseSocket(
       const std::string& group_name,
       ClientSocket* socket,
       int id) {
     base_.ReleaseSocket(group_name, socket, id);
   }
 
@@ skipping 130 matching lines @@
     // actually become pending until 2ms after they have been created. In order
     // to flush all tasks, we need to wait so that we know there are no
     // soon-to-be-pending tasks waiting.
     PlatformThread::Sleep(10);
     MessageLoop::current()->RunAllPending();
 
     // Need to delete |pool_| before we turn late binding back off. We also need
     // to delete |requests_| because the pool is reference counted and requests
     // keep reference to it.
     // TODO(willchan): Remove this part when late binding becomes the default.
+    TestClientSocketPool* pool = pool_.get();
     pool_ = NULL;
     requests_.reset();
+    pool = NULL;
 
     ClientSocketPoolTest::TearDown();
   }
 
   MockClientSocketFactory client_socket_factory_;
   TestConnectJobFactory* connect_job_factory_;
   scoped_refptr<TestSocketParams> params_;
   scoped_refptr<TestClientSocketPool> pool_;
   scoped_refptr<ClientSocketPoolHistograms> histograms_;
 };
@@ skipping 391 matching lines @@
     EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", params_,
                                                   kDefaultPriority, &callback,
                                                   pool_, BoundNetLog()));
 
     // Since it is stalled, it should have no connect jobs.
     EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
 
     // Cancel the stalled request.
     handles[0].Reset();
 
-    // Wait for the pending job to be guaranteed to complete.
-    PlatformThread::Sleep(TestConnectJob::kPendingConnectDelay * 2);
-
-    MessageLoop::current()->RunAllPending();
-
     // Now we should have a connect job.
     EXPECT_EQ(1, pool_->NumConnectJobsInGroup("foo"));
 
     // The stalled socket should connect.
     EXPECT_EQ(OK, callback.WaitForResult());
 
     EXPECT_EQ(kDefaultMaxSockets + 1,
               client_socket_factory_.allocation_count());
     EXPECT_EQ(0, pool_->IdleSocketCount());
     EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
@@ skipping 1141 matching lines @@
   // Finally, signal the waiting Connect.
   client_socket_factory_.SignalJobs();
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   MessageLoop::current()->RunAllPending();
 }
 
 }  // namespace
 
 }  // namespace net