Replace Chrome IPC with Mojo IPC for querying BatteryStatus service

device/battery/battery_status_manager_linux.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_linux.h"
+#include "device/battery/battery_status_manager_linux.h"
 
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
-#include "content/browser/battery_status/battery_status_manager.h"
-#include "content/public/browser/browser_thread.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/property.h"
 #include "dbus/values_util.h"
+#include "device/battery/battery_status_manager.h"
 
-namespace content {
+namespace device {
 
 namespace {
 
 const char kUPowerServiceName[] = "org.freedesktop.UPower";
 const char kUPowerDeviceName[] = "org.freedesktop.UPower.Device";
 const char kUPowerPath[] = "/org/freedesktop/UPower";
 const char kUPowerDeviceSignalChanged[] = "Changed";
 const char kUPowerEnumerateDevices[] = "EnumerateDevices";
 const char kBatteryNotifierThreadName[] = "BatteryStatusNotifier";
 
@@ skipping 75 matching lines @@
 // obtain battery information and receives battery change notifications.
 class BatteryStatusNotificationThread : public base::Thread {
  public:
   BatteryStatusNotificationThread(
       const BatteryStatusService::BatteryUpdateCallback& callback)
       : base::Thread(kBatteryNotifierThreadName),
         callback_(callback),
         battery_proxy_(NULL) {}
 
   virtual ~BatteryStatusNotificationThread() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
     // Make sure to shutdown the dbus connection if it is still open in the very
     // end. It needs to happen on the BatteryStatusNotificationThread.
     message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&BatteryStatusNotificationThread::ShutdownDBusConnection,
                    base::Unretained(this)));
 
     // Drain the message queue of the BatteryStatusNotificationThread and stop.
     Stop();
   }
@@ skipping 40 matching lines @@
                      << "using status data of the first battery only.";
       } else {
         battery_proxy_ = device_proxy;
       }
       num_batteries++;
     }
 
     UpdateNumberBatteriesHistogram(num_batteries);
 
     if (!battery_proxy_) {
-      callback_.Run(blink::WebBatteryStatus());
+      callback_.Run(BatteryStatus());
       return;
     }
 
     battery_proxy_->ConnectToSignal(
         kUPowerDeviceName,
         kUPowerDeviceSignalChanged,
         base::Bind(&BatteryStatusNotificationThread::BatteryChanged,
                    base::Unretained(this)),
         base::Bind(&BatteryStatusNotificationThread::OnSignalConnected,
                    base::Unretained(this)));
@@ skipping 44 matching lines @@
     }
 
     if (!system_bus_.get())
       return;
 
     if (success) {
       BatteryChanged(NULL);
     } else {
       // Failed to register for "Changed" signal, execute callback with the
       // default values.
-      callback_.Run(blink::WebBatteryStatus());
+      callback_.Run(BatteryStatus());
     }
   }
 
   void BatteryChanged(dbus::Signal* signal /* unsused */) {
     DCHECK(OnWatcherThread());
 
     if (!system_bus_.get())
       return;
 
     scoped_ptr<base::DictionaryValue> dictionary =
         GetPropertiesAsDictionary(battery_proxy_);
     if (dictionary)
       callback_.Run(ComputeWebBatteryStatus(*dictionary));
     else
-      callback_.Run(blink::WebBatteryStatus());
+      callback_.Run(BatteryStatus());
   }
 
   BatteryStatusService::BatteryUpdateCallback callback_;
   scoped_refptr<dbus::Bus> system_bus_;
   dbus::ObjectProxy* battery_proxy_;  // owned by the bus
 
   DISALLOW_COPY_AND_ASSIGN(BatteryStatusNotificationThread);
 };
 
-// Runs on IO thread and creates a notification thread and delegates Start/Stop
-// calls to it.
+// Creates a notification thread and delegates Start/Stop calls to it.
 class BatteryStatusManagerLinux : public BatteryStatusManager {
  public:
   explicit BatteryStatusManagerLinux(
       const BatteryStatusService::BatteryUpdateCallback& callback)
       : callback_(callback) {}
 
   virtual ~BatteryStatusManagerLinux() {}
 
  private:
   // BatteryStatusManager:
   virtual bool StartListeningBatteryChange() OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
     if (!StartNotifierThreadIfNecessary())
       return false;
 
     notifier_thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&BatteryStatusNotificationThread::StartListening,
                    base::Unretained(notifier_thread_.get())));
     return true;
   }
 
   virtual void StopListeningBatteryChange() OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
     if (!notifier_thread_)
       return;
 
     notifier_thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&BatteryStatusNotificationThread::StopListening,
                    base::Unretained(notifier_thread_.get())));
   }
 
   // Starts the notifier thread if not already started and returns true on
@@ skipping 14 matching lines @@
   }
 
   BatteryStatusService::BatteryUpdateCallback callback_;
   scoped_ptr<BatteryStatusNotificationThread> notifier_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerLinux);
 };
 
 }  // namespace
 
-blink::WebBatteryStatus ComputeWebBatteryStatus(
+BatteryStatus ComputeWebBatteryStatus(
     const base::DictionaryValue& dictionary) {
-  blink::WebBatteryStatus status;
+  BatteryStatus status;
   if (!dictionary.HasKey("State"))
     return status;
 
   uint32 state = static_cast<uint32>(
       GetPropertyAsDouble(dictionary, "State", UPOWER_DEVICE_STATE_UNKNOWN));
   status.charging = state != UPOWER_DEVICE_STATE_DISCHARGING &&
                     state != UPOWER_DEVICE_STATE_EMPTY;
   double percentage = GetPropertyAsDouble(dictionary, "Percentage", 100);
   // Convert percentage to a value between 0 and 1 with 2 digits of precision.
   // This is to bring it in line with other platforms like Mac and Android where
   // we report level with 1% granularity. It also serves the purpose of reducing
   // the possibility of fingerprinting and triggers less level change events on
   // the blink side.
   // TODO(timvolodine): consider moving this rounding to the blink side.
   status.level = round(percentage) / 100.f;
 
   switch (state) {
     case UPOWER_DEVICE_STATE_CHARGING : {
       double time_to_full = GetPropertyAsDouble(dictionary, "TimeToFull", 0);
-      status.chargingTime =
+      status.charging_time =
           (time_to_full > 0) ? time_to_full
                              : std::numeric_limits<double>::infinity();
       break;
     }
     case UPOWER_DEVICE_STATE_DISCHARGING : {
       double time_to_empty = GetPropertyAsDouble(dictionary, "TimeToEmpty", 0);
       // Set dischargingTime if it's available. Otherwise leave the default
       // value which is +infinity.
       if (time_to_empty > 0)
-        status.dischargingTime = time_to_empty;
-      status.chargingTime = std::numeric_limits<double>::infinity();
+        status.discharging_time = time_to_empty;
+      status.charging_time = std::numeric_limits<double>::infinity();
       break;
     }
     case UPOWER_DEVICE_STATE_FULL : {
       break;
     }
     default: {
-      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 BatteryStatusManagerLinux(callback));
 }
 
-}  // namespace content
+}  // namespace device