Bluetooth: gather usage metrics

device/bluetooth/bluetooth_device_experimental_chromeos.cc

 // Copyright (c) 2013 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/bluetooth/bluetooth_device_experimental_chromeos.h"
 
 #include "base/bind.h"
+#include "base/metrics/histogram.h"
+#include "base/string_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/experimental_bluetooth_adapter_client.h"
 #include "chromeos/dbus/experimental_bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/experimental_bluetooth_agent_service_provider.h"
 #include "chromeos/dbus/experimental_bluetooth_device_client.h"
 #include "chromeos/dbus/experimental_bluetooth_input_client.h"
 #include "dbus/bus.h"
 #include "device/bluetooth/bluetooth_adapter_experimental_chromeos.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using device::BluetoothDevice;
 
 namespace {
 
 // The agent path is relatively meaningless since BlueZ only supports one
 // at time and will fail in an attempt to register another with "Already Exists"
 // (which we fail in OnRegisterAgentError with ERROR_INPROGRESS).
 const char kAgentPath[] = "/org/chromium/bluetooth_agent";
 
+// Histogram enumerations for pairing methods.
+enum UMAPairingMethod {
+  UMA_PAIRING_METHOD_NONE,
+  UMA_PAIRING_METHOD_REQUEST_PINCODE,
+  UMA_PAIRING_METHOD_REQUEST_PASSKEY,
+  UMA_PAIRING_METHOD_DISPLAY_PINCODE,
+  UMA_PAIRING_METHOD_DISPLAY_PASSKEY,
+  UMA_PAIRING_METHOD_CONFIRM_PASSKEY,
+  // NOTE: Add new pairing methods immediately above this line. Make sure to
+  // update the enum list in tools/histogram/histograms.xml accordinly.
+  UMA_PAIRING_METHOD_COUNT
+};
+
+// Histogram enumerations for pairing results.
+enum UMAPairingResult {
+  UMA_PAIRING_RESULT_SUCCESS,
+  UMA_PAIRING_RESULT_INPROGRESS,
+  UMA_PAIRING_RESULT_FAILED,
+  UMA_PAIRING_RESULT_AUTH_FAILED,
+  UMA_PAIRING_RESULT_AUTH_CANCELED,
+  UMA_PAIRING_RESULT_AUTH_REJECTED,
+  UMA_PAIRING_RESULT_AUTH_TIMEOUT,
+  UMA_PAIRING_RESULT_UNSUPPORTED_DEVICE,
+  UMA_PAIRING_RESULT_UNKNOWN_ERROR,
+  // NOTE: Add new pairing results immediately above this line. Make sure to
+  // update the enum list in tools/histogram/histograms.xml accordinly.
+  UMA_PAIRING_RESULT_COUNT
+};
+
+void ParseModalias(const dbus::ObjectPath& object_path,
+                   uint16 *vendor_id,
+                   uint16 *product_id,
+                   uint16 *device_id) {
+  chromeos::ExperimentalBluetoothDeviceClient::Properties* properties =
+      chromeos::DBusThreadManager::Get()->
+          GetExperimentalBluetoothDeviceClient()->GetProperties(object_path);
+  DCHECK(properties);
+
+  std::string modalias = properties->modalias.value();
+  if (StartsWithASCII(modalias, "usb:", false) && modalias.length() == 19) {
+    // usb:vXXXXpXXXXdXXXX
+    if (modalias[4] == 'v' && vendor_id != NULL) {
+      uint64 component = 0;
+      base::HexStringToUInt64(modalias.substr(5, 4), &component);
+      *vendor_id = component;
+    }
+
+    if (modalias[9] == 'p' && product_id != NULL) {
+      uint64 component = 0;
+      base::HexStringToUInt64(modalias.substr(10, 4), &component);
+      *product_id = component;
+    }
+
+    if (modalias[14] == 'd' && device_id != NULL) {
+      uint64 component = 0;
+      base::HexStringToUInt64(modalias.substr(15, 4), &component);
+      *device_id = component;
+    }
+  }
+}
+
 }  // namespace
 
 namespace chromeos {
 
 BluetoothDeviceExperimentalChromeOS::BluetoothDeviceExperimentalChromeOS(
     BluetoothAdapterExperimentalChromeOS* adapter,
     const dbus::ObjectPath& object_path)
     : adapter_(adapter),
       object_path_(object_path),
       num_connecting_calls_(0),
       pairing_delegate_(NULL),
+      pairing_delegate_used_(false),
       weak_ptr_factory_(this) {
 }
 
 BluetoothDeviceExperimentalChromeOS::~BluetoothDeviceExperimentalChromeOS() {
 }
 
 uint32 BluetoothDeviceExperimentalChromeOS::GetBluetoothClass() const {
   ExperimentalBluetoothDeviceClient::Properties* properties =
       DBusThreadManager::Get()->GetExperimentalBluetoothDeviceClient()->
           GetProperties(object_path_);
@@ skipping 13 matching lines @@
 
 std::string BluetoothDeviceExperimentalChromeOS::GetAddress() const {
   ExperimentalBluetoothDeviceClient::Properties* properties =
       DBusThreadManager::Get()->GetExperimentalBluetoothDeviceClient()->
           GetProperties(object_path_);
   DCHECK(properties);
 
   return properties->address.value();
 }
 
+uint16 BluetoothDeviceExperimentalChromeOS::GetVendorID() const {
+  uint16 vendor_id  = 0;
+  ParseModalias(object_path_, &vendor_id, NULL, NULL);
+  return vendor_id;
+}
+
+uint16 BluetoothDeviceExperimentalChromeOS::GetProductID() const {
+  uint16 product_id  = 0;
+  ParseModalias(object_path_, NULL, &product_id, NULL);
+  return product_id;
+}
+
+uint16 BluetoothDeviceExperimentalChromeOS::GetDeviceID() const {
+  uint16 device_id  = 0;
+  ParseModalias(object_path_, NULL, NULL, &device_id);
+  return device_id;
+}
+
 bool BluetoothDeviceExperimentalChromeOS::IsPaired() const {
   ExperimentalBluetoothDeviceClient::Properties* properties =
       DBusThreadManager::Get()->GetExperimentalBluetoothDeviceClient()->
           GetProperties(object_path_);
   DCHECK(properties);
 
   // Trusted devices are devices that don't support pairing but that the
   // user has explicitly connected; it makes no sense for UI purposes to
   // treat them differently from each other.
   return properties->paired.value() || properties->trusted.value();
@@ skipping 72 matching lines @@
 
   if (IsPaired() || IsConnected() || !pairing_delegate || !IsPairable()) {
     // No need to pair, or unable to, skip straight to connection.
     ConnectInternal(callback, error_callback);
   } else {
     // Initiate high-security connection with pairing.
     DCHECK(!pairing_delegate_);
     DCHECK(agent_.get() == NULL);
 
     pairing_delegate_ = pairing_delegate;
+    pairing_delegate_used_ = false;
 
     // The agent path is relatively meaningless since BlueZ only supports
     // one per application at a time.
     dbus::Bus* system_bus = DBusThreadManager::Get()->GetSystemBus();
     agent_.reset(ExperimentalBluetoothAgentServiceProvider::Create(
         system_bus, dbus::ObjectPath(kAgentPath), this));
     DCHECK(agent_.get());
 
     VLOG(1) << object_path_.value() << ": Registering agent for pairing";
     DBusThreadManager::Get()->GetExperimentalBluetoothAgentManagerClient()->
@@ skipping 128 matching lines @@
   UnregisterAgent();
 }
 
 void BluetoothDeviceExperimentalChromeOS::RequestPinCode(
     const dbus::ObjectPath& device_path,
     const PinCodeCallback& callback) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
   VLOG(1) << object_path_.value() << ": RequestPinCode";
 
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingMethod",
+                            UMA_PAIRING_METHOD_REQUEST_PINCODE,
+                            UMA_PAIRING_METHOD_COUNT);
+
   DCHECK(pairing_delegate_);
   DCHECK(pincode_callback_.is_null());
   pincode_callback_ = callback;
   pairing_delegate_->RequestPinCode(this);
 }
 
 void BluetoothDeviceExperimentalChromeOS::DisplayPinCode(
     const dbus::ObjectPath& device_path,
     const std::string& pincode) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
   VLOG(1) << object_path_.value() << ": DisplayPinCode: " << pincode;
 
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingMethod",
+                            UMA_PAIRING_METHOD_DISPLAY_PINCODE,
+                            UMA_PAIRING_METHOD_COUNT);
+
   DCHECK(pairing_delegate_);
   pairing_delegate_->DisplayPinCode(this, pincode);
 }
 
 void BluetoothDeviceExperimentalChromeOS::RequestPasskey(
     const dbus::ObjectPath& device_path,
     const PasskeyCallback& callback) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
   VLOG(1) << object_path_.value() << ": RequestPasskey";
 
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingMethod",
+                            UMA_PAIRING_METHOD_REQUEST_PASSKEY,
+                            UMA_PAIRING_METHOD_COUNT);
+
   DCHECK(pairing_delegate_);
   DCHECK(passkey_callback_.is_null());
   passkey_callback_ = callback;
   pairing_delegate_->RequestPasskey(this);
 }
 
 void BluetoothDeviceExperimentalChromeOS::DisplayPasskey(
     const dbus::ObjectPath& device_path,
     uint32 passkey, int16 entered) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
   VLOG(1) << object_path_.value() << ": DisplayPasskey: " << passkey
           << " (" << entered << " entered)";
 
+  if (entered == 0)
+    UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingMethod",
+                              UMA_PAIRING_METHOD_DISPLAY_PASSKEY,
+                              UMA_PAIRING_METHOD_COUNT);
+
   DCHECK(pairing_delegate_);
   if (entered == 0)
     pairing_delegate_->DisplayPasskey(this, passkey);
   pairing_delegate_->KeysEntered(this, entered);
 }
 
 void BluetoothDeviceExperimentalChromeOS::RequestConfirmation(
     const dbus::ObjectPath& device_path,
     uint32 passkey,
     const ConfirmationCallback& callback) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
   VLOG(1) << object_path_.value() << ": RequestConfirmation: " << passkey;
 
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingMethod",
+                            UMA_PAIRING_METHOD_CONFIRM_PASSKEY,
+                            UMA_PAIRING_METHOD_COUNT);
+
   DCHECK(pairing_delegate_);
   DCHECK(confirmation_callback_.is_null());
   confirmation_callback_ = callback;
   pairing_delegate_->ConfirmPasskey(this, passkey);
 }
 
 void BluetoothDeviceExperimentalChromeOS::RequestAuthorization(
     const dbus::ObjectPath& device_path,
     const ConfirmationCallback& callback) {
   // TODO(keybuk): implement
@@ skipping 63 matching lines @@
   // Determine the error code from error_name.
   ConnectErrorCode error_code = ERROR_UNKNOWN;
   if (error_name == bluetooth_adapter::kErrorFailed) {
     error_code = ERROR_FAILED;
   } else if (error_name == bluetooth_adapter::kErrorInProgress) {
     error_code = ERROR_INPROGRESS;
   } else if (error_name == bluetooth_adapter::kErrorNotSupported) {
     error_code = ERROR_UNSUPPORTED_DEVICE;
   }
 
+  RecordPairingResult(false, error_code);
   error_callback.Run(error_code);
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnRegisterAgent(
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback) {
   VLOG(1) << object_path_.value() << ": Agent registered, now pairing";
 
   DBusThreadManager::Get()->GetExperimentalBluetoothDeviceClient()->
       Pair(object_path_,
@@ skipping 20 matching lines @@
   VLOG(1) << object_path_.value() << ": " << num_connecting_calls_
           << " still in progress";
 
   UnregisterAgent();
 
   // Determine the error code from error_name.
   ConnectErrorCode error_code = ERROR_UNKNOWN;
   if (error_name == bluetooth_adapter::kErrorAlreadyExists)
     error_code = ERROR_INPROGRESS;
 
+  RecordPairingResult(false, error_code);
   error_callback.Run(error_code);
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnPair(
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback) {
   VLOG(1) << object_path_.value() << ": Paired";
+
+  if (!pairing_delegate_used_)
+    UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingMethod",
+                              UMA_PAIRING_METHOD_NONE,
+                              UMA_PAIRING_METHOD_COUNT);
   UnregisterAgent();
   SetTrusted();
   ConnectInternal(callback, error_callback);
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnPairError(
     const ConnectErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   if (--num_connecting_calls_ == 0)
@@ skipping 14 matching lines @@
   } else if (error_name == bluetooth_adapter::kErrorAuthenticationFailed) {
     error_code = ERROR_AUTH_FAILED;
   } else if (error_name == bluetooth_adapter::kErrorAuthenticationCanceled) {
     error_code = ERROR_AUTH_CANCELED;
   } else if (error_name == bluetooth_adapter::kErrorAuthenticationRejected) {
     error_code = ERROR_AUTH_REJECTED;
   } else if (error_name == bluetooth_adapter::kErrorAuthenticationTimeout) {
     error_code = ERROR_AUTH_TIMEOUT;
   }
 
+  RecordPairingResult(false, error_code);
   error_callback.Run(error_code);
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnCancelPairingError(
     const std::string& error_name,
     const std::string& error_message) {
   LOG(WARNING) << object_path_.value() << ": Failed to cancel pairing: "
                << error_name << ": " << error_message;
 }
 
@@ skipping 89 matching lines @@
 
   if (!confirmation_callback_.is_null()) {
     confirmation_callback_.Run(status);
     confirmation_callback_.Reset();
     callback_run = true;
   }
 
   return callback_run;
 }
 
+void BluetoothDeviceExperimentalChromeOS::RecordPairingResult(
+    bool success,
+    ConnectErrorCode error_code) {
+  UMAPairingResult pairing_result;
+  if (success) {
+    pairing_result = UMA_PAIRING_RESULT_SUCCESS;
+  } else {
+    switch (error_code) {
+      case ERROR_INPROGRESS:
+        pairing_result = UMA_PAIRING_RESULT_INPROGRESS;
+        break;
+      case ERROR_FAILED:
+        pairing_result = UMA_PAIRING_RESULT_FAILED;
+        break;
+      case ERROR_AUTH_FAILED:
+        pairing_result = UMA_PAIRING_RESULT_AUTH_FAILED;
+        break;
+      case ERROR_AUTH_CANCELED:
+        pairing_result = UMA_PAIRING_RESULT_AUTH_CANCELED;
+        break;
+      case ERROR_AUTH_REJECTED:
+        pairing_result = UMA_PAIRING_RESULT_AUTH_REJECTED;
+        break;
+      case ERROR_AUTH_TIMEOUT:
+        pairing_result = UMA_PAIRING_RESULT_AUTH_TIMEOUT;
+        break;
+      case ERROR_UNSUPPORTED_DEVICE:
+        pairing_result = UMA_PAIRING_RESULT_UNSUPPORTED_DEVICE;
+        break;
+      default:
+        pairing_result = UMA_PAIRING_RESULT_UNKNOWN_ERROR;
+    }
+  }
+
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingResult",
+                            pairing_result,
+                            UMA_PAIRING_RESULT_COUNT);
+}
+
 }  // namespace chromeos