Make SystemMonitor not a Singleton and move it out of base

base/time_win.cc

 // Copyright (c) 2009 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.
 
 
 // Windows Timer Primer
 //
 // A good article:  http://www.ddj.com/windows/184416651
 // A good mozilla bug:  http://bugzilla.mozilla.org/show_bug.cgi?id=363258
 //
@@ skipping 27 matching lines @@
 
 #pragma comment(lib, "winmm.lib")
 #include <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/cpu.h"
 #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
 // 100-nanosecond intervals since January 1, 1601 (UTC)."
 int64 FileTimeToMicroseconds(const FILETIME& ft) {
@@ skipping 22 matching lines @@
 const int kMaxMillisecondsToAvoidDrift = 60 * Time::kMillisecondsPerSecond;
 
 int64 initial_time = 0;
 TimeTicks initial_ticks;
 
 void InitializeClock() {
   initial_ticks = TimeTicks::Now();
   initial_time = CurrentWallclockMicroseconds();
 }
 
-class HighResolutionTimerManager : public base::SystemMonitor::PowerObserver {
- public:
-  ~HighResolutionTimerManager() {
-    StopMonitoring();
-    UseHiResClock(false);
-  }
-
-  void Enable() {
-    StopMonitoring();
-    UseHiResClock(true);
-  }
-
-  void StartMonitoring() {
-    if (is_monitoring_)
-      return;
-    is_monitoring_ = true;
-    base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
-    system_monitor->AddObserver(this);
-    UseHiResClock(!system_monitor->BatteryPower());
-  }
-
-  void StopMonitoring() {
-    if (!is_monitoring_)
-      return;
-    is_monitoring_ = false;
-    base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
-    if (system_monitor)
-      system_monitor->RemoveObserver(this);
-  }
-
-  // Interfaces for monitoring Power changes.
-  void OnPowerStateChange(bool on_battery_power) {
-    UseHiResClock(!on_battery_power);
-  }
-
- private:
-  HighResolutionTimerManager()
-      : is_monitoring_(false),
-        hi_res_clock_enabled_(false) {
-  }
-  friend struct DefaultSingletonTraits<HighResolutionTimerManager>;
-
-  // Enable or disable the faster multimedia timer.
-  void UseHiResClock(bool enabled) {
-    if (enabled == hi_res_clock_enabled_)
-      return;
-    if (enabled)
-      timeBeginPeriod(1);
-    else
-      timeEndPeriod(1);
-    hi_res_clock_enabled_ = enabled;
-  }
-
-  bool is_monitoring_;
-  bool hi_res_clock_enabled_;
-
-  DISALLOW_COPY_AND_ASSIGN(HighResolutionTimerManager);
-};
-
 }  // namespace
 
 // Time -----------------------------------------------------------------------
 
 // The internal representation of Time uses FILETIME, whose epoch is 1601-01-01
 // 00:00:00 UTC.  ((1970-1601)*365+89)*24*60*60*1000*1000, where 89 is the
 // number of leap year days between 1601 and 1970: (1970-1601)/4 excluding
 // 1700, 1800, and 1900.
 // static
 const int64 Time::kTimeTToMicrosecondsOffset = GG_INT64_C(11644473600000000);
@@ skipping 41 matching lines @@
   return Time(FileTimeToMicroseconds(ft));
 }
 
 FILETIME Time::ToFileTime() const {
   FILETIME utc_ft;
   MicrosecondsToFileTime(us_, &utc_ft);
   return utc_ft;
 }
 
 // static
-void Time::StartSystemMonitorObserver() {
-  Singleton<HighResolutionTimerManager>()->StartMonitoring();
+bool Time::UseHighResolutionTimer(bool use) {
+  // TODO(mbelshe): Make sure that switching the system timer resolution
+  // doesn't break Timer firing order etc. An example test would be to have
+  // two threads. One would have a bunch of timers, and another would turn the
+  // high resolution timer on and off.
+
+  MMRESULT result;
+  if (use)
+    result = timeBeginPeriod(1);
+  else
+    result = timeEndPeriod(1);
+  return (result == TIMERR_NOERROR);
 }
 
 // static
-void Time::EnableHiResClockForTests() {
-  Singleton<HighResolutionTimerManager>()->Enable();
-}
-
-// static
 Time Time::FromExploded(bool is_local, const Exploded& exploded) {
   // Create the system struct representing our exploded time. It will either be
   // in local time or UTC.
   SYSTEMTIME st;
   st.wYear = exploded.year;
   st.wMonth = exploded.month;
   st.wDayOfWeek = exploded.day_of_week;
   st.wDay = exploded.day_of_month;
   st.wHour = exploded.hour;
   st.wMinute = exploded.minute;
@@ skipping 205 matching lines @@
 
 // static
 TimeTicks TimeTicks::Now() {
   return TimeTicks() + Singleton<NowSingleton>::get()->Now();
 }
 
 // static
 TimeTicks TimeTicks::HighResNow() {
   return TimeTicks() + Singleton<HighResNowSingleton>::get()->Now();
 }