bluetooth: Rename blink::mojom::WebBluetoothError

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 207 matching lines @@
                      // destructor starts.
                      base::Unretained(this)),
           /*is_repeating=*/false),
       weak_ptr_factory_(this) {
   CHECK(adapter_);
 }
 
 BluetoothDeviceChooserController::~BluetoothDeviceChooserController() {
   if (chooser_) {
     DCHECK(!error_callback_.is_null());
-    error_callback_.Run(blink::mojom::WebBluetoothError::CHOOSER_CANCELLED);
+    error_callback_.Run(blink::mojom::WebBluetoothResult::CHOOSER_CANCELLED);
   }
 }
 
 void BluetoothDeviceChooserController::GetDevice(
     blink::mojom::WebBluetoothRequestDeviceOptionsPtr options,
     const SuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // GetDevice should only be called once.
@@ skipping 10 matching lines @@
     return;
   }
   options_ = std::move(options);
   LogRequestDeviceOptions(options_);
 
   // Check blacklist to reject invalid filters and adjust optional_services.
   if (BluetoothBlacklist::Get().IsExcluded(options_->filters)) {
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLACKLISTED_SERVICE_IN_FILTER);
     PostErrorCallback(
-        blink::mojom::WebBluetoothError::REQUEST_DEVICE_WITH_BLACKLISTED_UUID);
+        blink::mojom::WebBluetoothResult::REQUEST_DEVICE_WITH_BLACKLISTED_UUID);
     return;
   }
   BluetoothBlacklist::Get().RemoveExcludedUUIDs(options_.get());
 
   const url::Origin requesting_origin =
       render_frame_host_->GetLastCommittedOrigin();
   const url::Origin embedding_origin =
       web_contents_->GetMainFrame()->GetLastCommittedOrigin();
 
   // TODO(crbug.com/518042): Enforce correctly-delegated permissions instead of
   // matching origins. When relaxing this, take care to handle non-sandboxed
   // unique origins.
   if (!embedding_origin.IsSameOriginWith(requesting_origin)) {
-    PostErrorCallback(blink::mojom::WebBluetoothError::
+    PostErrorCallback(blink::mojom::WebBluetoothResult::
                           REQUEST_DEVICE_FROM_CROSS_ORIGIN_IFRAME);
     return;
   }
   // The above also excludes unique origins, which are not even same-origin with
   // themselves.
   DCHECK(!requesting_origin.unique());
 
   if (!adapter_->IsPresent()) {
     VLOG(1) << "Bluetooth Adapter not present. Can't serve requestDevice.";
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLUETOOTH_ADAPTER_NOT_PRESENT);
-    PostErrorCallback(blink::mojom::WebBluetoothError::NO_BLUETOOTH_ADAPTER);
+    PostErrorCallback(blink::mojom::WebBluetoothResult::NO_BLUETOOTH_ADAPTER);
     return;
   }
 
   switch (GetContentClient()->browser()->AllowWebBluetooth(
       web_contents_->GetBrowserContext(), requesting_origin,
       embedding_origin)) {
     case ContentBrowserClient::AllowWebBluetoothResult::BLOCK_POLICY: {
       RecordRequestDeviceOutcome(
           UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_POLICY_DISABLED);
-      PostErrorCallback(blink::mojom::WebBluetoothError::
+      PostErrorCallback(blink::mojom::WebBluetoothResult::
                             CHOOSER_NOT_SHOWN_API_LOCALLY_DISABLED);
       return;
     }
     case ContentBrowserClient::AllowWebBluetoothResult::
         BLOCK_GLOBALLY_DISABLED: {
       // Log to the developer console.
       web_contents_->GetMainFrame()->AddMessageToConsole(
           content::CONSOLE_MESSAGE_LEVEL_LOG,
           "Bluetooth permission has been blocked.");
       // Block requests.
       RecordRequestDeviceOutcome(
           UMARequestDeviceOutcome::BLUETOOTH_GLOBALLY_DISABLED);
-      PostErrorCallback(blink::mojom::WebBluetoothError::
+      PostErrorCallback(blink::mojom::WebBluetoothResult::
                             CHOOSER_NOT_SHOWN_API_GLOBALLY_DISABLED);
       return;
     }
     case ContentBrowserClient::AllowWebBluetoothResult::ALLOW:
       break;
   }
 
   BluetoothChooser::EventHandler chooser_event_handler =
       base::Bind(&BluetoothDeviceChooserController::OnBluetoothChooserEvent,
                  base::Unretained(this));
 
   if (WebContentsDelegate* delegate = web_contents_->GetDelegate()) {
     chooser_ = delegate->RunBluetoothChooser(render_frame_host_,
                                              chooser_event_handler);
   }
 
   if (!chooser_.get()) {
     PostErrorCallback(
-        blink::mojom::WebBluetoothError::WEB_BLUETOOTH_NOT_SUPPORTED);
+        blink::mojom::WebBluetoothResult::WEB_BLUETOOTH_NOT_SUPPORTED);
     return;
   }
 
   if (!chooser_->CanAskForScanningPermission()) {
     VLOG(1) << "Closing immediately because Chooser cannot obtain permission.";
     OnBluetoothChooserEvent(BluetoothChooser::Event::DENIED_PERMISSION,
                             "" /* device_address */);
     return;
   }
 
@@ skipping 125 matching lines @@
 
   switch (event) {
     case BluetoothChooser::Event::RESCAN:
       PopulateConnectedDevices();
       DCHECK(chooser_);
       StartDeviceDiscovery();
       // No need to close the chooser so we return.
       return;
     case BluetoothChooser::Event::DENIED_PERMISSION:
       RecordRequestDeviceOutcome(OutcomeFromChooserEvent(event));
-      PostErrorCallback(blink::mojom::WebBluetoothError::
+      PostErrorCallback(blink::mojom::WebBluetoothResult::
                             CHOOSER_NOT_SHOWN_USER_DENIED_PERMISSION_TO_SCAN);
       break;
     case BluetoothChooser::Event::CANCELLED:
       RecordRequestDeviceOutcome(OutcomeFromChooserEvent(event));
-      PostErrorCallback(blink::mojom::WebBluetoothError::CHOOSER_CANCELLED);
+      PostErrorCallback(blink::mojom::WebBluetoothResult::CHOOSER_CANCELLED);
       break;
     case BluetoothChooser::Event::SHOW_OVERVIEW_HELP:
       VLOG(1) << "Overview Help link pressed.";
       RecordRequestDeviceOutcome(OutcomeFromChooserEvent(event));
-      PostErrorCallback(blink::mojom::WebBluetoothError::CHOOSER_CANCELLED);
+      PostErrorCallback(blink::mojom::WebBluetoothResult::CHOOSER_CANCELLED);
       break;
     case BluetoothChooser::Event::SHOW_ADAPTER_OFF_HELP:
       VLOG(1) << "Adapter Off Help link pressed.";
       RecordRequestDeviceOutcome(OutcomeFromChooserEvent(event));
-      PostErrorCallback(blink::mojom::WebBluetoothError::CHOOSER_CANCELLED);
+      PostErrorCallback(blink::mojom::WebBluetoothResult::CHOOSER_CANCELLED);
       break;
     case BluetoothChooser::Event::SHOW_NEED_LOCATION_HELP:
       VLOG(1) << "Need Location Help link pressed.";
       RecordRequestDeviceOutcome(OutcomeFromChooserEvent(event));
-      PostErrorCallback(blink::mojom::WebBluetoothError::CHOOSER_CANCELLED);
+      PostErrorCallback(blink::mojom::WebBluetoothResult::CHOOSER_CANCELLED);
       break;
     case BluetoothChooser::Event::SELECTED:
       PostSuccessCallback(device_address);
       break;
   }
   // Close chooser.
   chooser_.reset();
 }
 
 void BluetoothDeviceChooserController::PostSuccessCallback(
     const std::string& device_address) {
   if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(success_callback_, base::Passed(std::move(options_)),
                      device_address))) {
     LOG(WARNING) << "No TaskRunner.";
   }
 }
 
 void BluetoothDeviceChooserController::PostErrorCallback(
-    blink::mojom::WebBluetoothError error) {
+    blink::mojom::WebBluetoothResult error) {
   if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(error_callback_, error))) {
     LOG(WARNING) << "No TaskRunner.";
   }
 }
 
 }  // namespace content