Add a histogram to record requestDevice 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 24 matching lines @@
 // how common they are and if we need to investigate more.
 enum class BluetoothGATTError {
   UNKNOWN,
   FAILED,
   IN_PROGRESS,
   NOT_PAIRED,
   // Add errors above this line and update corresponding histograms.xml enum.
   MAX_ERROR,
 };
 
+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.
+  COUNT
+};
+
+void RecordRequestDeviceOutcome(UMARequestDeviceOutcome outcome) {
+  UMA_HISTOGRAM_ENUMERATION("Bluetooth.RequestDevice.Outcome",
+                            static_cast<int>(outcome),
+                            static_cast<int>(UMARequestDeviceOutcome::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 177 matching lines @@
     const std::vector<BluetoothUUID>& optional_services) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   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(
         thread_id, request_id, WebBluetoothError::RequestDeviceWithoutFrame));
   }
 
   // TODO(scheib): Device selection UI: crbug.com/436280
   // TODO(scheib): Utilize BluetoothAdapter::Observer::DeviceAdded/Removed.
   if (adapter_.get()) {
     if (!request_device_sessions_
              .insert(std::make_pair(
                  std::make_pair(thread_id, request_id),
                  RequestDeviceSession(filters, optional_services)))
              .second) {
       LOG(ERROR) << "2 requestDevice() calls with the same thread_id ("
                  << thread_id << ") and request_id (" << request_id
                  << ") shouldn't arrive at the same BluetoothDispatcherHost.";
       bad_message::ReceivedBadMessage(
           this, bad_message::BDH_DUPLICATE_REQUEST_DEVICE_ID);
     }
     adapter_->StartDiscoverySessionWithFilter(
         ComputeScanFilter(filters),
         base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStarted,
                    weak_ptr_factory_.GetWeakPtr(), thread_id, request_id),
         base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStartedError,
                    weak_ptr_factory_.GetWeakPtr(), thread_id, request_id));
   } else {
     DLOG(WARNING) << "No BluetoothAdapter. Can't serve requestDevice.";
+    RecordRequestDeviceOutcome(UMARequestDeviceOutcome::NO_BLUETOOTH_ADAPTER);
     Send(new BluetoothMsg_RequestDeviceError(
         thread_id, request_id, WebBluetoothError::NoBluetoothAdapter));
   }
   return;
 }
 
 void BluetoothDispatcherHost::OnConnectGATT(
     int thread_id,
     int request_id,
     const std::string& device_instance_id) {
@@ skipping 227 matching lines @@
       base::Bind(&BluetoothDispatcherHost::StopDiscoverySession,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
                  base::Passed(&discovery_session)),
       base::TimeDelta::FromSeconds(current_delay_time_));
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStartedError(int thread_id,
                                                              int request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DLOG(WARNING) << "BluetoothDispatcherHost::OnDiscoverySessionStartedError";
+  RecordRequestDeviceOutcome(UMARequestDeviceOutcome::DISCOVERY_START_FAILED);
   Send(new BluetoothMsg_RequestDeviceError(
       thread_id, request_id, WebBluetoothError::DiscoverySessionStartFailed));
   request_device_sessions_.erase(std::make_pair(thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::StopDiscoverySession(
     int thread_id,
     int request_id,
     scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 17 matching lines @@
           device->GetAddress(),         // instance_id
           device->GetName(),            // name
           device->GetBluetoothClass(),  // device_class
           device->GetVendorIDSource(),  // vendor_id_source
           device->GetVendorID(),        // vendor_id
           device->GetProductID(),       // product_id
           device->GetDeviceID(),        // product_version
           device->IsPaired(),           // paired
           content::BluetoothDevice::UUIDsFromBluetoothUUIDs(
               device->GetUUIDs()));  // uuids
+      RecordRequestDeviceOutcome(UMARequestDeviceOutcome::SUCCESS);
       Send(new BluetoothMsg_RequestDeviceSuccess(thread_id, request_id,
                                                  device_ipc));
       request_device_sessions_.erase(session);
       return;
     }
   }
+  RecordRequestDeviceOutcome(
+      UMARequestDeviceOutcome::NO_MATCHING_DEVICES_FOUND);
   Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
                                            WebBluetoothError::NoDevicesFound));
   request_device_sessions_.erase(session);
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStoppedError(int thread_id,
                                                              int request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DLOG(WARNING) << "BluetoothDispatcherHost::OnDiscoverySessionStoppedError";
+  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,
     scoped_ptr<device::BluetoothGattConnection> connection) {
@@ skipping 72 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