Remove old Sleep and PostDelayedTask interfaces that use int ms instead of TimeDelta.

base/message_loop.cc

 // Copyright (c) 2012 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 "base/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 240 matching lines @@
 
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.RemoveObserver(destruction_observer);
 }
 
 void MessageLoop::PostTask(
     const tracked_objects::Location& from_here, const base::Closure& task) {
   DCHECK(!task.is_null()) << from_here.ToString();
-  PendingTask pending_task(from_here, task, CalculateDelayedRuntime(0), true);
+  PendingTask pending_task(
+      from_here, task, CalculateDelayedRuntime(TimeDelta()), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
-    int64 delay_ms) {
+    TimeDelta delay) {
   DCHECK(!task.is_null()) << from_here.ToString();
-  PendingTask pending_task(from_here, task,
-                           CalculateDelayedRuntime(delay_ms), true);
+  PendingTask pending_task(
+      from_here, task, CalculateDelayedRuntime(delay), true);
   AddToIncomingQueue(&pending_task);
 }
 
-void MessageLoop::PostDelayedTask(
-    const tracked_objects::Location& from_here,
-    const base::Closure& task,
-    base::TimeDelta delay) {
-  PostDelayedTask(from_here, task, delay.InMillisecondsRoundedUp());
-}
-
 void MessageLoop::PostNonNestableTask(
     const tracked_objects::Location& from_here, const base::Closure& task) {
   DCHECK(!task.is_null()) << from_here.ToString();
-  PendingTask pending_task(from_here, task, CalculateDelayedRuntime(0), false);
-  AddToIncomingQueue(&pending_task);
-}
-
-void MessageLoop::PostNonNestableDelayedTask(
-    const tracked_objects::Location& from_here, const base::Closure& task,
-    int64 delay_ms) {
-  DCHECK(!task.is_null()) << from_here.ToString();
-  PendingTask pending_task(from_here, task,
-                           CalculateDelayedRuntime(delay_ms), false);
+  PendingTask pending_task(
+      from_here, task, CalculateDelayedRuntime(TimeDelta()), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
-    base::TimeDelta delay) {
-  PostNonNestableDelayedTask(from_here, task, delay.InMillisecondsRoundedUp());
+    TimeDelta delay) {
+  DCHECK(!task.is_null()) << from_here.ToString();
+  PendingTask pending_task(
+      from_here, task, CalculateDelayedRuntime(delay), false);
+  AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::Run() {
   AutoRunState save_state(this);
   RunHandler();
 }
 
 void MessageLoop::RunAllPending() {
   AutoRunState save_state(this);
   state_->quit_received = true;  // Means run until we would otherwise block.
@@ skipping 223 matching lines @@
   // not completely clear why we want to leak them in the loops above.  This
   // code is replicating legacy behavior, and should not be considered
   // absolutely "correct" behavior.  See TODO above about deleting all tasks
   // when it's safe.
   while (!delayed_work_queue_.empty()) {
     delayed_work_queue_.pop();
   }
   return did_work;
 }
 
-TimeTicks MessageLoop::CalculateDelayedRuntime(int64 delay_ms) {
+TimeTicks MessageLoop::CalculateDelayedRuntime(TimeDelta delay) {
   TimeTicks delayed_run_time;
-  if (delay_ms > 0) {
-    delayed_run_time =
-        TimeTicks::Now() + TimeDelta::FromMilliseconds(delay_ms);
+  if (delay > TimeDelta()) {
+    delayed_run_time = TimeTicks::Now() + delay;
 
 #if defined(OS_WIN)
     if (high_resolution_timer_expiration_.is_null()) {
       // Windows timers are granular to 15.6ms.  If we only set high-res
       // timers for those under 15.6ms, then a 18ms timer ticks at ~32ms,
       // which as a percentage is pretty inaccurate.  So enable high
       // res timers for any timer which is within 2x of the granularity.
       // This is a tradeoff between accuracy and power management.
-      bool needs_high_res_timers =
-          delay_ms < (2 * base::Time::kMinLowResolutionThresholdMs);
+      bool needs_high_res_timers = delay.InMilliseconds() <
+          (2 * base::Time::kMinLowResolutionThresholdMs);
       if (needs_high_res_timers) {
         if (base::Time::ActivateHighResolutionTimer(true)) {
           high_resolution_timer_expiration_ = TimeTicks::Now() +
               TimeDelta::FromMilliseconds(kHighResolutionTimerModeLeaseTimeMs);
         }
       }
     }
 #endif
   } else {
-    DCHECK_EQ(delay_ms, 0) << "delay should not be negative";
+    DCHECK_EQ(delay.InMilliseconds(), 0) << "delay should not be negative";
   }
 
 #if defined(OS_WIN)
   if (!high_resolution_timer_expiration_.is_null()) {
     if (TimeTicks::Now() > high_resolution_timer_expiration_) {
       base::Time::ActivateHighResolutionTimer(false);
       high_resolution_timer_expiration_ = TimeTicks();
     }
   }
 #endif
@@ skipping 220 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif