bluetooth: Add histogram for WebBluetooth actions

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 32 matching lines @@
 };
 
 enum class UMARequestDeviceOutcome {
   SUCCESS = 0,
   NO_BLUETOOTH_ADAPTER = 1,
   NO_RENDER_FRAME = 2,
   DISCOVERY_START_FAILED = 3,
   DISCOVERY_STOP_FAILED = 4,
   NO_MATCHING_DEVICES_FOUND = 5,
   // NOTE: Add new requestDevice() outcomes immediately above this line. Make
-  // sure to update the enum list in tools/histogram/histograms.xml accordingly.
+  // sure to update the enum list in
+  // tools/metrics/histogram/histograms.xml accordingly.
   COUNT
 };
 
+enum class UMAWebBluetoothFunction {

[Jeffrey Yasskin, 2015/08/03 21:51:13]

Maybe put these right next to the function that uses them, instead of putting
the enums together and then the functions together.

[ortuno, 2015/08/03 22:41:16]

Done.

+  REQUEST_DEVICE,
+  CONNECT_GATT,
+  GET_PRIMARY_SERVICE,
+  GET_CHARACTERISTIC,
+  READ_VALUE,

[Jeffrey Yasskin, 2015/08/03 21:51:13]

Similarly, mark that these are the characteristic functions.

[ortuno, 2015/08/03 22:41:16]

Done.

+  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
+};
+
 void RecordRequestDeviceOutcome(UMARequestDeviceOutcome outcome) {
   UMA_HISTOGRAM_ENUMERATION("Bluetooth.RequestDevice.Outcome",
                             static_cast<int>(outcome),
                             static_cast<int>(UMARequestDeviceOutcome::COUNT));
 }
 
+void RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction function) {
+  UMA_HISTOGRAM_ENUMERATION("WebBluetooth.FunctionCall.Count",
+                            static_cast<int>(function),
+                            static_cast<int>(UMAWebBluetoothFunction::COUNT));
+}
+
 // 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
 
 // Defined at
 // https://webbluetoothchrome.github.io/web-bluetooth/#dfn-matches-a-filter
 bool MatchesFilter(const std::set<BluetoothUUID>& device_uuids,
                    const content::BluetoothScanFilter& filter) {
@@ skipping 169 matching lines @@
   return discovery_filter.Pass();
 }
 
 void BluetoothDispatcherHost::OnRequestDevice(
     int thread_id,
     int request_id,
     int frame_routing_id,
     const std::vector<BluetoothScanFilter>& filters,
     const std::vector<BluetoothUUID>& optional_services) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::REQUEST_DEVICE);
 
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(render_process_id_, frame_routing_id);
 
   if (!render_frame_host) {
     DLOG(WARNING)
         << "Got a requestDevice IPC without a matching RenderFrameHost: "
         << render_process_id_ << ", " << frame_routing_id;
     RecordRequestDeviceOutcome(UMARequestDeviceOutcome::NO_RENDER_FRAME);
     Send(new BluetoothMsg_RequestDeviceError(
@@ skipping 27 matching lines @@
         thread_id, request_id, WebBluetoothError::NoBluetoothAdapter));
   }
   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);
+
   // 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.
     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),
       base::Bind(&BluetoothDispatcherHost::OnCreateGATTConnectionError,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
                  device_instance_id));
 }
 
 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);
+
   // TODO(ortuno): Check if device_instance_id is in "allowed devices"
   // https://crbug.com/493459
   // TODO(ortuno): Check if service_uuid is in "allowed services"
   // https://crbug.com/493460
   // For now just wait a fixed time and call OnServiceDiscovered.
   // TODO(ortuno): Use callback once it's implemented http://crbug.com/484504
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BluetoothDispatcherHost::OnServicesDiscovered,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
                  device_instance_id, service_uuid),
       base::TimeDelta::FromSeconds(current_delay_time_));
 }
 
 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);
+  RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::GET_CHARACTERISTIC);
 
   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;
   }
@@ skipping 41 matching lines @@
   }
   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);
+  RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::READ_VALUE);
 
   auto characteristic_iter =
       characteristic_to_service_.find(characteristic_instance_id);
   // A characteristic_instance_id not in the map implies a hostile renderer
   // because a renderer obtains the characteristic id from this class and
   // it will be added to the map at that time.
   if (characteristic_iter == characteristic_to_service_.end()) {
     // Kill the renderer
     bad_message::ReceivedBadMessage(this,
                                     bad_message::BDH_INVALID_CHARACTERISTIC_ID);
@@ skipping 35 matching lines @@
       base::Bind(&BluetoothDispatcherHost::OnCharacteristicReadValueError,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::OnWriteValue(
     int thread_id,
     int request_id,
     const std::string& characteristic_instance_id,
     const std::vector<uint8_t>& value) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::WRITE_VALUE);
 
   // Length check per step 3 of writeValue algorithm:
   // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothgattcharacteristic-writevalue
   // We perform the length check on the renderer side. So if we
   // get a value with length > 512, we can assume it's a hostile
   // renderer and kill it.
   if (value.size() > 512) {
     bad_message::ReceivedBadMessage(
         this, bad_message::BDH_INVALID_WRITE_VALUE_LENGTH);
     return;
@@ skipping 204 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