Refactor device::BluetoothGattXXX classes to split into remote/local.

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 13 matching lines @@
 #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"
-#include "device/bluetooth/bluetooth_gatt_characteristic.h"
-#include "device/bluetooth/bluetooth_gatt_service.h"
+#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_remote_gatt_service.h"
 
 using blink::WebBluetoothError;
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
-using device::BluetoothGattCharacteristic;
-using device::BluetoothGattService;
+using device::BluetoothRemoteGattCharacteristic;
+using device::BluetoothRemoteGattService;
 using device::BluetoothUUID;
 
 namespace content {
 
 namespace {
 
 // TODO(ortuno): Once we have a chooser for scanning, a way to control that
 // chooser from tests, and the right callback for discovered services we should
 // delete these constants.
 // https://crbug.com/436280 and https://crbug.com/484504
@@ skipping 120 matching lines @@
     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));
 }
 
 // TODO(ortuno): This should really be a BluetoothDevice method.
 // Replace when implemented. http://crbug.com/552022
-std::vector<BluetoothGattService*> GetPrimaryServicesByUUID(
+std::vector<BluetoothRemoteGattService*> GetPrimaryServicesByUUID(
     device::BluetoothDevice* device,
     const std::string& service_uuid) {
-  std::vector<BluetoothGattService*> services;
+  std::vector<BluetoothRemoteGattService*> services;
   VLOG(1) << "Looking for service: " << service_uuid;
-  for (BluetoothGattService* service : device->GetGattServices()) {
+  for (BluetoothRemoteGattService* service : device->GetGattServices()) {
     VLOG(1) << "Service in cache: " << service->GetUUID().canonical_value();
     if (service->GetUUID().canonical_value() == service_uuid &&
         service->IsPrimary()) {
       services.push_back(service);
     }
   }
   return services;
 }
 
 UMARequestDeviceOutcome OutcomeFromChooserEvent(BluetoothChooser::Event event) {
@@ skipping 386 matching lines @@
 
   auto iter = pending_primary_services_requests_.find(device_address);
   if (iter == pending_primary_services_requests_.end()) {
     return;
   }
   std::vector<PrimaryServicesRequest> requests;
   requests.swap(iter->second);
   pending_primary_services_requests_.erase(iter);
 
   for (const PrimaryServicesRequest& request : requests) {
-    std::vector<BluetoothGattService*> services =
+    std::vector<BluetoothRemoteGattService*> services =
         GetPrimaryServicesByUUID(device, request.service_uuid);
     switch (request.func) {
       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);
@@ skipping 131 matching lines @@
   // There are four possibilities here:
   // 1. Services not discovered and service present in |device|: Send back the
   //    service to the renderer.
   // 2. Services discovered and service present in |device|: Send back the
   //    service to the renderer.
   // 3. Services discovered and service not present in |device|: Send back not
   //    found error.
   // 4. Services not discovered and service not present in |device|: Add request
   //    to map of pending getPrimaryService requests.
 
-  std::vector<BluetoothGattService*> services =
+  std::vector<BluetoothRemoteGattService*> services =
       GetPrimaryServicesByUUID(query_result.device, service_uuid);
 
   // 1. & 2.
   if (!services.empty()) {
     VLOG(1) << "Service found in device.";
-    const BluetoothGattService& service = *services[0];
+    const BluetoothRemoteGattService& service = *services[0];
     DCHECK(service.IsPrimary());
     AddToServicesMapAndSendGetPrimaryServiceSuccess(service, thread_id,
                                                     request_id);
     return;
   }
 
   // 3.
   if (query_result.device->IsGattServicesDiscoveryComplete()) {
     VLOG(1) << "Service not found in device.";
     RecordGetPrimaryServiceOutcome(UMAGetPrimaryServiceOutcome::NOT_FOUND);
@@ skipping 37 matching lines @@
     return;
   }
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordGetCharacteristicOutcome(query_result.outcome);
     Send(new BluetoothMsg_GetCharacteristicError(thread_id, request_id,
                                                  query_result.GetWebError()));
     return;
   }
 
-  for (BluetoothGattCharacteristic* characteristic :
+  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)
@@ skipping 46 matching lines @@
     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 (BluetoothGattCharacteristic* characteristic :
+  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());
@@ skipping 385 matching lines @@
   // There was an error creating the ATT Bearer so we reject with
   // NetworkError.
   // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
   RecordConnectGATTTimeFailed(base::TimeTicks::Now() - start_time);
   // RecordConnectGATTOutcome is called by TranslateConnectError.
   Send(new BluetoothMsg_GATTServerConnectError(
       thread_id, request_id, TranslateConnectError(error_code)));
 }
 
 void BluetoothDispatcherHost::AddToServicesMapAndSendGetPrimaryServiceSuccess(
-    const device::BluetoothGattService& service,
+    const device::BluetoothRemoteGattService& service,
     int thread_id,
     int request_id) {
   const std::string& service_identifier = service.GetIdentifier();
   const std::string& device_address = service.GetDevice()->GetAddress();
   auto insert_result =
       service_to_device_.insert(make_pair(service_identifier, device_address));
 
   // If a value is already in map, DCHECK it's valid.
   if (!insert_result.second)
     DCHECK_EQ(insert_result.first->second, device_address);
@@ skipping 118 matching lines @@
     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