bluetooth: Implement acceptAllDevices

content/browser/bluetooth/bluetooth_device_chooser_controller.cc

 // Copyright 2016 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.
 
 #include "content/browser/bluetooth/bluetooth_device_chooser_controller.h"
 
 #include <set>
 #include <string>
 #include <unordered_set>
 
@@ skipping 43 matching lines @@
 constexpr size_t kMaxLengthForDeviceName =
     29;  // max length of device name in filter.
 
 // The duration of a Bluetooth Scan in seconds.
 constexpr int kScanDuration = 60;
 constexpr int kTestScanDuration = 0;
 
 void LogRequestDeviceOptions(
     const blink::mojom::WebBluetoothRequestDeviceOptionsPtr& options) {
   VLOG(1) << "requestDevice called with the following filters: ";
+  VLOG(1) << "acceptAllDevices: " << options->accept_all_devices;
+
+  if (!options->filters)
+    return;
+
   int i = 0;
-  for (const auto& filter : options->filters) {
+  for (const auto& filter : options->filters.value()) {
     VLOG(1) << "Filter #" << ++i;
     if (filter->name)
       VLOG(1) << "Name: " << filter->name.value();
 
     if (filter->name_prefix)
       VLOG(1) << "Name Prefix: " << filter->name_prefix.value();
 
     if (filter->services) {
       VLOG(1) << "Services: ";
       VLOG(1) << "\t[";
@@ skipping 17 matching lines @@
   if (filter->name_prefix && filter->name_prefix->size() == 0)
     return true;
   if (filter->name_prefix &&
       filter->name_prefix->size() > kMaxLengthForDeviceName)
     return true;
 
   return false;
 }
 
 bool HasEmptyOrInvalidFilter(
-    const std::vector<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
-  return filters.empty()
+    const base::Optional<std::vector<blink::mojom::WebBluetoothScanFilterPtr>>&
+        filters) {
+  if (!filters) {
+    return true;
+  }
+
+  return filters->empty()
              ? true
-             : filters.end() != std::find_if(filters.begin(), filters.end(),
-                                             IsEmptyOrInvalidFilter);
+             : filters->end() != std::find_if(filters->begin(), filters->end(),
+                                              IsEmptyOrInvalidFilter);
+}
+
+bool IsOptionsInvalid(
+    const blink::mojom::WebBluetoothRequestDeviceOptionsPtr& options) {
+  if (options->accept_all_devices) {
+    return options->filters.has_value();
+  } else {
+    return HasEmptyOrInvalidFilter(options->filters);
+  }
 }
 
 bool MatchesFilter(const std::string* device_name,
                    const UUIDSet& device_uuids,
                    const blink::mojom::WebBluetoothScanFilterPtr& filter) {
   if (filter->name) {
     if (device_name == nullptr)
       return false;
     if (filter->name.value() != *device_name)
       return false;
@@ skipping 14 matching lines @@
       }
     }
   }
 
   return true;
 }
 
 bool MatchesFilters(
     const std::string* device_name,
     const UUIDSet& device_uuids,
-    const std::vector<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
+    const base::Optional<std::vector<blink::mojom::WebBluetoothScanFilterPtr>>&
+        filters) {
   DCHECK(!HasEmptyOrInvalidFilter(filters));
-  for (const auto& filter : filters) {
+  for (const auto& filter : filters.value()) {
     if (MatchesFilter(device_name, device_uuids, filter)) {
       return true;
     }
   }
   return false;
 }
 
 std::unique_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter(
-    const std::vector<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
+    const base::Optional<std::vector<blink::mojom::WebBluetoothScanFilterPtr>>&
+        filters) {
   std::unordered_set<BluetoothUUID, device::BluetoothUUIDHash> services;
-  for (const auto& filter : filters) {
-    if (!filter->services) {
-      continue;
-    }
-    for (const auto& service : filter->services.value()) {
-      services.insert(service);
+
+  if (filters) {
+    for (const auto& filter : filters.value()) {
+      if (!filter->services) {
+        continue;
+      }
+      for (const auto& service : filter->services.value()) {
+        services.insert(service);
+      }
     }
   }
+
   // There isn't much support for GATT over BR/EDR from neither platforms nor
   // devices so performing a Dual scan will find devices that the API is not
   // able to interact with. To avoid wasting power and confusing users with
   // devices they are not able to interact with, we only perform an LE Scan.
   auto discovery_filter = base::MakeUnique<device::BluetoothDiscoveryFilter>(
       device::BLUETOOTH_TRANSPORT_LE);
   for (const BluetoothUUID& service : services) {
     discovery_filter->AddUUID(service);
   }
   return discovery_filter;
@@ skipping 81 matching lines @@
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // GetDevice should only be called once.
   DCHECK(success_callback_.is_null());
   DCHECK(error_callback_.is_null());
 
   success_callback_ = success_callback;
   error_callback_ = error_callback;
 
-  // The renderer should never send empty filters.
-  if (HasEmptyOrInvalidFilter(options->filters)) {
+  // The renderer should never send invalid options.
+  if (IsOptionsInvalid(options)) {
     web_bluetooth_service_->CrashRendererAndClosePipe(
-        bad_message::BDH_EMPTY_OR_INVALID_FILTERS);
+        bad_message::BDH_INVALID_OPTIONS);
     return;
   }
   options_ = std::move(options);
   LogRequestDeviceOptions(options_);
 
   // Check blocklist to reject invalid filters and adjust optional_services.
-  if (BluetoothBlocklist::Get().IsExcluded(options_->filters)) {
+  if (options_->filters &&
+      BluetoothBlocklist::Get().IsExcluded(options_->filters.value())) {
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLOCKLISTED_SERVICE_IN_FILTER);
     PostErrorCallback(
         blink::mojom::WebBluetoothResult::REQUEST_DEVICE_WITH_BLOCKLISTED_UUID);
     return;
   }
   BluetoothBlocklist::Get().RemoveExcludedUUIDs(options_.get());
 
   const url::Origin requesting_origin =
       render_frame_host_->GetLastCommittedOrigin();
@@ skipping 80 matching lines @@
         BluetoothChooser::AdapterPresence::POWERED_OFF);
     return;
   }
 
   StartDeviceDiscovery();
 }
 
 void BluetoothDeviceChooserController::AddFilteredDevice(
     const device::BluetoothDevice& device) {
   base::Optional<std::string> device_name = device.GetName();
-  if (chooser_.get() &&
-      MatchesFilters(device_name ? &device_name.value() : nullptr,
-                     device.GetUUIDs(), options_->filters)) {
-    base::Optional<int8_t> rssi = device.GetInquiryRSSI();
-    chooser_->AddOrUpdateDevice(
-        device.GetAddress(), !!device.GetName() /* should_update_name */,
-        device.GetNameForDisplay(), device.IsGattConnected(),
-        web_bluetooth_service_->IsDevicePaired(device.GetAddress()),
-        rssi ? CalculateSignalStrengthLevel(rssi.value()) : -1);
+  if (chooser_.get()) {
+    if (options_->accept_all_devices ||
+        MatchesFilters(device_name ? &device_name.value() : nullptr,
+                       device.GetUUIDs(), options_->filters)) {
+      base::Optional<int8_t> rssi = device.GetInquiryRSSI();
+      chooser_->AddOrUpdateDevice(
+          device.GetAddress(), !!device.GetName() /* should_update_name */,
+          device.GetNameForDisplay(), device.IsGattConnected(),
+          web_bluetooth_service_->IsDevicePaired(device.GetAddress()),
+          rssi ? CalculateSignalStrengthLevel(rssi.value()) : -1);
+    }
   }
 }
 
 void BluetoothDeviceChooserController::AdapterPoweredChanged(bool powered) {
   if (!powered && discovery_session_.get()) {
     StopDiscoverySession(std::move(discovery_session_));
   }
 
   if (chooser_.get()) {
     chooser_->SetAdapterPresence(
@@ skipping 163 matching lines @@
 
 void BluetoothDeviceChooserController::PostErrorCallback(
     blink::mojom::WebBluetoothResult error) {
   if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(error_callback_, error))) {
     LOG(WARNING) << "No TaskRunner.";
   }
 }
 
 }  // namespace content