Change code in base (primarily unit tests) to use Sleep(TimeDelta).

base/message_loop_unittest.cc

Index: base/message_loop_unittest.cc
diff --git a/base/message_loop_unittest.cc b/base/message_loop_unittest.cc
index 7eb4f4a02ccb7318a1e7ffb4298f49864b041a1c..01a57c876121fa8599dcc785899a757a22421650 100644
--- a/base/message_loop_unittest.cc
+++ b/base/message_loop_unittest.cc
@@ -176,8 +176,8 @@ void RunTest_PostTask_SEH(MessageLoop::Type message_loop_type) {
 }
 
 // This function runs slowly to simulate a large amount of work being done.
-static void SlowFunc(int pause_ms, int* quit_counter) {
-    PlatformThread::Sleep(pause_ms);
+static void SlowFunc(TimeDelta pause, int* quit_counter) {
+    PlatformThread::Sleep(pause);
     if (--(*quit_counter) == 0)
       MessageLoop::current()->Quit();
 }
@@ -190,7 +190,7 @@ static void RecordRunTimeFunc(Time* run_time, int* quit_counter) {
     // Cause our Run function to take some time to execute.  As a result we can
     // count on subsequent RecordRunTimeFunc()s running at a future time,
     // without worry about the resolution of our system clock being an issue.
-  SlowFunc(10, quit_counter);
+  SlowFunc(TimeDelta::FromMilliseconds(10), quit_counter);
 }
 
 void RunTest_PostDelayedTask_Basic(MessageLoop::Type message_loop_type) {
@@ -273,12 +273,12 @@ void RunTest_PostDelayedTask_InPostOrder_2(
   // Test that a delayed task still runs after a normal tasks even if the
   // normal tasks take a long time to run.
 
-  const int kPauseMS = 50;
+  const TimeDelta kPause = TimeDelta::FromMilliseconds(50);
 
   int num_tasks = 2;
   Time run_time;
 
-  loop.PostTask(FROM_HERE, base::Bind(&SlowFunc, kPauseMS, &num_tasks));
+  loop.PostTask(FROM_HERE, base::Bind(&SlowFunc, kPause, &num_tasks));
   loop.PostDelayedTask(
       FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time, &num_tasks), 10);
 
@@ -288,7 +288,7 @@ void RunTest_PostDelayedTask_InPostOrder_2(
 
   EXPECT_EQ(0, num_tasks);
 
-  EXPECT_LT(kPauseMS, (time_after_run - time_before_run).InMilliseconds());
+  EXPECT_LT(kPause, time_after_run - time_before_run);
 }
 
 void RunTest_PostDelayedTask_InPostOrder_3(
@@ -349,7 +349,7 @@ void RunTest_PostDelayedTask_SharedTimer(
   // In case both timers somehow run at nearly the same time, sleep a little
   // and then run all pending to force them both to have run.  This is just
   // encouraging flakiness if there is any.
-  PlatformThread::Sleep(100);
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
   loop.RunAllPending();
 
   EXPECT_TRUE(run_time1.is_null());
@@ -402,7 +402,7 @@ void RunTest_PostDelayedTask_SharedTimer_SubPump() {
   // In case both timers somehow run at nearly the same time, sleep a little
   // and then run all pending to force them both to have run.  This is just
   // encouraging flakiness if there is any.
-  PlatformThread::Sleep(100);
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
   loop.RunAllPending();
 
   EXPECT_TRUE(run_time.is_null());
@@ -497,7 +497,7 @@ class Crasher : public base::RefCounted<Crasher> {
   }
 
   void Run() {
-    PlatformThread::Sleep(1);
+    PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
     if (trash_SEH_handler_)
       ::SetUnhandledExceptionFilter(&BadExceptionHandler);
     // Generate a SEH fault. We do it in asm to make sure we know how to undo
@@ -736,7 +736,7 @@ void RecursiveFunc(TaskList* order, int cookie, int depth,
 void RecursiveSlowFunc(TaskList* order, int cookie, int depth,
                        bool is_reentrant) {
   RecursiveFunc(order, cookie, depth, is_reentrant);
-  PlatformThread::Sleep(10);  // milliseconds
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
 }
 
 void QuitFunc(TaskList* order, int cookie) {
@@ -745,9 +745,9 @@ void QuitFunc(TaskList* order, int cookie) {
   order->RecordEnd(QUITMESSAGELOOP, cookie);
 }
 
-void SleepFunc(TaskList* order, int cookie, int ms) {
+void SleepFunc(TaskList* order, int cookie, TimeDelta delay) {
   order->RecordStart(SLEEP, cookie);
-  PlatformThread::Sleep(ms);
+  PlatformThread::Sleep(delay);
   order->RecordEnd(SLEEP, cookie);
 }
 
@@ -1056,8 +1056,9 @@ void RunTest_NonNestableInNestedLoop(MessageLoop::Type message_loop_type,
   }
   MessageLoop::current()->PostTask(FROM_HERE,
                                    base::Bind(&OrderedFunc, &order, 3));
-  MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(&SleepFunc, &order, 4, 50));
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50)));
   MessageLoop::current()->PostTask(FROM_HERE,
                                    base::Bind(&OrderedFunc, &order, 5));
   if (use_delayed) {
@@ -1220,7 +1221,8 @@ void RunTest_IOHandler() {
   TestIOHandler handler(kPipeName, callback_called, false);
   thread_loop->PostTask(FROM_HERE, base::Bind(&TestIOHandler::Init,
                                               base::Unretained(&handler)));
-  Sleep(100);  // Make sure the thread runs and sleeps for lack of work.
+  // Make sure the thread runs and sleeps for lack of work.
+  base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
 
   const char buffer[] = "Hello there!";
   DWORD written;
@@ -1262,10 +1264,12 @@ void RunTest_WaitForIO() {
   thread_loop->PostTask(FROM_HERE, base::Bind(&TestIOHandler::Init,
                                               base::Unretained(&handler1)));
   // TODO(ajwong): Do we really need such long Sleeps in ths function?
-  Sleep(100);  // Make sure the thread runs and sleeps for lack of work.
+  // Make sure the thread runs and sleeps for lack of work.
+  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(100);
+  base::PlatformThread::Sleep(delay);
   thread_loop->PostTask(FROM_HERE, base::Bind(&TestIOHandler::Init,
                                               base::Unretained(&handler2)));
-  Sleep(100);
+  base::PlatformThread::Sleep(delay);
 
   // At this time handler1 is waiting to be called, and the thread is waiting
   // on the Init method of handler2, filtering only handler2 callbacks.
@@ -1273,7 +1277,7 @@ void RunTest_WaitForIO() {
   const char buffer[] = "Hello there!";
   DWORD written;
   EXPECT_TRUE(WriteFile(server1, buffer, sizeof(buffer), &written, NULL));
-  Sleep(200);
+  base::PlatformThread::Sleep(2 * delay);
   EXPECT_EQ(WAIT_TIMEOUT, WaitForSingleObject(callback1_called, 0)) <<
       "handler1 has not been called";
 
@@ -1542,7 +1546,8 @@ TEST(MessageLoopTest, HighResolutionTimer) {
   EXPECT_TRUE(loop.high_resolution_timers_enabled());
 
   // Wait for a while so that high-resolution mode elapses.
-  Sleep(MessageLoop::kHighResolutionTimerModeLeaseTimeMs);
+  base::PlatformThread::Sleep(TimeDelta::FromMilliseconds(
+      MessageLoop::kHighResolutionTimerModeLeaseTimeMs));
 
   // Post a slow task to disable the high resolution timers.
   loop.PostDelayedTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, 1),