Add '.mojom' suffix for battery mojom modules.

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 <CoreFoundation/CoreFoundation.h>
 #include <IOKit/ps/IOPSKeys.h>
 #include <IOKit/ps/IOPowerSources.h>
 
@@ skipping 41 matching lines @@
   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);
 }
 
-void FetchBatteryStatus(CFDictionaryRef description, BatteryStatus* status) {
+void FetchBatteryStatus(CFDictionaryRef description,
+                        mojom::BatteryStatus* status) {
   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);
@@ skipping 34 matching lines @@
       SInt64 discharging_time =
           GetValueAsSInt64(description, CFSTR(kIOPSTimeToEmptyKey), -1);
       if (discharging_time != -1) {
         status->discharging_time =
             base::TimeDelta::FromMinutes(discharging_time).InSeconds();
       }
     }
   }
 }
 
-std::vector<BatteryStatus> GetInternalBatteriesStates() {
-  std::vector<BatteryStatus> internal_sources;
+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));
 
     if (!description)
       continue;
 
     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) {
-      BatteryStatus status;
+      mojom::BatteryStatus status;
       FetchBatteryStatus(description, &status);
       internal_sources.push_back(status);
     }
   }
 
   return internal_sources;
 }
 
 void OnBatteryStatusChanged(const BatteryCallback& callback) {
-  std::vector<BatteryStatus> batteries(GetInternalBatteriesStates());
+  std::vector<mojom::BatteryStatus> batteries(GetInternalBatteriesStates());
 
   if (batteries.empty()) {
-    callback.Run(BatteryStatus());
+    callback.Run(mojom::BatteryStatus());
     return;
   }
 
   // TODO(timvolodine): implement the case when there are multiple internal
   // sources, e.g. when multiple batteries are present. Currently this will
   // fail a DCHECK.
   DCHECK(batteries.size() == 1);
   callback.Run(batteries.front());
 }
 
 class BatteryStatusObserver {
  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_)));
     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(BatteryStatus());
+      callback_.Run(mojom::BatteryStatus());
       return;
     }
 
     CallOnBatteryStatusChanged(static_cast<void*>(&callback_));
     CFRunLoopAddSource(CFRunLoopGetCurrent(), notifier_run_loop_source_,
                        kCFRunLoopDefaultMode);
     UpdateNumberBatteriesHistogram(GetInternalBatteriesStates().size());
   }
 
   void Stop() {
@@ skipping 42 matching lines @@
 } // end namespace
 
 // static
 std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
   return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerMac(callback));
 }
 
 }  // namespace device