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

base/message_loop_unittest.cc

 // Copyright (c) 2011 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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/eintr_wrapper.h"
@@ skipping 158 matching lines @@
   // Now kick things off with the SEH block active.
   MessageLoop::current()->set_exception_restoration(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->set_exception_restoration(false);
 
   EXPECT_EQ(foo->test_count(), 105);
   EXPECT_EQ(foo->result(), "abacad");
 }
 
 // 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();
 }
 
 // This function records the time when Run was called in a Time object, which is
 // useful for building a variety of MessageLoop tests.
 static void RecordRunTimeFunc(Time* run_time, int* quit_counter) {
   *run_time = Time::Now();
 
     // 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) {
   MessageLoop loop(message_loop_type);
 
   // Test that PostDelayedTask results in a delayed task.
 
   const int kDelayMS = 100;
 
   int num_tasks = 1;
@@ skipping 62 matching lines @@
   EXPECT_TRUE(run_time1 < run_time2);
 }
 
 void RunTest_PostDelayedTask_InPostOrder_2(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // 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);
 
   Time time_before_run = Time::Now();
   loop.Run();
   Time time_after_run = Time::Now();
 
   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(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that a delayed task still runs after a pile of normal tasks.  The key
   // difference between this test and the previous one is that here we return
   // the MessageLoop a lot so we give the MessageLoop plenty of opportunities
   // to maybe run the delayed task.  It should know not to do so until the
@@ skipping 40 matching lines @@
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   // Ensure that we ran in far less time than the slower timer.
   TimeDelta total_time = Time::Now() - start_time;
   EXPECT_GT(5000, total_time.InMilliseconds());
 
   // 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());
   EXPECT_FALSE(run_time2.is_null());
 }
 
 #if defined(OS_WIN)
 
 void SubPumpFunc() {
   MessageLoop::current()->SetNestableTasksAllowed(true);
@@ skipping 32 matching lines @@
   loop.Run();
   EXPECT_EQ(1, num_tasks);
 
   // Ensure that we ran in far less time than the slower timer.
   TimeDelta total_time = Time::Now() - start_time;
   EXPECT_GT(5000, total_time.InMilliseconds());
 
   // 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());
 }
 
 #endif  // defined(OS_WIN)
 
 // This is used to inject a test point for recording the destructor calls for
 // Closure objects send to MessageLoop::PostTask(). It is awkward usage since we
 // are trying to hook the actual destruction, which is not a common operation.
@@ skipping 74 matching lines @@
 // If the right SEH filter is installed, it will fix the error.
 class Crasher : public base::RefCounted<Crasher> {
  public:
   // Ctor. If trash_SEH_handler is true, the task will override the unhandled
   // exception handler with one sure to crash this test.
   explicit Crasher(bool trash_SEH_handler)
       : trash_SEH_handler_(trash_SEH_handler) {
   }
 
   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
     // the damage.
 
 #if defined(_M_IX86)
 
     __asm {
       mov eax, dword ptr [Crasher::bad_array_]
       mov byte ptr [eax], 66
@@ skipping 218 matching lines @@
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
   }
   order->RecordEnd(RECURSIVE, cookie);
 }
 
 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) {
   order->RecordStart(QUITMESSAGELOOP, cookie);
   MessageLoop::current()->Quit();
   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);
 }
 
 #if defined(OS_WIN)
 void RecursiveFuncWin(MessageLoop* target,
                       HANDLE event,
                       bool expect_window,
                       TaskList* order,
                       bool is_reentrant) {
   target->PostTask(FROM_HERE,
@@ skipping 288 matching lines @@
         FROM_HERE,
         base::Bind(&OrderedFunc, &order, 2),
         1);
   } else {
     MessageLoop::current()->PostNonNestableTask(
         FROM_HERE,
         base::Bind(&OrderedFunc, &order, 2));
   }
   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) {
     MessageLoop::current()->PostNonNestableDelayedTask(
         FROM_HERE,
         base::Bind(&QuitFunc, &order, 6),
         2);
   } else {
     MessageLoop::current()->PostNonNestableTask(
         FROM_HERE,
@@ skipping 142 matching lines @@
   Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   ASSERT_TRUE(thread.StartWithOptions(options));
 
   MessageLoop* thread_loop = thread.message_loop();
   ASSERT_TRUE(NULL != thread_loop);
 
   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;
   EXPECT_TRUE(WriteFile(server, buffer, sizeof(buffer), &written, NULL));
 
   DWORD result = WaitForSingleObject(callback_called, 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
   thread.Stop();
 }
@@ skipping 21 matching lines @@
   ASSERT_TRUE(thread.StartWithOptions(options));
 
   MessageLoop* thread_loop = thread.message_loop();
   ASSERT_TRUE(NULL != thread_loop);
 
   TestIOHandler handler1(kPipeName1, callback1_called, false);
   TestIOHandler handler2(kPipeName2, callback2_called, true);
   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.
 
   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";
 
   EXPECT_TRUE(WriteFile(server2, buffer, sizeof(buffer), &written, NULL));
 
   HANDLE objects[2] = { callback1_called.Get(), callback2_called.Get() };
   DWORD result = WaitForMultipleObjects(2, objects, TRUE, 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
   thread.Stop();
@@ skipping 248 matching lines @@
   EXPECT_TRUE(loop.high_resolution_timers_enabled());
 
   // Post a slow task and verify high resolution timers
   // are still enabled.
   loop.PostDelayedTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, 1),
                        kSlowTimerMs);
   loop.Run();
   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),
                        kSlowTimerMs);
   loop.Run();
   EXPECT_FALSE(loop.high_resolution_timers_enabled());
 }
 
 #endif  // defined(OS_WIN)
 
@@ skipping 132 matching lines @@
       base::Bind(&DestructionObserverProbe::Run,
                  new DestructionObserverProbe(&task_destroyed,
                                               &destruction_observer_called)),
       kDelayMS);
   delete loop;
   EXPECT_TRUE(observer.task_destroyed_before_message_loop());
   // The task should have been destroyed when we deleted the loop.
   EXPECT_TRUE(task_destroyed);
   EXPECT_TRUE(destruction_observer_called);
 }