Base: Add power requirements to the System monitor.

base/system_monitor/system_monitor_win.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
 #include "base/system_monitor/system_monitor.h"
+#include "base/utf_string_conversions.h"
+#include "base/win/windows_version.h"
+
+namespace {
+
+// Maps a request's reason to the handle and requests count.
+typedef std::map<std::string, std::pair<HANDLE, int>> HanledMap;

[brettw, 2012/05/18 05:47:05]

Also space in >>

Hanled -> Handle

+
+#if _WIN32_WINNT <= _WIN32_WINNT_WIN7
+  POWER_REQUEST_TYPE PowerRequestExecutionRequired =
+      static_cast<POWER_REQUEST_TYPE>(PowerRequestAwayModeRequired + 1);
+#endif
+
+POWER_REQUEST_TYPE PowerRequestTestRequired =
+  static_cast<POWER_REQUEST_TYPE>(PowerRequestExecutionRequired + 10);

[brettw, 2012/05/18 05:47:05]

Indent 2 more spaces.

+
+POWER_REQUEST_TYPE PowerRequirementToType(
+    base::SystemMonitor::PowerRequirement requirement) {
+  switch (requirement) {
+    case base::SystemMonitor::DISPLAY_REQUIRED:
+      return PowerRequestDisplayRequired;
+    case base::SystemMonitor::SYSTEM_REQUIRED:
+      return PowerRequestSystemRequired;
+    case base::SystemMonitor::CPU_REQUIRED:
+      return PowerRequestExecutionRequired;
+    case base::SystemMonitor::TEST_REQUIRED:
+      return PowerRequestTestRequired;
+  }
+  NOTREACHED();
+  return PowerRequestTestRequired;
+}
+
+HANDLE CreatePowerRequest(POWER_REQUEST_TYPE type, const std::string& reason) {
+  typedef HANDLE (WINAPI* PowerCreateRequestPtr)(PREASON_CONTEXT);
+  typedef BOOL (WINAPI* PowerSetRequestPtr)(HANDLE, POWER_REQUEST_TYPE);
+
+  if (type == PowerRequestTestRequired)
+    return NULL;
+
+  if (type == PowerRequestExecutionRequired &&
+      base::win::GetVersion() < base::win::VERSION_WIN8) {
+    return INVALID_HANDLE_VALUE;
+  }
+
+  static PowerCreateRequestPtr PowerCreateRequestFn = NULL;
+  static PowerSetRequestPtr PowerSetRequestFn = NULL;
+
+  if (!PowerCreateRequestFn || !PowerSetRequestFn) {
+    HMODULE module = GetModuleHandle(L"kernel32.dll");
+    PowerCreateRequestFn = reinterpret_cast<PowerCreateRequestPtr>(
+        GetProcAddress(module, "PowerCreateRequest"));
+    PowerSetRequestFn = reinterpret_cast<PowerSetRequestPtr>(
+        GetProcAddress(module, "PowerSetRequest"));
+
+    if (!PowerCreateRequestFn || !PowerSetRequestFn)
+      return INVALID_HANDLE_VALUE;
+  }
+  std::wstring wide_reason = ASCIIToWide(reason);

[brettw, 2012/05/18 05:47:05]

Can you use string16 in new code?

+  REASON_CONTEXT context = {0};
+  context.Version = POWER_REQUEST_CONTEXT_VERSION;
+  context.Flags = POWER_REQUEST_CONTEXT_SIMPLE_STRING;
+  context.Reason.SimpleReasonString = const_cast<wchar_t*>(wide_reason.c_str());
+
+  base::win::ScopedHandle handle(PowerCreateRequestFn(&context));
+  if (!handle.IsValid())
+    return INVALID_HANDLE_VALUE;
+
+  if (PowerSetRequestFn(handle, type))
+    return handle.Take();
+
+  // Something went wrong.
+  return INVALID_HANDLE_VALUE;
+}
+
+// Takes ownership of the |handle|.
+void DeletePowerRequest(POWER_REQUEST_TYPE type, HANDLE handle) {
+  if (type == PowerRequestTestRequired)
+    return;
+
+  if (type == PowerRequestExecutionRequired &&
+      base::win::GetVersion() < base::win::VERSION_WIN8) {
+    return;
+  }
+
+  base::win::ScopedHandle request_handle(handle);

[brettw, 2012/05/18 05:47:05]

I'd feel better if this was before the "< win8" early return since it will
ensure the handle is closed (although in practice the handle won't be valid so
it won't matter).

+  if (!request_handle.IsValid())
+    return;
+
+  typedef BOOL (WINAPI* PowerClearRequestPtr)(HANDLE, POWER_REQUEST_TYPE);
+  HMODULE module = GetModuleHandle(L"kernel32.dll");
+  PowerClearRequestPtr PowerClearRequestFn =
+      reinterpret_cast<PowerClearRequestPtr>(
+          GetProcAddress(module, "PowerClearRequest"));
+
+  if (!PowerClearRequestFn)
+    return;
+
+  BOOL success = PowerClearRequest(request_handle, type);
+  DCHECK(success);
+}
+
+}  // namespace.
 
 namespace base {
 
 void SystemMonitor::ProcessWmPowerBroadcastMessage(int event_id) {
   PowerEvent power_event;
   switch (event_id) {
     case PBT_APMPOWERSTATUSCHANGE:  // The power status changed.
       power_event = POWER_STATE_EVENT;
       break;
     case PBT_APMRESUMEAUTOMATIC:  // Resume from suspend.
@@ skipping 13 matching lines @@
     // PBT_APMBATTERYLOW - removed in Vista.
     // PBT_APMOEMEVENT - removed in Vista.
     // PBT_APMQUERYSUSPEND - removed in Vista.
     // PBT_APMQUERYSUSPENDFAILED - removed in Vista.
     // PBT_APMRESUMECRITICAL - removed in Vista.
     // PBT_POWERSETTINGCHANGE - user changed the power settings.
   }
   ProcessPowerMessage(power_event);
 }
 
+void SystemMonitor::BeginPowerRequirement(PowerRequirement requirement,
+                                          const std::string& reason) {
+  thread_checker_.CalledOnValidThread();
+
+  HanledMap::iterator i = handles_.find(reason);
+  if (i != handles_.end()) {
+    // This is not the first request, just increase the requests count.
+    i->second.second++;
+    DCHECK_GT(i->second.second, 1);
+    return;
+  }
+
+  HANDLE handle = CreatePowerRequest(PowerRequirementToType(requirement),
+                                     reason);
+
+  if (handle != INVALID_HANDLE_VALUE)
+    handles_[reason] = std::pair<HANDLE, int>(handle, 1);
+}
+
+void SystemMonitor::EndPowerRequirement(PowerRequirement requirement,
+                                        const std::string& reason) {
+  thread_checker_.CalledOnValidThread();
+
+  HanledMap::iterator i = handles_.find(reason);
+  if (i == handles_.end()) {
+    NOTREACHED();
+    return;
+  }
+
+  // Decrease the requests count and see if this the last request.
+  i->second.second--;
+  DCHECK_GE(i->second.second, 0);
+
+  if (i->second.second)
+    return;
+
+  DeletePowerRequest(PowerRequirementToType(requirement), i->second.first);
+  handles_.erase(i);
+}
+
+size_t SystemMonitor::GetPowerRequirementsCountForTest() const {
+  return handles_.size();
+}
+
 // Function to query the system to see if it is currently running on
 // battery power.  Returns true if running on battery.
 bool SystemMonitor::IsBatteryPower() {
   SYSTEM_POWER_STATUS status;
   if (!GetSystemPowerStatus(&status)) {
     DLOG(ERROR) << "GetSystemPowerStatus failed: " << GetLastError();
     return false;
   }
   return (status.ACLineStatus == 0);
 }
 
 }  // namespace base