Change code in base (primarily unit tests) to use Sleep(TimeDelta).
BUG=108171
TEST=
Review URL: http://codereview.chromium.org/9055001
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@116065 0039d316-1c4b-4281-b951-d872f2087c98
CrOS-Libchrome-Original-Commit: a1b75b94f61d90054e3b432e8be3c897383450bd
diff --git a/base/debug/debugger.cc b/base/debug/debugger.cc
index a0d8a92..79233c5 100644
--- a/base/debug/debugger.cc
+++ b/base/debug/debugger.cc
@@ -24,7 +24,7 @@
BreakDebugger();
return true;
}
- PlatformThread::Sleep(100);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
}
return false;
}
diff --git a/base/debug/debugger_posix.cc b/base/debug/debugger_posix.cc
index 4dee92d..f16cd6d 100644
--- a/base/debug/debugger_posix.cc
+++ b/base/debug/debugger_posix.cc
@@ -198,7 +198,9 @@
// Use GDB to set |go| to 1 to resume execution.
#define DEBUG_BREAK() do { \
volatile int go = 0; \
- while (!go) { base::PlatformThread::Sleep(100); } \
+ while (!go) { \
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100)); \
+ } \
} while (0)
#else
// ARM && !ANDROID
diff --git a/base/debug/trace_event_unittest.cc b/base/debug/trace_event_unittest.cc
index 36a510c..cb77fee 100644
--- a/base/debug/trace_event_unittest.cc
+++ b/base/debug/trace_event_unittest.cc
@@ -629,7 +629,7 @@
// 100+ seconds to avoid flakiness.
TRACE_EVENT_IF_LONGER_THAN0(100000000, "time", "threshold long1");
TRACE_EVENT_IF_LONGER_THAN0(200000000, "time", "threshold long2");
- base::PlatformThread::Sleep(20); // 20000 us
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
}
// Test that a normal nested event remains after it's parent event is dropped.
@@ -654,7 +654,8 @@
TRACE_EVENT_IF_LONGER_THAN0(1000, "time", "3threshold1000");
{
TRACE_EVENT_IF_LONGER_THAN0(100, "time", "3threshold100");
- base::PlatformThread::Sleep(20);
+ base::PlatformThread::Sleep(
+ base::TimeDelta::FromMilliseconds(20));
}
}
}
@@ -678,7 +679,8 @@
{
TRACE_EVENT_IF_LONGER_THAN0(200000000, "time",
"4thresholdlong2");
- base::PlatformThread::Sleep(20);
+ base::PlatformThread::Sleep(
+ base::TimeDelta::FromMilliseconds(20));
}
}
}
diff --git a/base/file_util_unittest.cc b/base/file_util_unittest.cc
index 4cd6f03..0cade2a 100644
--- a/base/file_util_unittest.cc
+++ b/base/file_util_unittest.cc
@@ -22,7 +22,6 @@
#include "base/path_service.h"
#include "base/scoped_temp_dir.h"
#include "base/threading/platform_thread.h"
-#include "base/time.h"
#include "base/utf_string_conversions.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
@@ -349,11 +348,11 @@
// Age to perfection
#if defined(OS_WIN)
- base::PlatformThread::Sleep(100);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
#elif defined(OS_POSIX)
// We need to wait at least one second here because the precision of
// file creation time is one second.
- base::PlatformThread::Sleep(1500);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1500));
#endif
// Establish our cutoff time
@@ -1250,9 +1249,9 @@
SYSTEMTIME start_time;
GetLocalTime(&start_time);
- Sleep(100);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
CreateTextFile(file_name, L"New file!");
- Sleep(100);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
SYSTEMTIME end_time;
GetLocalTime(&end_time);
diff --git a/base/lazy_instance_unittest.cc b/base/lazy_instance_unittest.cc
index b177745..9ccbbd5 100644
--- a/base/lazy_instance_unittest.cc
+++ b/base/lazy_instance_unittest.cc
@@ -27,7 +27,7 @@
public:
SlowConstructor() : some_int_(0) {
// Sleep for 1 second to try to cause a race.
- base::PlatformThread::Sleep(1000);
+ base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
++constructed;
some_int_ = 12;
}
diff --git a/base/message_loop_unittest.cc b/base/message_loop_unittest.cc
index 7eb4f4a..01a57c8 100644
--- a/base/message_loop_unittest.cc
+++ b/base/message_loop_unittest.cc
@@ -176,8 +176,8 @@
}
// 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 @@
// 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 @@
// 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 @@
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 @@
// 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 @@
// 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 @@
}
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 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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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),
diff --git a/base/process_util_posix.cc b/base/process_util_posix.cc
index addd1c3..5a1d442 100644
--- a/base/process_util_posix.cc
+++ b/base/process_util_posix.cc
@@ -31,7 +31,6 @@
#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
#include "base/threading/platform_thread.h"
#include "base/threading/thread_restrictions.h"
-#include "base/time.h"
#if defined(OS_FREEBSD)
#include <sys/event.h>
@@ -1197,7 +1196,7 @@
result = true;
break;
}
- base::PlatformThread::Sleep(100);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
} while ((end_time - base::Time::Now()) > base::TimeDelta());
return result;
@@ -1264,7 +1263,7 @@
// Wait for 2 * timeout_ 500 milliseconds intervals.
for (unsigned i = 0; i < 2 * timeout_; ++i) {
- PlatformThread::Sleep(500); // 0.5 seconds
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(500));
if (IsChildDead(child_))
return;
}
diff --git a/base/process_util_unittest.cc b/base/process_util_unittest.cc
index 36d48b6..426a78f 100644
--- a/base/process_util_unittest.cc
+++ b/base/process_util_unittest.cc
@@ -74,7 +74,7 @@
void WaitToDie(const char* filename) {
FILE *fp;
do {
- base::PlatformThread::Sleep(10);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
fp = fopen(filename, "r");
} while (!fp);
fclose(fp);
@@ -95,14 +95,14 @@
int* exit_code) {
// Now we wait until the result is something other than STILL_RUNNING.
base::TerminationStatus status = base::TERMINATION_STATUS_STILL_RUNNING;
- const int kIntervalMs = 20;
- int waited = 0;
+ const base::TimeDelta kInterval = base::TimeDelta::FromMilliseconds(20);
+ base::TimeDelta waited;
do {
status = base::GetTerminationStatus(handle, exit_code);
- base::PlatformThread::Sleep(kIntervalMs);
- waited += kIntervalMs;
+ base::PlatformThread::Sleep(kInterval);
+ waited += kInterval;
} while (status == base::TERMINATION_STATUS_STILL_RUNNING &&
- waited < TestTimeouts::action_max_timeout_ms());
+ waited.InMilliseconds() < TestTimeouts::action_max_timeout_ms());
return status;
}
diff --git a/base/shared_memory_posix.cc b/base/shared_memory_posix.cc
index a66c859..32a55e9 100644
--- a/base/shared_memory_posix.cc
+++ b/base/shared_memory_posix.cc
@@ -340,7 +340,7 @@
continue;
} else if (errno == ENOLCK) {
// temporary kernel resource exaustion
- base::PlatformThread::Sleep(500);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
continue;
} else {
NOTREACHED() << "lockf() failed."
diff --git a/base/shared_memory_unittest.cc b/base/shared_memory_unittest.cc
index ef5cf2e..a0df9b5 100644
--- a/base/shared_memory_unittest.cc
+++ b/base/shared_memory_unittest.cc
@@ -58,7 +58,7 @@
for (int idx = 0; idx < 100; idx++) {
*ptr = idx;
- PlatformThread::Sleep(1); // Short wait.
+ PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
EXPECT_EQ(*ptr, idx);
}
// Reset back to 0 for the next test that uses the same name.
@@ -113,7 +113,7 @@
memory2.Lock();
int i = (id_ << 16) + idx;
*ptr = i;
- PlatformThread::Sleep(1); // Short wait.
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
EXPECT_EQ(*ptr, i);
memory2.Unlock();
}
@@ -388,7 +388,7 @@
memory.Lock();
int i = (1 << 16) + idx;
*ptr = i;
- PlatformThread::Sleep(10); // Short wait.
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
if (*ptr != i)
errors++;
memory.Unlock();
diff --git a/base/spin_wait.h b/base/spin_wait.h
index 1e31b14..b609ba5 100644
--- a/base/spin_wait.h
+++ b/base/spin_wait.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
@@ -44,7 +44,7 @@
kTimeout.InMilliseconds()) << "Timed out"; \
break; \
} \
- base::PlatformThread::Sleep(50); \
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50)); \
} \
} while (0)
diff --git a/base/synchronization/condition_variable_unittest.cc b/base/synchronization/condition_variable_unittest.cc
index 808ecde..d3a53f2 100644
--- a/base/synchronization/condition_variable_unittest.cc
+++ b/base/synchronization/condition_variable_unittest.cc
@@ -661,7 +661,7 @@
if (waiting_thread_count_ == thread_count_)
break;
}
- PlatformThread::Sleep(30);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(30));
}
}
@@ -672,7 +672,7 @@
if (task_count_ < task_count)
break;
}
- PlatformThread::Sleep(30);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(30));
}
}
diff --git a/base/synchronization/lock_unittest.cc b/base/synchronization/lock_unittest.cc
index 5ac3e6b..1dae49b 100644
--- a/base/synchronization/lock_unittest.cc
+++ b/base/synchronization/lock_unittest.cc
@@ -25,13 +25,13 @@
for (int i = 0; i < 10; i++) {
lock_->Acquire();
acquired_++;
- PlatformThread::Sleep(rand() % 20);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
lock_->Release();
}
for (int i = 0; i < 10; i++) {
if (lock_->Try()) {
acquired_++;
- PlatformThread::Sleep(rand() % 20);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
lock_->Release();
}
}
@@ -62,20 +62,20 @@
for (int i = 0; i < 10; i++) {
lock.Acquire();
acquired++;
- PlatformThread::Sleep(rand() % 20);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
lock.Release();
}
for (int i = 0; i < 10; i++) {
if (lock.Try()) {
acquired++;
- PlatformThread::Sleep(rand() % 20);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
lock.Release();
}
}
for (int i = 0; i < 5; i++) {
lock.Acquire();
acquired++;
- PlatformThread::Sleep(rand() % 20);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
lock.Release();
}
@@ -154,7 +154,7 @@
for (int i = 0; i < 40; i++) {
lock->Acquire();
int v = *value;
- PlatformThread::Sleep(rand() % 10);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 10));
*value = v + 1;
lock->Release();
}
diff --git a/base/synchronization/waitable_event_unittest.cc b/base/synchronization/waitable_event_unittest.cc
index ad86d14..f253265 100644
--- a/base/synchronization/waitable_event_unittest.cc
+++ b/base/synchronization/waitable_event_unittest.cc
@@ -77,7 +77,7 @@
}
void ThreadMain() {
- PlatformThread::Sleep(static_cast<int>(seconds_ * 1000));
+ PlatformThread::Sleep(TimeDelta::FromSeconds(static_cast<int>(seconds_)));
ev_->Signal();
}
diff --git a/base/synchronization/waitable_event_watcher_unittest.cc b/base/synchronization/waitable_event_watcher_unittest.cc
index 1715dff..ee9478a 100644
--- a/base/synchronization/waitable_event_watcher_unittest.cc
+++ b/base/synchronization/waitable_event_watcher_unittest.cc
@@ -80,7 +80,7 @@
event.Signal();
// Let the background thread do its business
- base::PlatformThread::Sleep(30);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30));
watcher.StopWatching();
diff --git a/base/threading/platform_thread_unittest.cc b/base/threading/platform_thread_unittest.cc
index 4b49450..6bff1d4 100644
--- a/base/threading/platform_thread_unittest.cc
+++ b/base/threading/platform_thread_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
@@ -59,7 +59,7 @@
virtual void ThreadMain() {
thread_id_ = PlatformThread::CurrentId();
PlatformThread::YieldCurrentThread();
- PlatformThread::Sleep(50);
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
TrivialThread::ThreadMain();
}
diff --git a/base/threading/thread_collision_warner_unittest.cc b/base/threading/thread_collision_warner_unittest.cc
index 4613955..d9e535b 100644
--- a/base/threading/thread_collision_warner_unittest.cc
+++ b/base/threading/thread_collision_warner_unittest.cc
@@ -190,7 +190,7 @@
void push(int value) {
DFAKE_SCOPED_LOCK(push_pop_);
- base::PlatformThread::Sleep(5000);
+ base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(5));
}
int pop() {
@@ -248,7 +248,7 @@
void push(int value) {
DFAKE_SCOPED_LOCK(push_pop_);
- base::PlatformThread::Sleep(2000);
+ base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(2));
}
int pop() {
@@ -318,7 +318,7 @@
void push(int) {
DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
bar();
- base::PlatformThread::Sleep(2000);
+ base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(2));
}
int pop() {
diff --git a/base/threading/thread_unittest.cc b/base/threading/thread_unittest.cc
index be5ad90..0444947 100644
--- a/base/threading/thread_unittest.cc
+++ b/base/threading/thread_unittest.cc
@@ -36,7 +36,7 @@
}
virtual void Init() {
- base::PlatformThread::Sleep(500);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
init_called_ = true;
}
bool InitCalled() { return init_called_; }
@@ -162,7 +162,7 @@
// instead to avoid busy waiting, but this is sufficient for
// testing purposes).
for (int i = 100; i >= 0 && !was_invoked; --i) {
- base::PlatformThread::Sleep(10);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
}
EXPECT_TRUE(was_invoked);
}
@@ -179,8 +179,10 @@
// event that will toggle our sentinel value.
a.message_loop()->PostTask(
FROM_HERE,
- base::Bind(static_cast<void (*)(int)>(&base::PlatformThread::Sleep),
- 20));
+ base::Bind(
+ static_cast<void (*)(base::TimeDelta)>(
+ &base::PlatformThread::Sleep),
+ base::TimeDelta::FromMilliseconds(20)));
a.message_loop()->PostTask(FROM_HERE, base::Bind(&ToggleValue,
&was_invoked));
}
diff --git a/base/threading/watchdog_unittest.cc b/base/threading/watchdog_unittest.cc
index f96487b..32a137f 100644
--- a/base/threading/watchdog_unittest.cc
+++ b/base/threading/watchdog_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
@@ -99,7 +99,7 @@
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());
}
@@ -109,7 +109,8 @@
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();
@@ -124,7 +125,7 @@
// 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...
diff --git a/base/time_unittest.cc b/base/time_unittest.cc
index 6ba03b8..261b831 100644
--- a/base/time_unittest.cc
+++ b/base/time_unittest.cc
@@ -311,7 +311,7 @@
TEST(TimeTicks, Deltas) {
for (int index = 0; index < 50; index++) {
TimeTicks ticks_start = TimeTicks::Now();
- base::PlatformThread::Sleep(10);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
TimeTicks ticks_stop = TimeTicks::Now();
TimeDelta delta = ticks_stop - ticks_start;
// Note: Although we asked for a 10ms sleep, if the
diff --git a/base/timer_unittest.cc b/base/timer_unittest.cc
index 0013bcc..a31f7ba 100644
--- a/base/timer_unittest.cc
+++ b/base/timer_unittest.cc
@@ -267,7 +267,7 @@
// When the timer is deleted, the DelayTimerFatalTarget should never be
// called.
- base::PlatformThread::Sleep(100);
+ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
}
} // namespace
diff --git a/base/tools_sanity_unittest.cc b/base/tools_sanity_unittest.cc
index 547fc98..60ac015 100644
--- a/base/tools_sanity_unittest.cc
+++ b/base/tools_sanity_unittest.cc
@@ -170,7 +170,7 @@
// 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_;
@@ -186,7 +186,7 @@
// 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_;
@@ -198,7 +198,7 @@
~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: