bluetooth: Change definition of WebBluetoothError to mojo enum

content/browser/bluetooth/bluetooth_dispatcher_host.cc

 // Copyright 2014 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.
 
 // ID Not In Map Note:
 // A service, characteristic, or descriptor ID not in the corresponding
 // BluetoothDispatcherHost map [service_to_device_, characteristic_to_service_,
 // descriptor_to_characteristic_] implies a hostile renderer because a renderer
 // obtains the corresponding ID from this class and it will be added to the map
 // at that time.
@@ skipping 100 matching lines @@
     }
   }
   return false;
 }
 
 WebBluetoothError TranslateConnectError(
     device::BluetoothDevice::ConnectErrorCode error_code) {
   switch (error_code) {
     case device::BluetoothDevice::ERROR_UNKNOWN:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::UNKNOWN);
-      return WebBluetoothError::ConnectUnknownError;
+      return WebBluetoothError::CONNECT_UNKNOWN_ERROR;
     case device::BluetoothDevice::ERROR_INPROGRESS:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::IN_PROGRESS);
-      return WebBluetoothError::ConnectAlreadyInProgress;
+      return WebBluetoothError::CONNECT_ALREADY_IN_PROGRESS;
     case device::BluetoothDevice::ERROR_FAILED:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::FAILED);
-      return WebBluetoothError::ConnectUnknownFailure;
+      return WebBluetoothError::CONNECT_UNKNOWN_FAILURE;
     case device::BluetoothDevice::ERROR_AUTH_FAILED:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::AUTH_FAILED);
-      return WebBluetoothError::ConnectAuthFailed;
+      return WebBluetoothError::CONNECT_AUTH_FAILED;
     case device::BluetoothDevice::ERROR_AUTH_CANCELED:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::AUTH_CANCELED);
-      return WebBluetoothError::ConnectAuthCanceled;
+      return WebBluetoothError::CONNECT_AUTH_CANCELED;
     case device::BluetoothDevice::ERROR_AUTH_REJECTED:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::AUTH_REJECTED);
-      return WebBluetoothError::ConnectAuthRejected;
+      return WebBluetoothError::CONNECT_AUTH_REJECTED;
     case device::BluetoothDevice::ERROR_AUTH_TIMEOUT:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::AUTH_TIMEOUT);
-      return WebBluetoothError::ConnectAuthTimeout;
+      return WebBluetoothError::CONNECT_AUTH_TIMEOUT;
     case device::BluetoothDevice::ERROR_UNSUPPORTED_DEVICE:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::UNSUPPORTED_DEVICE);
-      return WebBluetoothError::ConnectUnsupportedDevice;
+      return WebBluetoothError::CONNECT_UNSUPPORTED_DEVICE;
     case device::BluetoothDevice::ERROR_ATTRIBUTE_LENGTH_INVALID:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::ATTRIBUTE_LENGTH_INVALID);
-      return WebBluetoothError::ConnectAttributeLengthInvalid;
+      return WebBluetoothError::CONNECT_ATTRIBUTE_LENGTH_INVALID;
     case device::BluetoothDevice::ERROR_CONNECTION_CONGESTED:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::CONNECTION_CONGESTED);
-      return WebBluetoothError::ConnectConnectionCongested;
+      return WebBluetoothError::CONNECT_CONNECTION_CONGESTED;
     case device::BluetoothDevice::ERROR_INSUFFICIENT_ENCRYPTION:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::INSUFFICIENT_ENCRYPTION);
-      return WebBluetoothError::ConnectInsufficientEncryption;
+      return WebBluetoothError::CONNECT_INSUFFICIENT_ENCRYPTION;
     case device::BluetoothDevice::ERROR_OFFSET_INVALID:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::OFFSET_INVALID);
-      return WebBluetoothError::ConnectOffsetInvalid;
+      return WebBluetoothError::CONNECT_OFFSET_INVALID;
     case device::BluetoothDevice::ERROR_READ_NOT_PERMITTED:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::READ_NOT_PERMITTED);
-      return WebBluetoothError::ConnectReadNotPermitted;
+      return WebBluetoothError::CONNECT_READ_NOT_PERMITTED;
     case device::BluetoothDevice::ERROR_REQUEST_NOT_SUPPORTED:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::REQUEST_NOT_SUPPORTED);
-      return WebBluetoothError::ConnectRequestNotSupported;
+      return WebBluetoothError::CONNECT_REQUEST_NOT_SUPPORTED;
     case device::BluetoothDevice::ERROR_WRITE_NOT_PERMITTED:
       RecordConnectGATTOutcome(UMAConnectGATTOutcome::WRITE_NOT_PERMITTED);
-      return WebBluetoothError::ConnectWriteNotPermitted;
+      return WebBluetoothError::CONNECT_WRITE_NOT_PERMITTED;
     case device::BluetoothDevice::NUM_CONNECT_ERROR_CODES:
       NOTREACHED();
-      return WebBluetoothError::UntranslatedConnectErrorCode;
+      return WebBluetoothError::UNTRANSLATED_CONNECT_ERROR_CODE;
   }
   NOTREACHED();
-  return WebBluetoothError::UntranslatedConnectErrorCode;
+  return WebBluetoothError::UNTRANSLATED_CONNECT_ERROR_CODE;
 }
 
 blink::WebBluetoothError TranslateGATTError(
     BluetoothGattService::GattErrorCode error_code,
     UMAGATTOperation operation) {
   switch (error_code) {
     case BluetoothGattService::GATT_ERROR_UNKNOWN:
       RecordGATTOperationOutcome(operation, UMAGATTOperationOutcome::UNKNOWN);
-      return blink::WebBluetoothError::GATTUnknownError;
+      return blink::WebBluetoothError::GATT_UNKNOWN_ERROR;
     case BluetoothGattService::GATT_ERROR_FAILED:
       RecordGATTOperationOutcome(operation, UMAGATTOperationOutcome::FAILED);
-      return blink::WebBluetoothError::GATTUnknownFailure;
+      return blink::WebBluetoothError::GATT_UNKNOWN_FAILURE;
     case BluetoothGattService::GATT_ERROR_IN_PROGRESS:
       RecordGATTOperationOutcome(operation,
                                  UMAGATTOperationOutcome::IN_PROGRESS);
-      return blink::WebBluetoothError::GATTOperationInProgress;
+      return blink::WebBluetoothError::GATT_OPERATION_IN_PROGRESS;
     case BluetoothGattService::GATT_ERROR_INVALID_LENGTH:
       RecordGATTOperationOutcome(operation,
                                  UMAGATTOperationOutcome::INVALID_LENGTH);
-      return blink::WebBluetoothError::GATTInvalidAttributeLength;
+      return blink::WebBluetoothError::GATT_INVALID_ATTRIBUTE_LENGTH;
     case BluetoothGattService::GATT_ERROR_NOT_PERMITTED:
       RecordGATTOperationOutcome(operation,
                                  UMAGATTOperationOutcome::NOT_PERMITTED);
-      return blink::WebBluetoothError::GATTNotPermitted;
+      return blink::WebBluetoothError::GATT_NOT_PERMITTED;
     case BluetoothGattService::GATT_ERROR_NOT_AUTHORIZED:
       RecordGATTOperationOutcome(operation,
                                  UMAGATTOperationOutcome::NOT_AUTHORIZED);
-      return blink::WebBluetoothError::GATTNotAuthorized;
+      return blink::WebBluetoothError::GATT_NOT_AUTHORIZED;
     case BluetoothGattService::GATT_ERROR_NOT_PAIRED:
       RecordGATTOperationOutcome(operation,
                                  UMAGATTOperationOutcome::NOT_PAIRED);
-      return blink::WebBluetoothError::GATTNotPaired;
+      return blink::WebBluetoothError::GATT_NOT_PAIRED;
     case BluetoothGattService::GATT_ERROR_NOT_SUPPORTED:
       RecordGATTOperationOutcome(operation,
                                  UMAGATTOperationOutcome::NOT_SUPPORTED);
-      return blink::WebBluetoothError::GATTNotSupported;
+      return blink::WebBluetoothError::GATT_NOT_SUPPORTED;
   }
   NOTREACHED();
-  return blink::WebBluetoothError::GATTUntranslatedErrorCode;
+  return blink::WebBluetoothError::GATT_UNTRANSLATED_ERROR_CODE;
 }
 
 void StopDiscoverySession(
     scoped_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 200 matching lines @@
       : device(nullptr),
         service(nullptr),
         characteristic(nullptr),
         outcome(outcome) {}
   ~CacheQueryResult() {}
   WebBluetoothError GetWebError() const {
     switch (outcome) {
       case CacheQueryOutcome::SUCCESS:
       case CacheQueryOutcome::BAD_RENDERER:
         NOTREACHED();
-        return WebBluetoothError::DeviceNoLongerInRange;
+        return WebBluetoothError::DEVICE_NO_LONGER_IN_RANGE;
       case CacheQueryOutcome::NO_DEVICE:
-        return WebBluetoothError::DeviceNoLongerInRange;
+        return WebBluetoothError::DEVICE_NO_LONGER_IN_RANGE;
       case CacheQueryOutcome::NO_SERVICE:
-        return WebBluetoothError::ServiceNoLongerExists;
+        return WebBluetoothError::SERVICE_NO_LONGER_EXISTS;
       case CacheQueryOutcome::NO_CHARACTERISTIC:
-        return WebBluetoothError::CharacteristicNoLongerExists;
+        return WebBluetoothError::CHARACTERISTIC_NO_LONGER_EXISTS;
     }
     NOTREACHED();
-    return WebBluetoothError::DeviceNoLongerInRange;
+    return WebBluetoothError::DEVICE_NO_LONGER_IN_RANGE;
   }
 
   device::BluetoothDevice* device;
   device::BluetoothGattService* service;
   device::BluetoothGattCharacteristic* characteristic;
   CacheQueryOutcome outcome;
 };
 
 struct BluetoothDispatcherHost::PrimaryServicesRequest {
   enum CallingFunction { GET_PRIMARY_SERVICE, GET_PRIMARY_SERVICES };
@@ skipping 135 matching lines @@
       case PrimaryServicesRequest::GET_PRIMARY_SERVICE:
         if (!services.empty()) {
           AddToServicesMapAndSendGetPrimaryServiceSuccess(
               *services[0], request.thread_id, request.request_id);
         } else {
           VLOG(1) << "No service found";
           RecordGetPrimaryServiceOutcome(
               UMAGetPrimaryServiceOutcome::NOT_FOUND);
           Send(new BluetoothMsg_GetPrimaryServiceError(
               request.thread_id, request.request_id,
-              WebBluetoothError::ServiceNotFound));
+              WebBluetoothError::SERVICE_NOT_FOUND));
         }
         break;
       case PrimaryServicesRequest::GET_PRIMARY_SERVICES:
         NOTIMPLEMENTED();
         break;
     }
   }
   DCHECK(!ContainsKey(pending_primary_services_requests_, device_address))
       << "Sending get-service responses unexpectedly queued another request.";
 }
@@ skipping 46 matching lines @@
     if (BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
       BluetoothAdapterFactory::GetAdapter(base::Bind(
           &BluetoothDispatcherHost::OnGetAdapter, weak_ptr_on_ui_thread_,
           base::Bind(&BluetoothDispatcherHost::OnRequestDeviceImpl,
                      weak_ptr_on_ui_thread_, thread_id, request_id,
                      frame_routing_id, filters, optional_services)));
       return;
     }
     RecordRequestDeviceOutcome(UMARequestDeviceOutcome::NO_BLUETOOTH_ADAPTER);
     Send(new BluetoothMsg_RequestDeviceError(
-        thread_id, request_id, WebBluetoothError::NoBluetoothAdapter));
+        thread_id, request_id, WebBluetoothError::NO_BLUETOOTH_ADAPTER));
     return;
   }
   OnRequestDeviceImpl(thread_id, request_id, frame_routing_id, filters,
                       optional_services);
 }
 
 void BluetoothDispatcherHost::OnGATTServerConnect(
     int thread_id,
     int request_id,
     int frame_routing_id,
@@ skipping 63 matching lines @@
     int frame_routing_id,
     const std::string& device_id,
     const std::string& service_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::GET_PRIMARY_SERVICE);
   RecordGetPrimaryServiceService(BluetoothUUID(service_uuid));
 
   if (!allowed_devices_map_.IsOriginAllowedToAccessService(
           GetOrigin(frame_routing_id), device_id, service_uuid)) {
     Send(new BluetoothMsg_GetPrimaryServiceError(
-        thread_id, request_id, WebBluetoothError::NotAllowedToAccessService));
+        thread_id, request_id,
+        WebBluetoothError::NOT_ALLOWED_TO_ACCESS_SERVICE));
     return;
   }
 
   const CacheQueryResult query_result =
       QueryCacheForDevice(GetOrigin(frame_routing_id), device_id);
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordGetPrimaryServiceOutcome(query_result.outcome);
     Send(new BluetoothMsg_GetPrimaryServiceError(thread_id, request_id,
                                                  query_result.GetWebError()));
@@ skipping 21 matching lines @@
     AddToServicesMapAndSendGetPrimaryServiceSuccess(service, thread_id,
                                                     request_id);
     return;
   }
 
   // 3.
   if (query_result.device->IsGattServicesDiscoveryComplete()) {
     VLOG(1) << "Service not found in device.";
     RecordGetPrimaryServiceOutcome(UMAGetPrimaryServiceOutcome::NOT_FOUND);
     Send(new BluetoothMsg_GetPrimaryServiceError(
-        thread_id, request_id, WebBluetoothError::ServiceNotFound));
+        thread_id, request_id, WebBluetoothError::SERVICE_NOT_FOUND));
     return;
   }
 
   VLOG(1) << "Adding service request to pending requests.";
   // 4.
   AddToPendingPrimaryServicesRequest(
       query_result.device->GetAddress(),
       PrimaryServicesRequest(thread_id, request_id, service_uuid,
                              PrimaryServicesRequest::GET_PRIMARY_SERVICE));
 }
 
 void BluetoothDispatcherHost::OnGetCharacteristic(
     int thread_id,
     int request_id,
     int frame_routing_id,
     const std::string& service_instance_id,
     const std::string& characteristic_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::GET_CHARACTERISTIC);
   RecordGetCharacteristicCharacteristic(characteristic_uuid);
 
   // Check Blacklist for characteristic_uuid.
   if (BluetoothBlacklist::Get().IsExcluded(
           BluetoothUUID(characteristic_uuid))) {
     RecordGetCharacteristicOutcome(UMAGetCharacteristicOutcome::BLACKLISTED);
     Send(new BluetoothMsg_GetCharacteristicError(
         thread_id, request_id,
-        WebBluetoothError::BlacklistedCharacteristicUUID));
+        WebBluetoothError::BLACKLISTED_CHARACTERISTIC_UUID));
     return;
   }
 
   const CacheQueryResult query_result =
       QueryCacheForService(GetOrigin(frame_routing_id), service_instance_id);
 
   if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
     return;
   }
 
@@ skipping 21 matching lines @@
       // TODO(ortuno): Use generated instance ID instead.
       // https://crbug.com/495379
       Send(new BluetoothMsg_GetCharacteristicSuccess(
           thread_id, request_id, characteristic_instance_id,
           static_cast<uint32_t>(characteristic->GetProperties())));
       return;
     }
   }
   RecordGetCharacteristicOutcome(UMAGetCharacteristicOutcome::NOT_FOUND);
   Send(new BluetoothMsg_GetCharacteristicError(
-      thread_id, request_id, WebBluetoothError::CharacteristicNotFound));
+      thread_id, request_id, WebBluetoothError::CHARACTERISTIC_NOT_FOUND));
 }
 
 void BluetoothDispatcherHost::OnGetCharacteristics(
     int thread_id,
     int request_id,
     int frame_routing_id,
     const std::string& service_instance_id,
     const std::string& characteristics_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(
       UMAWebBluetoothFunction::SERVICE_GET_CHARACTERISTICS);
   RecordGetCharacteristicsCharacteristic(characteristics_uuid);
 
   // Check Blacklist for characteristics_uuid.
   if (!characteristics_uuid.empty() &&
       BluetoothBlacklist::Get().IsExcluded(
           BluetoothUUID(characteristics_uuid))) {
     RecordGetCharacteristicsOutcome(UMAGetCharacteristicOutcome::BLACKLISTED);
     Send(new BluetoothMsg_GetCharacteristicsError(
         thread_id, request_id,
-        WebBluetoothError::BlacklistedCharacteristicUUID));
+        WebBluetoothError::BLACKLISTED_CHARACTERISTIC_UUID));
     return;
   }
 
   const CacheQueryResult query_result =
       QueryCacheForService(GetOrigin(frame_routing_id), service_instance_id);
 
   if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
     return;
   }
 
@@ skipping 36 matching lines @@
     Send(new BluetoothMsg_GetCharacteristicsSuccess(
         thread_id, request_id, characteristics_instance_ids,
         characteristics_uuids, characteristics_properties));
     return;
   }
   RecordGetCharacteristicsOutcome(
       characteristics_uuid.empty()
           ? UMAGetCharacteristicOutcome::NO_CHARACTERISTICS
           : UMAGetCharacteristicOutcome::NOT_FOUND);
   Send(new BluetoothMsg_GetCharacteristicsError(
-      thread_id, request_id, characteristics_uuid.empty()
-                                 ? WebBluetoothError::NoCharacteristicsFound
-                                 : WebBluetoothError::CharacteristicNotFound));
+      thread_id, request_id,
+      characteristics_uuid.empty()
+          ? WebBluetoothError::NO_CHARACTERISTICS_FOUND
+          : WebBluetoothError::CHARACTERISTIC_NOT_FOUND));
 }
 
 void BluetoothDispatcherHost::OnReadValue(
     int thread_id,
     int request_id,
     int frame_routing_id,
     const std::string& characteristic_instance_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(
       UMAWebBluetoothFunction::CHARACTERISTIC_READ_VALUE);
 
   const CacheQueryResult query_result = QueryCacheForCharacteristic(
       GetOrigin(frame_routing_id), characteristic_instance_id);
 
   if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
     return;
   }
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordCharacteristicReadValueOutcome(query_result.outcome);
     Send(new BluetoothMsg_ReadCharacteristicValueError(
         thread_id, request_id, query_result.GetWebError()));
     return;
   }
 
   if (BluetoothBlacklist::Get().IsExcludedFromReads(
           query_result.characteristic->GetUUID())) {
     RecordCharacteristicReadValueOutcome(UMAGATTOperationOutcome::BLACKLISTED);
     Send(new BluetoothMsg_ReadCharacteristicValueError(
-        thread_id, request_id, WebBluetoothError::BlacklistedRead));
+        thread_id, request_id, WebBluetoothError::BLACKLISTED_READ));
     return;
   }
 
   query_result.characteristic->ReadRemoteCharacteristic(
       base::Bind(&BluetoothDispatcherHost::OnCharacteristicValueRead,
                  weak_ptr_on_ui_thread_, thread_id, request_id),
       base::Bind(&BluetoothDispatcherHost::OnCharacteristicReadValueError,
                  weak_ptr_on_ui_thread_, thread_id, request_id));
 }
 
@@ skipping 29 matching lines @@
     RecordCharacteristicWriteValueOutcome(query_result.outcome);
     Send(new BluetoothMsg_WriteCharacteristicValueError(
         thread_id, request_id, query_result.GetWebError()));
     return;
   }
 
   if (BluetoothBlacklist::Get().IsExcludedFromWrites(
           query_result.characteristic->GetUUID())) {
     RecordCharacteristicWriteValueOutcome(UMAGATTOperationOutcome::BLACKLISTED);
     Send(new BluetoothMsg_WriteCharacteristicValueError(
-        thread_id, request_id, WebBluetoothError::BlacklistedWrite));
+        thread_id, request_id, WebBluetoothError::BLACKLISTED_WRITE));
     return;
   }
 
   query_result.characteristic->WriteRemoteCharacteristic(
       value, base::Bind(&BluetoothDispatcherHost::OnWriteValueSuccess,
                         weak_ptr_on_ui_thread_, thread_id, request_id),
       base::Bind(&BluetoothDispatcherHost::OnWriteValueFailed,
                  weak_ptr_on_ui_thread_, thread_id, request_id));
 }
 
@@ skipping 130 matching lines @@
   VLOG(1) << "requestDevice called with the following optional services: ";
   for (const BluetoothUUID& service : optional_services)
     VLOG(1) << "\t" << service.value();
 
   // Check blacklist to reject invalid filters and adjust optional_services.
   if (BluetoothBlacklist::Get().IsExcluded(filters)) {
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLACKLISTED_SERVICE_IN_FILTER);
     Send(new BluetoothMsg_RequestDeviceError(
         thread_id, request_id,
-        WebBluetoothError::RequestDeviceWithBlacklistedUUID));
+        WebBluetoothError::REQUEST_DEVICE_WITH_BLACKLISTED_UUID));
     return;
   }
   std::vector<BluetoothUUID> optional_services_blacklist_filtered(
       optional_services);
   BluetoothBlacklist::Get().RemoveExcludedUuids(
       &optional_services_blacklist_filtered);
 
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(render_process_id_, frame_routing_id);
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
 
   if (!render_frame_host || !web_contents) {
     DLOG(WARNING) << "Got a requestDevice IPC without a matching "
                   << "RenderFrameHost or WebContents: " << render_process_id_
                   << ", " << frame_routing_id;
     RecordRequestDeviceOutcome(UMARequestDeviceOutcome::NO_RENDER_FRAME);
     Send(new BluetoothMsg_RequestDeviceError(
-        thread_id, request_id, WebBluetoothError::RequestDeviceWithoutFrame));
+        thread_id, request_id,
+        WebBluetoothError::REQUEST_DEVICE_WITHOUT_FRAME));
     return;
   }
 
   const url::Origin requesting_origin =
       render_frame_host->GetLastCommittedOrigin();
   const url::Origin embedding_origin =
       web_contents->GetMainFrame()->GetLastCommittedOrigin();
 
   if (requesting_origin.unique()) {
     VLOG(1) << "Request device with unique origin.";
     Send(new BluetoothMsg_RequestDeviceError(
         thread_id, request_id,
-        WebBluetoothError::RequestDeviceWithUniqueOrigin));
+        WebBluetoothError::REQUEST_DEVICE_WITH_UNIQUE_ORIGIN));
     return;
   }
 
   DCHECK(adapter_.get());
 
   if (!adapter_->IsPresent()) {
     VLOG(1) << "Bluetooth Adapter not present. Can't serve requestDevice.";
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLUETOOTH_ADAPTER_NOT_PRESENT);
     Send(new BluetoothMsg_RequestDeviceError(
-        thread_id, request_id, WebBluetoothError::NoBluetoothAdapter));
+        thread_id, request_id, WebBluetoothError::NO_BLUETOOTH_ADAPTER));
     return;
   }
 
   // The renderer should never send empty filters.
   if (HasEmptyOrInvalidFilter(filters)) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::BDH_EMPTY_OR_INVALID_FILTERS);
     return;
   }
 
   if (!GetContentClient()->browser()->AllowWebBluetooth(
           web_contents->GetBrowserContext(), requesting_origin,
           embedding_origin)) {
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_GLOBALLY_DISABLED);
     Send(new BluetoothMsg_RequestDeviceError(
-        thread_id, request_id, WebBluetoothError::ChooserDisabled));
+        thread_id, request_id, WebBluetoothError::CHOOSER_DISABLED));
     return;
   }
 
   // Create storage for the information that backs the chooser, and show the
   // chooser.
   RequestDeviceSession* const session = new RequestDeviceSession(
       thread_id, request_id, frame_routing_id, requesting_origin, filters,
       optional_services_blacklist_filtered);
   int chooser_id = request_device_sessions_.Add(session);
 
@@ skipping 123 matching lines @@
     const std::string& device_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RequestDeviceSession* session = request_device_sessions_.Lookup(chooser_id);
   DCHECK(session) << "Session removed unexpectedly.";
 
   if ((event != BluetoothChooser::Event::DENIED_PERMISSION) &&
       (event != BluetoothChooser::Event::SELECTED)) {
     RecordRequestDeviceOutcome(OutcomeFromChooserEvent(event));
     Send(new BluetoothMsg_RequestDeviceError(
         session->thread_id, session->request_id,
-        WebBluetoothError::ChooserCancelled));
+        WebBluetoothError::CHOOSER_CANCELLED));
     request_device_sessions_.Remove(chooser_id);
     return;
   }
   if (event == BluetoothChooser::Event::DENIED_PERMISSION) {
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_DENIED_PERMISSION);
     VLOG(1) << "Bluetooth chooser denied permission";
     Send(new BluetoothMsg_RequestDeviceError(
         session->thread_id, session->request_id,
-        WebBluetoothError::ChooserDeniedPermission));
+        WebBluetoothError::CHOOSER_DENIED_PERMISSION));
     request_device_sessions_.Remove(chooser_id);
     return;
   }
   DCHECK_EQ(static_cast<int>(event),
             static_cast<int>(BluetoothChooser::Event::SELECTED));
 
   // |device_id| is the Device Address that RequestDeviceSession passed to
   // chooser->AddDevice().
   const device::BluetoothDevice* const device = adapter_->GetDevice(device_id);
   if (device == nullptr) {
     VLOG(1) << "Device " << device_id << " no longer in adapter";
     RecordRequestDeviceOutcome(UMARequestDeviceOutcome::CHOSEN_DEVICE_VANISHED);
     Send(new BluetoothMsg_RequestDeviceError(
         session->thread_id, session->request_id,
-        WebBluetoothError::ChosenDeviceVanished));
+        WebBluetoothError::CHOSEN_DEVICE_VANISHED));
     request_device_sessions_.Remove(chooser_id);
     return;
   }
 
   const std::string& device_id_for_origin = allowed_devices_map_.AddDevice(
       session->origin, device->GetAddress(), session->filters,
       session->optional_services);
 
   VLOG(1) << "Device: " << device->GetName();
   VLOG(1) << "UUIDs: ";
@@ skipping 256 matching lines @@
 
 bool BluetoothDispatcherHost::CanFrameAccessCharacteristicInstance(
     int frame_routing_id,
     const std::string& characteristic_instance_id) {
   return QueryCacheForCharacteristic(GetOrigin(frame_routing_id),
                                      characteristic_instance_id)
              .outcome != CacheQueryOutcome::BAD_RENDERER;
 }
 
 }  // namespace content