From 26f34dd42f1af46a4c68e9082290c359706685db Mon Sep 17 00:00:00 2001
From: "jshin@chromium.org"
 <jshin@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>
Date: Fri, 25 Sep 2009 01:13:20 +0000
Subject: [PATCH] Roll back Markus's CL (
 http://codereview.chromium.org/196053)

BUG=none
TEST=UI test and valgrind test pass
TBR=markus
Review URL: http://codereview.chromium.org/222031

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@27160 0039d316-1c4b-4281-b951-d872f2087c98
---
 base/time.cc                                  |  5 ---
 base/time.h                                   |  1 -
 base/timer.cc                                 |  2 +-
 .../client_socket_pool_base_unittest.cc       | 39 ++++++-------------
 net/socket/socket_test_util.cc                |  9 -----
 webkit/glue/webkitclient_impl.cc              | 16 +-------
 6 files changed, 14 insertions(+), 58 deletions(-)

diff --git a/base/time.cc b/base/time.cc
index 2c40d21e4bd3b..afe8c8f32532d 100644
--- a/base/time.cc
+++ b/base/time.cc
@@ -41,11 +41,6 @@ int64 TimeDelta::InMilliseconds() const {
   return delta_ / Time::kMicrosecondsPerMillisecond;
 }
 
-int64 TimeDelta::InMillisecondsRoundedUp() const {
-  return (delta_ + Time::kMicrosecondsPerMillisecond - 1) /
-      Time::kMicrosecondsPerMillisecond;
-}
-
 int64 TimeDelta::InMicroseconds() const {
   return delta_;
 }
diff --git a/base/time.h b/base/time.h
index eb990eff8e764..6a181afb51415 100644
--- a/base/time.h
+++ b/base/time.h
@@ -71,7 +71,6 @@ class TimeDelta {
   int64 InSeconds() const;
   double InMillisecondsF() const;
   int64 InMilliseconds() const;
-  int64 InMillisecondsRoundedUp() const;
   int64 InMicroseconds() const;
 
   TimeDelta& operator=(TimeDelta other) {
diff --git a/base/timer.cc b/base/timer.cc
index ce5fab680efd1..280760681dc2b 100644
--- a/base/timer.cc
+++ b/base/timer.cc
@@ -22,7 +22,7 @@ void BaseTimer_Helper::InitiateDelayedTask(TimerTask* timer_task) {
   delayed_task_->timer_ = this;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, timer_task,
-      static_cast<int>(timer_task->delay_.InMillisecondsRoundedUp()));
+      static_cast<int>(timer_task->delay_.InMilliseconds()));
 }
 
 }  // namespace base
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index c0a04aa277ba1..249d7e3dafe9f 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -143,34 +143,31 @@ class TestConnectJob : public ConnectJob {
         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();
@@ -720,8 +717,6 @@ TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
   // 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);
@@ -958,26 +953,14 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
       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_;
diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc
index 7f4af08f892e1..cd4423be7cc43 100644
--- a/net/socket/socket_test_util.cc
+++ b/net/socket/socket_test_util.cc
@@ -343,15 +343,6 @@ void ClientSocketPoolTest::SetUp() {
 void ClientSocketPoolTest::TearDown() {
   // The tests often call Reset() on handles at the end which may post
   // DoReleaseSocket() tasks.
-  // Pending tasks created by client_socket_pool_base_unittest.cc are
-  // posted two milliseconds into the future and thus won't become
-  // scheduled until that time.
-  // We wait a few milliseconds to make sure that all such future tasks
-  // are ready to run, before calling RunAllPending(). This will work
-  // correctly even if Sleep() finishes late (and it should never finish
-  // early), as all we have to ensure is that actual wall-time has progressed
-  // past the scheduled starting time of the pending task.
-  PlatformThread::Sleep(10);
   MessageLoop::current()->RunAllPending();
 }
 
diff --git a/webkit/glue/webkitclient_impl.cc b/webkit/glue/webkitclient_impl.cc
index 79ddffd6d58cd..4315db73c381f 100644
--- a/webkit/glue/webkitclient_impl.cc
+++ b/webkit/glue/webkitclient_impl.cc
@@ -2,7 +2,6 @@
 // source code is governed by a BSD-style license that can be found in the
 // LICENSE file.
 
-#include <math.h>
 #include "config.h"
 
 #include "FrameView.h"
@@ -266,23 +265,12 @@ void WebKitClientImpl::setSharedTimerFiredFunction(void (*func)()) {
 }
 
 void WebKitClientImpl::setSharedTimerFireTime(double fire_time) {
-  // By converting between double and int64 representation, we run the risk
-  // of losing precision due to rounding errors. Performing computations in
-  // microseconds reduces this risk somewhat. But there still is the potential
-  // of us computing a fire time for the timer that is shorter than what we
-  // need.
-  // As the event loop will check event deadlines prior to actually firing
-  // them, there is a risk of needlessly rescheduling events and of
-  // needlessly looping if sleep times are too short even by small amounts.
-  // This results in measurable performance degradation unless we use ceil() to
-  // always round up the sleep times.
-  int64 interval = static_cast<int64>(
-      ceil((fire_time - currentTime()) * base::Time::kMicrosecondsPerSecond));
+  int interval = static_cast<int>((fire_time - currentTime()) * 1000);
   if (interval < 0)
     interval = 0;
 
   shared_timer_.Stop();
-  shared_timer_.Start(base::TimeDelta::FromMicroseconds(interval), this,
+  shared_timer_.Start(base::TimeDelta::FromMilliseconds(interval), this,
                       &WebKitClientImpl::DoTimeout);
 }
 
-- 
GitLab