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

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.cc

 // Copyright 2015 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/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 11 matching lines @@
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_notify_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::StringPiece;
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
-using device::BluetoothGattCharacteristic;
-using device::BluetoothGattService;
+using device::BluetoothRemoteGattCharacteristic;
+using device::BluetoothRemoteGattService;
 using device::BluetoothUUID;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothDiscoverySession;
 using device::MockBluetoothGattCharacteristic;
 using device::MockBluetoothGattConnection;
 using device::MockBluetoothGattNotifySession;
 using device::MockBluetoothGattService;
 using testing::ElementsAre;
 using testing::Invoke;
@@ skipping 402 matching lines @@
   MockBluetoothAdapter* adapter_ptr = adapter.get();
   MockBluetoothDevice* device_ptr = device.get();
 
   // Override the previous mock implementation of
   // IsGattServicesDiscoveryComplete so that the first time the function is
   // called it returns false, adds a service and posts a task to notify
   // the services have been discovered. Subsequent calls to the function
   // will return true.
   ON_CALL(*device, IsGattServicesDiscoveryComplete())
       .WillByDefault(Invoke([adapter_ptr, device_ptr] {
-        std::vector<BluetoothGattService*> services =
+        std::vector<BluetoothRemoteGattService*> services =
             device_ptr->GetMockServices();
 
         if (services.size() == 0) {
           std::unique_ptr<NiceMockBluetoothGattService> heart_rate(
               GetBaseGATTService(device_ptr, kHeartRateServiceUUID));
 
           device_ptr->AddMockService(std::move(heart_rate));
           base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE,
               base::Bind(&NotifyServicesDiscovered,
@@ skipping 77 matching lines @@
 
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(errorsServiceUUID));
 
   std::unique_ptr<NiceMockBluetoothDevice> device(
       GetConnectableDevice(adapter.get(), "Errors Device", uuids));
 
   std::unique_ptr<NiceMockBluetoothGattService> service(
       GetBaseGATTService(device.get(), errorsServiceUUID));
 
-  for (int error = BluetoothGattService::GATT_ERROR_UNKNOWN;
-       error <= BluetoothGattService::GATT_ERROR_NOT_SUPPORTED; error++) {
+  for (int error = BluetoothRemoteGattService::GATT_ERROR_UNKNOWN;
+       error <= BluetoothRemoteGattService::GATT_ERROR_NOT_SUPPORTED; error++) {
     service->AddMockCharacteristic(GetErrorCharacteristic(
         service.get(),
-        static_cast<BluetoothGattService::GattErrorCode>(error)));
+        static_cast<BluetoothRemoteGattService::GattErrorCode>(error)));
   }
 
   device->AddMockService(std::move(service));
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // Discovery Sessions
 
@@ skipping 150 matching lines @@
 std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetBlacklistTestService(
     device::MockBluetoothDevice* device) {
   std::unique_ptr<NiceMockBluetoothGattService> blacklist_test_service(
       GetBaseGATTService(device, kBlacklistTestServiceUUID));
 
   std::unique_ptr<NiceMockBluetoothGattCharacteristic>
       blacklist_exclude_reads_characteristic(GetBaseGATTCharacteristic(
           "Excluded Reads Characteristic", blacklist_test_service.get(),
           kBlacklistExcludeReadsCharacteristicUUID,
-          BluetoothGattCharacteristic::PROPERTY_READ |
-              BluetoothGattCharacteristic::PROPERTY_WRITE));
+          BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+              BluetoothRemoteGattCharacteristic::PROPERTY_WRITE));
 
   // Crash if ReadRemoteCharacteristic called. Not using GoogleMock's Expect
   // because this is used in layout tests that may not report a mock expectation
   // error correctly as a layout test failure.
   ON_CALL(*blacklist_exclude_reads_characteristic,
           ReadRemoteCharacteristic(_, _))
       .WillByDefault(
-          Invoke([](const BluetoothGattCharacteristic::ValueCallback&,
-                    const BluetoothGattCharacteristic::ErrorCallback&) {
+          Invoke([](const BluetoothRemoteGattCharacteristic::ValueCallback&,
+                    const BluetoothRemoteGattCharacteristic::ErrorCallback&) {
             NOTREACHED();
           }));
 
   // Write response.
   ON_CALL(*blacklist_exclude_reads_characteristic,
           WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<1 /* success callback */>());
 
   blacklist_test_service->AddMockCharacteristic(
       std::move(blacklist_exclude_reads_characteristic));
 
   return blacklist_test_service;
 }
 
 // static
 std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetDeviceInformationService(
     device::MockBluetoothDevice* device) {
   std::unique_ptr<NiceMockBluetoothGattService> device_information(
       GetBaseGATTService(device, kDeviceInformationServiceUUID));
 
   std::unique_ptr<NiceMockBluetoothGattCharacteristic> serial_number_string(
       GetBaseGATTCharacteristic(
           "Serial Number String", device_information.get(),
-          kSerialNumberStringUUID, BluetoothGattCharacteristic::PROPERTY_READ));
+          kSerialNumberStringUUID,
+          BluetoothRemoteGattCharacteristic::PROPERTY_READ));
 
   // Crash if ReadRemoteCharacteristic called. Not using GoogleMock's Expect
   // because this is used in layout tests that may not report a mock expectation
   // error correctly as a layout test failure.
   ON_CALL(*serial_number_string, ReadRemoteCharacteristic(_, _))
       .WillByDefault(
-          Invoke([](const BluetoothGattCharacteristic::ValueCallback&,
-                    const BluetoothGattCharacteristic::ErrorCallback&) {
+          Invoke([](const BluetoothRemoteGattCharacteristic::ValueCallback&,
+                    const BluetoothRemoteGattCharacteristic::ErrorCallback&) {
             NOTREACHED();
           }));
 
   device_information->AddMockCharacteristic(std::move(serial_number_string));
 
   return device_information;
 }
 
 // static
 std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetGenericAccessService(
     device::MockBluetoothDevice* device) {
   std::unique_ptr<NiceMockBluetoothGattService> generic_access(
       GetBaseGATTService(device, kGenericAccessServiceUUID));
 
   {  // Device Name:
     std::unique_ptr<NiceMockBluetoothGattCharacteristic> device_name(
         GetBaseGATTCharacteristic(
             "Device Name", generic_access.get(), kDeviceNameUUID,
-            BluetoothGattCharacteristic::PROPERTY_READ |
-                BluetoothGattCharacteristic::PROPERTY_WRITE));
+            BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+                BluetoothRemoteGattCharacteristic::PROPERTY_WRITE));
 
     // Read response.
     std::string device_name_str = device->GetDeviceName();
     std::vector<uint8_t> device_name_value(device_name_str.begin(),
                                            device_name_str.end());
 
     ON_CALL(*device_name, ReadRemoteCharacteristic(_, _))
         .WillByDefault(RunCallback<0>(device_name_value));
 
     // Write response.
     ON_CALL(*device_name, WriteRemoteCharacteristic(_, _, _))
         .WillByDefault(RunCallback<1 /* success callback */>());
 
     generic_access->AddMockCharacteristic(std::move(device_name));
   }
 
   {  // Peripheral Privacy Flag:
     std::unique_ptr<NiceMockBluetoothGattCharacteristic>
         peripheral_privacy_flag(GetBaseGATTCharacteristic(
             "Peripheral Privacy Flag", generic_access.get(),
             kPeripheralPrivacyFlagUUID,
-            BluetoothGattCharacteristic::PROPERTY_READ |
-                BluetoothGattCharacteristic::PROPERTY_WRITE));
+            BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+                BluetoothRemoteGattCharacteristic::PROPERTY_WRITE));
 
     // Read response.
     std::vector<uint8_t> value(1);
     value[0] = false;
 
     ON_CALL(*peripheral_privacy_flag, ReadRemoteCharacteristic(_, _))
         .WillByDefault(RunCallback<0>(value));
 
     // Crash if WriteRemoteCharacteristic called. Not using GoogleMock's Expect
     // because this is used in layout tests that may not report a mock
     // expectation error correctly as a layout test failure.
     ON_CALL(*peripheral_privacy_flag, WriteRemoteCharacteristic(_, _, _))
         .WillByDefault(
             Invoke([](const std::vector<uint8_t>&, const base::Closure&,
-                      const BluetoothGattCharacteristic::ErrorCallback&) {
+                      const BluetoothRemoteGattCharacteristic::ErrorCallback&) {
               NOTREACHED();
             }));
 
     generic_access->AddMockCharacteristic(std::move(peripheral_privacy_flag));
   }
 
   return generic_access;
 }
 
 // static
 std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetHeartRateService(
     MockBluetoothAdapter* adapter,
     MockBluetoothDevice* device) {
   std::unique_ptr<NiceMockBluetoothGattService> heart_rate(
       GetBaseGATTService(device, kHeartRateServiceUUID));
 
   // Heart Rate Measurement
   std::unique_ptr<NiceMockBluetoothGattCharacteristic> heart_rate_measurement(
-      GetBaseGATTCharacteristic("Heart Rate Measurement", heart_rate.get(),
-                                kHeartRateMeasurementUUID,
-                                BluetoothGattCharacteristic::PROPERTY_NOTIFY));
+      GetBaseGATTCharacteristic(
+          "Heart Rate Measurement", heart_rate.get(), kHeartRateMeasurementUUID,
+          BluetoothRemoteGattCharacteristic::PROPERTY_NOTIFY));
   NiceMockBluetoothGattCharacteristic* measurement_ptr =
       heart_rate_measurement.get();
 
   ON_CALL(*heart_rate_measurement, StartNotifySession(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, measurement_ptr]() {
             std::unique_ptr<NiceMockBluetoothGattNotifySession> notify_session(
                 GetBaseGATTNotifySession(measurement_ptr->GetIdentifier()));
 
             std::vector<uint8_t> rate(1 /* size */);
             rate[0] = 60;
 
             notify_session->StartTestNotifications(adapter, measurement_ptr,
                                                    rate);
 
             return notify_session;
           }));
 
   // Body Sensor Location Characteristic (Chest)
   std::unique_ptr<NiceMockBluetoothGattCharacteristic>
       body_sensor_location_chest(GetBaseGATTCharacteristic(
           "Body Sensor Location Chest", heart_rate.get(), kBodySensorLocation,
-          BluetoothGattCharacteristic::PROPERTY_READ));
-  BluetoothGattCharacteristic* location_chest_ptr =
+          BluetoothRemoteGattCharacteristic::PROPERTY_READ));
+  BluetoothRemoteGattCharacteristic* location_chest_ptr =
       body_sensor_location_chest.get();
 
   ON_CALL(*body_sensor_location_chest, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, location_chest_ptr]() {
             std::vector<uint8_t> location(1 /* size */);
             location[0] = 1;  // Chest
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
             FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
                               adapter->GetObservers(),
                               GattCharacteristicValueChanged(
                                   adapter, location_chest_ptr, location));
             return location;
           }));
 
   // Body Sensor Location Characteristic (Wrist)
   std::unique_ptr<NiceMockBluetoothGattCharacteristic>
       body_sensor_location_wrist(GetBaseGATTCharacteristic(
           "Body Sensor Location Wrist", heart_rate.get(), kBodySensorLocation,
-          BluetoothGattCharacteristic::PROPERTY_READ));
-  BluetoothGattCharacteristic* location_wrist_ptr =
+          BluetoothRemoteGattCharacteristic::PROPERTY_READ));
+  BluetoothRemoteGattCharacteristic* location_wrist_ptr =
       body_sensor_location_wrist.get();
 
   ON_CALL(*body_sensor_location_wrist, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, location_wrist_ptr]() {
             std::vector<uint8_t> location(1 /* size */);
             location[0] = 2;  // Wrist
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
             FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
@@ skipping 11 matching lines @@
 }
 
 // Characteristics
 
 // static
 std::unique_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTCharacteristic(
     const std::string& identifier,
     MockBluetoothGattService* service,
     const std::string& uuid,
-    BluetoothGattCharacteristic::Properties properties) {
+    BluetoothRemoteGattCharacteristic::Properties properties) {
   return base::WrapUnique(new NiceMockBluetoothGattCharacteristic(
       service, identifier, BluetoothUUID(uuid), false /* is_local */,
       properties, NULL /* permissions */));
 }
 
 // static
 std::unique_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetErrorCharacteristic(
     MockBluetoothGattService* service,
-    BluetoothGattService::GattErrorCode error_code) {
+    BluetoothRemoteGattService::GattErrorCode error_code) {
   uint32_t error_alias = error_code + 0xA1;  // Error UUIDs start at 0xA1.
   std::unique_ptr<NiceMockBluetoothGattCharacteristic> characteristic(
       GetBaseGATTCharacteristic(
           // Use the UUID to generate unique identifiers.
           "Error Characteristic " + errorUUID(error_alias), service,
           errorUUID(error_alias),
-          BluetoothGattCharacteristic::PROPERTY_READ |
-              BluetoothGattCharacteristic::PROPERTY_WRITE |
-              BluetoothGattCharacteristic::PROPERTY_INDICATE));
+          BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+              BluetoothRemoteGattCharacteristic::PROPERTY_WRITE |
+              BluetoothRemoteGattCharacteristic::PROPERTY_INDICATE));
 
   // Read response.
   ON_CALL(*characteristic, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
   // Write response.
   ON_CALL(*characteristic, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>(error_code));
 
   // StartNotifySession response
@@ skipping 74 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content