Battery Status API: implementation for Windows.

Implementation of the Battery Status API for the Windows platform.
Implementation uses a message window to receive battery notifications.
On versions prior to Vista there is limited support as the
RegisterPowerSettingNotification function is not available.

BUG=122593
TEST=http://jsbin.com/battery-status-test (manual)

Review URL: https://codereview.chromium.org/447853002

Cr-Commit-Position: refs/heads/master@{#289634}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@289634 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/battery_status/battery_status_manager_win.cc

+// Copyright 2014 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 "content/browser/battery_status/battery_status_manager_win.h"
+
+#include "base/memory/ref_counted.h"
+#include "base/strings/string16.h"
+#include "base/win/message_window.h"
+#include "base/win/windows_version.h"
+#include "content/browser/battery_status/battery_status_manager.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace content {
+
+namespace {
+
+typedef BatteryStatusService::BatteryUpdateCallback BatteryCallback;
+
+const wchar_t kWindowClassName[] = L"BatteryStatusMessageWindow";
+
+// Message-only window for handling battery changes on Windows.
+class BatteryStatusObserver
+    : public base::RefCountedThreadSafe<BatteryStatusObserver> {
+ public:
+  explicit BatteryStatusObserver(const BatteryCallback& callback)
+      : power_handle_(NULL),
+        battery_change_handle_(NULL),
+        callback_(callback) {
+  }
+
+  virtual ~BatteryStatusObserver() { DCHECK(!window_); }
+
+  void Start() {
+    // Need to start on the UI thread to receive battery status notifications.
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&BatteryStatusObserver::StartOnUI, this));
+  }
+
+  void Stop() {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&BatteryStatusObserver::StopOnUI, this));
+  }
+
+ private:
+  void StartOnUI() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (window_)
+      return;
+
+    if (CreateMessageWindow()) {
+      BatteryChanged();
+      // RegisterPowerSettingNotification function work from Windows Vista
+      // onwards. However even without them we will receive notifications,
+      // e.g. when a power source is connected.
+      // TODO(timvolodine) : consider polling for battery changes on windows
+      // versions prior to Vista, see crbug.com/402466.
+      power_handle_ =
+          RegisterNotification(&GUID_ACDC_POWER_SOURCE);
+      battery_change_handle_ =
+          RegisterNotification(&GUID_BATTERY_PERCENTAGE_REMAINING);
+    } else {
+      // Could not create a message window, execute callback with the default
+      // values.
+      callback_.Run(blink::WebBatteryStatus());
+    }
+  }
+
+  void StopOnUI() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (!window_)
+      return;
+
+    if (power_handle_)
+      UnregisterNotification(power_handle_);
+    if (battery_change_handle_)
+      UnregisterNotification(battery_change_handle_);
+    window_.reset();
+  }
+
+  void BatteryChanged() {
+    SYSTEM_POWER_STATUS win_status;
+    if (GetSystemPowerStatus(&win_status))
+      callback_.Run(ComputeWebBatteryStatus(win_status));
+    else
+      callback_.Run(blink::WebBatteryStatus());
+  }
+
+  bool HandleMessage(UINT message,
+                     WPARAM wparam,
+                     LPARAM lparam,
+                     LRESULT* result) {
+    switch(message) {
+      case WM_POWERBROADCAST:
+        if (wparam == PBT_APMPOWERSTATUSCHANGE ||
+            wparam == PBT_POWERSETTINGCHANGE) {
+          BatteryChanged();
+        }
+        *result = NULL;
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  HPOWERNOTIFY RegisterNotification(LPCGUID power_setting) {
+    if (base::win::GetVersion() < base::win::VERSION_VISTA)
+      return NULL;
+
+    return RegisterPowerSettingNotification(window_->hwnd(), power_setting,
+                                     DEVICE_NOTIFY_WINDOW_HANDLE);
+  }
+
+  BOOL UnregisterNotification(HPOWERNOTIFY handle) {
+    if (base::win::GetVersion() < base::win::VERSION_VISTA)
+      return FALSE;
+
+    return UnregisterPowerSettingNotification(handle);
+  }
+
+  bool CreateMessageWindow() {
+    // TODO(timvolodine): consider reusing the message window of PowerMonitor.
+    window_.reset(new base::win::MessageWindow());
+    if (!window_->CreateNamed(base::Bind(&BatteryStatusObserver::HandleMessage,
+                                         base::Unretained(this)),
+                              base::string16(kWindowClassName))) {
+      LOG(ERROR) << "Failed to create message window: " << kWindowClassName;
+      window_.reset();
+      return false;
+    }
+    return true;
+  }
+
+  HPOWERNOTIFY power_handle_;
+  HPOWERNOTIFY battery_change_handle_;
+  BatteryCallback callback_;
+  scoped_ptr<base::win::MessageWindow> window_;
+
+  DISALLOW_COPY_AND_ASSIGN(BatteryStatusObserver);
+};
+
+class BatteryStatusManagerWin : public BatteryStatusManager {
+ public:
+  explicit BatteryStatusManagerWin(const BatteryCallback& callback)
+      : battery_observer_(new BatteryStatusObserver(callback)) {}
+  virtual ~BatteryStatusManagerWin() { battery_observer_->Stop(); }
+
+ public:
+  // BatteryStatusManager:
+  virtual bool StartListeningBatteryChange() OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    battery_observer_->Start();
+    return true;
+  }
+
+  virtual void StopListeningBatteryChange() OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    battery_observer_->Stop();
+  }
+
+ private:
+  scoped_refptr<BatteryStatusObserver> battery_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerWin);
+};
+
+}  // namespace
+
+blink::WebBatteryStatus ComputeWebBatteryStatus(
+    const SYSTEM_POWER_STATUS& win_status) {
+  blink::WebBatteryStatus status;
+  status.charging = win_status.ACLineStatus != WIN_AC_LINE_STATUS_OFFLINE;
+
+  // Set level if available. Otherwise keep the default value which is 1.
+  if (win_status.BatteryLifePercent != 255) {
+    // Convert percentage to a value between 0 and 1 with 2 significant digits.
+    status.level = static_cast<double>(win_status.BatteryLifePercent) / 100.;
+  }
+
+  if (!status.charging) {
+    // Set dischargingTime if available otherwise keep the default value,
+    // which is +Infinity.
+    if (win_status.BatteryLifeTime != (DWORD)-1)
+      status.dischargingTime = win_status.BatteryLifeTime;
+    status.chargingTime = std::numeric_limits<double>::infinity();
+  } else {
+    // Set chargingTime to +Infinity if not fully charged, otherwise leave the
+    // default value, which is 0.
+    if (status.level < 1)
+      status.chargingTime = std::numeric_limits<double>::infinity();
+  }
+  return status;
+}
+
+// static
+scoped_ptr<BatteryStatusManager> BatteryStatusManager::Create(
+    const BatteryStatusService::BatteryUpdateCallback& callback) {
+  return scoped_ptr<BatteryStatusManager>(
+      new BatteryStatusManagerWin(callback));
+}
+
+}  // namespace content

content/browser/battery_status/battery_status_manager_win.h

+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_BATTERY_STATUS_BATTERY_STATUS_MANAGER_WIN_H_
+#define CHROME_BROWSER_BATTERY_STATUS_BATTERY_STATUS_MANAGER_WIN_H_
+
+#include <windows.h>
+#include "content/common/content_export.h"
+#include "third_party/WebKit/public/platform/WebBatteryStatus.h"
+
+namespace content {
+
+enum WinACLineStatus {
+  WIN_AC_LINE_STATUS_OFFLINE = 0,
+  WIN_AC_LINE_STATUS_ONLINE = 1,
+  WIN_AC_LINE_STATUS_UNKNOWN = 255,
+};
+
+// Returns WebBatteryStatus corresponding to the given SYSTEM_POWER_STATUS.
+CONTENT_EXPORT blink::WebBatteryStatus ComputeWebBatteryStatus(
+    const SYSTEM_POWER_STATUS& win_status);
+
+}  // namespace content
+
+#endif  // CHROME_BROWSER_BATTERY_STATUS_BATTERY_STATUS_MANAGER_WIN_H_
\ No newline at end of file

content/browser/battery_status/battery_status_manager_win_unittest.cc

+// Copyright 2014 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 "content/browser/battery_status/battery_status_manager_win.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+namespace {
+
+TEST(BatteryStatusManagerWinTest, ACLineStatusOffline) {
+  SYSTEM_POWER_STATUS win_status;
+  win_status.ACLineStatus = WIN_AC_LINE_STATUS_OFFLINE;
+  win_status.BatteryLifePercent = 100;
+  win_status.BatteryLifeTime = 200;
+
+  blink::WebBatteryStatus status = ComputeWebBatteryStatus(win_status);
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.chargingTime);
+  EXPECT_EQ(200, status.dischargingTime);
+  EXPECT_EQ(1, status.level);
+}
+
+TEST(BatteryStatusManagerWinTest, ACLineStatusOfflineDischargingTimeUnknown) {
+  SYSTEM_POWER_STATUS win_status;
+  win_status.ACLineStatus = WIN_AC_LINE_STATUS_OFFLINE;
+  win_status.BatteryLifePercent = 100;
+  win_status.BatteryLifeTime = (DWORD)-1;
+
+  blink::WebBatteryStatus status = ComputeWebBatteryStatus(win_status);
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.chargingTime);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.dischargingTime);
+  EXPECT_EQ(1, status.level);
+}
+
+TEST(BatteryStatusManagerWinTest, ACLineStatusOnline) {
+  SYSTEM_POWER_STATUS win_status;
+  win_status.ACLineStatus = WIN_AC_LINE_STATUS_ONLINE;
+  win_status.BatteryLifePercent = 50;
+  win_status.BatteryLifeTime = 200;
+
+  blink::WebBatteryStatus status = ComputeWebBatteryStatus(win_status);
+  EXPECT_TRUE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.chargingTime);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.dischargingTime);
+  EXPECT_EQ(.5, status.level);
+}
+
+TEST(BatteryStatusManagerWinTest, ACLineStatusOnlineFullBattery) {
+  SYSTEM_POWER_STATUS win_status;
+  win_status.ACLineStatus = WIN_AC_LINE_STATUS_ONLINE;
+  win_status.BatteryLifePercent = 100;
+  win_status.BatteryLifeTime = 200;
+
+  blink::WebBatteryStatus status = ComputeWebBatteryStatus(win_status);
+  EXPECT_TRUE(status.charging);
+  EXPECT_EQ(0, status.chargingTime);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.dischargingTime);
+  EXPECT_EQ(1, status.level);
+}
+
+TEST(BatteryStatusManagerWinTest, ACLineStatusUnknown) {
+  SYSTEM_POWER_STATUS win_status;
+  win_status.ACLineStatus = WIN_AC_LINE_STATUS_UNKNOWN;
+  win_status.BatteryLifePercent = 50;
+  win_status.BatteryLifeTime = 200;
+
+  blink::WebBatteryStatus status = ComputeWebBatteryStatus(win_status);
+  EXPECT_TRUE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.chargingTime);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.dischargingTime);
+  EXPECT_EQ(.5, status.level);
+}
+
+}  // namespace
+
+}  // namespace content

content/content_browser.gypi

@@ -377,6 +377,8 @@
       'browser/battery_status/battery_status_manager_linux.cc',
       'browser/battery_status/battery_status_manager_linux.h',
       'browser/battery_status/battery_status_manager_mac.cc',
+      'browser/battery_status/battery_status_manager_win.cc',
+      'browser/battery_status/battery_status_manager_win.h',
       'browser/battery_status/battery_status_manager.h',
       'browser/battery_status/battery_status_message_filter.cc',
       'browser/battery_status/battery_status_message_filter.h',
@@ -1847,6 +1849,7 @@
     }],
     ['OS == "win"', {
       'sources!': [
+        'browser/battery_status/battery_status_manager_default.cc',
         'browser/geolocation/empty_wifi_data_provider.cc',
       ],
     }],

content/content_tests.gypi

@@ -405,6 +405,7 @@
         'browser/appcache/mock_appcache_storage.h',
         'browser/appcache/mock_appcache_storage_unittest.cc',
         'browser/battery_status/battery_status_manager_linux_unittest.cc',
+        'browser/battery_status/battery_status_manager_win_unittest.cc',
         'browser/battery_status/battery_status_service_unittest.cc',
         'browser/browser_thread_unittest.cc',
         'browser/browser_url_handler_impl_unittest.cc',