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

components/proximity_auth/ble/bluetooth_low_energy_connection_unittest.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 "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
 #include "components/proximity_auth/bluetooth_throttler.h"
 #include "components/proximity_auth/connection_finder.h"
 #include "components/proximity_auth/proximity_auth_test_util.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/wire_message.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
-#include "device/bluetooth/bluetooth_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 using testing::SaveArg;
 
 namespace proximity_auth {
 namespace {
 
 const char kServiceUUID[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEEF";
 const char kToPeripheralCharUUID[] = "977c6674-1239-4e72-993b-502369b8bb5a";
 const char kFromPeripheralCharUUID[] = "f4b904a2-a030-43b3-98a8-221c536c03cb";
 
 const char kServiceID[] = "service id";
 const char kToPeripheralCharID[] = "to peripheral char id";
 const char kFromPeripheralCharID[] = "from peripheral char id";
 
-const device::BluetoothGattCharacteristic::Properties
+const device::BluetoothRemoteGattCharacteristic::Properties
     kCharacteristicProperties =
-        device::BluetoothGattCharacteristic::PROPERTY_BROADCAST |
-        device::BluetoothGattCharacteristic::PROPERTY_READ |
-        device::BluetoothGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE |
-        device::BluetoothGattCharacteristic::PROPERTY_INDICATE;
+        device::BluetoothRemoteGattCharacteristic::PROPERTY_BROADCAST |
+        device::BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+        device::BluetoothRemoteGattCharacteristic::
+            PROPERTY_WRITE_WITHOUT_RESPONSE |
+        device::BluetoothRemoteGattCharacteristic::PROPERTY_INDICATE;
 
 const int kMaxNumberOfTries = 3;
 
 class MockBluetoothThrottler : public BluetoothThrottler {
  public:
   MockBluetoothThrottler() {}
   ~MockBluetoothThrottler() override {}
 
   MOCK_CONST_METHOD0(GetDelay, base::TimeDelta());
   MOCK_METHOD1(OnConnection, void(Connection* connection));
@@ skipping 70 matching lines @@
     device_ = make_scoped_ptr(new NiceMock<device::MockBluetoothDevice>(
         adapter_.get(), 0, kTestRemoteDeviceName,
         kTestRemoteDeviceBluetoothAddress, false, false));
 
     service_ = make_scoped_ptr(new NiceMock<device::MockBluetoothGattService>(
         device_.get(), kServiceID, service_uuid_, true, false));
     to_peripheral_char_ =
         make_scoped_ptr(new NiceMock<device::MockBluetoothGattCharacteristic>(
             service_.get(), kToPeripheralCharID, to_peripheral_char_uuid_,
             false, kCharacteristicProperties,
-            device::BluetoothGattCharacteristic::PERMISSION_NONE));
+            device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
 
     from_peripheral_char_ =
         make_scoped_ptr(new NiceMock<device::MockBluetoothGattCharacteristic>(
             service_.get(), kFromPeripheralCharID, from_peripheral_char_uuid_,
             false, kCharacteristicProperties,
-            device::BluetoothGattCharacteristic::PERMISSION_NONE));
+            device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
 
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     std::vector<const device::BluetoothDevice*> devices;
     devices.push_back(device_.get());
     ON_CALL(*adapter_, GetDevices()).WillByDefault(Return(devices));
     ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
         .WillByDefault(Return(device_.get()));
     ON_CALL(*device_, GetGattService(kServiceID))
         .WillByDefault(Return(service_.get()));
@@ skipping 203 matching lines @@
   device::BluetoothDevice::GattConnectionCallback
       create_gatt_connection_success_callback_;
   device::BluetoothDevice::ConnectErrorCallback
       create_gatt_connection_error_callback_;
 
   BluetoothLowEnergyCharacteristicsFinder::SuccessCallback
       characteristics_finder_success_callback_;
   BluetoothLowEnergyCharacteristicsFinder::ErrorCallback
       characteristics_finder_error_callback_;
 
-  device::BluetoothGattCharacteristic::NotifySessionCallback
+  device::BluetoothRemoteGattCharacteristic::NotifySessionCallback
       notify_session_success_callback_;
-  device::BluetoothGattCharacteristic::ErrorCallback
+  device::BluetoothRemoteGattCharacteristic::ErrorCallback
       notify_session_error_callback_;
 
   base::Closure write_remote_characteristic_success_callback_;
-  device::BluetoothGattCharacteristic::ErrorCallback
+  device::BluetoothRemoteGattCharacteristic::ErrorCallback
       write_remote_characteristic_error_callback_;
 };
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        CreateAndDestroyWithouthConnectCallDoesntCrash) {
   BluetoothLowEnergyConnection connection(
       remote_device_, adapter_, service_uuid_, bluetooth_throttler_.get(),
       kMaxNumberOfTries);
 }
 
@@ skipping 65 matching lines @@
   scoped_ptr<MockBluetoothLowEnergyConnection> connection(CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
 
   EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
       .Times(0);
   EXPECT_FALSE(notify_session_success_callback_.is_null());
   ASSERT_FALSE(notify_session_error_callback_.is_null());
 
   notify_session_error_callback_.Run(
-      device::BluetoothGattService::GATT_ERROR_UNKNOWN);
+      device::BluetoothRemoteGattService::GATT_ERROR_UNKNOWN);
 
   EXPECT_EQ(connection->sub_status(),
             BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        Connect_Fails_ErrorSendingInviteToConnectSignal) {
   scoped_ptr<MockBluetoothLowEnergyConnection> connection(CreateConnection());
   ConnectGatt(connection.get());
@@ skipping 14 matching lines @@
 
   for (int i = 0; i < kMaxNumberOfTries; i++) {
     const std::vector<uint8_t> kInviteToConnectSignal = ToByteVector(
         static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
                                   kInviteToConnectSignal));
     EXPECT_EQ(last_value_written_on_to_peripheral_char_,
               kInviteToConnectSignal);
     ASSERT_FALSE(write_remote_characteristic_error_callback_.is_null());
     EXPECT_FALSE(write_remote_characteristic_success_callback_.is_null());
     write_remote_characteristic_error_callback_.Run(
-        device::BluetoothGattService::GATT_ERROR_UNKNOWN);
+        device::BluetoothRemoteGattService::GATT_ERROR_UNKNOWN);
   }
 
   EXPECT_EQ(connection->sub_status(),
             BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        Receive_MessageSmallerThanCharacteristicSize) {
   scoped_ptr<MockBluetoothLowEnergyConnection> connection(CreateConnection());
@@ skipping 159 matching lines @@
   create_gatt_connection_success_callback_.Run(
       make_scoped_ptr(new NiceMock<device::MockBluetoothGattConnection>(
           adapter_, kTestRemoteDeviceBluetoothAddress)));
 
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
   ResponseSignalReceived(connection.get());
 }
 
 }  // namespace proximity_auth