bluetooth: Remove non const references from BluetoothDispatcherHost

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 335 matching lines @@
   scoped_ptr<BluetoothChooser> chooser;
   scoped_ptr<device::BluetoothDiscoverySession> discovery_session;
 };
 
 struct BluetoothDispatcherHost::CacheQueryResult {
   CacheQueryResult()
       : device(nullptr),
         service(nullptr),
         characteristic(nullptr),
         outcome(CacheQueryOutcome::SUCCESS) {}
+  CacheQueryResult(CacheQueryOutcome outcome)
+      : device(nullptr),
+        service(nullptr),
+        characteristic(nullptr),
+        outcome(outcome) {}
   ~CacheQueryResult() {}
-  WebBluetoothError GetWebError() {
+  WebBluetoothError GetWebError() const {
     switch (outcome) {
       case CacheQueryOutcome::SUCCESS:
       case CacheQueryOutcome::BAD_RENDERER:
         NOTREACHED();
         return WebBluetoothError::DeviceNoLongerInRange;
       case CacheQueryOutcome::NO_DEVICE:
         return WebBluetoothError::DeviceNoLongerInRange;
       case CacheQueryOutcome::NO_SERVICE:
         return WebBluetoothError::ServiceNoLongerExists;
       case CacheQueryOutcome::NO_CHARACTERISTIC:
@@ skipping 315 matching lines @@
                                             const std::string& device_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::CONNECT_GATT);
   const base::TimeTicks start_time = base::TimeTicks::Now();
 
   // TODO(ortuno): Right now it's pointless to check if the domain has access to
   // the device, because any domain can connect to any device. But once
   // permissions are implemented we should check that the domain has access to
   // the device. https://crbug.com/484745
 
-  CacheQueryResult query_result;
-  QueryCacheForDevice(device_id, query_result);
+  const CacheQueryResult query_result = QueryCacheForDevice(device_id);
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordConnectGATTOutcome(query_result.outcome);
     Send(new BluetoothMsg_ConnectGATTError(thread_id, request_id,
                                            query_result.GetWebError()));
     return;
   }
 
   query_result.device->CreateGattConnection(
       base::Bind(&BluetoothDispatcherHost::OnGATTConnectionCreated,
@@ skipping 11 matching lines @@
     const std::string& service_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::GET_PRIMARY_SERVICE);
   RecordGetPrimaryServiceService(BluetoothUUID(service_uuid));
 
   // TODO(ortuno): Check if device_id is in "allowed devices"
   // https://crbug.com/493459
   // TODO(ortuno): Check if service_uuid is in "allowed services"
   // https://crbug.com/493460
 
-  CacheQueryResult query_result;
-  QueryCacheForDevice(device_id, query_result);
+  const CacheQueryResult query_result = QueryCacheForDevice(device_id);
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordGetPrimaryServiceOutcome(query_result.outcome);
     Send(new BluetoothMsg_GetPrimaryServiceError(thread_id, request_id,
                                                  query_result.GetWebError()));
     return;
   }
 
   // There are four possibilities here:
   // 1. Services not discovered and service present in |device|: Send back the
@@ skipping 35 matching lines @@
 
 void BluetoothDispatcherHost::OnGetCharacteristic(
     int thread_id,
     int request_id,
     const std::string& service_instance_id,
     const std::string& characteristic_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::GET_CHARACTERISTIC);
   RecordGetCharacteristicCharacteristic(characteristic_uuid);
 
-  CacheQueryResult query_result;
-  QueryCacheForService(service_instance_id, query_result);
+  const CacheQueryResult query_result =
+      QueryCacheForService(service_instance_id);
 
   if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
     return;
   }
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordGetCharacteristicOutcome(query_result.outcome);
     Send(new BluetoothMsg_GetCharacteristicError(thread_id, request_id,
                                                  query_result.GetWebError()));
     return;
@@ skipping 27 matching lines @@
 }
 
 void BluetoothDispatcherHost::OnReadValue(
     int thread_id,
     int request_id,
     const std::string& characteristic_instance_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(
       UMAWebBluetoothFunction::CHARACTERISTIC_READ_VALUE);
 
-  CacheQueryResult query_result;
-  QueryCacheForCharacteristic(characteristic_instance_id, query_result);
+  const CacheQueryResult query_result =
+      QueryCacheForCharacteristic(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;
@@ skipping 19 matching lines @@
   // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothgattcharacteristic-writevalue
   // We perform the length check on the renderer side. So if we
   // get a value with length > 512, we can assume it's a hostile
   // renderer and kill it.
   if (value.size() > 512) {
     bad_message::ReceivedBadMessage(
         this, bad_message::BDH_INVALID_WRITE_VALUE_LENGTH);
     return;
   }
 
-  CacheQueryResult query_result;
-  QueryCacheForCharacteristic(characteristic_instance_id, query_result);
+  const CacheQueryResult query_result =
+      QueryCacheForCharacteristic(characteristic_instance_id);
 
   if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
     return;
   }
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordCharacteristicWriteValueOutcome(query_result.outcome);
     Send(new BluetoothMsg_WriteCharacteristicValueError(
         thread_id, request_id, query_result.GetWebError()));
     return;
@@ skipping 19 matching lines @@
   if (characteristic_id_to_notify_session_.find(characteristic_instance_id) !=
       characteristic_id_to_notify_session_.end()) {
     bad_message::ReceivedBadMessage(
         this, bad_message::BDH_CHARACTERISTIC_ALREADY_SUBSCRIBED);
     return;
   }
 
   // TODO(ortuno): Check if notify/indicate bit is set.
   // http://crbug.com/538869
 
-  CacheQueryResult query_result;
-  QueryCacheForCharacteristic(characteristic_instance_id, query_result);
+  const CacheQueryResult query_result =
+      QueryCacheForCharacteristic(characteristic_instance_id);
 
   if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
     return;
   }
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordStartNotificationsOutcome(query_result.outcome);
     Send(new BluetoothMsg_StartNotificationsError(thread_id, request_id,
                                                   query_result.GetWebError()));
     return;
@@ skipping 310 matching lines @@
 }
 
 void BluetoothDispatcherHost::OnStopNotifySession(
     int thread_id,
     int request_id,
     const std::string& characteristic_instance_id) {
   characteristic_id_to_notify_session_.erase(characteristic_instance_id);
   Send(new BluetoothMsg_StopNotificationsSuccess(thread_id, request_id));
 }
 
-void BluetoothDispatcherHost::QueryCacheForDevice(const std::string& device_id,
-                                                  CacheQueryResult& result) {
+BluetoothDispatcherHost::CacheQueryResult
+BluetoothDispatcherHost::QueryCacheForDevice(const std::string& device_id) {
+  CacheQueryResult result;
   result.device = adapter_->GetDevice(device_id);
   // When a device can't be found in the BluetoothAdapter, that generally
   // indicates that it's gone out of range. We reject with a NetworkError in
   // that case.
   // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
   if (result.device == nullptr) {
     result.outcome = CacheQueryOutcome::NO_DEVICE;
   }
+  return result;
 }
 
-void BluetoothDispatcherHost::QueryCacheForService(
-    const std::string& service_instance_id,
-    CacheQueryResult& result) {
+BluetoothDispatcherHost::CacheQueryResult
+BluetoothDispatcherHost::QueryCacheForService(
+    const std::string& service_instance_id) {
   auto device_iter = service_to_device_.find(service_instance_id);
 
   // Kill the renderer, see "ID Not In Map Note" above.
   if (device_iter == service_to_device_.end()) {
     bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_SERVICE_ID);
-    result.outcome = CacheQueryOutcome::BAD_RENDERER;
-    return;
+    return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
   }
 
   // TODO(ortuno): Check if domain has access to device.
   // https://crbug.com/493459
 
-  QueryCacheForDevice(device_iter->second, result);
+  CacheQueryResult result = QueryCacheForDevice(device_iter->second);
 
   if (result.outcome != CacheQueryOutcome::SUCCESS) {
-    return;
+    return result;
   }
 
   result.service = result.device->GetGattService(service_instance_id);
   if (result.service == nullptr) {
     result.outcome = CacheQueryOutcome::NO_SERVICE;
   }
+  return result;
 }
 
-void BluetoothDispatcherHost::QueryCacheForCharacteristic(
-    const std::string& characteristic_instance_id,
-    CacheQueryResult& result) {
+BluetoothDispatcherHost::CacheQueryResult
+BluetoothDispatcherHost::QueryCacheForCharacteristic(
+    const std::string& characteristic_instance_id) {
   auto characteristic_iter =
       characteristic_to_service_.find(characteristic_instance_id);
 
   // Kill the renderer, see "ID Not In Map Note" above.
   if (characteristic_iter == characteristic_to_service_.end()) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::BDH_INVALID_CHARACTERISTIC_ID);
-    result.outcome = CacheQueryOutcome::BAD_RENDERER;
-    return;
+    return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
   }
 
-  QueryCacheForService(characteristic_iter->second, result);
+  CacheQueryResult result = QueryCacheForService(characteristic_iter->second);
   if (result.outcome != CacheQueryOutcome::SUCCESS) {
-    return;
+    return result;
   }
 
   result.characteristic =
       result.service->GetCharacteristic(characteristic_instance_id);
 
   if (result.characteristic == nullptr) {
     result.outcome = CacheQueryOutcome::NO_CHARACTERISTIC;
   }
+
+  return result;
 }
 
 bool BluetoothDispatcherHost::IsServicesDiscoveryCompleteForDevice(
     const std::string& device_id) {
   return ContainsKey(devices_with_discovered_services_, device_id);
 }
 
 void BluetoothDispatcherHost::AddToPendingPrimaryServicesRequest(
     const std::string& device_id,
     const PrimaryServicesRequest& request) {
@@ skipping 14 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowNeedLocationLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 }  // namespace content