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

base/threading/watchdog_unittest.cc

 // Copyright (c) 2010 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/threading/watchdog.h"
 
 #include "base/logging.h"
 #include "base/spin_wait.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
@@ skipping 81 matching lines @@
                                    watchdog.alarm_counter() > 0);
 
   EXPECT_EQ(1, watchdog.alarm_counter());
 }
 
 // Make sure a disable alarm does nothing, even if we arm it.
 TEST_F(WatchdogTest, ConstructorDisabledTest) {
   WatchdogCounter watchdog(TimeDelta::FromMilliseconds(10), "Disabled", false);
   watchdog.Arm();
   // Alarm should not fire, as it was disabled.
-  PlatformThread::Sleep(500);
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(500));
   EXPECT_EQ(0, watchdog.alarm_counter());
 }
 
 // Make sure Disarming will prevent firing, even after Arming.
 TEST_F(WatchdogTest, DisarmTest) {
   WatchdogCounter watchdog(TimeDelta::FromSeconds(1), "Enabled3", true);
 
   TimeTicks start = TimeTicks::Now();
   watchdog.Arm();
-  PlatformThread::Sleep(100);  // Sleep a bit, but not past the alarm point.
+  // Sleep a bit, but not past the alarm point.
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
   watchdog.Disarm();
   TimeTicks end = TimeTicks::Now();
 
   if (end - start > TimeDelta::FromMilliseconds(500)) {
     LOG(WARNING) << "100ms sleep took over 500ms, making the results of this "
                  << "timing-sensitive test suspicious.  Aborting now.";
     return;
   }
 
   // Alarm should not have fired before it was disarmed.
   EXPECT_EQ(0, watchdog.alarm_counter());
 
   // Sleep past the point where it would have fired if it wasn't disarmed,
   // and verify that it didn't fire.
-  PlatformThread::Sleep(1000);
+  PlatformThread::Sleep(TimeDelta::FromSeconds(1));
   EXPECT_EQ(0, watchdog.alarm_counter());
 
   // ...but even after disarming, we can still use the alarm...
   // Set a time greater than the timeout into the past.
   watchdog.ArmSomeTimeDeltaAgo(TimeDelta::FromSeconds(10));
   // It should almost instantly go off, but certainly in less than 5 minutes.
   SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(5),
                                    watchdog.alarm_counter() > 0);
 
   EXPECT_EQ(1, watchdog.alarm_counter());
 }
 
 }  // namespace base