bluetooth: Use BluetoothUUID instead of string when sending uuids

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/bluetooth/bluetooth_blacklist.h"
 #include "content/browser/bluetooth/bluetooth_metrics.h"
 #include "content/browser/bluetooth/first_device_bluetooth_chooser.h"
 #include "content/browser/bluetooth/web_bluetooth_service_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 
+using device::BluetoothUUID;
+
 namespace content {
 
 namespace {
 constexpr size_t kMaxLengthForDeviceName =
     29;  // max length of device name in filter.
 
 void LogRequestDeviceOptions(
     const blink::mojom::WebBluetoothRequestDeviceOptionsPtr& options) {
   VLOG(1) << "requestDevice called with the following filters: ";
   int i = 0;
   for (const auto& filter : options->filters) {
     VLOG(1) << "Filter #" << ++i;
     if (!filter->name.is_null())
       VLOG(1) << "Name: " << filter->name;
 
     if (!filter->name_prefix.is_null())
       VLOG(1) << "Name Prefix: " << filter->name_prefix;
 
     if (!filter->services.is_null()) {
       VLOG(1) << "Services: ";
       VLOG(1) << "\t[";
       for (const auto& service : filter->services)
-        VLOG(1) << "\t\t" << service;
+        VLOG(1) << "\t\t" << service->canonical_value();
       VLOG(1) << "\t]";
     }
   }
 }
 
-bool IsValidUUID(const mojo::String& uuid) {
-  device::BluetoothUUID parsed_uuid(uuid);
-  return parsed_uuid.IsValid() &&
-         parsed_uuid.format() == device::BluetoothUUID::kFormat128Bit;
-}
-
-bool HasInvalidOptionalServices(
-    const mojo::Array<mojo::String>& optional_services) {
-  return optional_services.end() != std::find_if_not(optional_services.begin(),
-                                                     optional_services.end(),
-                                                     IsValidUUID);
-}
-
 bool IsEmptyOrInvalidFilter(
     const blink::mojom::WebBluetoothScanFilterPtr& filter) {
   // At least one member needs to be present.
   if (filter->name.is_null() && filter->name_prefix.is_null() &&
       filter->services.is_null())
     return true;
 
   // The renderer will never send a name or a name_prefix longer than
   // kMaxLengthForDeviceName.
   if (!filter->name.is_null() && filter->name.size() > kMaxLengthForDeviceName)
     return true;
   if (!filter->name_prefix.is_null() &&
       filter->name_prefix.size() > kMaxLengthForDeviceName)
     return true;
 
-  if (!filter->services.is_null()) {
-    const auto& services = filter->services;
-    return services.end() !=
-           std::find_if_not(services.begin(), services.end(), IsValidUUID);
-  }
-
   return false;
 }
 
 bool HasEmptyOrInvalidFilter(
     const mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
   return filters.empty()
              ? true
              : filters.end() != std::find_if(filters.begin(), filters.end(),
                                              IsEmptyOrInvalidFilter);
 }
 
 bool MatchesFilter(const device::BluetoothDevice& device,
                    const blink::mojom::WebBluetoothScanFilterPtr& filter) {
   DCHECK(!IsEmptyOrInvalidFilter(filter));
 
   const std::string device_name = base::UTF16ToUTF8(device.GetName());
 
   if (!filter->name.is_null() && (device_name != filter->name)) {
     return false;
   }
 
   if (!filter->name_prefix.is_null() &&
       (!base::StartsWith(device_name, filter->name_prefix.get(),
                          base::CompareCase::SENSITIVE))) {
     return false;
   }
 
   if (!filter->services.is_null()) {
     const auto& device_uuid_list = device.GetUUIDs();
-    const std::set<device::BluetoothUUID> device_uuids(device_uuid_list.begin(),
-                                                       device_uuid_list.end());
-    for (const auto& service : filter->services) {
-      if (!ContainsKey(device_uuids, device::BluetoothUUID(service))) {
+    const std::set<BluetoothUUID> device_uuids(device_uuid_list.begin(),
+                                               device_uuid_list.end());
+    for (const std::unique_ptr<BluetoothUUID>& service : filter->services) {
+      if (!ContainsKey(device_uuids, *service)) {
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool MatchesFilters(
     const device::BluetoothDevice& device,
     const mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
   DCHECK(!HasEmptyOrInvalidFilter(filters));
   for (const auto& filter : filters) {
     if (MatchesFilter(device, filter)) {
       return true;
     }
   }
   return false;
 }
 
 std::unique_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter(
     const mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
-  std::unordered_set<std::string> services;
+  std::set<BluetoothUUID> services;
   for (const auto& filter : filters) {
-    for (const std::string& service : filter->services) {
-      services.insert(service);
+    for (const std::unique_ptr<BluetoothUUID>& service : filter->services) {
+      services.insert(*service);
     }
   }
   auto discovery_filter = base::MakeUnique<device::BluetoothDiscoveryFilter>(
       device::BluetoothDiscoveryFilter::TRANSPORT_DUAL);
-  for (const std::string& service : services) {
-    discovery_filter->AddUUID(device::BluetoothUUID(service));
+  for (const BluetoothUUID& service : services) {
+    discovery_filter->AddUUID(service);
   }
   return discovery_filter;
 }
 
 void StopDiscoverySession(
     std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) {
   // Nothing goes wrong if the discovery session fails to stop, and we don't
   // need to wait for it before letting the user's script proceed, so we ignore
   // the results here.
   discovery_session->Stop(base::Bind(&base::DoNothing),
@@ skipping 62 matching lines @@
   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) ||
-      HasInvalidOptionalServices(options->optional_services)) {
+  if (HasEmptyOrInvalidFilter(options->filters)) {
     web_bluetooth_service_->CrashRendererAndClosePipe(
         bad_message::BDH_EMPTY_OR_INVALID_FILTERS);
     return;
   }
   options_ = std::move(options);
   LogRequestDeviceOptions(options_);
 
   // Check blacklist to reject invalid filters and adjust optional_services.
   if (BluetoothBlacklist::Get().IsExcluded(options_->filters)) {
     RecordRequestDeviceOutcome(
@@ skipping 226 matching lines @@
 
 void BluetoothDeviceChooserController::PostErrorCallback(
     blink::mojom::WebBluetoothError error) {
   if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(error_callback_, error))) {
     LOG(WARNING) << "No TaskRunner.";
   }
 }
 
 }  // namespace content