bluetooth: Move histogram related code to its own file

content/browser/bluetooth/bluetooth_metrics.cc

Index: content/browser/bluetooth/bluetooth_metrics.cc
diff --git a/content/browser/bluetooth/bluetooth_metrics.cc b/content/browser/bluetooth/bluetooth_metrics.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fcb819916b7e4ad2d0f8f90458468de5909f3aeb
--- /dev/null
+++ b/content/browser/bluetooth/bluetooth_metrics.cc
@@ -0,0 +1,136 @@
+// Copyright 2015 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/bluetooth/bluetooth_metrics.h"
+
+#include <map>
+#include <set>
+#include "base/hash.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/metrics/sparse_histogram.h"
+#include "content/common/bluetooth/bluetooth_scan_filter.h"
+#include "device/bluetooth/bluetooth_uuid.h"
+
+using device::BluetoothUUID;
+
+namespace {
+// TODO(ortuno): Remove once we have a macro to histogram strings.
+// http://crbug.com/520284
+int HashUUID(const std::string& uuid) {
+  uint32 data = base::SuperFastHash(uuid.data(), uuid.size());
+
+  // Strip off the signed bit because UMA doesn't support negative values,
+  // but takes a signed int as input.
+  return static_cast<int>(data & 0x7fffffff);
+}
+}  // namespace
+
+namespace content {
+
+// General
+
+void RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction function) {
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.Web.FunctionCall.Count",
+                            static_cast<int>(function),
+                            static_cast<int>(UMAWebBluetoothFunction::COUNT));
+}
+
+// requestDevice()
+
+void RecordRequestDeviceOutcome(UMARequestDeviceOutcome outcome) {
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.Web.RequestDevice.Outcome",
+                            static_cast<int>(outcome),
+                            static_cast<int>(UMARequestDeviceOutcome::COUNT));
+}
+
+static void RecordRequestDeviceFilters(
+    const std::vector<content::BluetoothScanFilter>& filters) {
+  UMA_HISTOGRAM_COUNTS_100("Bluetooth.Web.RequestDevice.Filters.Count",
+                           filters.size());
+  for (const content::BluetoothScanFilter& filter : filters) {
+    UMA_HISTOGRAM_COUNTS_100("Bluetooth.Web.RequestDevice.FilterSize",
+                             filter.services.size());
+    for (const BluetoothUUID& service : filter.services) {
+      // TODO(ortuno): Use a macro to histogram strings.
+      // http://crbug.com/520284
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Bluetooth.Web.RequestDevice.Filters.Services",
+          HashUUID(service.canonical_value()));
+    }
+  }
+}
+
+static void RecordRequestDeviceOptionalServices(
+    const std::vector<BluetoothUUID>& optional_services) {
+  UMA_HISTOGRAM_COUNTS_100("Bluetooth.Web.RequestDevice.OptionalServices.Count",
+                           optional_services.size());
+  for (const BluetoothUUID& service : optional_services) {
+    // TODO(ortuno): Use a macro to histogram strings.
+    // http://crbug.com/520284
+    UMA_HISTOGRAM_SPARSE_SLOWLY(
+        "Bluetooth.Web.RequestDevice.OptionalServices.Services",
+        HashUUID(service.canonical_value()));
+  }
+}
+
+static void RecordUnionOfServices(
+    const std::vector<content::BluetoothScanFilter>& filters,
+    const std::vector<BluetoothUUID>& optional_services) {
+  std::set<BluetoothUUID> union_of_services(optional_services.begin(),
+                                            optional_services.end());
+
+  for (const content::BluetoothScanFilter& filter : filters)
+    union_of_services.insert(filter.services.begin(), filter.services.end());
+
+  UMA_HISTOGRAM_COUNTS_100("Bluetooth.Web.RequestDevice.UnionOfServices.Count",
+                           union_of_services.size());
+}
+
+void RecordRequestDeviceArguments(
+    const std::vector<content::BluetoothScanFilter>& filters,
+    const std::vector<device::BluetoothUUID>& optional_services) {
+  RecordRequestDeviceFilters(filters);
+  RecordRequestDeviceOptionalServices(optional_services);
+  RecordUnionOfServices(filters, optional_services);
+}
+
+// connectGATT
+
+void RecordConnectGATTOutcome(UMAConnectGATTOutcome outcome) {
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.Web.ConnectGATT.Outcome",
+                            static_cast<int>(outcome),
+                            static_cast<int>(UMAConnectGATTOutcome::COUNT));
+}
+
+void RecordConnectGATTTimeSuccess(const base::TimeDelta& duration) {
+  UMA_HISTOGRAM_MEDIUM_TIMES("Bluetooth.Web.ConnectGATT.TimeSuccess", duration);
+}
+
+void RecordConnectGATTTimeFailed(const base::TimeDelta& duration) {
+  UMA_HISTOGRAM_MEDIUM_TIMES("Bluetooth.Web.ConnectGATT.TimeFailed", duration);
+}
+
+// getPrimaryService
+
+void RecordGetPrimaryServiceService(const BluetoothUUID& service) {
+  // TODO(ortuno): Use a macro to histogram strings.
+  // http://crbug.com/520284
+  UMA_HISTOGRAM_SPARSE_SLOWLY("Bluetooth.Web.GetPrimaryService.Services",
+                              HashUUID(service.canonical_value()));
+}
+
+void RecordGetPrimaryServiceOutcome(UMAGetPrimaryServiceOutcome outcome) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "Bluetooth.Web.GetPrimaryService.Outcome", static_cast<int>(outcome),
+      static_cast<int>(UMAGetPrimaryServiceOutcome::COUNT));
+}
+
+// read/write characteristic
+
+void RecordGATTError(UMAGATTError error) {
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.GATTErrors", static_cast<int>(error),
+                            static_cast<int>(UMAGATTError::MAX_ERROR));
+}
+
+}  // namespace content