bluetooth: Add histograms and logging for connectGATT

content/browser/bluetooth/bluetooth_dispatcher_host.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.
 
 // NETWORK_ERROR Note:
 // When a device can't be found in the BluetoothAdapter, that generally
 // indicates that it's gone out of range. We reject with a NetworkError in that
 // case.
 // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
 
@@ skipping 99 matching lines @@
   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());
 }
 
+enum class UMAConnectGATTOutcome {
+  SUCCESS,
+  NO_DEVICE,
+  UNKNOWN,
+  IN_PROGRESS,
+  FAILED,
+  AUTH_FAILED,
+  AUTH_CANCELED,
+  AUTH_REJECTED,
+  AUTH_TIMEOUT,
+  UNSUPPORTED_DEVICE,
+  // Note: Add new ConnectGATT outcomes immediately above this line. Make sure
+  // to update the enum list in tools/metrisc/histogram/histograms.xml
+  // accordingly.
+  COUNT
+};
+
+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);
+}
+
 enum class UMAWebBluetoothFunction {
   REQUEST_DEVICE,
   CONNECT_GATT,
   GET_PRIMARY_SERVICE,
   GET_CHARACTERISTIC,
   CHARACTERISTIC_READ_VALUE,
   CHARACTERISTIC_WRITE_VALUE,
   // NOTE: Add new actions immediately above this line. Make sure to update the
   // enum list in tools/metrics/histogram/histograms.xml accordingly.
   COUNT
@@ skipping 40 matching lines @@
 
 void AddToHistogram(BluetoothGATTError error) {
   UMA_HISTOGRAM_ENUMERATION("Bluetooth.GATTErrors", static_cast<int>(error),
                             static_cast<int>(BluetoothGATTError::MAX_ERROR));
 }
 
 WebBluetoothError TranslateConnectError(
     device::BluetoothDevice::ConnectErrorCode error_code) {
   switch (error_code) {
     case device::BluetoothDevice::ERROR_UNKNOWN:
+      RecordConnectGATTOutcome(UMAConnectGATTOutcome::UNKNOWN);
       return WebBluetoothError::ConnectUnknownError;
     case device::BluetoothDevice::ERROR_INPROGRESS:
+      RecordConnectGATTOutcome(UMAConnectGATTOutcome::IN_PROGRESS);
       return WebBluetoothError::ConnectAlreadyInProgress;
     case device::BluetoothDevice::ERROR_FAILED:
+      RecordConnectGATTOutcome(UMAConnectGATTOutcome::FAILED);
       return WebBluetoothError::ConnectUnknownFailure;
     case device::BluetoothDevice::ERROR_AUTH_FAILED:
+      RecordConnectGATTOutcome(UMAConnectGATTOutcome::AUTH_FAILED);
       return WebBluetoothError::ConnectAuthFailed;
     case device::BluetoothDevice::ERROR_AUTH_CANCELED:
+      RecordConnectGATTOutcome(UMAConnectGATTOutcome::AUTH_CANCELED);
       return WebBluetoothError::ConnectAuthCanceled;
     case device::BluetoothDevice::ERROR_AUTH_REJECTED:
+      RecordConnectGATTOutcome(UMAConnectGATTOutcome::AUTH_REJECTED);
       return WebBluetoothError::ConnectAuthRejected;
     case device::BluetoothDevice::ERROR_AUTH_TIMEOUT:
+      RecordConnectGATTOutcome(UMAConnectGATTOutcome::AUTH_TIMEOUT);
       return WebBluetoothError::ConnectAuthTimeout;
     case device::BluetoothDevice::ERROR_UNSUPPORTED_DEVICE:
+      RecordConnectGATTOutcome(UMAConnectGATTOutcome::UNSUPPORTED_DEVICE);
       return WebBluetoothError::ConnectUnsupportedDevice;
   }
   NOTREACHED();
   return WebBluetoothError::UntranslatedConnectErrorCode;
 }
 
 blink::WebBluetoothError TranslateGATTError(
     BluetoothGattService::GattErrorCode error_code) {
   switch (error_code) {
     case BluetoothGattService::GATT_ERROR_UNKNOWN:
@@ skipping 201 matching lines @@
   }
   return;
 }
 
 void BluetoothDispatcherHost::OnConnectGATT(
     int thread_id,
     int request_id,
     const std::string& device_instance_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::CONNECT_GATT);
+  const base::TimeTicks start_time = base::TimeTicks::Now();
 
   // TODO(ortuno): Right now it's pointless to check if the domain has access to
   // the device, because any domain can connect to any device. But once
   // permissions are implemented we should check that the domain has access to
   // the device. https://crbug.com/484745
   device::BluetoothDevice* device = adapter_->GetDevice(device_instance_id);
   if (device == nullptr) {  // See "NETWORK_ERROR Note" above.
+    RecordConnectGATTOutcome(UMAConnectGATTOutcome::NO_DEVICE);
+    VLOG(1) << "Bluetooth Device no longer in range.";
     Send(new BluetoothMsg_ConnectGATTError(
         thread_id, request_id, WebBluetoothError::DeviceNoLongerInRange));
     return;
   }
   device->CreateGattConnection(
       base::Bind(&BluetoothDispatcherHost::OnGATTConnectionCreated,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
-                 device_instance_id),
+                 device_instance_id, start_time),
       base::Bind(&BluetoothDispatcherHost::OnCreateGATTConnectionError,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
-                 device_instance_id));
+                 device_instance_id, start_time));
 }
 
 void BluetoothDispatcherHost::OnGetPrimaryService(
     int thread_id,
     int request_id,
     const std::string& device_instance_id,
     const std::string& service_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::GET_PRIMARY_SERVICE);
 
@@ skipping 278 matching lines @@
   RecordRequestDeviceOutcome(UMARequestDeviceOutcome::DISCOVERY_STOP_FAILED);
   Send(new BluetoothMsg_RequestDeviceError(
       thread_id, request_id, WebBluetoothError::DiscoverySessionStopFailed));
   request_device_sessions_.erase(std::make_pair(thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::OnGATTConnectionCreated(
     int thread_id,
     int request_id,
     const std::string& device_instance_id,
+    base::TimeTicks start_time,
     scoped_ptr<device::BluetoothGattConnection> connection) {
   // TODO(ortuno): Save the BluetoothGattConnection so we can disconnect
   // from it.
+  RecordConnectGATTTimeSuccess(base::TimeTicks::Now() - start_time);
+  RecordConnectGATTOutcome(UMAConnectGATTOutcome::SUCCESS);
   Send(new BluetoothMsg_ConnectGATTSuccess(thread_id, request_id,
                                            device_instance_id));
 }
 
 void BluetoothDispatcherHost::OnCreateGATTConnectionError(
     int thread_id,
     int request_id,
     const std::string& device_instance_id,
+    base::TimeTicks start_time,
     device::BluetoothDevice::ConnectErrorCode error_code) {
   // There was an error creating the ATT Bearer so we reject with
   // NetworkError.
   // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
+  RecordConnectGATTTimeFailed(base::TimeTicks::Now() - start_time);
+  // RecordConnectGATTOutcome is called by TranslateConnectError.
   Send(new BluetoothMsg_ConnectGATTError(thread_id, request_id,
                                          TranslateConnectError(error_code)));
 }
 
 void BluetoothDispatcherHost::OnServicesDiscovered(
     int thread_id,
     int request_id,
     const std::string& device_instance_id,
     const std::string& service_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 48 matching lines @@
 
 void BluetoothDispatcherHost::OnWriteValueFailed(
     int thread_id,
     int request_id,
     device::BluetoothGattService::GattErrorCode error_code) {
   Send(new BluetoothMsg_WriteCharacteristicValueError(
       thread_id, request_id, TranslateGATTError(error_code)));
 }
 
 }  // namespace content