[DeviceService] Expose battery monitoring solely via the Device Service

services/device/battery/battery_status_manager_mac.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 "device/battery/battery_status_manager.h"
+#include "services/device/battery/battery_status_manager.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/ps/IOPSKeys.h>
 #include <IOKit/ps/IOPowerSources.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_cftyperef.h"
@@ skipping 32 matching lines @@
   return boolean ? CFBooleanGetValue(boolean) : default_value;
 }
 
 bool CFStringsAreEqual(CFStringRef string1, CFStringRef string2) {
   if (!string1 || !string2)
     return false;
   return CFStringCompare(string1, string2, 0) == kCFCompareEqualTo;
 }
 
 void UpdateNumberBatteriesHistogram(int count) {
-  UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "BatteryStatus.NumberBatteriesMac", count, 1, 5, 6);
+  UMA_HISTOGRAM_CUSTOM_COUNTS("BatteryStatus.NumberBatteriesMac", count, 1, 5,
+                              6);
 }
 
 void FetchBatteryStatus(CFDictionaryRef description,
                         mojom::BatteryStatus* status) {
-  CFStringRef current_state =
-      base::mac::GetValueFromDictionary<CFStringRef>(description,
-          CFSTR(kIOPSPowerSourceStateKey));
+  CFStringRef current_state = base::mac::GetValueFromDictionary<CFStringRef>(
+      description, CFSTR(kIOPSPowerSourceStateKey));
 
   bool on_battery_power =
       CFStringsAreEqual(current_state, CFSTR(kIOPSBatteryPowerValue));
   bool is_charging =
       GetValueAsBoolean(description, CFSTR(kIOPSIsChargingKey), true);
   bool is_charged =
       GetValueAsBoolean(description, CFSTR(kIOPSIsChargedKey), false);
 
   status->charging = !on_battery_power || is_charging;
 
   SInt64 current_capacity =
       GetValueAsSInt64(description, CFSTR(kIOPSCurrentCapacityKey), -1);
   SInt64 max_capacity =
       GetValueAsSInt64(description, CFSTR(kIOPSMaxCapacityKey), -1);
 
   // Set level if it is available and valid. Otherwise leave the default value,
   // which is 1.
   if (current_capacity != -1 && max_capacity != -1 &&
       current_capacity <= max_capacity && max_capacity != 0) {
     status->level = current_capacity / static_cast<double>(max_capacity);
   }
 
   if (is_charging) {
     SInt64 charging_time =
         GetValueAsSInt64(description, CFSTR(kIOPSTimeToFullChargeKey), -1);
 
     // Battery is charging: set the charging time if it's available, otherwise
     // set to +infinity.
-    status->charging_time = charging_time != -1
-        ? base::TimeDelta::FromMinutes(charging_time).InSeconds()
-        : std::numeric_limits<double>::infinity();
+    status->charging_time =
+        charging_time != -1
+            ? base::TimeDelta::FromMinutes(charging_time).InSeconds()
+            : std::numeric_limits<double>::infinity();
   } else {
     // Battery is not charging.
     // Set chargingTime to +infinity if the battery is not charged. Otherwise
     // leave the default value, which is 0.
     if (!is_charged)
       status->charging_time = std::numeric_limits<double>::infinity();
 
     // Set dischargingTime if it's available and valid, i.e. when on battery
     // power. Otherwise leave the default value, which is +infinity.
     if (on_battery_power) {
       SInt64 discharging_time =
           GetValueAsSInt64(description, CFSTR(kIOPSTimeToEmptyKey), -1);
       if (discharging_time != -1) {
         status->discharging_time =
             base::TimeDelta::FromMinutes(discharging_time).InSeconds();
       }
     }
   }
 }
 
 std::vector<mojom::BatteryStatus> GetInternalBatteriesStates() {
   std::vector<mojom::BatteryStatus> internal_sources;
 
   base::ScopedCFTypeRef<CFTypeRef> info(IOPSCopyPowerSourcesInfo());
   base::ScopedCFTypeRef<CFArrayRef> power_sources_list(
       IOPSCopyPowerSourcesList(info));
   CFIndex count = CFArrayGetCount(power_sources_list);
 
   for (CFIndex i = 0; i < count; ++i) {
-    CFDictionaryRef description = IOPSGetPowerSourceDescription(info,
-        CFArrayGetValueAtIndex(power_sources_list, i));
+    CFDictionaryRef description = IOPSGetPowerSourceDescription(
+        info, CFArrayGetValueAtIndex(power_sources_list, i));
 
     if (!description)
       continue;
 
-    CFStringRef transport_type =
-        base::mac::GetValueFromDictionary<CFStringRef>(description,
-            CFSTR(kIOPSTransportTypeKey));
+    CFStringRef transport_type = base::mac::GetValueFromDictionary<CFStringRef>(
+        description, CFSTR(kIOPSTransportTypeKey));
 
     bool internal_source =
         CFStringsAreEqual(transport_type, CFSTR(kIOPSInternalType));
     bool source_present =
         GetValueAsBoolean(description, CFSTR(kIOPSIsPresentKey), false);
 
     if (internal_source && source_present) {
       mojom::BatteryStatus status;
       FetchBatteryStatus(description, &status);
       internal_sources.push_back(status);
@@ skipping 22 matching lines @@
  public:
   explicit BatteryStatusObserver(const BatteryCallback& callback)
       : callback_(callback) {}
 
   ~BatteryStatusObserver() { DCHECK(!notifier_run_loop_source_); }
 
   void Start() {
     if (notifier_run_loop_source_)
       return;
 
-    notifier_run_loop_source_.reset(
-        IOPSNotificationCreateRunLoopSource(CallOnBatteryStatusChanged,
-                                            static_cast<void*>(&callback_)));
+    notifier_run_loop_source_.reset(IOPSNotificationCreateRunLoopSource(
+        CallOnBatteryStatusChanged, static_cast<void*>(&callback_)));
     if (!notifier_run_loop_source_) {
       LOG(ERROR) << "Failed to create battery status notification run loop";
       // Make sure to execute to callback with the default values.
       callback_.Run(mojom::BatteryStatus());
       return;
     }
 
     CallOnBatteryStatusChanged(static_cast<void*>(&callback_));
     CFRunLoopAddSource(CFRunLoopGetCurrent(), notifier_run_loop_source_,
                        kCFRunLoopDefaultMode);
@@ skipping 26 matching lines @@
       : notifier_(new BatteryStatusObserver(callback)) {}
 
   ~BatteryStatusManagerMac() override { notifier_->Stop(); }
 
   // BatteryStatusManager:
   bool StartListeningBatteryChange() override {
     notifier_->Start();
     return true;
   }
 
-  void StopListeningBatteryChange() override {
-    notifier_->Stop();
-  }
+  void StopListeningBatteryChange() override { notifier_->Stop(); }
 
  private:
   std::unique_ptr<BatteryStatusObserver> notifier_;
 
   DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerMac);
 };
 
-} // end namespace
+}  // end namespace
 
 // static
 std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
   return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerMac(callback));
 }
 
 }  // namespace device