bluetooth: Add histograms and logging for getCharacteristic

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 19 matching lines @@
 using device::BluetoothGattService;
 using device::BluetoothUUID;
 
 using UMAWebBluetoothFunction =
     content::BluetoothMetrics::UMAWebBluetoothFunction;
 using UMARequestDeviceOutcome =
     content::BluetoothMetrics::UMARequestDeviceOutcome;
 using UMAConnectGATTOutcome = content::BluetoothMetrics::UMAConnectGATTOutcome;
 using UMAGetPrimaryServiceOutcome =
     content::BluetoothMetrics::UMAGetPrimaryServiceOutcome;
+using UMAGetCharacteristicOutcome =
+    content::BluetoothMetrics::UMAGetCharacteristicOutcome;
 using UMAGATTError = content::BluetoothMetrics::UMAGATTError;
 
 namespace {
 
 // TODO(ortuno): Once we have a chooser for scanning and the right
 // callback for discovered services we should delete these constants.
 // https://crbug.com/436280 and https://crbug.com/484504
 const int kDelayTime = 5;         // 5 seconds for scanning and discovering
 const int kTestingDelayTime = 0;  // No need to wait during tests
 
@@ skipping 331 matching lines @@
 }
 
 void BluetoothDispatcherHost::OnGetCharacteristic(
     int thread_id,
     int request_id,
     const std::string& service_instance_id,
     const std::string& characteristic_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BluetoothMetrics::RecordWebBluetoothFunctionCall(
       UMAWebBluetoothFunction::GET_CHARACTERISTIC);
+  BluetoothMetrics::RecordGetCharacteristicCharacteristic(characteristic_uuid);
 
   auto device_iter = service_to_device_.find(service_instance_id);
   // A service_instance_id not in the map implies a hostile renderer
   // because a renderer obtains the service id from this class and
   // it will be added to the map at that time.
   if (device_iter == service_to_device_.end()) {
     // Kill the renderer
     bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_SERVICE_ID);
     return;
   }
 
   // TODO(ortuno): Check if domain has access to device.
   // https://crbug.com/493459
   device::BluetoothDevice* device =
       adapter_->GetDevice(device_iter->second /* device_instance_id */);
 
   if (device == nullptr) {  // See "NETWORK_ERROR Note" above.
+    BluetoothMetrics::RecordGetCharacteristicOutcome(
+        UMAGetCharacteristicOutcome::NO_DEVICE);
+    VLOG(1) << "Bluetooth Device is no longer in range.";

[Jeffrey Yasskin, 2015/08/13 21:32:53]

As discussed over IM, we should drop the VLOGs with constant strings that come
just before a Send(Error(WebBluetoothError)) when the WebBluetoothError is
equivalent to the string.

[ortuno, 2015/08/14 16:23:35]

Done.

     Send(new BluetoothMsg_GetCharacteristicError(
         thread_id, request_id, WebBluetoothError::DeviceNoLongerInRange));
     return;
   }
 
   // TODO(ortuno): Check if domain has access to service
   // http://crbug.com/493460
   device::BluetoothGattService* service =
       device->GetGattService(service_instance_id);
   if (!service) {
+    BluetoothMetrics::RecordGetCharacteristicOutcome(
+        UMAGetCharacteristicOutcome::NO_SERVICE);
+    VLOG(1) << "GATT Service no longer exists.";
     Send(new BluetoothMsg_GetCharacteristicError(
         thread_id, request_id, WebBluetoothError::ServiceNoLongerExists));
     return;
   }
 
   for (BluetoothGattCharacteristic* characteristic :
        service->GetCharacteristics()) {
     if (characteristic->GetUUID().canonical_value() == characteristic_uuid) {
       const std::string& characteristic_instance_id =
           characteristic->GetIdentifier();
 
       auto insert_result = characteristic_to_service_.insert(
           make_pair(characteristic_instance_id, service_instance_id));
 
       // If  value is already in map, DCHECK it's valid.
       if (!insert_result.second)
         DCHECK(insert_result.first->second == service_instance_id);
 
+      BluetoothMetrics::RecordGetCharacteristicOutcome(
+          UMAGetCharacteristicOutcome::SUCCESS);
       // TODO(ortuno): Use generated instance ID instead.
       // https://crbug.com/495379
       Send(new BluetoothMsg_GetCharacteristicSuccess(
           thread_id, request_id, characteristic_instance_id));
       return;
     }
   }
+  BluetoothMetrics::RecordGetCharacteristicOutcome(
+      UMAGetCharacteristicOutcome::NOT_FOUND);
+  VLOG(1) << "No GATT Characteristic with UUID: " << characteristic_uuid;

[Jeffrey Yasskin, 2015/08/13 21:32:52]

This one's probably also equivalent to its rejection message, since the caller
has the UUID they passed in.

[ortuno, 2015/08/14 16:23:35]

Removed.

   Send(new BluetoothMsg_GetCharacteristicError(
       thread_id, request_id, WebBluetoothError::CharacteristicNotFound));
 }
 
 void BluetoothDispatcherHost::OnReadValue(
     int thread_id,
     int request_id,
     const std::string& characteristic_instance_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BluetoothMetrics::RecordWebBluetoothFunctionCall(
@@ skipping 298 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