Roll back Markus's CL ( http://codereview.chromium.org/196053)...

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 125 matching lines @@
     AddressList ignored;
     client_socket_factory_->CreateTCPClientSocket(ignored);
     set_socket(new MockClientSocket());
     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()->PostDelayedTask(
+        MessageLoop::current()->PostTask(
             FROM_HERE,
             method_factory_.NewRunnableMethod(
-                &TestConnectJob::DoConnect,
-                true /* successful */,
-                true /* async */),
-            2);
+               &TestConnectJob::DoConnect,
+               true /* successful */,
+               true /* async */));
         return ERR_IO_PENDING;
       case kMockPendingFailingJob:
         set_load_state(LOAD_STATE_CONNECTING);
-        MessageLoop::current()->PostDelayedTask(
+        MessageLoop::current()->PostTask(
             FROM_HERE,
             method_factory_.NewRunnableMethod(
-                &TestConnectJob::DoConnect,
-                false /* error */,
-                true  /* async */),
-            2);
+               &TestConnectJob::DoConnect,
+               false /* error */,
+               true  /* async */));
         return ERR_IO_PENDING;
       case kMockWaitingJob:
         client_socket_factory_->WaitForSignal(this);
         waiting_success_ = true;
         return ERR_IO_PENDING;
       case kMockAdvancingLoadStateJob:
-        MessageLoop::current()->PostDelayedTask(
+        MessageLoop::current()->PostTask(
             FROM_HERE,
             method_factory_.NewRunnableMethod(
-                &TestConnectJob::AdvanceLoadState, load_state_),
-            2);
+                &TestConnectJob::AdvanceLoadState, load_state_));
         return ERR_IO_PENDING;
       default:
         NOTREACHED();
         set_socket(NULL);
         return ERR_FAILED;
     }
   }
 
   void set_load_state(LoadState load_state) { load_state_ = load_state; }
 
@@ skipping 529 matching lines @@
 TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
   EXPECT_EQ(OK, StartRequest("c", kDefaultPriority));
 
   // Create one asynchronous request.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", kDefaultPriority));
-  PlatformThread::Sleep(10);
-  MessageLoop::current()->RunAllPending();
 
   // The next synchronous request should wait for its turn.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority));
 
   ReleaseAllConnections(KEEP_ALIVE);
 
   EXPECT_EQ(static_cast<int>(requests_.size()),
             client_socket_factory_.allocation_count());
 
@@ skipping 216 matching lines @@
         next_job_type_(next_job_type) {}
 
   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;
-      TestCompletionCallback next_job_callback;
       int rv = InitHandle(
-          handle_, "a", kDefaultPriority, &next_job_callback, pool_.get(),
-          NULL);
+          handle_, "a", kDefaultPriority, this, pool_.get(), NULL);
       switch (next_job_type_) {
         case TestConnectJob::kMockJob:
           EXPECT_EQ(OK, rv);
           break;
         case TestConnectJob::kMockPendingJob:
           EXPECT_EQ(ERR_IO_PENDING, rv);
-
-          // For pending jobs, wait for new socket to be created. This makes
-          // sure there are no more pending operations nor any unclosed sockets
-          // when the test finishes.
-          // We need to give it a little bit of time to run, so that all the
-          // operations that happen on timers (e.g. cleanup of idle
-          // connections) can execute.
-          MessageLoop::current()->SetNestableTasksAllowed(true);
-          PlatformThread::Sleep(10);
-          EXPECT_EQ(OK, next_job_callback.WaitForResult());
           break;
         default:
           FAIL() << "Unexpected job type: " << next_job_type_;
           break;
       }
     }
   }
 
   int WaitForResult() {
     return callback_.WaitForResult();
@@ skipping 850 matching lines @@
 
   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