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,

[satorux1, 2013/04/23 21:23:15]

function comment is missing. uint16 parameters seem to be optional (NULL is
acceptable)

[keybuk, 2013/04/23 21:34:40]

they are optional

+                   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) {

[satorux1, 2013/04/23 21:23:15]

Converting ConnectErrorCode to UMAPairingResult looks tedious. Would it be bad
to directly use ConnectErrorCode for UMA?

COMPILE_ASSERT may be useful to verify if ConnectErrorCode and UMAPairingResult
are consistent (i.e. comparing the counts)

[Ilya Sherman, 2013/04/23 21:32:26]

The really important thing is that enums used with UMA are not allowed to ever
be re-arranged or modified in any way other than appending new values at the
tail.  As long as you can guarantee this behavior, it's fine to structure the
code however you like.  But often the easiest way to guarantee this behavior is
to define a separate enum that's used only with UMA reporting, and have some
translation code like what you see here.

[keybuk, 2013/04/23 21:34:40]

They're not consistent ...

UMAPairingResult has a "success" case that ConnectErrorCode does not have

+      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