Rename BluetoothScanFilterInit to BluetoothLEScanFilterInit

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 97 matching lines @@
       DVLOG(1) << "Services: ";
       DVLOG(1) << "\t[";
       for (const auto& service : filter->services.value())
         DVLOG(1) << "\t\t" << service.canonical_value();
       DVLOG(1) << "\t]";
     }
   }
 }
 
 bool IsEmptyOrInvalidFilter(
-    const blink::mojom::WebBluetoothScanFilterPtr& filter) {
+    const blink::mojom::WebBluetoothLeScanFilterPtr& filter) {
   // At least one member needs to be present.
   if (!filter->name && !filter->name_prefix && !filter->services)
     return true;
 
   // The renderer will never send a name or a name_prefix longer than
   // kMaxLengthForDeviceName.
   if (filter->name && filter->name->size() > kMaxLengthForDeviceName)
     return true;
   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 base::Optional<std::vector<blink::mojom::WebBluetoothScanFilterPtr>>&
-        filters) {
+    const base::Optional<
+        std::vector<blink::mojom::WebBluetoothLeScanFilterPtr>>& filters) {
   if (!filters) {
     return true;
   }
 
   return filters->empty()
              ? true
              : 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) {
+                   const blink::mojom::WebBluetoothLeScanFilterPtr& filter) {
   if (filter->name) {
     if (device_name == nullptr)
       return false;
     if (filter->name.value() != *device_name)
       return false;
   }
 
   if (filter->name_prefix && filter->name_prefix->size()) {
     if (device_name == nullptr)
       return false;
     if (!base::StartsWith(*device_name, filter->name_prefix.value(),
                           base::CompareCase::SENSITIVE))
       return false;
   }
 
   if (filter->services) {
     for (const auto& service : filter->services.value()) {
       if (!base::ContainsKey(device_uuids, service)) {
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool MatchesFilters(
     const std::string* device_name,
     const UUIDSet& device_uuids,
-    const base::Optional<std::vector<blink::mojom::WebBluetoothScanFilterPtr>>&
-        filters) {
+    const base::Optional<
+        std::vector<blink::mojom::WebBluetoothLeScanFilterPtr>>& filters) {
   DCHECK(!HasEmptyOrInvalidFilter(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 base::Optional<std::vector<blink::mojom::WebBluetoothScanFilterPtr>>&
-        filters) {
+    const base::Optional<
+        std::vector<blink::mojom::WebBluetoothLeScanFilterPtr>>& filters) {
   std::unordered_set<BluetoothUUID, device::BluetoothUUIDHash> services;
 
   if (filters) {
     for (const auto& filter : filters.value()) {
       if (!filter->services) {
         continue;
       }
       for (const auto& service : filter->services.value()) {
         services.insert(service);
       }
@@ skipping 403 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