bluetooth: Add histograms for readValue and writeValue outcomes

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 81 matching lines @@
       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) {
+    BluetoothGattService::GattErrorCode error_code,
+    UMAGATTOperation operation) {
   switch (error_code) {
     case BluetoothGattService::GATT_ERROR_UNKNOWN:
-      RecordGATTError(UMAGATTError::UNKNOWN);
+      RecordGATTOperationOutcome(operation, UMAGATTOperationOutcome::UNKNOWN);
       return blink::WebBluetoothError::GATTUnknownError;
     case BluetoothGattService::GATT_ERROR_FAILED:
-      RecordGATTError(UMAGATTError::FAILED);
+      RecordGATTOperationOutcome(operation, UMAGATTOperationOutcome::FAILED);
       return blink::WebBluetoothError::GATTUnknownFailure;
     case BluetoothGattService::GATT_ERROR_IN_PROGRESS:
-      RecordGATTError(UMAGATTError::IN_PROGRESS);
+      RecordGATTOperationOutcome(operation,
+                                 UMAGATTOperationOutcome::IN_PROGRESS);
       return blink::WebBluetoothError::GATTOperationInProgress;
     case BluetoothGattService::GATT_ERROR_INVALID_LENGTH:
+      RecordGATTOperationOutcome(operation,
+                                 UMAGATTOperationOutcome::INVALID_LENGTH);
       return blink::WebBluetoothError::GATTInvalidAttributeLength;
     case BluetoothGattService::GATT_ERROR_NOT_PERMITTED:
+      RecordGATTOperationOutcome(operation,
+                                 UMAGATTOperationOutcome::NOT_PERMITTED);
       return blink::WebBluetoothError::GATTNotPermitted;
     case BluetoothGattService::GATT_ERROR_NOT_AUTHORIZED:
+      RecordGATTOperationOutcome(operation,
+                                 UMAGATTOperationOutcome::NOT_AUTHORIZED);
       return blink::WebBluetoothError::GATTNotAuthorized;
     case BluetoothGattService::GATT_ERROR_NOT_PAIRED:
-      RecordGATTError(UMAGATTError::NOT_PAIRED);
+      RecordGATTOperationOutcome(operation,
+                                 UMAGATTOperationOutcome::NOT_PAIRED);
       return blink::WebBluetoothError::GATTNotPaired;
     case BluetoothGattService::GATT_ERROR_NOT_SUPPORTED:
+      RecordGATTOperationOutcome(operation,
+                                 UMAGATTOperationOutcome::NOT_SUPPORTED);
       return blink::WebBluetoothError::GATTNotSupported;
   }
   NOTREACHED();
   return blink::WebBluetoothError::GATTUntranslatedErrorCode;
 }
 
 }  //  namespace
 
 BluetoothDispatcherHost::BluetoothDispatcherHost(int render_process_id)
     : BrowserMessageFilter(BluetoothMsgStart),
@@ skipping 309 matching lines @@
   }
   const std::string& service_instance_id = characteristic_iter->second;
 
   auto device_iter = service_to_device_.find(service_instance_id);
 
   CHECK(device_iter != service_to_device_.end());
 
   device::BluetoothDevice* device =
       adapter_->GetDevice(device_iter->second /* device_instance_id */);
   if (device == nullptr) {  // See "NETWORK_ERROR Note" above.
+    RecordCharacteristicReadValueOutcome(UMAGATTOperationOutcome::NO_DEVICE);
     Send(new BluetoothMsg_ReadCharacteristicValueError(
         thread_id, request_id, WebBluetoothError::DeviceNoLongerInRange));
     return;
   }
 
   BluetoothGattService* service = device->GetGattService(service_instance_id);
   if (service == nullptr) {
+    RecordCharacteristicReadValueOutcome(UMAGATTOperationOutcome::NO_SERVICE);
     Send(new BluetoothMsg_ReadCharacteristicValueError(
         thread_id, request_id, WebBluetoothError::ServiceNoLongerExists));
     return;
   }
 
   BluetoothGattCharacteristic* characteristic =
       service->GetCharacteristic(characteristic_instance_id);
   if (characteristic == nullptr) {
+    RecordCharacteristicReadValueOutcome(
+        UMAGATTOperationOutcome::NO_CHARACTERISTIC);
     Send(new BluetoothMsg_ReadCharacteristicValueError(
         thread_id, request_id,
         WebBluetoothError::CharacteristicNoLongerExists));
     return;
   }
 
   characteristic->ReadRemoteCharacteristic(
       base::Bind(&BluetoothDispatcherHost::OnCharacteristicValueRead,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id),
       base::Bind(&BluetoothDispatcherHost::OnCharacteristicReadValueError,
@@ skipping 32 matching lines @@
   }
   const std::string& service_instance_id = characteristic_iter->second;
 
   auto device_iter = service_to_device_.find(service_instance_id);
 
   CHECK(device_iter != service_to_device_.end());
 
   device::BluetoothDevice* device =
       adapter_->GetDevice(device_iter->second /* device_instance_id */);
   if (device == nullptr) {  // See "NETWORK_ERROR Note" above.
+    RecordCharacteristicWriteValueOutcome(UMAGATTOperationOutcome::NO_DEVICE);
     Send(new BluetoothMsg_WriteCharacteristicValueError(
         thread_id, request_id, WebBluetoothError::DeviceNoLongerInRange));
     return;
   }
 
   BluetoothGattService* service = device->GetGattService(service_instance_id);
   if (service == nullptr) {
+    RecordCharacteristicWriteValueOutcome(UMAGATTOperationOutcome::NO_SERVICE);
     Send(new BluetoothMsg_WriteCharacteristicValueError(
         thread_id, request_id, WebBluetoothError::ServiceNoLongerExists));
     return;
   }
 
   BluetoothGattCharacteristic* characteristic =
       service->GetCharacteristic(characteristic_instance_id);
   if (characteristic == nullptr) {
+    RecordCharacteristicWriteValueOutcome(
+        UMAGATTOperationOutcome::NO_CHARACTERISTIC);
     Send(new BluetoothMsg_WriteCharacteristicValueError(
         thread_id, request_id,
         WebBluetoothError::CharacteristicNoLongerExists));
     return;
   }
   characteristic->WriteRemoteCharacteristic(
       value, base::Bind(&BluetoothDispatcherHost::OnWriteValueSuccess,
                         weak_ptr_factory_.GetWeakPtr(), thread_id, request_id),
       base::Bind(&BluetoothDispatcherHost::OnWriteValueFailed,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id));
@@ skipping 145 matching lines @@
   }
   RecordGetPrimaryServiceOutcome(UMAGetPrimaryServiceOutcome::NOT_FOUND);
   Send(new BluetoothMsg_GetPrimaryServiceError(
       thread_id, request_id, WebBluetoothError::ServiceNotFound));
 }
 
 void BluetoothDispatcherHost::OnCharacteristicValueRead(
     int thread_id,
     int request_id,
     const std::vector<uint8>& value) {
+  RecordCharacteristicReadValueOutcome(UMAGATTOperationOutcome::SUCCESS);
   Send(new BluetoothMsg_ReadCharacteristicValueSuccess(thread_id, request_id,
                                                        value));
 }
 
 void BluetoothDispatcherHost::OnCharacteristicReadValueError(
     int thread_id,
     int request_id,
     device::BluetoothGattService::GattErrorCode error_code) {
+  // TranslateGATTError calls RecordGATTOperationOutcome with

[Jeffrey Yasskin, 2015/08/14 21:33:22]

This comment could be shorter: "TranslateGATTError calls
RecordGATTOperationOutcome."

[ortuno, 2015/08/14 21:42:20]

Done.

+  // UMAGATTOperation::CHARACTERISTIC_READ as a parameter.
+  // This should take care of recording the outcome for this readValue call.
   Send(new BluetoothMsg_ReadCharacteristicValueError(
-      thread_id, request_id, TranslateGATTError(error_code)));
+      thread_id, request_id,
+      TranslateGATTError(error_code, UMAGATTOperation::CHARACTERISTIC_READ)));
 }
 
 void BluetoothDispatcherHost::OnWriteValueSuccess(int thread_id,
                                                   int request_id) {
+  RecordCharacteristicWriteValueOutcome(UMAGATTOperationOutcome::SUCCESS);
   Send(new BluetoothMsg_WriteCharacteristicValueSuccess(thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::OnWriteValueFailed(
     int thread_id,
     int request_id,
     device::BluetoothGattService::GattErrorCode error_code) {
+  // TranslateGATTError calls RecordGATTOperationOutcome with
+  // UMAGATTOperation::CHARACTERISTIC_WRITE as a parameter.
+  // This should take care of recording the outcome for this writeValue call.
   Send(new BluetoothMsg_WriteCharacteristicValueError(
-      thread_id, request_id, TranslateGATTError(error_code)));
+      thread_id, request_id,
+      TranslateGATTError(error_code, UMAGATTOperation::CHARACTERISTIC_WRITE)));
 }
 
 }  // namespace content