Replace Chrome IPC with Mojo IPC for querying BatteryStatus service

device/battery/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 "device/battery/battery_status_manager_win.h"
 
-#include "base/memory/ref_counted.h"
+#include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.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"
+#include "device/battery/battery_status_manager.h"
 
-namespace content {
+namespace device {
 
 namespace {
 
 typedef BatteryStatusService::BatteryUpdateCallback BatteryCallback;
 
 const wchar_t kWindowClassName[] = L"BatteryStatusMessageWindow";
 
 // This enum is used for histogram. Don't change the order of the existing
 // values.
 enum NumberBatteriesType {
@@ skipping 18 matching lines @@
 
   if (win_status.BatteryFlag == 255)
     UpdateNumberBatteriesHistogram(UNKNOWN_BATTERIES);
   else if (win_status.BatteryFlag == 128)
     UpdateNumberBatteriesHistogram(NO_BATTERY);
   else
     UpdateNumberBatteriesHistogram(ONE_OR_MORE_BATTERIES);
 }
 
 // Message-only window for handling battery changes on Windows.
-class BatteryStatusObserver
-    : public base::RefCountedThreadSafe<BatteryStatusObserver> {
+class BatteryStatusObserver {
  public:
   explicit BatteryStatusObserver(const BatteryCallback& callback)
       : power_handle_(NULL),
         battery_change_handle_(NULL),
         callback_(callback) {
   }
 
-  virtual ~BatteryStatusObserver() { DCHECK(!window_); }
+  ~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());
+      callback_.Run(BatteryStatus());
     }
 
     UpdateNumberBatteriesHistogram();
   }
 
-  void StopOnUI() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (!window_)
-      return;
-
+  void Stop() {
     if (power_handle_)
       UnregisterNotification(power_handle_);
     if (battery_change_handle_)
       UnregisterNotification(battery_change_handle_);
     window_.reset();
   }
 
+ private:
   void BatteryChanged() {
     SYSTEM_POWER_STATUS win_status;
     if (GetSystemPowerStatus(&win_status))
       callback_.Run(ComputeWebBatteryStatus(win_status));
     else
-      callback_.Run(blink::WebBatteryStatus());
+      callback_.Run(BatteryStatus());
   }
 
   bool HandleMessage(UINT message,
                      WPARAM wparam,
                      LPARAM lparam,
                      LRESULT* result) {
     switch(message) {
       case WM_POWERBROADCAST:
         if (wparam == PBT_APMPOWERSTATUSCHANGE ||
             wparam == PBT_POWERSETTINGCHANGE) {
@@ skipping 44 matching lines @@
 
 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_;
+  scoped_ptr<BatteryStatusObserver> battery_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerWin);
 };
 
 }  // namespace
 
-blink::WebBatteryStatus ComputeWebBatteryStatus(
-    const SYSTEM_POWER_STATUS& win_status) {
-  blink::WebBatteryStatus status;
+BatteryStatus ComputeWebBatteryStatus(const SYSTEM_POWER_STATUS& win_status) {
+  BatteryStatus 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,
+    // Set discharging_time 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();
+      status.discharging_time = win_status.BatteryLifeTime;
+    status.charging_time = std::numeric_limits<double>::infinity();
   } else {
-    // Set chargingTime to +Infinity if not fully charged, otherwise leave the
+    // Set charging_time 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();
+      status.charging_time = 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
+}  // namespace device