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

base/tools_sanity_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.
 //
 // This file contains intentional memory errors, some of which may lead to
 // crashes if the test is ran without special memory testing tools. We use these
 // errors to verify the sanity of the tools.
 
 #include "base/atomicops.h"
 #include "base/message_loop.h"
@@ skipping 152 matching lines @@
 class TOOLS_SANITY_TEST_CONCURRENT_THREAD : public PlatformThread::Delegate {
  public:
   explicit TOOLS_SANITY_TEST_CONCURRENT_THREAD(bool *value) : value_(value) {}
   ~TOOLS_SANITY_TEST_CONCURRENT_THREAD() {}
   void ThreadMain() {
     *value_ = true;
 
     // Sleep for a few milliseconds so the two threads are more likely to live
     // simultaneously. Otherwise we may miss the report due to mutex
     // lock/unlock's inside thread creation code in pure-happens-before mode...
-    PlatformThread::Sleep(100);
+    PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
   }
  private:
   bool *value_;
 };
 
 class ReleaseStoreThread : public PlatformThread::Delegate {
  public:
   explicit ReleaseStoreThread(base::subtle::Atomic32 *value) : value_(value) {}
   ~ReleaseStoreThread() {}
   void ThreadMain() {
     base::subtle::Release_Store(value_, kMagicValue);
 
     // Sleep for a few milliseconds so the two threads are more likely to live
     // simultaneously. Otherwise we may miss the report due to mutex
     // lock/unlock's inside thread creation code in pure-happens-before mode...
-    PlatformThread::Sleep(100);
+    PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
   }
  private:
   base::subtle::Atomic32 *value_;
 };
 
 class AcquireLoadThread : public PlatformThread::Delegate {
  public:
   explicit AcquireLoadThread(base::subtle::Atomic32 *value) : value_(value) {}
   ~AcquireLoadThread() {}
   void ThreadMain() {
     // Wait for the other thread to make Release_Store
-    PlatformThread::Sleep(100);
+    PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
     base::subtle::Acquire_Load(value_);
   }
  private:
   base::subtle::Atomic32 *value_;
 };
 
 void RunInParallel(PlatformThread::Delegate *d1, PlatformThread::Delegate *d2) {
   PlatformThreadHandle a;
   PlatformThreadHandle b;
   PlatformThread::Create(0, d1, &a);
@@ skipping 22 matching lines @@
 
 TEST(ToolsSanityTest, AtomicsAreIgnored) {
   base::subtle::Atomic32 shared = 0;
   ReleaseStoreThread thread1(&shared);
   AcquireLoadThread thread2(&shared);
   RunInParallel(&thread1, &thread2);
   EXPECT_EQ(kMagicValue, shared);
 }
 
 }  // namespace base