SystemMonitor refactoring: move power state monitor into a separate class called PowerMonitor

base/power_monitor/power_monitor_mac.mm

 // Copyright (c) 2012 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.
 
 // Implementation based on sample code from
 // http://developer.apple.com/library/mac/#qa/qa1340/_index.html.
 
-#include "base/system_monitor/system_monitor.h"
+#include "base/power_monitor/power_monitor.h"
 
 #include <IOKit/pwr_mgt/IOPMLib.h>
 #include <IOKit/IOMessage.h>
 
 namespace base {
 
+// A helper function as a friend function of PowerMonitor.
+void ProcessPowerEventHelper(PowerMonitor::PowerEvent power_event) {
+  PowerMonitor* power_monitor = PowerMonitor::GetInstance();
+  power_monitor->ProcessPowerEvent(power_event);
+}
+
 namespace {
 
 io_connect_t g_system_power_io_port = 0;
 IONotificationPortRef g_notification_port_ref = 0;
 io_object_t g_notifier_object = 0;
 
 void SystemPowerEventCallback(void*,
                               io_service_t service,
                               natural_t message_type,
                               void* message_argument) {
-  SystemMonitor* sys_monitor = SystemMonitor::Get();
-  DCHECK(sys_monitor);
   switch (message_type) {
     case kIOMessageSystemWillSleep:
-      sys_monitor->ProcessPowerMessage(SystemMonitor::SUSPEND_EVENT);
+      ProcessPowerEventHelper(PowerMonitor::SUSPEND_EVENT);
       IOAllowPowerChange(g_system_power_io_port,
           reinterpret_cast<intptr_t>(message_argument));
       break;
 
     case kIOMessageSystemWillPowerOn:
-      sys_monitor->ProcessPowerMessage(SystemMonitor::RESUME_EVENT);
+      ProcessPowerEventHelper(PowerMonitor::RESUME_EVENT);
       break;
   }
 }
 
 }  // namespace
 
 // The reason we can't include this code in the constructor is because
 // PlatformInit() requires an active runloop and the IO port needs to be
 // allocated at sandbox initialization time, before there's a runloop.
 // See crbug.com/83783 .
 
 // static
-void SystemMonitor::AllocateSystemIOPorts() {
-  DCHECK_EQ(g_system_power_io_port, 0u);
+void PowerMonitor::AllocateSystemIOPorts() {
+  if (g_system_power_io_port != 0u)

[Hongbo Min, 2012/10/16 14:14:40]

base/power_monitor/power_monitor_mac.mm:53: if (g_system_power_io_port != 0u)
Here I removed the DCHECK_EQ stmt because AllocateSystemIOPorts is designed to
be called once, otherwise, the g_system_power_io_port will be leaked without
IOServiceClose calling when AllocateSystemSystemIOPorts is called multiple
times.

If the AllocateSystemIOPort was ever called and so g_system_power_io_port is
retrieved correctly, we just returns the value got already immediately.

[vandebo (ex-Chrome), 2012/10/16 18:50:16]

Hmm, this is a consequence of changing it to a Singleton. I'm not happy with the
extra changes that have to be made, but it's not too bad either.  I'll defer to
Will on this one.

[willchan no longer on Chromium, 2012/10/16 20:32:37]

I'm confused. Why is this better than before? Let me restate my understanding.
Before:
* Asserts in debug mode if this is ever called more than once.
* Leaks in release mode if this is ever called more than once.

After:
* Gracefully handles calling it more than once.

I think it's a bug to call it more than once and would prefer to catch it. I do
think it's an improvement to gracefully handle it in release mode, but it'd be
great to keep the DCHECK there for debug mode to prevent people from calling
this multiple times.

[vandebo (ex-Chrome), 2012/10/16 23:55:09]

Maybe this and the other issue is why it wasn't a Singleton before... As a
Singleton it's created once per test binary.  However, the test instance will
call AllocateSystemIOPorts once per test.

+    return;
 
   // Notification port allocated by IORegisterForSystemPower.
 
   g_system_power_io_port = IORegisterForSystemPower(
       NULL, &g_notification_port_ref, SystemPowerEventCallback,
       &g_notifier_object);
 
   DCHECK_NE(g_system_power_io_port, 0u);
 }
 
-void SystemMonitor::PlatformInit() {
-  // Need to call AllocateSystemIOPorts() before constructing a SystemMonitor
+void PowerMonitor::PlatformInit() {
+  // Need to call AllocateSystemIOPorts() before creating a PowerMonitor
   // object.
-  DCHECK_NE(g_system_power_io_port, 0u);
-  if (g_system_power_io_port == 0)
-    return;
+  CHECK_NE(g_system_power_io_port, 0u);
 
   // Add the notification port to the application runloop
   CFRunLoopAddSource(
       CFRunLoopGetCurrent(),
       IONotificationPortGetRunLoopSource(g_notification_port_ref),
       kCFRunLoopCommonModes);
 }
 
-void SystemMonitor::PlatformDestroy() {
-  DCHECK_NE(g_system_power_io_port, 0u);
-  if (g_system_power_io_port == 0)
-    return;
+
+void PowerMonitor::PlatformDestroy() {
+  CHECK_NE(g_system_power_io_port, 0u);
 
   // Remove the sleep notification port from the application runloop
   CFRunLoopRemoveSource(
       CFRunLoopGetCurrent(),
       IONotificationPortGetRunLoopSource(g_notification_port_ref),
       kCFRunLoopCommonModes);
 
   // Deregister for system sleep notifications
   IODeregisterForSystemPower(&g_notifier_object);
 
   // IORegisterForSystemPower implicitly opens the Root Power Domain IOService,
   // so we close it here.
   IOServiceClose(g_system_power_io_port);
 
   g_system_power_io_port = 0;
 
   // Destroy the notification port allocated by IORegisterForSystemPower.
   IONotificationPortDestroy(g_notification_port_ref);
 }
 
 }  // namespace base