Handle RESCAN events from the Bluetooth chooser by starting or extending a discovery session.

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 225 matching lines @@
         request_id(request_id),
         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.Pass();
+  }
+
   const int thread_id;
   const int request_id;
   const std::vector<BluetoothScanFilter> filters;
   const std::vector<BluetoothUUID> optional_services;
   scoped_ptr<BluetoothChooser> chooser;
   scoped_ptr<device::BluetoothDiscoverySession> discovery_session;
 };
 
 void BluetoothDispatcherHost::set_adapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (adapter_.get())
     adapter_->RemoveObserver(this);
   adapter_ = adapter;
   if (adapter_.get())
     adapter_->AddObserver(this);
 }
 
+void BluetoothDispatcherHost::StartDiscovery(RequestDeviceSession* session,
+                                             int chooser_id) {
+  if (session->discovery_session) {
+    // Already running; just increase the timeout.
+    discovery_session_timer_.Reset();
+  } else {
+    session->chooser->ShowDiscoveryState(
+        BluetoothChooser::DiscoveryState::DISCOVERING);
+    adapter_->StartDiscoverySessionWithFilter(
+        session->ComputeScanFilter(),
+        base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStarted,
+                   weak_ptr_factory_.GetWeakPtr(), chooser_id),
+        base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStartedError,
+                   weak_ptr_factory_.GetWeakPtr(), chooser_id));
+  }
+}
+
 void BluetoothDispatcherHost::StopDeviceDiscovery() {
   for (IDMap<RequestDeviceSession, IDMapOwnPointer>::iterator iter(
            &request_device_sessions_);
        !iter.IsAtEnd(); iter.Advance()) {
     RequestDeviceSession* session = iter.GetCurrentValue();
     if (session->discovery_session) {
       StopDiscoverySession(session->discovery_session.Pass());
     }
     if (session->chooser) {
       session->chooser->ShowDiscoveryState(
@@ skipping 34 matching lines @@
   for (IDMap<RequestDeviceSession, IDMapOwnPointer>::iterator iter(
            &request_device_sessions_);
        !iter.IsAtEnd(); iter.Advance()) {
     RequestDeviceSession* session = iter.GetCurrentValue();
     if (session->chooser) {
       session->chooser->RemoveDevice(device->GetAddress());
     }
   }
 }
 
-static scoped_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter(
-    const std::vector<BluetoothScanFilter>& filters) {
-  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.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);
   RecordRequestDeviceArguments(filters, optional_services);
 
@@ skipping 75 matching lines @@
     // If the dialog's closing, no need to do any of the rest of this.
     return;
   }
 
   if (!adapter_->IsPowered()) {
     session->chooser->SetAdapterPresence(
         BluetoothChooser::AdapterPresence::POWERED_OFF);
     return;
   }
 
-  // Redundant with the chooser's default; just to be clear:
-  session->chooser->ShowDiscoveryState(
-      BluetoothChooser::DiscoveryState::DISCOVERING);
-  adapter_->StartDiscoverySessionWithFilter(
-      ComputeScanFilter(filters),
-      base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStarted,
-                 weak_ptr_factory_.GetWeakPtr(), chooser_id),
-      base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStartedError,
-                 weak_ptr_factory_.GetWeakPtr(), chooser_id));
+  StartDiscovery(session, chooser_id);
 }
 
 void BluetoothDispatcherHost::OnConnectGATT(
     int thread_id,
     int request_id,
     const std::string& device_instance_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::CONNECT_GATT);
   const base::TimeTicks start_time = base::TimeTicks::Now();
 
@@ skipping 267 matching lines @@
     }
   }
   // Ignore discovery session start errors when the dialog was already closed by
   // the time they happen.
 }
 
 void BluetoothDispatcherHost::OnBluetoothChooserEvent(
     int chooser_id,
     BluetoothChooser::Event event,
     const std::string& device_id) {
+  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:
-      // TODO(jyasskin): Implement starting a new Bluetooth discovery session.
-      NOTIMPLEMENTED();
+      StartDiscovery(session, chooser_id);
       break;
     case BluetoothChooser::Event::CANCELLED:
     case BluetoothChooser::Event::SELECTED: {
-      RequestDeviceSession* session =
-          request_device_sessions_.Lookup(chooser_id);
-      DCHECK(session) << "Shouldn't close the dialog twice.";
-      CHECK(session->chooser) << "Shouldn't close the dialog twice.";
-
       // 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_factory_.GetWeakPtr(), chooser_id, event,
@@ skipping 174 matching lines @@
 
 void BluetoothDispatcherHost::ShowBluetoothPairingLink() {
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowBluetoothAdapterOffLink() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace content