Fix Sleep() calls to use TimeDelta in portions of chrome/browser.

chrome/browser/net/url_info_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.
 
 // Single threaded tests of UrlInfo functionality.
 
 #include <time.h>
 #include <string>
 
 #include "base/threading/platform_thread.h"
@@ skipping 39 matching lines @@
   info.SetFoundState();
   // "Immediately" check to see if we need an update yet (we shouldn't).
   if (info.NeedsDnsUpdate()) {
     // The test bot must be really slow, so we can verify that.
     EXPECT_GT((TimeTicks::Now() - before_resolution_complete).InMilliseconds(),
               UrlInfo::get_cache_expiration().InMilliseconds());
     return;  // Lets punt here, the test bot is too slow.
   }
 
   // Run similar test with a shortened expiration, so we can trigger it.
-  const int kMockExpirationTime(300);  // Vastly reduced expiration time.
-  info.set_cache_expiration(TimeDelta::FromMilliseconds(kMockExpirationTime));
+  const TimeDelta kMockExpirationTime = TimeDelta::FromMilliseconds(300);
+  info.set_cache_expiration(kMockExpirationTime);
 
   // That was a nice life when the object was found.... but next time it won't
   // be found.  We'll sleep for a while, and then come back with not-found.
   info.SetQueuedState(UrlInfo::UNIT_TEST_MOTIVATED);
   EXPECT_FALSE(info.NeedsDnsUpdate());
   info.SetAssignedState();
   EXPECT_FALSE(info.NeedsDnsUpdate());
   // Greater than minimal expected network latency on DNS lookup.
-  base::PlatformThread::Sleep(25);
+  base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(25));
   before_resolution_complete = TimeTicks::Now();
   info.SetNoSuchNameState();
   // "Immediately" check to see if we need an update yet (we shouldn't).
   if (info.NeedsDnsUpdate()) {
     // The test bot must be really slow, so we can verify that.
-    EXPECT_GT((TimeTicks::Now() - before_resolution_complete).InMilliseconds(),
+    EXPECT_GT((TimeTicks::Now() - before_resolution_complete),
               kMockExpirationTime);
     return;
   }
   // Wait over 300ms, so it should definately be considered out of cache.
-  base::PlatformThread::Sleep(kMockExpirationTime + 20);
+  base::PlatformThread::Sleep(kMockExpirationTime +
+                              TimeDelta::FromMilliseconds(20));
   EXPECT_TRUE(info.NeedsDnsUpdate()) << "expiration time not honored";
 }
 
 // When a system gets "congested" relative to DNS, it means it is doing too many
 // DNS resolutions, and bogging down the system.  When we detect such a
 // situation, we divert the sequence of states a UrlInfo instance moves
 // through.  Rather than proceeding from QUEUED (waiting in a name queue for a
 // worker thread that can resolve the name) to ASSIGNED (where a worker thread
 // actively resolves the name), we enter the ASSIGNED state (without actually
 // getting sent to a resolver thread) and reset our state to what it was before
@@ skipping 28 matching lines @@
   info.RemoveFromQueue();  // Do the reset.
   EXPECT_FALSE(info.is_assigned());
   EXPECT_TRUE(info.was_found());  // Back to what it was before being queued.
 }
 
 
 // TODO(jar): Add death test for illegal state changes, and also for setting
 // hostname when already set.
 
 }  // namespace