Use new wrapper types for web_bluetooth.mojom

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 46 matching lines @@
 // 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: ";
   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)
+      VLOG(1) << "Name: " << filter->name.value();
 
-    if (!filter->name_prefix.is_null())
-      VLOG(1) << "Name Prefix: " << filter->name_prefix;
+    if (filter->name_prefix)
+      VLOG(1) << "Name Prefix: " << filter->name_prefix.value();
 
-    if (!filter->services.is_null()) {
+    if (filter->services) {
       VLOG(1) << "Services: ";
       VLOG(1) << "\t[";
-      for (const auto& service : filter->services)
-        VLOG(1) << "\t\t" << service->canonical_value();
+      for (const auto& service : filter->services.value())
+        VLOG(1) << "\t\t" << service.canonical_value();
       VLOG(1) << "\t]";
     }
   }
 }
 
 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())
+  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.is_null() && filter->name.size() > kMaxLengthForDeviceName)
+  if (filter->name && filter->name->size() > kMaxLengthForDeviceName)
     return true;
-  if (!filter->name_prefix.is_null() && filter->name_prefix.size() == 0)
+  if (filter->name_prefix && filter->name_prefix->size() == 0)
     return true;
-  if (!filter->name_prefix.is_null() &&
-      filter->name_prefix.size() > kMaxLengthForDeviceName)
+  if (filter->name_prefix &&
+      filter->name_prefix->size() > kMaxLengthForDeviceName)
     return true;
 
   return false;
 }
 
 bool HasEmptyOrInvalidFilter(
-    const mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
+    const std::vector<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
   return filters.empty()
              ? true
              : filters.end() != std::find_if(filters.begin(), filters.end(),
                                              IsEmptyOrInvalidFilter);
 }
 
 bool MatchesFilter(const std::string* device_name,
                    const UUIDSet& device_uuids,
                    const blink::mojom::WebBluetoothScanFilterPtr& filter) {
-  if (!filter->name.is_null()) {
+  if (filter->name) {
     if (device_name == nullptr)
       return false;
-    if (filter->name != *device_name)
+    if (filter->name.value() != *device_name)
       return false;
   }
 
-  if (!filter->name_prefix.is_null() && filter->name_prefix.size()) {
+  if (filter->name_prefix && filter->name_prefix->size()) {
     if (device_name == nullptr)
       return false;
-    if (!base::StartsWith(*device_name, filter->name_prefix.get(),
+    if (!base::StartsWith(*device_name, filter->name_prefix.value(),
                           base::CompareCase::SENSITIVE))
       return false;
   }
 
-  if (!filter->services.is_null()) {
-    for (const base::Optional<BluetoothUUID>& service : filter->services) {
-      if (!base::ContainsKey(device_uuids, service.value())) {
+  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 mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
+    const std::vector<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
   DCHECK(!HasEmptyOrInvalidFilter(filters));
   for (const auto& filter : filters) {
-    if (MatchesFilter(device_name, device_uuids, 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) {
+    const std::vector<blink::mojom::WebBluetoothScanFilterPtr>& filters) {
   std::unordered_set<BluetoothUUID, device::BluetoothUUIDHash> services;
   for (const auto& filter : filters) {
-    for (const base::Optional<BluetoothUUID>& service : filter->services) {
-      services.insert(service.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) {
+  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),
                           base::Bind(&base::DoNothing));
@@ skipping 196 matching lines @@
     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()) {
+  if (!powered && discovery_session_.get())
     StopDiscoverySession(std::move(discovery_session_));
-  }
 
   if (chooser_.get()) {
     chooser_->SetAdapterPresence(
         powered ? BluetoothChooser::AdapterPresence::POWERED_ON
                 : BluetoothChooser::AdapterPresence::POWERED_OFF);
     if (powered) {
       OnBluetoothChooserEvent(BluetoothChooser::Event::RESCAN,
                               "" /* device_address */);
     }
   }
 
-  if (!powered) {
+  if (!powered)
     discovery_session_timer_.Stop();
-  }
 }
 
 int BluetoothDeviceChooserController::CalculateSignalStrengthLevel(
     int8_t rssi) {
   RecordRSSISignalStrength(rssi);
 
   if (rssi <= kMinRSSI) {
     RecordRSSISignalStrengthLevel(
         UMARSSISignalStrengthLevel::LESS_THAN_OR_EQUAL_TO_MIN_RSSI);
     return 0;
@@ skipping 12 matching lines @@
   RecordRSSISignalStrengthLevel(kRSSISignalStrengthEnumTable[level]);
   return level;
 }
 
 void BluetoothDeviceChooserController::SetTestScanDurationForTesting() {
   BluetoothDeviceChooserController::use_test_scan_duration_ = true;
 }
 
 void BluetoothDeviceChooserController::PopulateConnectedDevices() {
   for (const device::BluetoothDevice* device : adapter_->GetDevices()) {
-    if (device->IsGattConnected()) {
+    if (device->IsGattConnected())
       AddFilteredDevice(*device);
-    }
   }
 }
 
 void BluetoothDeviceChooserController::StartDeviceDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (discovery_session_.get() && discovery_session_->IsActive()) {
     // Already running; just increase the timeout.
     discovery_session_timer_.Reset();
     return;
@@ skipping 15 matching lines @@
 void BluetoothDeviceChooserController::StopDeviceDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (scanning_start_time_) {
     RecordScanningDuration(base::TimeTicks::Now() -
                            scanning_start_time_.value());
     scanning_start_time_.reset();
   }
 
   StopDiscoverySession(std::move(discovery_session_));
-  if (chooser_) {
+  if (chooser_)
     chooser_->ShowDiscoveryState(BluetoothChooser::DiscoveryState::IDLE);
-  }
 }
 
 void BluetoothDeviceChooserController::OnStartDiscoverySessionSuccess(
     std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   VLOG(1) << "Started discovery session.";
   if (chooser_.get()) {
     discovery_session_ = std::move(discovery_session);
     discovery_session_timer_.Reset();
   } else {
@@ skipping 69 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