diff options
Diffstat (limited to 'base')
47 files changed, 121 insertions, 67 deletions
diff --git a/base/condition_variable.h b/base/condition_variable.h index 9307d8c..bceef5e 100644 --- a/base/condition_variable.h +++ b/base/condition_variable.h @@ -80,7 +80,7 @@ class ConditionVariable { // Wait() releases the caller's critical section atomically as it starts to // sleep, and the reacquires it when it is signaled. void Wait(); - void TimedWait(const TimeDelta& max_time); + void TimedWait(const base::TimeDelta& max_time); // Broadcast() revives all waiting threads. void Broadcast(); diff --git a/base/condition_variable_posix.cc b/base/condition_variable_posix.cc index c6f5f07..7a7f5dd 100644 --- a/base/condition_variable_posix.cc +++ b/base/condition_variable_posix.cc @@ -11,6 +11,9 @@ #include "base/lock_impl.h" #include "base/logging.h" +using base::Time; +using base::TimeDelta; + ConditionVariable::ConditionVariable(Lock* user_lock) : user_mutex_(user_lock->lock_impl()->os_lock()) { int rv = pthread_cond_init(&condition_, NULL); diff --git a/base/condition_variable_unittest.cc b/base/condition_variable_unittest.cc index 219944e..ee5d1c5 100644 --- a/base/condition_variable_unittest.cc +++ b/base/condition_variable_unittest.cc @@ -16,6 +16,9 @@ #include "base/spin_wait.h" #include "testing/gtest/include/gtest/gtest.h" +using base::TimeDelta; +using base::TimeTicks; + namespace { //------------------------------------------------------------------------------ // Define our test class, with several common variables. diff --git a/base/condition_variable_win.cc b/base/condition_variable_win.cc index ba4baf7..5284133 100644 --- a/base/condition_variable_win.cc +++ b/base/condition_variable_win.cc @@ -9,6 +9,8 @@ #include "base/lock.h" #include "base/logging.h" +using base::TimeDelta; + ConditionVariable::ConditionVariable(Lock* user_lock) : user_lock_(*user_lock), run_state_(RUNNING), diff --git a/base/field_trial.cc b/base/field_trial.cc index 103e539..9fd9d8f 100644 --- a/base/field_trial.cc +++ b/base/field_trial.cc @@ -7,6 +7,8 @@ #include "base/logging.h" #include "base/rand_util.h" +using base::Time; + //------------------------------------------------------------------------------ // FieldTrialList methods and members. diff --git a/base/field_trial.h b/base/field_trial.h index a812d4d..99e213c 100644 --- a/base/field_trial.h +++ b/base/field_trial.h @@ -70,11 +70,11 @@ class FieldTrialList : NonThreadSafe { // of the application. In some experiments it may be useful to discount // data that is gathered before the application has reach sufficient // stability (example: most DLL have loaded, etc.) - static Time application_start_time() { + static base::Time application_start_time() { if (global_) return global_->application_start_time_; // For testing purposes only, or when we don't yet have a start time. - return Time::Now(); + return base::Time::Now(); } private: @@ -86,7 +86,7 @@ class FieldTrialList : NonThreadSafe { static FieldTrialList* global_; // The singleton of this class. static int constructor_count_; // Prevent having more than one. - Time application_start_time_; + base::Time application_start_time_; RegistrationList registered_; DISALLOW_COPY_AND_ASSIGN(FieldTrialList); diff --git a/base/histogram.cc b/base/histogram.cc index 19dcf83..384716d 100644 --- a/base/histogram.cc +++ b/base/histogram.cc @@ -16,6 +16,8 @@ #include "base/scoped_ptr.h" #include "base/string_util.h" +using base::TimeDelta; + typedef Histogram::Count Count; // static diff --git a/base/histogram.h b/base/histogram.h index a7c1b92..af5f1fd 100644 --- a/base/histogram.h +++ b/base/histogram.h @@ -44,8 +44,8 @@ // These macros all use 50 buckets. #define HISTOGRAM_TIMES(name, sample) do { \ - static Histogram counter((name), TimeDelta::FromMilliseconds(1), \ - TimeDelta::FromSeconds(10), 50); \ + static Histogram counter((name), base::TimeDelta::FromMilliseconds(1), \ + base::TimeDelta::FromSeconds(10), 50); \ counter.AddTime(sample); \ } while (0) @@ -103,16 +103,16 @@ static const int kUmaTargetedHistogramFlag = 0x1; #define UMA_HISTOGRAM_TIMES(name, sample) do { \ - static Histogram counter((name), TimeDelta::FromMilliseconds(1), \ - TimeDelta::FromSeconds(10), 50); \ + static Histogram counter((name), base::TimeDelta::FromMilliseconds(1), \ + base::TimeDelta::FromSeconds(10), 50); \ counter.SetFlags(kUmaTargetedHistogramFlag); \ counter.AddTime(sample); \ } while (0) // Use this macro when times can routinely be much longer than 10 seconds. #define UMA_HISTOGRAM_LONG_TIMES(name, sample) do { \ - static Histogram counter((name), TimeDelta::FromMilliseconds(1), \ - TimeDelta::FromHours(1), 50); \ + static Histogram counter((name), base::TimeDelta::FromMilliseconds(1), \ + base::TimeDelta::FromHours(1), 50); \ counter.SetFlags(kUmaTargetedHistogramFlag); \ counter.AddTime(sample); \ } while (0) @@ -191,8 +191,8 @@ class Histogram : public StatsRate { Histogram(const wchar_t* name, Sample minimum, Sample maximum, size_t bucket_count); - Histogram(const wchar_t* name, TimeDelta minimum, - TimeDelta maximum, size_t bucket_count); + Histogram(const wchar_t* name, base::TimeDelta minimum, + base::TimeDelta maximum, size_t bucket_count); virtual ~Histogram(); // Hooks to override stats counter methods. This ensures that we gather all @@ -330,8 +330,8 @@ class LinearHistogram : public Histogram { }; LinearHistogram(const wchar_t* name, Sample minimum, Sample maximum, size_t bucket_count); - LinearHistogram(const wchar_t* name, TimeDelta minimum, - TimeDelta maximum, size_t bucket_count); + LinearHistogram(const wchar_t* name, base::TimeDelta minimum, + base::TimeDelta maximum, size_t bucket_count); ~LinearHistogram() {} // Store a list of number/text values for use in rendering the histogram. diff --git a/base/histogram_unittest.cc b/base/histogram_unittest.cc index 092d0543..7085f97 100644 --- a/base/histogram_unittest.cc +++ b/base/histogram_unittest.cc @@ -10,6 +10,8 @@ #include "base/time.h" #include "testing/gtest/include/gtest/gtest.h" +using base::TimeDelta; + namespace { class HistogramTest : public testing::Test { diff --git a/base/idletimer_unittest.cc b/base/idletimer_unittest.cc index fe723b6..dda7468 100644 --- a/base/idletimer_unittest.cc +++ b/base/idletimer_unittest.cc @@ -6,6 +6,8 @@ #include "base/message_loop.h" #include "testing/gtest/include/gtest/gtest.h" +using base::Time; +using base::TimeDelta; using base::IdleTimer; namespace { diff --git a/base/message_loop.cc b/base/message_loop.cc index cc87fe6..73cb7da 100644 --- a/base/message_loop.cc +++ b/base/message_loop.cc @@ -23,6 +23,9 @@ #include "base/message_pump_glib.h" #endif +using base::Time; +using base::TimeDelta; + // A lazily created thread local storage for quick access to a thread's message // loop, if one exists. This should be safe and free of static constructors. static base::LazyInstance<base::ThreadLocalPointer<MessageLoop> > lazy_tls_ptr( diff --git a/base/message_loop.h b/base/message_loop.h index 4ca6fae..2d38853 100644 --- a/base/message_loop.h +++ b/base/message_loop.h @@ -256,10 +256,10 @@ class MessageLoop : public base::MessagePump::Delegate { // This structure is copied around by value. struct PendingTask { - Task* task; // The task to run. - Time delayed_run_time; // The time when the task should be run. - int sequence_num; // Used to facilitate sorting by run time. - bool nestable; // True if OK to dispatch from a nested loop. + Task* task; // The task to run. + base::Time delayed_run_time; // The time when the task should be run. + int sequence_num; // Used to facilitate sorting by run time. + bool nestable; // True if OK to dispatch from a nested loop. PendingTask(Task* task, bool nestable) : task(task), sequence_num(0), nestable(nestable) { @@ -334,7 +334,7 @@ class MessageLoop : public base::MessagePump::Delegate { // base::MessagePump::Delegate methods: virtual bool DoWork(); - virtual bool DoDelayedWork(Time* next_delayed_work_time); + virtual bool DoDelayedWork(base::Time* next_delayed_work_time); virtual bool DoIdleWork(); // Start recording histogram info about events and action IF it was enabled diff --git a/base/message_loop_unittest.cc b/base/message_loop_unittest.cc index b742d76..83be2b1 100644 --- a/base/message_loop_unittest.cc +++ b/base/message_loop_unittest.cc @@ -15,6 +15,8 @@ #endif using base::Thread; +using base::Time; +using base::TimeDelta; // TODO(darin): Platform-specific MessageLoop tests should be grouped together // to avoid chopping this file up with so many #ifdefs. diff --git a/base/message_pump.h b/base/message_pump.h index da4d214..1a7770e 100644 --- a/base/message_pump.h +++ b/base/message_pump.h @@ -7,10 +7,10 @@ #include "base/ref_counted.h" -class Time; - namespace base { +class Time; + class MessagePump : public RefCountedThreadSafe<MessagePump> { public: // Please see the comments above the Run method for an illustration of how @@ -120,4 +120,3 @@ class MessagePump : public RefCountedThreadSafe<MessagePump> { } // namespace base #endif // BASE_MESSAGE_PUMP_H_ - diff --git a/base/message_pump_default.cc b/base/message_pump_default.cc index d1ecd12..d69fc03 100644 --- a/base/message_pump_default.cc +++ b/base/message_pump_default.cc @@ -75,4 +75,3 @@ void MessagePumpDefault::ScheduleDelayedWork(const Time& delayed_work_time) { } } // namespace base - diff --git a/base/message_pump_default.h b/base/message_pump_default.h index f565518..aa0dab9 100644 --- a/base/message_pump_default.h +++ b/base/message_pump_default.h @@ -38,4 +38,3 @@ class MessagePumpDefault : public MessagePump { } // namespace base #endif // BASE_MESSAGE_PUMP_DEFAULT_H_ - diff --git a/base/message_pump_libevent.cc b/base/message_pump_libevent.cc index 12cb6d1..0dd533e 100644 --- a/base/message_pump_libevent.cc +++ b/base/message_pump_libevent.cc @@ -179,4 +179,3 @@ void MessagePumpLibevent::ScheduleDelayedWork(const Time& delayed_work_time) { } } // namespace base - diff --git a/base/message_pump_libevent.h b/base/message_pump_libevent.h index 7534e50..9934f31 100644 --- a/base/message_pump_libevent.h +++ b/base/message_pump_libevent.h @@ -86,4 +86,3 @@ class MessagePumpLibevent : public MessagePump { } // namespace base #endif // BASE_MESSAGE_PUMP_LIBEVENT_H_ - diff --git a/base/message_pump_win.cc b/base/message_pump_win.cc index 4eb0995..542fcf1 100644 --- a/base/message_pump_win.cc +++ b/base/message_pump_win.cc @@ -9,6 +9,8 @@ #include "base/histogram.h" #include "base/win_util.h" +using base::Time; + namespace { class HandlerData : public base::MessagePumpForIO::Watcher { diff --git a/base/message_pump_win.h b/base/message_pump_win.h index 50a5223..eb4253f 100644 --- a/base/message_pump_win.h +++ b/base/message_pump_win.h @@ -249,4 +249,3 @@ class MessagePumpForIO : public MessagePumpWin { } // namespace base #endif // BASE_MESSAGE_PUMP_WIN_H_ - diff --git a/base/observer_list_unittest.cc b/base/observer_list_unittest.cc index 529e8a9..8f69256 100644 --- a/base/observer_list_unittest.cc +++ b/base/observer_list_unittest.cc @@ -9,6 +9,8 @@ #include "base/ref_counted.h" #include "testing/gtest/include/gtest/gtest.h" +using base::Time; + namespace { class ObserverListTest : public testing::Test { diff --git a/base/perftimer.h b/base/perftimer.h index 86314e9..9558697 100644 --- a/base/perftimer.h +++ b/base/perftimer.h @@ -31,16 +31,16 @@ void LogPerfResult(const char* test_name, double value, const char* units); class PerfTimer { public: PerfTimer() { - begin_ = TimeTicks::Now(); + begin_ = base::TimeTicks::Now(); } // Returns the time elapsed since object construction - TimeDelta Elapsed() const { - return TimeTicks::Now() - begin_; + base::TimeDelta Elapsed() const { + return base::TimeTicks::Now() - begin_; } private: - TimeTicks begin_; + base::TimeTicks begin_; }; // ---------------------------------------------------------------------- diff --git a/base/pr_time_unittest.cc b/base/pr_time_unittest.cc index 38c3140..3b096a2 100644 --- a/base/pr_time_unittest.cc +++ b/base/pr_time_unittest.cc @@ -9,6 +9,8 @@ #include "base/time.h" #include "testing/gtest/include/gtest/gtest.h" +using base::Time; + namespace { // time_t representation of 15th Oct 2007 12:45:00 PDT diff --git a/base/spin_wait.h b/base/spin_wait.h index 86818af..36ae083 100644 --- a/base/spin_wait.h +++ b/base/spin_wait.h @@ -31,14 +31,15 @@ // that the test passes, even if load varies, and external events vary. #define SPIN_FOR_1_SECOND_OR_UNTIL_TRUE(expression) \ - SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromSeconds(1), (expression)) + SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(base::TimeDelta::FromSeconds(1), \ + (expression)) #define SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(delta, expression) do { \ - Time start = Time::Now(); \ - const TimeDelta kTimeout = delta; \ + base::Time start = base::Time::Now(); \ + const base::TimeDelta kTimeout = delta; \ while(!(expression)) { \ - if (kTimeout < Time::Now() - start) { \ - EXPECT_LE((Time::Now() - start).InMilliseconds(), \ + if (kTimeout < base::Time::Now() - start) { \ + EXPECT_LE((base::Time::Now() - start).InMilliseconds(), \ kTimeout.InMilliseconds()) << "Timed out"; \ break; \ } \ @@ -48,4 +49,3 @@ while(0) #endif // BASE_SPIN_WAIT_H__ - diff --git a/base/stats_counters.h b/base/stats_counters.h index eaff1b4..5dc7b89c 100644 --- a/base/stats_counters.h +++ b/base/stats_counters.h @@ -187,15 +187,15 @@ class StatsCounterTimer : protected StatsCounter { void Start() { if (!Enabled()) return; - start_time_ = TimeTicks::Now(); - stop_time_ = TimeTicks(); + start_time_ = base::TimeTicks::Now(); + stop_time_ = base::TimeTicks(); } // Stop the timer and record the results. void Stop() { if (!Enabled() || !Running()) return; - stop_time_ = TimeTicks::Now(); + stop_time_ = base::TimeTicks::Now(); Record(); } @@ -205,12 +205,12 @@ class StatsCounterTimer : protected StatsCounter { } // Accept a TimeDelta to increment. - virtual void AddTime(TimeDelta time) { + virtual void AddTime(base::TimeDelta time) { Add(static_cast<int>(time.InMilliseconds())); } // TODO(jar) temporary hack include method till base and chrome use new name. - void IncrementTimer(TimeDelta time) { + void IncrementTimer(base::TimeDelta time) { AddTime(time); } @@ -220,8 +220,8 @@ class StatsCounterTimer : protected StatsCounter { AddTime(stop_time_ - start_time_); } - TimeTicks start_time_; - TimeTicks stop_time_; + base::TimeTicks start_time_; + base::TimeTicks stop_time_; }; // A StatsRate is a timer that keeps a count of the number of intervals added so diff --git a/base/stats_table_unittest.cc b/base/stats_table_unittest.cc index 7d5f015..c6e53e9 100644 --- a/base/stats_table_unittest.cc +++ b/base/stats_table_unittest.cc @@ -14,6 +14,8 @@ #include <windows.h> #endif +using base::TimeTicks; + namespace { class StatsTableTest : public MultiProcessTest { }; diff --git a/base/time.cc b/base/time.cc index 38f732c..83b5c09 100644 --- a/base/time.cc +++ b/base/time.cc @@ -8,6 +8,8 @@ #include "base/logging.h" +namespace base { + // TimeDelta ------------------------------------------------------------------ // static @@ -120,3 +122,4 @@ bool Time::FromString(const wchar_t* time_string, Time* parsed_time) { return true; } +} // namespace base diff --git a/base/time.h b/base/time.h index 4141116..cb0eeb8 100644 --- a/base/time.h +++ b/base/time.h @@ -33,6 +33,8 @@ #include <windows.h> #endif +namespace base { + class Time; class TimeTicks; @@ -438,4 +440,6 @@ inline TimeTicks TimeDelta::operator+(TimeTicks t) const { return TimeTicks(t.ticks_ + delta_); } +} // namespace base + #endif // BASE_TIME_H_ diff --git a/base/time_format.cc b/base/time_format.cc index 230c24e..0cd4eba 100644 --- a/base/time_format.cc +++ b/base/time_format.cc @@ -9,6 +9,8 @@ #include "base/time.h" #include "unicode/datefmt.h" +using base::Time; + namespace { std::wstring TimeFormat(const DateFormat* formatter, diff --git a/base/time_format.h b/base/time_format.h index af44897..b51c768 100644 --- a/base/time_format.h +++ b/base/time_format.h @@ -10,10 +10,10 @@ #include <string> -class Time; - namespace base { +class Time; + // Returns the time of day, e.g., "3:07 PM". std::wstring TimeFormatTimeOfDay(const Time& time); @@ -38,4 +38,3 @@ std::wstring TimeFormatFriendlyDate(const Time& time); } // namespace base #endif // BASE_TIME_FORMAT_H_ - diff --git a/base/time_posix.cc b/base/time_posix.cc index 18dc240..901b65c 100644 --- a/base/time_posix.cc +++ b/base/time_posix.cc @@ -13,6 +13,8 @@ #include "base/basictypes.h" #include "base/logging.h" +namespace base { + // The Time routines in this file use standard POSIX routines, or almost- // standard routines in the case of timegm. We need to use a Mach-specific // function for TimeTicks::Now() on Mac OS X. @@ -140,3 +142,5 @@ TimeTicks TimeTicks::Now() { TimeTicks TimeTicks::HighResNow() { return Now(); } + +} // namespace base diff --git a/base/time_unittest.cc b/base/time_unittest.cc index db0990f4..ebe69eb 100644 --- a/base/time_unittest.cc +++ b/base/time_unittest.cc @@ -9,6 +9,10 @@ #include "build/build_config.h" #include "testing/gtest/include/gtest/gtest.h" +using base::Time; +using base::TimeDelta; +using base::TimeTicks; + // Test conversions to/from time_t and exploding/unexploding. TEST(Time, TimeT) { // C library time and exploded time. diff --git a/base/time_unittest_win.cc b/base/time_unittest_win.cc index 1c3ea08..d0f606d4 100644 --- a/base/time_unittest_win.cc +++ b/base/time_unittest_win.cc @@ -9,6 +9,10 @@ #include "base/time.h" #include "testing/gtest/include/gtest/gtest.h" +using base::Time; +using base::TimeDelta; +using base::TimeTicks; + namespace { class MockTimeTicks : public TimeTicks { diff --git a/base/time_win.cc b/base/time_win.cc index e7d7ae8..bc9d0c7 100644 --- a/base/time_win.cc +++ b/base/time_win.cc @@ -47,6 +47,10 @@ #include "base/singleton.h" #include "base/system_monitor.h" +using base::Time; +using base::TimeDelta; +using base::TimeTicks; + namespace { // From MSDN, FILETIME "Contains a 64-bit value representing the number of diff --git a/base/timer_unittest.cc b/base/timer_unittest.cc index a9d13e2..face9c8 100644 --- a/base/timer_unittest.cc +++ b/base/timer_unittest.cc @@ -7,6 +7,8 @@ #include "base/timer.h" #include "testing/gtest/include/gtest/gtest.h" +using base::TimeDelta; + namespace { class OneShotTimerTester { diff --git a/base/trace_event.cc b/base/trace_event.cc index 972f17c..fa47184 100644 --- a/base/trace_event.cc +++ b/base/trace_event.cc @@ -150,4 +150,3 @@ void TraceLog::Log(const std::string& msg) { } } // namespace base - diff --git a/base/tracked.cc b/base/tracked.cc index b47a4e4..5e519b1 100644 --- a/base/tracked.cc +++ b/base/tracked.cc @@ -7,6 +7,8 @@ #include "base/string_util.h" #include "base/tracked_objects.h" +using base::Time; + namespace tracked_objects { //------------------------------------------------------------------------------ diff --git a/base/tracked.h b/base/tracked.h index f976175..002b858 100644 --- a/base/tracked.h +++ b/base/tracked.h @@ -116,7 +116,7 @@ class Tracked { // The time this object was constructed. If its life consisted of a long // waiting period, and then it became active, then this value is generally // reset before the object begins it active life. - Time tracked_birth_time_; + base::Time tracked_birth_time_; #endif // TRACK_ALL_TASK_OBJECTS diff --git a/base/tracked_objects.cc b/base/tracked_objects.cc index c9e8eb0..4102075 100644 --- a/base/tracked_objects.cc +++ b/base/tracked_objects.cc @@ -8,6 +8,8 @@ #include "base/string_util.h" +using base::TimeDelta; + namespace tracked_objects { // A TLS slot to the TrackRegistry for the current thread. diff --git a/base/tracked_objects.h b/base/tracked_objects.h index 2e6f046..638ea24 100644 --- a/base/tracked_objects.h +++ b/base/tracked_objects.h @@ -80,11 +80,11 @@ class DeathData { // a corrosponding death. explicit DeathData(int count) : count_(count), square_duration_(0) {} - void RecordDeath(const TimeDelta& duration); + void RecordDeath(const base::TimeDelta& duration); // Metrics accessors. int count() const { return count_; } - TimeDelta life_duration() const { return life_duration_; } + base::TimeDelta life_duration() const { return life_duration_; } int64 square_duration() const { return square_duration_; } int AverageMsDuration() const; double StandardDeviation() const; @@ -99,7 +99,7 @@ class DeathData { private: int count_; // Number of destructions. - TimeDelta life_duration_; // Sum of all lifetime durations. + base::TimeDelta life_duration_; // Sum of all lifetime durations. int64 square_duration_; // Sum of squares in milliseconds. }; @@ -128,7 +128,7 @@ class Snapshot { const std::string DeathThreadName() const; int count() const { return death_data_.count(); } - TimeDelta life_duration() const { return death_data_.life_duration(); } + base::TimeDelta life_duration() const { return death_data_.life_duration(); } int64 square_duration() const { return death_data_.square_duration(); } int AverageMsDuration() const { return death_data_.AverageMsDuration(); } @@ -339,7 +339,7 @@ class ThreadData { Births* FindLifetime(const Location& location); // Find a place to record a death on this thread. - void TallyADeath(const Births& lifetimes, const TimeDelta& duration); + void TallyADeath(const Births& lifetimes, const base::TimeDelta& duration); // (Thread safe) Get start of list of instances. static ThreadData* first(); diff --git a/base/waitable_event.h b/base/waitable_event.h index 3aa42d4..b723653 100644 --- a/base/waitable_event.h +++ b/base/waitable_event.h @@ -14,10 +14,10 @@ typedef void* HANDLE; #include "base/lock.h" #endif -class TimeDelta; - namespace base { +class TimeDelta; + // A WaitableEvent can be a useful thread synchronization tool when you want to // allow one thread to wait for another thread to finish some work. // @@ -80,4 +80,3 @@ class WaitableEvent { } // namespace base #endif // BASE_WAITABLE_EVENT_H_ - diff --git a/base/waitable_event_generic.cc b/base/waitable_event_generic.cc index 6afbf18..61eeeb8 100644 --- a/base/waitable_event_generic.cc +++ b/base/waitable_event_generic.cc @@ -69,4 +69,3 @@ bool WaitableEvent::TimedWait(const TimeDelta& max_time) { } } // namespace base - diff --git a/base/waitable_event_unittest.cc b/base/waitable_event_unittest.cc index 9dc9335..e7bab49 100644 --- a/base/waitable_event_unittest.cc +++ b/base/waitable_event_unittest.cc @@ -6,6 +6,7 @@ #include "base/waitable_event.h" #include "testing/gtest/include/gtest/gtest.h" +using base::TimeDelta; using base::WaitableEvent; namespace { diff --git a/base/waitable_event_win.cc b/base/waitable_event_win.cc index 8c1efe6..257f145 100644 --- a/base/waitable_event_win.cc +++ b/base/waitable_event_win.cc @@ -63,4 +63,3 @@ bool WaitableEvent::TimedWait(const TimeDelta& max_time) { } } // namespace base - diff --git a/base/watchdog.cc b/base/watchdog.cc index 06ab871..b1db70b 100644 --- a/base/watchdog.cc +++ b/base/watchdog.cc @@ -7,6 +7,9 @@ #include "base/platform_thread.h" #include "base/string_util.h" +using base::TimeDelta; +using base::TimeTicks; + //------------------------------------------------------------------------------ // Public API methods. @@ -145,4 +148,3 @@ Lock Watchdog::static_lock_; // Lock for access of static data... TimeTicks Watchdog::last_debugged_alarm_time_ = TimeTicks(); // static TimeDelta Watchdog::last_debugged_alarm_delay_; - diff --git a/base/watchdog.h b/base/watchdog.h index 0b77749..c7e967f 100644 --- a/base/watchdog.h +++ b/base/watchdog.h @@ -28,15 +28,15 @@ class Watchdog { public: // TODO(JAR)change default arg to required arg after all users have migrated. // Constructor specifies how long the Watchdog will wait before alarming. - Watchdog(const TimeDelta& duration, + Watchdog(const base::TimeDelta& duration, const std::wstring& thread_watched_name, bool enabled = true); virtual ~Watchdog(); // Start timing, and alarm when time expires (unless we're disarm()ed.) void Arm(); // Arm starting now. - void ArmSomeTimeDeltaAgo(const TimeDelta& time_delta); - void ArmAtStartTime(const TimeTicks start_time); + void ArmSomeTimeDeltaAgo(const base::TimeDelta& time_delta); + void ArmAtStartTime(const base::TimeTicks start_time); // Reset time, and do not set off the alarm. void Disarm(); @@ -60,12 +60,12 @@ class Watchdog { Lock lock_; // Mutex for state_. ConditionVariable condition_variable_; State state_; - const TimeDelta duration_; // How long after start_time_ do we alarm? + const base::TimeDelta duration_; // How long after start_time_ do we alarm? const std::wstring thread_watched_name_; HANDLE handle_; // Handle for watchdog thread. DWORD thread_id_; // Also for watchdog thread. - TimeTicks start_time_; // Start of epoch, and alarm after duration_. + base::TimeTicks start_time_; // Start of epoch, and alarm after duration_. // When the debugger breaks (when we alarm), all the other alarms that are // armed will expire (also alarm). To diminish this effect, we track any @@ -75,9 +75,9 @@ class Watchdog { // on alarms from callers that specify old times. static Lock static_lock_; // Lock for access of static data... // When did we last alarm and get stuck (for a while) in a debugger? - static TimeTicks last_debugged_alarm_time_; + static base::TimeTicks last_debugged_alarm_time_; // How long did we sit on a break in the debugger? - static TimeDelta last_debugged_alarm_delay_; + static base::TimeDelta last_debugged_alarm_delay_; DISALLOW_EVIL_CONSTRUCTORS(Watchdog); diff --git a/base/watchdog_unittest.cc b/base/watchdog_unittest.cc index c74b941..c4a664f 100644 --- a/base/watchdog_unittest.cc +++ b/base/watchdog_unittest.cc @@ -10,6 +10,8 @@ #include "base/time.h" #include "testing/gtest/include/gtest/gtest.h" +using base::TimeDelta; + namespace { //------------------------------------------------------------------------------ |