bluetooth: Move GetCharacteristic(s) over to Mojo

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.
 
 #include "content/browser/bluetooth/bluetooth_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/bluetooth/bluetooth_blacklist.h"
+#include "content/browser/bluetooth/bluetooth_metrics.h"
+#include "content/browser/bluetooth/cache_query_result.h"
 #include "content/browser/bluetooth/first_device_bluetooth_chooser.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
@@ skipping 228 matching lines @@
 
 bool BluetoothDispatcherHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BluetoothDispatcherHost, message)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_RequestDevice, OnRequestDevice)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_GATTServerConnect, OnGATTServerConnect)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_GATTServerDisconnect,
                       OnGATTServerDisconnect)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_GetPrimaryService, OnGetPrimaryService)
-  IPC_MESSAGE_HANDLER(BluetoothHostMsg_GetCharacteristic, OnGetCharacteristic)
-  IPC_MESSAGE_HANDLER(BluetoothHostMsg_GetCharacteristics, OnGetCharacteristics)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void BluetoothDispatcherHost::SetBluetoothAdapterForTesting(
     scoped_refptr<device::BluetoothAdapter> mock_adapter) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (mock_adapter.get()) {
     current_delay_time_ = kTestingDelayTime;
     // Reset the discovery session timer to use the new delay time.
     discovery_session_timer_.Start(
         FROM_HERE, base::TimeDelta::FromSecondsD(current_delay_time_),
         base::Bind(&BluetoothDispatcherHost::StopDeviceDiscovery,
                    // base::Timer guarantees it won't call back after its
                    // destructor starts.
                    base::Unretained(this)));
   } else {
     // The following data structures are used to store pending operations.
     // They should never contain elements at the end of a test.
     DCHECK(request_device_sessions_.IsEmpty());
     DCHECK(pending_primary_services_requests_.empty());
 
     // The following data structures are cleaned up when a
     // device/service/characteristic is removed.
     // Since this can happen after the test is done and the cleanup function is
     // called, we clean them here.
     service_to_device_.clear();
-    characteristic_to_service_.clear();
     connected_devices_map_.reset(new ConnectedDevicesMap(render_process_id_));
     allowed_devices_map_ = BluetoothAllowedDevicesMap();
   }
 
   set_adapter(std::move(mock_adapter));
 }
 
 BluetoothDispatcherHost::~BluetoothDispatcherHost() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Clear adapter, releasing observer references.
@@ skipping 37 matching lines @@
 
   const int thread_id;
   const int request_id;
   const url::Origin origin;
   const std::vector<BluetoothScanFilter> filters;
   const std::vector<BluetoothUUID> optional_services;
   std::unique_ptr<BluetoothChooser> chooser;
   std::unique_ptr<device::BluetoothDiscoverySession> discovery_session;
 };
 
-BluetoothDispatcherHost::CacheQueryResult::CacheQueryResult() {}
-
-BluetoothDispatcherHost::CacheQueryResult::CacheQueryResult(
-    CacheQueryOutcome outcome)
-    : outcome(outcome) {}
-
-BluetoothDispatcherHost::CacheQueryResult::~CacheQueryResult() {}
-
-WebBluetoothError BluetoothDispatcherHost::CacheQueryResult::GetWebError()
-    const {
-  switch (outcome) {
-    case CacheQueryOutcome::SUCCESS:
-    case CacheQueryOutcome::BAD_RENDERER:
-      NOTREACHED();
-      return WebBluetoothError::DEVICE_NO_LONGER_IN_RANGE;
-    case CacheQueryOutcome::NO_DEVICE:
-      return WebBluetoothError::DEVICE_NO_LONGER_IN_RANGE;
-    case CacheQueryOutcome::NO_SERVICE:
-      return WebBluetoothError::SERVICE_NO_LONGER_EXISTS;
-    case CacheQueryOutcome::NO_CHARACTERISTIC:
-      return WebBluetoothError::CHARACTERISTIC_NO_LONGER_EXISTS;
-  }
-  NOTREACHED();
-  return WebBluetoothError::DEVICE_NO_LONGER_IN_RANGE;
-}
-
 struct BluetoothDispatcherHost::PrimaryServicesRequest {
   enum CallingFunction { GET_PRIMARY_SERVICE, GET_PRIMARY_SERVICES };
 
   PrimaryServicesRequest(int thread_id,
                          int request_id,
                          const std::string& service_uuid,
                          PrimaryServicesRequest::CallingFunction func)
       : thread_id(thread_id),
         request_id(request_id),
         service_uuid(service_uuid),
@@ skipping 375 matching lines @@
   }
 
   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::BLACKLISTED_CHARACTERISTIC_UUID));
-    return;
-  }
-
-  const CacheQueryResult query_result =
-      QueryCacheForService(GetOrigin(frame_routing_id), 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;
-  }
-
-  for (BluetoothRemoteGattCharacteristic* characteristic :
-       query_result.service->GetCharacteristics()) {
-    if (characteristic->GetUUID().canonical_value() == characteristic_uuid) {
-      const std::string& characteristic_instance_id =
-          characteristic->GetIdentifier();
-
-      auto insert_result = characteristic_to_service_.insert(
-          make_pair(characteristic_instance_id, service_instance_id));
-
-      // If  value is already in map, DCHECK it's valid.
-      if (!insert_result.second)
-        DCHECK(insert_result.first->second == service_instance_id);
-
-      RecordGetCharacteristicOutcome(UMAGetCharacteristicOutcome::SUCCESS);
-      // 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::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::BLACKLISTED_CHARACTERISTIC_UUID));
-    return;
-  }
-
-  const CacheQueryResult query_result =
-      QueryCacheForService(GetOrigin(frame_routing_id), service_instance_id);
-
-  if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
-    return;
-  }
-
-  if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
-    RecordGetCharacteristicsOutcome(query_result.outcome);
-    Send(new BluetoothMsg_GetCharacteristicsError(thread_id, request_id,
-                                                  query_result.GetWebError()));
-    return;
-  }
-
-  std::vector<std::string> characteristics_instance_ids;
-  std::vector<std::string> characteristics_uuids;
-  std::vector<uint32_t> characteristics_properties;
-
-  for (BluetoothRemoteGattCharacteristic* characteristic :
-       query_result.service->GetCharacteristics()) {
-    if (!BluetoothBlacklist::Get().IsExcluded(characteristic->GetUUID()) &&
-        (characteristics_uuid.empty() ||
-         characteristics_uuid == characteristic->GetUUID().canonical_value())) {
-      const std::string& characteristic_instance_id =
-          characteristic->GetIdentifier();
-
-      characteristics_instance_ids.push_back(characteristic_instance_id);
-      characteristics_uuids.push_back(
-          characteristic->GetUUID().canonical_value());
-      characteristics_properties.push_back(
-          static_cast<uint32_t>(characteristic->GetProperties()));
-
-      auto insert_result = characteristic_to_service_.insert(
-          make_pair(characteristic_instance_id, service_instance_id));
-
-      // If  value is already in map, DCHECK it's valid.
-      if (!insert_result.second)
-        DCHECK(insert_result.first->second == service_instance_id);
-    }
-  }
-
-  if (!characteristics_instance_ids.empty()) {
-    RecordGetCharacteristicsOutcome(UMAGetCharacteristicOutcome::SUCCESS);
-    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::NO_CHARACTERISTICS_FOUND
-          : WebBluetoothError::CHARACTERISTIC_NOT_FOUND));
-}
-
 void BluetoothDispatcherHost::OnGetAdapter(
     base::Closure continuation,
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   set_adapter(adapter);
   continuation.Run();
 }
 
 void BluetoothDispatcherHost::OnRequestDeviceImpl(
     int thread_id,
@@ skipping 362 matching lines @@
 
   // If a value is already in map, DCHECK it's valid.
   if (!insert_result.second)
     DCHECK_EQ(insert_result.first->second, device_address);
 
   RecordGetPrimaryServiceOutcome(UMAGetPrimaryServiceOutcome::SUCCESS);
   Send(new BluetoothMsg_GetPrimaryServiceSuccess(thread_id, request_id,
                                                  service_identifier));
 }
 
-BluetoothDispatcherHost::CacheQueryResult
-BluetoothDispatcherHost::QueryCacheForDevice(const url::Origin& origin,
-                                             const std::string& device_id) {
+CacheQueryResult BluetoothDispatcherHost::QueryCacheForDevice(
+    const url::Origin& origin,
+    const std::string& device_id) {
   const std::string& device_address =
       allowed_devices_map_.GetDeviceAddress(origin, device_id);
   if (device_address.empty()) {
     bad_message::ReceivedBadMessage(
         this, bad_message::BDH_DEVICE_NOT_ALLOWED_FOR_ORIGIN);
     return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
   }
 
   CacheQueryResult result;
   result.device = adapter_->GetDevice(device_address);
 
   // 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;
 }
 
-BluetoothDispatcherHost::CacheQueryResult
-BluetoothDispatcherHost::QueryCacheForService(
+CacheQueryResult BluetoothDispatcherHost::QueryCacheForService(
     const url::Origin& origin,
     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);
     return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
   }
 
@@ skipping 18 matching lines @@
   } else if (!allowed_devices_map_.IsOriginAllowedToAccessService(
                  origin, device_id,
                  result.service->GetUUID().canonical_value())) {
     bad_message::ReceivedBadMessage(
         this, bad_message::BDH_SERVICE_NOT_ALLOWED_FOR_ORIGIN);
     return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
   }
   return result;
 }
 
-BluetoothDispatcherHost::CacheQueryResult
-BluetoothDispatcherHost::QueryCacheForCharacteristic(
-    const url::Origin& origin,
-    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);
-    return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
-  }
-
-  CacheQueryResult result =
-      QueryCacheForService(origin, characteristic_iter->second);
-  if (result.outcome != CacheQueryOutcome::SUCCESS) {
-    return result;
-  }
-
-  result.characteristic =
-      result.service->GetCharacteristic(characteristic_instance_id);
-
-  if (result.characteristic == nullptr) {
-    result.outcome = CacheQueryOutcome::NO_CHARACTERISTIC;
-  }
-
-  return result;
-}
-
 void BluetoothDispatcherHost::AddAdapterObserver(
     device::BluetoothAdapter::Observer* observer) {
   adapter_observers_.insert(observer);
   if (adapter_) {
     adapter_->AddObserver(observer);
   }
 }
 
 void BluetoothDispatcherHost::RemoveAdapterObserver(
     device::BluetoothAdapter::Observer* observer) {
   DCHECK(adapter_observers_.erase(observer));
   if (adapter_) {
     adapter_->RemoveObserver(observer);
   }
 }
 
 void BluetoothDispatcherHost::AddToPendingPrimaryServicesRequest(
     const std::string& device_address,
     const PrimaryServicesRequest& request) {
   pending_primary_services_requests_[device_address].push_back(request);
 }
 
 url::Origin BluetoothDispatcherHost::GetOrigin(int frame_routing_id) {
   return RenderFrameHostImpl::FromID(render_process_id_, frame_routing_id)
       ->GetLastCommittedOrigin();
 }
 
 }  // namespace content