Chromium side of RequestDeviceOptions implementation.

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://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
 
 #include "content/browser/bluetooth/bluetooth_dispatcher_host.h"
 
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/bad_message.h"
 #include "content/common/bluetooth/bluetooth_messages.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothGattCharacteristic;
 using device::BluetoothGattService;
+using device::BluetoothUUID;
 
 namespace {
 
 // These types of errors aren't as common. We log them to understand
 // how common they are and if we need to investigate more.
 enum class BluetoothGATTError {
   UNKNOWN,
   FAILED,
   IN_PROGRESS,
   NOT_PAIRED,
@@ skipping 134 matching lines @@
   current_delay_time_ = kTestingDelayTime;
   set_adapter(mock_adapter.Pass());
 }
 
 BluetoothDispatcherHost::~BluetoothDispatcherHost() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Clear adapter, releasing observer references.
   set_adapter(scoped_refptr<device::BluetoothAdapter>());
 }
 
+struct BluetoothDispatcherHost::DiscoverySessionOptions {
+  DiscoverySessionOptions(const std::vector<BluetoothScanFilter>& filters,
+                          const std::vector<BluetoothUUID>& optional_services)
+      : filters(filters), optional_services(optional_services) {}
+
+  std::vector<BluetoothScanFilter> filters;
+  std::vector<BluetoothUUID> optional_services;
+};
+
 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::OnRequestDevice(int thread_id, int request_id) {
+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,
+    const std::vector<BluetoothScanFilter>& filters,
+    const std::vector<BluetoothUUID>& optional_services) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  // TODO(scheib): Filter devices by services: crbug.com/440594
   // TODO(scheib): Device selection UI: crbug.com/436280
   // TODO(scheib): Utilize BluetoothAdapter::Observer::DeviceAdded/Removed.
   if (adapter_.get()) {
-    adapter_->StartDiscoverySession(
+    adapter_->StartDiscoverySessionWithFilter(
+        ComputeScanFilter(filters),
         base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStarted,
-                   weak_ptr_factory_.GetWeakPtr(), thread_id, request_id),
+                   weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
+                   base::Passed(make_scoped_ptr(new DiscoverySessionOptions(
+                       filters, optional_services)))),
         base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStartedError,
                    weak_ptr_factory_.GetWeakPtr(), thread_id, request_id));
   } else {
     DLOG(WARNING) << "No BluetoothAdapter. Can't serve requestDevice.";
     Send(new BluetoothMsg_RequestDeviceError(
         thread_id, request_id, BluetoothError::NOT_FOUND, kNoBluetoothAdapter));
   }
   return;
 }
 
@@ skipping 159 matching lines @@
   characteristic->ReadRemoteCharacteristic(
       base::Bind(&BluetoothDispatcherHost::OnCharacteristicValueRead,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id),
       base::Bind(&BluetoothDispatcherHost::OnCharacteristicReadValueError,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStarted(
     int thread_id,
     int request_id,
+    scoped_ptr<DiscoverySessionOptions> options,
     scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BluetoothDispatcherHost::StopDiscoverySession,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
-                 base::Passed(&discovery_session)),
+                 base::Passed(&options), 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";
   Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
                                            BluetoothError::NOT_FOUND,
                                            kDiscoverySessionStartFailed));
 }
 
 void BluetoothDispatcherHost::StopDiscoverySession(
     int thread_id,
     int request_id,
+    scoped_ptr<DiscoverySessionOptions> options,
     scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   discovery_session->Stop(
       base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStopped,
-                 weak_ptr_factory_.GetWeakPtr(), thread_id, request_id),
+                 weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
+                 base::Passed(&options)),
       base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStoppedError,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id));
 }
 
-void BluetoothDispatcherHost::OnDiscoverySessionStopped(int thread_id,
-                                                        int request_id) {
+// Defined at
+// https://webbluetoothcg.github.io/web-bluetooth/#dfn-matches-a-filter
+static bool MatchesFilter(const std::set<BluetoothUUID>& device_uuids,
+                          const BluetoothScanFilter& filter) {
+  if (filter.services.empty())
+    return false;
+  for (const BluetoothUUID& service : filter.services) {
+    if (!ContainsKey(device_uuids, service)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool MatchesFilters(const device::BluetoothDevice& device,
+                           const std::vector<BluetoothScanFilter>& filters) {
+  const std::vector<BluetoothUUID>& device_uuid_list = device.GetUUIDs();
+  const std::set<BluetoothUUID> device_uuids(device_uuid_list.begin(),
+                                             device_uuid_list.end());
+  for (const BluetoothScanFilter& filter : filters) {
+    if (MatchesFilter(device_uuids, filter)) {
+      return true;
+    }
+  }
+  return false;
+}
+void BluetoothDispatcherHost::OnDiscoverySessionStopped(
+    int thread_id,
+    int request_id,
+    scoped_ptr<DiscoverySessionOptions> options) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
-  if (devices.begin() == devices.end()) {
-    Send(new BluetoothMsg_RequestDeviceError(
-        thread_id, request_id, BluetoothError::NOT_FOUND, kNoDevicesFound));
-  } else {
-    device::BluetoothDevice* device = *devices.begin();
-    content::BluetoothDevice device_ipc(
-        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
-    Send(new BluetoothMsg_RequestDeviceSuccess(thread_id, request_id,
-                                               device_ipc));
+  for (device::BluetoothDevice* device : devices) {
+    if (MatchesFilters(*device, options->filters)) {
+      content::BluetoothDevice device_ipc(
+          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
+      Send(new BluetoothMsg_RequestDeviceSuccess(thread_id, request_id,
+                                                 device_ipc));
+      return;
+    }
   }
+  Send(new BluetoothMsg_RequestDeviceError(
+      thread_id, request_id, BluetoothError::NOT_FOUND, kNoDevicesFound));
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStoppedError(int thread_id,
                                                              int request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DLOG(WARNING) << "BluetoothDispatcherHost::OnDiscoverySessionStoppedError";
   Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
                                            BluetoothError::NOT_FOUND,
                                            kDiscoverySessionStopFailed));
 }
@@ skipping 68 matching lines @@
 void BluetoothDispatcherHost::OnCharacteristicReadValueError(
     int thread_id,
     int request_id,
     device::BluetoothGattService::GattErrorCode error_code) {
   std::pair<BluetoothError, std::string> error = TranslateGATTError(error_code);
   Send(new BluetoothMsg_ReadCharacteristicValueError(
       thread_id, request_id, error.first, error.second));
 }
 
 }  // namespace content