bluetooth: Implement requestDevice by name or name prefix

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 29 matching lines @@
 
 namespace {
 
 // TODO(ortuno): Once we have a chooser for scanning, a way to control that
 // chooser from tests, 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
 
+bool EmptyFilter(const content::BluetoothScanFilter& filter) {

[scheib, 2015/10/22 18:35:52]

IsEmptyFilter will be clearer that 'empty' is an adjective and not a verb. 

[ortuno, 2015/10/22 20:47:22]

Done.

+  return filter.name.empty() && filter.namePrefix.empty() &&
+         filter.services.empty();
+}
+
+bool EmptyFilters(const std::vector<content::BluetoothScanFilter>& filters) {

[scheib, 2015/10/22 18:35:52]

IsEmptyFilters.... is sort of poor grammar. IsEmptyFilterSet gets around that
with 'Is', or I suppose the less common 'are' prefix: AreEmptyFilters 

[ortuno, 2015/10/22 20:47:22]

Changed it to HasEmptyFilter.

+  if (filters.empty()) {
+    return true;
+  }
+  for (const content::BluetoothScanFilter& filter : filters) {
+    if (EmptyFilter(filter)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // Defined at
 // https://webbluetoothchrome.github.io/web-bluetooth/#dfn-matches-a-filter
-bool MatchesFilter(const std::set<BluetoothUUID>& device_uuids,
+bool MatchesFilter(const device::BluetoothDevice& device,
                    const content::BluetoothScanFilter& filter) {
-  if (filter.services.empty())
-    return false;
-  for (const BluetoothUUID& service : filter.services) {
-    if (!ContainsKey(device_uuids, service)) {
+  DCHECK(!EmptyFilter(filter));
+
+  const std::string device_name = base::UTF16ToUTF8(device.GetName());
+
+  if (!filter.name.empty()) {
+    if (device_name != filter.name) {
       return false;
     }
   }
+
+  if (!filter.namePrefix.empty()) {
+    if (!base::StartsWith(device_name, filter.namePrefix,
+                          base::CompareCase::SENSITIVE)) {
+      return false;
+    }
+  }
+
+  if (!filter.services.empty()) {
+    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 BluetoothUUID& service : filter.services) {
+      if (!ContainsKey(device_uuids, service)) {
+        return false;
+      }
+    }
+  }
+
   return true;
 }
 
 bool MatchesFilters(const device::BluetoothDevice& device,
                     const std::vector<content::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());
+  DCHECK(!EmptyFilters(filters));
   for (const content::BluetoothScanFilter& filter : filters) {
-    if (MatchesFilter(device_uuids, filter)) {
+    if (MatchesFilter(device, filter)) {
       return true;
     }
   }
   return false;
 }
 
 WebBluetoothError TranslateConnectError(
     device::BluetoothDevice::ConnectErrorCode error_code) {
   switch (error_code) {
     case device::BluetoothDevice::ERROR_UNKNOWN:
@@ skipping 355 matching lines @@
     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);
 
   VLOG(1) << "requestDevice called with the following filters: ";
   for (const BluetoothScanFilter& filter : filters) {
+    VLOG(1) << "Name: " << filter.name;
+    VLOG(1) << "Name Prefix: " << filter.namePrefix;
+    VLOG(1) << "Services:";
     VLOG(1) << "\t[";
     for (const BluetoothUUID& service : filter.services)
       VLOG(1) << "\t\t" << service.value();
     VLOG(1) << "\t]";
   }
 
   VLOG(1) << "requestDevice called with the following optional services: ";
   for (const BluetoothUUID& service : optional_services)
     VLOG(1) << "\t" << service.value();
 
@@ skipping 20 matching lines @@
 
   if (!adapter_->IsPresent()) {
     VLOG(1) << "Bluetooth Adapter not present. Can't serve requestDevice.";
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLUETOOTH_ADAPTER_NOT_PRESENT);
     Send(new BluetoothMsg_RequestDeviceError(
         thread_id, request_id, WebBluetoothError::NoBluetoothAdapter));
     return;
   }
 
+  // The renderer should never send empty filters.
+  if (EmptyFilters(filters)) {
+    bad_message::ReceivedBadMessage(this, bad_message::BDH_EMPTY_FILTERS);
+  }

[scheib, 2015/10/22 18:35:52]

return; in this case instead of opening chooser.

[ortuno, 2015/10/22 20:47:22]

Done.

+
   // Create storage for the information that backs the chooser, and show the
   // chooser.
   RequestDeviceSession* const session = new RequestDeviceSession(
       thread_id, request_id, filters, optional_services);
   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 =
@@ skipping 640 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowBluetoothAdapterOffLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 }  // namespace content