Battery Status API: add UMA logging for Mac.

content/browser/battery_status/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 "content/browser/battery_status/battery_status_manager.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/ps/IOPowerSources.h>
 #include <IOKit/ps/IOPSKeys.h>
 
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/ref_counted.h"
+#include "base/metrics/histogram.h"
 #include "base/time/time.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/WebKit/public/platform/WebBatteryStatus.h"
 
 namespace content {
 
 namespace {
 
 typedef BatteryStatusService::BatteryUpdateCallback BatteryCallback;
 
@@ skipping 21 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);
+}
+
 void FetchBatteryStatus(CFDictionaryRef description,
                         blink::WebBatteryStatus& 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);
@@ skipping 44 matching lines @@
 }
 
 void OnBatteryStatusChanged(const BatteryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   blink::WebBatteryStatus status;
   base::ScopedCFTypeRef<CFTypeRef> info(IOPSCopyPowerSourcesInfo());
   base::ScopedCFTypeRef<CFArrayRef> power_sources_list(
       IOPSCopyPowerSourcesList(info));
   CFIndex count = CFArrayGetCount(power_sources_list);
 
-  bool internal_source_found = false;
+  int num_internal_sources = 0;
 
   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) {
       // 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(!internal_source_found);
+      DCHECK(num_internal_sources == 0);
       FetchBatteryStatus(description, status);
-      internal_source_found = true;
+      num_internal_sources++;
     }
   }
 
+  UpdateNumberBatteriesHistogram(num_internal_sources);
   callback.Run(status);
 }
 
 class BatteryStatusObserver
     : public base::RefCountedThreadSafe<BatteryStatusObserver> {
  public:
   explicit BatteryStatusObserver(const BatteryCallback& callback)
       : callback_(callback) {}
 
   void Start() {
@@ skipping 102 matching lines @@
 } // end namespace
 
 // static
 scoped_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
   return scoped_ptr<BatteryStatusManager>(
       new BatteryStatusManagerMac(callback));
 }
 
 }  // namespace content