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

components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder_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_characteristics_finder.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/proximity_auth/ble/remote_attribute.h"
@@ skipping 19 matching lines @@
 const char kDeviceName[] = "Device name";
 const char kBluetoothAddress[] = "11:22:33:44:55:66";
 
 const char kServiceUUID[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEEF";
 const char kToPeripheralCharUUID[] = "FBAE09F2-0482-11E5-8418-1697F925EC7B";
 const char kFromPeripheralCharUUID[] = "5539ED10-0483-11E5-8418-1697F925EC7B";
 
 const char kToPeripheralCharID[] = "to peripheral id";
 const char kFromPeripheralCharID[] = "from peripheral 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 char kOtherCharUUID[] = "09731422-048A-11E5-8418-1697F925EC7B";
 const char kOtherCharID[] = "other id";
 }  //  namespace
 
 class ProximityAuthBluetoothLowEnergyCharacteristicFinderTest
     : public testing::Test {
  protected:
   ProximityAuthBluetoothLowEnergyCharacteristicFinderTest()
       : adapter_(new NiceMock<device::MockBluetoothAdapter>),
@@ skipping 19 matching lines @@
             false)),
         remote_service_({device::BluetoothUUID(kServiceUUID), ""}),
         to_peripheral_char_({device::BluetoothUUID(kToPeripheralCharUUID), ""}),
         from_peripheral_char_(
             {device::BluetoothUUID(kFromPeripheralCharUUID), ""}) {
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     // The default behavior for |device_| is to have no services discovered. Can
     // be overrided later.
     ON_CALL(*device_, GetGattServices())
-        .WillByDefault(Return(std::vector<device::BluetoothGattService*>()));
+        .WillByDefault(
+            Return(std::vector<device::BluetoothRemoteGattService*>()));
   }
 
   void SetUp() {
     EXPECT_CALL(*adapter_, AddObserver(_));
     EXPECT_CALL(*adapter_, RemoveObserver(_));
   }
 
   MOCK_METHOD3(OnCharacteristicsFound,
                void(const RemoteAttribute&,
                     const RemoteAttribute&,
                     const RemoteAttribute&));
   MOCK_METHOD2(OnCharacteristicsFinderError,
                void(const RemoteAttribute&, const RemoteAttribute&));
 
   scoped_ptr<device::MockBluetoothGattCharacteristic>
   ExpectToFindCharacteristic(const device::BluetoothUUID& uuid,
                              const std::string& id,
                              bool valid) {
     scoped_ptr<device::MockBluetoothGattCharacteristic> characteristic(
         new NiceMock<device::MockBluetoothGattCharacteristic>(
             service_.get(), id, uuid, true, kCharacteristicProperties,
-            device::BluetoothGattCharacteristic::PERMISSION_NONE));
+            device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
 
     ON_CALL(*characteristic.get(), GetUUID()).WillByDefault(Return(uuid));
     if (valid)
       ON_CALL(*characteristic.get(), GetIdentifier()).WillByDefault(Return(id));
     ON_CALL(*characteristic.get(), GetService())
         .WillByDefault(Return(service_.get()));
     return characteristic;
   }
 
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
@@ skipping 140 matching lines @@
   EXPECT_CALL(*this, OnCharacteristicsFinderError(_, _)).Times(0);
 
   scoped_ptr<device::MockBluetoothGattCharacteristic> from_char =
       ExpectToFindCharacteristic(device::BluetoothUUID(kFromPeripheralCharUUID),
                                  kFromPeripheralCharID, true);
 
   scoped_ptr<device::MockBluetoothGattCharacteristic> to_char =
       ExpectToFindCharacteristic(device::BluetoothUUID(kToPeripheralCharUUID),
                                  kToPeripheralCharID, true);
 
-  std::vector<device::BluetoothGattService*> services;
+  std::vector<device::BluetoothRemoteGattService*> services;
   services.push_back(service_.get());
   ON_CALL(*device_, GetGattServices()).WillByDefault(Return(services));
 
-  std::vector<device::BluetoothGattCharacteristic*> characteristics;
+  std::vector<device::BluetoothRemoteGattCharacteristic*> characteristics;
   characteristics.push_back(from_char.get());
   characteristics.push_back(to_char.get());
   ON_CALL(*service_, GetCharacteristics())
       .WillByDefault(Return(characteristics));
 
   BluetoothLowEnergyCharacteristicsFinder characteristic_finder(
       adapter_, device_.get(), remote_service_, to_peripheral_char_,
       from_peripheral_char_, success_callback_, error_callback_);
   device::BluetoothAdapter::Observer* observer =
       static_cast<device::BluetoothAdapter::Observer*>(&characteristic_finder);
 
   EXPECT_EQ(kToPeripheralCharID, found_to_char.id);
   EXPECT_EQ(kFromPeripheralCharID, found_from_char.id);
 
   EXPECT_CALL(*service_, GetUUID())
       .WillOnce(Return(device::BluetoothUUID(kServiceUUID)));
   observer->GattDiscoveryCompleteForService(adapter_.get(), service_.get());
 }
 
 }  // namespace proximity_auth