bluetooth: Add URLs for Web Bluetooth help links.

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.
 
 // ID Not In Map Note:
 // A service, characteristic, or descriptor ID not in the corresponding
 // BluetoothDispatcherHost map [service_to_device_, characteristic_to_service_,
 // descriptor_to_characteristic_] implies a hostile renderer because a renderer
 // obtains the corresponding ID from this class and it will be added to the map
 // at that time.
@@ skipping 215 matching lines @@
   for (BluetoothGattService* service : device->GetGattServices()) {
     VLOG(1) << "Service in cache: " << service->GetUUID().canonical_value();
     if (service->GetUUID().canonical_value() == service_uuid &&
         service->IsPrimary()) {
       services.push_back(service);
     }
   }
   return services;
 }
 
+UMARequestDeviceOutcome OutcomeFromChooserEvent(BluetoothChooser::Event event) {
+  switch (event) {
+    case BluetoothChooser::Event::DENIED_PERMISSION:
+      return UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_DENIED_PERMISSION;
+    case BluetoothChooser::Event::CANCELLED:
+      return UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_CANCELLED;
+    case BluetoothChooser::Event::SHOW_OVERVIEW_HELP:
+      return UMARequestDeviceOutcome::BLUETOOTH_OVERVIEW_HELP_LINK_PRESSED;
+    case BluetoothChooser::Event::SHOW_ADAPTER_OFF_HELP:
+      return UMARequestDeviceOutcome::ADAPTER_OFF_HELP_LINK_PRESSED;
+    case BluetoothChooser::Event::SHOW_NEED_LOCATION_HELP:
+      return UMARequestDeviceOutcome::NEED_LOCATION_HELP_LINK_PRESSED;
+    case BluetoothChooser::Event::SELECTED:
+      // We can't know if we are going to send a success message yet because
+      // the device could have vanished. This event should be histogramed
+      // manually after checking if the device is still around.
+      NOTREACHED();
+      return UMARequestDeviceOutcome::SUCCESS;
+    case BluetoothChooser::Event::RESCAN:
+      // Rescanning doesn't result in a IPC message for the request being sent
+      // so no need to histogram it.
+      NOTREACHED();
+      return UMARequestDeviceOutcome::SUCCESS;
+  }
+  NOTREACHED();
+  return UMARequestDeviceOutcome::SUCCESS;
+}
+
 }  //  namespace
 
 BluetoothDispatcherHost::BluetoothDispatcherHost(int render_process_id)
     : BrowserMessageFilter(BluetoothMsgStart),
       render_process_id_(render_process_id),
       current_delay_time_(kDelayTime),
       discovery_session_timer_(
           FROM_HERE,
           // TODO(jyasskin): Add a way for tests to control the dialog
           // directly, and change this to a reasonable discovery timeout.
@@ skipping 85 matching lines @@
   // Clear adapter, releasing observer references.
   set_adapter(scoped_refptr<device::BluetoothAdapter>());
 }
 
 // Stores information associated with an in-progress requestDevice call. This
 // will include the state of the active chooser dialog in a future patch.
 struct BluetoothDispatcherHost::RequestDeviceSession {
  public:
   RequestDeviceSession(int thread_id,
                        int request_id,
+                       int frame_routing_id,
                        url::Origin origin,
                        const std::vector<BluetoothScanFilter>& filters,
                        const std::vector<BluetoothUUID>& optional_services)
       : thread_id(thread_id),
         request_id(request_id),
+        frame_routing_id(frame_routing_id),
         origin(origin),
         filters(filters),
         optional_services(optional_services) {}
 
   void AddFilteredDevice(const device::BluetoothDevice& device) {
     if (chooser && MatchesFilters(device, filters)) {
       chooser->AddDevice(device.GetAddress(), device.GetName());
     }
   }
 
   scoped_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter() const {
     std::set<BluetoothUUID> services;
     for (const BluetoothScanFilter& filter : filters) {
       services.insert(filter.services.begin(), filter.services.end());
     }
     scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter(
         new device::BluetoothDiscoveryFilter(
             device::BluetoothDiscoveryFilter::TRANSPORT_DUAL));
     for (const BluetoothUUID& service : services) {
       discovery_filter->AddUUID(service);
     }
     return discovery_filter;
   }
 
   const int thread_id;
   const int request_id;
+  const int frame_routing_id;
   const url::Origin origin;
   const std::vector<BluetoothScanFilter> filters;
   const std::vector<BluetoothUUID> optional_services;
   scoped_ptr<BluetoothChooser> chooser;
   scoped_ptr<device::BluetoothDiscoverySession> discovery_session;
 };
 
 struct BluetoothDispatcherHost::CacheQueryResult {
   CacheQueryResult()
       : device(nullptr),
@@ skipping 674 matching lines @@
 
   // The renderer should never send empty filters.
   if (HasEmptyOrInvalidFilter(filters)) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::BDH_EMPTY_OR_INVALID_FILTERS);
     return;
   }
 
   // Create storage for the information that backs the chooser, and show the
   // chooser.
-  RequestDeviceSession* const session = new RequestDeviceSession(
-      thread_id, request_id, render_frame_host->GetLastCommittedOrigin(),
-      filters, optional_services_blacklist_filtered);
+  RequestDeviceSession* const session =
+      new RequestDeviceSession(thread_id, request_id, frame_routing_id,
+                               render_frame_host->GetLastCommittedOrigin(),
+                               filters, optional_services_blacklist_filtered);
   int chooser_id = request_device_sessions_.Add(session);
 
   BluetoothChooser::EventHandler chooser_event_handler =
       base::Bind(&BluetoothDispatcherHost::OnBluetoothChooserEvent,
                  weak_ptr_on_ui_thread_, chooser_id);
   if (WebContents* web_contents =
           WebContents::FromRenderFrameHost(render_frame_host)) {
     if (WebContentsDelegate* delegate = web_contents->GetDelegate()) {
       session->chooser = delegate->RunBluetoothChooser(render_frame_host,
                                                        chooser_event_handler);
@@ skipping 74 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RequestDeviceSession* session = request_device_sessions_.Lookup(chooser_id);
   DCHECK(session) << "Shouldn't receive an event (" << static_cast<int>(event)
                   << ") from a closed chooser.";
   CHECK(session->chooser) << "Shouldn't receive an event ("
                           << static_cast<int>(event)
                           << ") from a closed chooser.";
   switch (event) {
     case BluetoothChooser::Event::RESCAN:
       StartDeviceDiscovery(session, chooser_id);
-      break;
+      // No need to close the chooser so we return.
+      return;
     case BluetoothChooser::Event::DENIED_PERMISSION:
     case BluetoothChooser::Event::CANCELLED:
-    case BluetoothChooser::Event::SELECTED: {
-      // Synchronously ensure nothing else calls into the chooser after it has
-      // asked to be closed.
-      session->chooser.reset();
-
-      // Yield to the event loop to make sure we don't destroy the session
-      // within a BluetoothDispatcherHost stack frame.
-      if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
-              FROM_HERE,
-              base::Bind(&BluetoothDispatcherHost::FinishClosingChooser,
-                         weak_ptr_on_ui_thread_, chooser_id, event,
-                         device_id))) {
-        LOG(WARNING) << "No TaskRunner; not closing requestDevice dialog.";
-      }
+    case BluetoothChooser::Event::SELECTED:
       break;
-    }
     case BluetoothChooser::Event::SHOW_OVERVIEW_HELP:
-      ShowBluetoothOverviewLink();
-      break;
-    case BluetoothChooser::Event::SHOW_PAIRING_HELP:
-      ShowBluetoothPairingLink();
+      VLOG(1) << "Overview Help link pressed.";
       break;
     case BluetoothChooser::Event::SHOW_ADAPTER_OFF_HELP:
-      ShowBluetoothAdapterOffLink();
+      VLOG(1) << "Adapter Off Help link pressed.";
       break;
     case BluetoothChooser::Event::SHOW_NEED_LOCATION_HELP:
-      ShowNeedLocationLink();
+      VLOG(1) << "Need Location Help link pressed.";
       break;
   }
+
+  // Synchronously ensure nothing else calls into the chooser after it has
+  // asked to be closed.
+  session->chooser.reset();
+
+  // Yield to the event loop to make sure we don't destroy the session
+  // within a BluetoothDispatcherHost stack frame.
+  if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&BluetoothDispatcherHost::FinishClosingChooser,
+                     weak_ptr_on_ui_thread_, chooser_id, event, device_id))) {
+    LOG(WARNING) << "No TaskRunner; not closing requestDevice dialog.";
+  }
 }
 
 void BluetoothDispatcherHost::FinishClosingChooser(
     int chooser_id,
     BluetoothChooser::Event event,
     const std::string& device_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RequestDeviceSession* session = request_device_sessions_.Lookup(chooser_id);
   DCHECK(session) << "Session removed unexpectedly.";
 
-  if (event == BluetoothChooser::Event::CANCELLED) {
-    RecordRequestDeviceOutcome(
-        UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_CANCELLED);
-    VLOG(1) << "Bluetooth chooser cancelled";
+  if ((event != BluetoothChooser::Event::DENIED_PERMISSION) &&
+      (event != BluetoothChooser::Event::SELECTED)) {
+    RecordRequestDeviceOutcome(OutcomeFromChooserEvent(event));
     Send(new BluetoothMsg_RequestDeviceError(
         session->thread_id, session->request_id,
         WebBluetoothError::ChooserCancelled));
     request_device_sessions_.Remove(chooser_id);
     return;
   }
   if (event == BluetoothChooser::Event::DENIED_PERMISSION) {
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_DENIED_PERMISSION);
     VLOG(1) << "Bluetooth chooser denied permission";
@@ skipping 274 matching lines @@
 }
 
 bool BluetoothDispatcherHost::CanFrameAccessCharacteristicInstance(
     int frame_routing_id,
     const std::string& characteristic_instance_id) {
   return QueryCacheForCharacteristic(GetOrigin(frame_routing_id),
                                      characteristic_instance_id)
              .outcome != CacheQueryOutcome::BAD_RENDERER;
 }
 
-void BluetoothDispatcherHost::ShowBluetoothOverviewLink() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  NOTIMPLEMENTED();
-}
-
-void BluetoothDispatcherHost::ShowBluetoothPairingLink() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  NOTIMPLEMENTED();
-}
-
-void BluetoothDispatcherHost::ShowBluetoothAdapterOffLink() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  NOTIMPLEMENTED();
-}
-
-void BluetoothDispatcherHost::ShowNeedLocationLink() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  NOTIMPLEMENTED();
-}
-
 }  // namespace content