bluetooth: Cache device name and uuids when iterating over filters

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/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_common.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 
 using device::BluetoothUUID;
+using UUIDSet = device::BluetoothDevice::UUIDSet;
 
 namespace {
 
 // Anything worse than or equal to this will show 0 bars.
 const int kMinRSSI = -100;
 // Anything better than or equal to this will show the maximum bars.
 const int kMaxRSSI = -55;
 // Number of RSSI levels used in the signal strength image.
 const int kNumSignalStrengthLevels = 5;
 
@@ skipping 61 matching lines @@
 }
 
 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,
+bool MatchesFilter(const std::string* device_name,
+                   const UUIDSet& device_uuids,
                    const blink::mojom::WebBluetoothScanFilterPtr& filter) {
   if (!filter->name.is_null()) {
-    if (!device.GetName())
+    if (device_name == nullptr)
       return false;
-    if (filter->name != device.GetName().value())
+    if (filter->name != *device_name)
       return false;
   }
 
   if (!filter->name_prefix.is_null() && filter->name_prefix.size()) {
-    if (!device.GetName())
+    if (device_name == nullptr)
       return false;
-    if (!base::StartsWith(device.GetName().value(), filter->name_prefix.get(),
+    if (!base::StartsWith(*device_name, filter->name_prefix.get(),
                           base::CompareCase::SENSITIVE))
       return false;
   }
 
   if (!filter->services.is_null()) {
-    const device::BluetoothDevice::UUIDSet& device_uuids = device.GetUUIDs();
     for (const base::Optional<BluetoothUUID>& service : filter->services) {
       if (!base::ContainsKey(device_uuids, service.value())) {
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool MatchesFilters(
-    const device::BluetoothDevice& device,
+    const std::string* device_name,
+    const UUIDSet& device_uuids,
     const mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
   DCHECK(!HasEmptyOrInvalidFilter(filters));
   for (const auto& filter : filters) {
-    if (MatchesFilter(device, filter)) {
+    if (MatchesFilter(device_name, device_uuids, filter)) {
       return true;
     }
   }
   return false;
 }
 
 std::unique_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter(
     const mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
   std::unordered_set<BluetoothUUID, device::BluetoothUUIDHash> services;
   for (const auto& filter : filters) {
@@ skipping 198 matching lines @@
     chooser_->SetAdapterPresence(
         BluetoothChooser::AdapterPresence::POWERED_OFF);
     return;
   }
 
   StartDeviceDiscovery();
 }
 
 void BluetoothDeviceChooserController::AddFilteredDevice(
     const device::BluetoothDevice& device) {
-  if (chooser_.get() && MatchesFilters(device, options_->filters)) {
+  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);
   }
 }
 
 void BluetoothDeviceChooserController::AdapterPoweredChanged(bool powered) {
@@ skipping 157 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