Bluetooth: gather usage metrics

chrome/browser/metrics/metrics_log.cc

 // Copyright (c) 2012 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 "chrome/browser/metrics/metrics_log.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/perftimer.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
@@ skipping 15 matching lines @@
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/metrics/proto/omnibox_event.pb.h"
 #include "chrome/common/metrics/proto/profiler_event.pb.h"
 #include "chrome/common/metrics/proto/system_profile.pb.h"
 #include "chrome/common/metrics/variations/variations_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/gpu_info.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/bluetooth_device.h"
 #include "googleurl/src/gurl.h"
 #include "ui/gfx/screen.h"
 #include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 #define OPEN_ELEMENT_FOR_SCOPE(name) ScopedElement scoped_element(this, name)
 
@@ skipping 239 matching lines @@
             reinterpret_cast<LPARAM>(&si))) {
       hardware->set_max_dpi_x(si.max_dpi_x);
       hardware->set_max_dpi_y(si.max_dpi_y);
     }
     ReleaseDC(GetDesktopWindow(), desktop_dc);
   }
 }
 
 #endif  // defined(OS_WIN)
 
+#if defined(OS_CHROMEOS)
+SystemProfileProto::Hardware::Bluetooth::PairedDevice::Type
+AsBluetoothDeviceType(
+    enum device::BluetoothDevice::DeviceType device_type) {
+  switch (device_type) {
+    case device::BluetoothDevice::DEVICE_UNKNOWN:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_UNKNOWN;
+    case device::BluetoothDevice::DEVICE_COMPUTER:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_COMPUTER;
+    case device::BluetoothDevice::DEVICE_PHONE:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_PHONE;
+    case device::BluetoothDevice::DEVICE_MODEM:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_MODEM;
+    case device::BluetoothDevice::DEVICE_AUDIO:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_AUDIO;
+    case device::BluetoothDevice::DEVICE_CAR_AUDIO:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_CAR_AUDIO;
+    case device::BluetoothDevice::DEVICE_VIDEO:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_VIDEO;
+    case device::BluetoothDevice::DEVICE_PERIPHERAL:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_PERIPHERAL;
+    case device::BluetoothDevice::DEVICE_JOYSTICK:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_JOYSTICK;
+    case device::BluetoothDevice::DEVICE_GAMEPAD:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_GAMEPAD;
+    case device::BluetoothDevice::DEVICE_KEYBOARD:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_KEYBOARD;
+    case device::BluetoothDevice::DEVICE_MOUSE:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_MOUSE;
+    case device::BluetoothDevice::DEVICE_TABLET:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_TABLET;
+    case device::BluetoothDevice::DEVICE_KEYBOARD_MOUSE_COMBO:
+      return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+          DEVICE_KEYBOARD_MOUSE_COMBO;
+  }
+
+  NOTREACHED();
+  return SystemProfileProto::Hardware::Bluetooth::PairedDevice::
+      DEVICE_UNKNOWN;
+}
+#endif  // defined(OS_CHROMEOS)
+
 }  // namespace
 
 GoogleUpdateMetrics::GoogleUpdateMetrics() : is_system_install(false) {}
 
 GoogleUpdateMetrics::~GoogleUpdateMetrics() {}
 
 static base::LazyInstance<std::string>::Leaky
   g_version_extension = LAZY_INSTANCE_INITIALIZER;
 
 MetricsLog::MetricsLog(const std::string& client_id, int session_id)
-    : MetricsLogBase(client_id, session_id, MetricsLog::GetVersionString()) {}
+    : MetricsLogBase(client_id, session_id, MetricsLog::GetVersionString()),
+      weak_ptr_factory_(this) {}
 
 MetricsLog::~MetricsLog() {}
 
 // static
 void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(prefs::kStabilityPluginStats);
 }
 
 // static
 int64 MetricsLog::GetIncrementalUptime(PrefService* pref) {
@@ skipping 543 matching lines @@
   WritePluginList(plugin_list, write_as_xml);
 
   std::vector<ActiveGroupId> field_trial_ids;
   GetFieldTrialIds(&field_trial_ids);
   WriteFieldTrials(field_trial_ids, system_profile);
 
 #if defined(OS_CHROMEOS)
   PerfDataProto perf_data_proto;
   if (perf_provider_.GetPerfData(&perf_data_proto))
     uma_proto()->add_perf_data()->Swap(&perf_data_proto);
+
+  device::BluetoothAdapterFactory::GetAdapter(
+      base::Bind(&MetricsLog::WriteBluetoothProto,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 hardware));

[Ilya Sherman, 2013/04/23 00:09:43]

Sorry, I should have caught this in the previous round of review: If this call
is asynchronous, then there's a really good chance -- possibly a 100% chance --
that it will come in too late to make it into the protocol buffer that's
uploaded to the server.  Generally, any asynchronous fetching of data is handled
by the MetricsService class.

[keybuk, 2013/04/23 00:41:42]

On Chrome OS it's guaranteed to be 100% synchronous, the common method only
appears to be async for the benfit of Windows and OS X where we're not
collecting these metrics.

The MetricsService doesn't use SystemProfileProto, nor any protobuf that I could
see, which is why I opted for the MetricsLog approach with the Chrome OS-only
guard

 #endif
 }
 
 void MetricsLog::RecordProfilerData(
     const tracked_objects::ProcessDataSnapshot& process_data,
     int process_type) {
   DCHECK(!locked());
 
   if (tracked_objects::GetTimeSourceType() !=
           tracked_objects::TIME_SOURCE_TYPE_WALL_TIME) {
@@ skipping 190 matching lines @@
     ProductDataToProto(google_update_metrics.google_update_data,
                        google_update->mutable_google_update_status());
   }
 
   if (!google_update_metrics.product_data.version.empty()) {
     ProductDataToProto(google_update_metrics.product_data,
                        google_update->mutable_client_status());
   }
 #endif  // defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN)
 }
+
+void MetricsLog::WriteBluetoothProto(
+    SystemProfileProto::Hardware* hardware,
+    scoped_refptr<device::BluetoothAdapter> adapter) {
+#if defined(OS_CHROMEOS)
+  SystemProfileProto::Hardware::Bluetooth* bluetooth =
+      hardware->mutable_bluetooth();
+
+  bluetooth->set_is_present(adapter->IsPresent());
+  bluetooth->set_is_enabled(adapter->IsPowered());
+
+  device::BluetoothAdapter::DeviceList devices = adapter->GetDevices();
+  for (device::BluetoothAdapter::DeviceList::iterator iter =
+           devices.begin(); iter != devices.end(); ++iter) {
+    SystemProfileProto::Hardware::Bluetooth::PairedDevice* paired_device =
+        bluetooth->add_paired_device();
+
+    device::BluetoothDevice* device = *iter;
+    paired_device->set_bluetooth_class(device->GetBluetoothClass());
+    paired_device->set_type(AsBluetoothDeviceType(device->GetDeviceType()));
+
+    // address is xx:xx:xx:xx:xx:xx, extract the first three components and
+    // pack into a uint32
+    std::string address = device->GetAddress();
+    if (address.length() > 9 &&
+        address[2] == ':' && address[5] == ':' && address[8] == ':') {
+      uint32 vendor_prefix = 0;
+
+      uint64 component = 0;
+      base::HexStringToUInt64(address.substr(0, 2), &component);
+      vendor_prefix |= component << 16;
+
+      component = 0;
+      base::HexStringToUInt64(address.substr(3, 2), &component);
+      vendor_prefix |= component << 8;
+
+      component = 0;
+      base::HexStringToUInt64(address.substr(6, 2), &component);
+      vendor_prefix |= component;

[Ilya Sherman, 2013/04/23 00:09:43]

Rather than calling HexStringToUInt64 three times, could you just trim out the
colons and call HexStringToUInt64 a single time on the trimmed string?

[keybuk, 2013/04/23 00:41:42]

Done.

+
+      paired_device->set_vendor_prefix(vendor_prefix);
+    }
+
+    paired_device->set_vendor_id(device->GetVendorID());
+    paired_device->set_product_id(device->GetProductID());
+    paired_device->set_device_id(device->GetDeviceID());
+  }
+#endif  // defined(OS_CHROMEOS)
+}