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

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_apitest.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.
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
 #include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_event_router.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.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_descriptor.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_notify_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_service.h"
 #include "extensions/common/test_util.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using device::BluetoothUUID;
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
-using device::BluetoothGattCharacteristic;
+using device::BluetoothRemoteGattCharacteristic;
 using device::BluetoothGattConnection;
-using device::BluetoothGattDescriptor;
-using device::BluetoothGattService;
+using device::BluetoothRemoteGattDescriptor;
+using device::BluetoothRemoteGattService;
 using device::BluetoothGattNotifySession;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothGattCharacteristic;
 using device::MockBluetoothGattConnection;
 using device::MockBluetoothGattDescriptor;
 using device::MockBluetoothGattService;
 using device::MockBluetoothGattNotifySession;
 using extensions::BluetoothLowEnergyEventRouter;
 using extensions::ResultCatcher;
@@ skipping 15 matching lines @@
 
 const char kTestServiceId0[] = "service_id0";
 const char kTestServiceUuid0[] = "1234";
 
 const char kTestServiceId1[] = "service_id1";
 const char kTestServiceUuid1[] = "5678";
 
 // Test characteristic constants.
 const char kTestCharacteristicId0[] = "char_id0";
 const char kTestCharacteristicUuid0[] = "1211";
-const BluetoothGattCharacteristic::Properties kTestCharacteristicProperties0 =
-    BluetoothGattCharacteristic::PROPERTY_BROADCAST |
-    BluetoothGattCharacteristic::PROPERTY_READ |
-    BluetoothGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE |
-    BluetoothGattCharacteristic::PROPERTY_INDICATE;
+const BluetoothRemoteGattCharacteristic::Properties
+    kTestCharacteristicProperties0 =
+        BluetoothRemoteGattCharacteristic::PROPERTY_BROADCAST |
+        BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+        BluetoothRemoteGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE |
+        BluetoothRemoteGattCharacteristic::PROPERTY_INDICATE;
 const uint8_t kTestCharacteristicDefaultValue0[] = {0x01, 0x02, 0x03, 0x04,
                                                     0x05};
 
 const char kTestCharacteristicId1[] = "char_id1";
 const char kTestCharacteristicUuid1[] = "1212";
-const BluetoothGattCharacteristic::Properties kTestCharacteristicProperties1 =
-    BluetoothGattCharacteristic::PROPERTY_READ |
-    BluetoothGattCharacteristic::PROPERTY_WRITE |
-    BluetoothGattCharacteristic::PROPERTY_NOTIFY;
+const BluetoothRemoteGattCharacteristic::Properties
+    kTestCharacteristicProperties1 =
+        BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+        BluetoothRemoteGattCharacteristic::PROPERTY_WRITE |
+        BluetoothRemoteGattCharacteristic::PROPERTY_NOTIFY;
 const uint8_t kTestCharacteristicDefaultValue1[] = {0x06, 0x07, 0x08};
 
 const char kTestCharacteristicId2[] = "char_id2";
 const char kTestCharacteristicUuid2[] = "1213";
-const BluetoothGattCharacteristic::Properties kTestCharacteristicProperties2 =
-    BluetoothGattCharacteristic::PROPERTY_NONE;
+const BluetoothRemoteGattCharacteristic::Properties
+    kTestCharacteristicProperties2 =
+        BluetoothRemoteGattCharacteristic::PROPERTY_NONE;
 
 // Test descriptor constants.
 const char kTestDescriptorId0[] = "desc_id0";
 const char kTestDescriptorUuid0[] = "1221";
 const uint8_t kTestDescriptorDefaultValue0[] = {0x01, 0x02, 0x03};
 
 const char kTestDescriptorId1[] = "desc_id1";
 const char kTestDescriptorUuid1[] = "1222";
 const uint8_t kTestDescriptorDefaultValue1[] = {0x04, 0x05};
 
@@ skipping 46 matching lines @@
     service1_.reset(new testing::NiceMock<MockBluetoothGattService>(
         device0_.get(),
         kTestServiceId1,
         BluetoothUUID(kTestServiceUuid1),
         false /* is_primary */,
         false /* is_local */));
 
     // Assign characteristics some random properties and permissions. They don't
     // need to reflect what the characteristic is actually capable of, since
     // the JS API just passes values through from
-    // device::BluetoothGattCharacteristic.
+    // device::BluetoothRemoteGattCharacteristic.
     std::vector<uint8_t> default_value;
     chrc0_.reset(new testing::NiceMock<MockBluetoothGattCharacteristic>(
-        service0_.get(),
-        kTestCharacteristicId0,
-        BluetoothUUID(kTestCharacteristicUuid0),
-        false /* is_local */,
+        service0_.get(), kTestCharacteristicId0,
+        BluetoothUUID(kTestCharacteristicUuid0), false /* is_local */,
         kTestCharacteristicProperties0,
-        BluetoothGattCharacteristic::PERMISSION_NONE));
+        BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
     default_value.assign(kTestCharacteristicDefaultValue0,
                          (kTestCharacteristicDefaultValue0 +
                           sizeof(kTestCharacteristicDefaultValue0)));
     ON_CALL(*chrc0_, GetValue()).WillByDefault(ReturnRefOfCopy(default_value));
 
     chrc1_.reset(new testing::NiceMock<MockBluetoothGattCharacteristic>(
-        service0_.get(),
-        kTestCharacteristicId1,
-        BluetoothUUID(kTestCharacteristicUuid1),
-        false /* is_local */,
+        service0_.get(), kTestCharacteristicId1,
+        BluetoothUUID(kTestCharacteristicUuid1), false /* is_local */,
         kTestCharacteristicProperties1,
-        BluetoothGattCharacteristic::PERMISSION_NONE));
+        BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
     default_value.assign(kTestCharacteristicDefaultValue1,
                          (kTestCharacteristicDefaultValue1 +
                           sizeof(kTestCharacteristicDefaultValue1)));
     ON_CALL(*chrc1_, GetValue()).WillByDefault(ReturnRefOfCopy(default_value));
 
     chrc2_.reset(new testing::NiceMock<MockBluetoothGattCharacteristic>(
-        service1_.get(),
-        kTestCharacteristicId2,
-        BluetoothUUID(kTestCharacteristicUuid2),
-        false /* is_local */,
+        service1_.get(), kTestCharacteristicId2,
+        BluetoothUUID(kTestCharacteristicUuid2), false /* is_local */,
         kTestCharacteristicProperties2,
-        BluetoothGattCharacteristic::PERMISSION_NONE));
+        BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
 
     desc0_.reset(new testing::NiceMock<MockBluetoothGattDescriptor>(
-        chrc0_.get(),
-        kTestDescriptorId0,
-        BluetoothUUID(kTestDescriptorUuid0),
+        chrc0_.get(), kTestDescriptorId0, BluetoothUUID(kTestDescriptorUuid0),
         false /* is_local */,
-        BluetoothGattCharacteristic::PERMISSION_NONE));
+        BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
     default_value.assign(
         kTestDescriptorDefaultValue0,
         (kTestDescriptorDefaultValue0 + sizeof(kTestDescriptorDefaultValue0)));
     ON_CALL(*desc0_, GetValue()).WillByDefault(ReturnRefOfCopy(default_value));
 
     desc1_.reset(new testing::NiceMock<MockBluetoothGattDescriptor>(
-        chrc0_.get(),
-        kTestDescriptorId1,
-        BluetoothUUID(kTestDescriptorUuid1),
+        chrc0_.get(), kTestDescriptorId1, BluetoothUUID(kTestDescriptorUuid1),
         false /* is_local */,
-        BluetoothGattCharacteristic::PERMISSION_NONE));
+        BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
     default_value.assign(
         kTestDescriptorDefaultValue1,
         (kTestDescriptorDefaultValue1 + sizeof(kTestDescriptorDefaultValue1)));
     ON_CALL(*desc1_, GetValue()).WillByDefault(ReturnRefOfCopy(default_value));
   }
 
  protected:
   BluetoothLowEnergyEventRouter* event_router() {
     return extensions::BluetoothLowEnergyAPI::Get(browser()->profile())
         ->event_router();
@@ skipping 40 matching lines @@
       new testing::NiceMock<MockBluetoothGattConnection>(adapter,
                                                          device_address);
   EXPECT_CALL(*conn, Disconnect()).Times(expect_disconnect ? 1 : 0);
   return conn;
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothLowEnergyApiTest, GetServices) {
   ResultCatcher catcher;
   catcher.RestrictToBrowserContext(browser()->profile());
 
-  std::vector<BluetoothGattService*> services;
+  std::vector<BluetoothRemoteGattService*> services;
   services.push_back(service0_.get());
   services.push_back(service1_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(_))
       .Times(3)
       .WillOnce(Return(static_cast<BluetoothDevice*>(NULL)))
       .WillRepeatedly(Return(device0_.get()));
 
   EXPECT_CALL(*device0_, GetGattServices())
       .Times(2)
-      .WillOnce(Return(std::vector<BluetoothGattService*>()))
+      .WillOnce(Return(std::vector<BluetoothRemoteGattService*>()))
       .WillOnce(Return(services));
 
   // Load and wait for setup.
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("bluetooth_low_energy/get_services")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothLowEnergyApiTest, GetService) {
   ResultCatcher catcher;
   catcher.RestrictToBrowserContext(browser()->profile());
 
   event_router()->GattServiceAdded(
       mock_adapter_, device0_.get(), service0_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(_))
       .Times(3)
       .WillOnce(Return(static_cast<BluetoothDevice*>(NULL)))
       .WillRepeatedly(Return(device0_.get()));
 
   EXPECT_CALL(*device0_, GetGattService(kTestServiceId0))
       .Times(2)
-      .WillOnce(Return(static_cast<BluetoothGattService*>(NULL)))
+      .WillOnce(Return(static_cast<BluetoothRemoteGattService*>(NULL)))
       .WillOnce(Return(service0_.get()));
 
   // Load and wait for setup.
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("bluetooth_low_energy/get_service")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
@@ skipping 100 matching lines @@
       "bluetooth_low_energy/get_included_services")));
 
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   // Set up for the rest of the calls before replying. Included services can be
   // returned even if there is no instance ID mapping for them yet, so no need
   // to call GattServiceAdded for |service1_| here.
   event_router()->GattServiceAdded(
       mock_adapter_, device0_.get(), service0_.get());
 
-  std::vector<BluetoothGattService*> includes;
+  std::vector<BluetoothRemoteGattService*> includes;
   includes.push_back(service1_.get());
   EXPECT_CALL(*mock_adapter_, GetDevice(kTestLeDeviceAddress0))
       .Times(2)
       .WillRepeatedly(Return(device0_.get()));
   EXPECT_CALL(*device0_, GetGattService(kTestServiceId0))
       .Times(2)
       .WillRepeatedly(Return(service0_.get()));
   EXPECT_CALL(*service0_, GetIncludedServices())
       .Times(2)
-      .WillOnce(Return(std::vector<BluetoothGattService*>()))
+      .WillOnce(Return(std::vector<BluetoothRemoteGattService*>()))
       .WillOnce(Return(includes));
 
   listener.Reply("go");
   listener.Reset();
 
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   event_router()->GattServiceRemoved(
       mock_adapter_, device0_.get(), service0_.get());
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothLowEnergyApiTest, GetCharacteristics) {
   ResultCatcher catcher;
   catcher.RestrictToBrowserContext(browser()->profile());
 
-  std::vector<BluetoothGattCharacteristic*> characteristics;
+  std::vector<BluetoothRemoteGattCharacteristic*> characteristics;
   characteristics.push_back(chrc0_.get());
   characteristics.push_back(chrc1_.get());
 
   event_router()->GattServiceAdded(
       mock_adapter_, device0_.get(), service0_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(_)).Times(3).WillRepeatedly(
       Return(device0_.get()));
   EXPECT_CALL(*device0_, GetGattService(kTestServiceId0))
       .Times(3)
-      .WillOnce(Return(static_cast<BluetoothGattService*>(NULL)))
+      .WillOnce(Return(static_cast<BluetoothRemoteGattService*>(NULL)))
       .WillRepeatedly(Return(service0_.get()));
   EXPECT_CALL(*service0_, GetCharacteristics())
       .Times(2)
-      .WillOnce(Return(std::vector<BluetoothGattCharacteristic*>()))
+      .WillOnce(Return(std::vector<BluetoothRemoteGattCharacteristic*>()))
       .WillOnce(Return(characteristics));
 
   ExtensionTestMessageListener listener("ready", true);
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("bluetooth_low_energy/get_characteristics")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   event_router()->GattServiceRemoved(
       mock_adapter_, device0_.get(), service0_.get());
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothLowEnergyApiTest, GetCharacteristic) {
   ResultCatcher catcher;
   catcher.RestrictToBrowserContext(browser()->profile());
 
   event_router()->GattServiceAdded(
       mock_adapter_, device0_.get(), service0_.get());
   event_router()->GattCharacteristicAdded(mock_adapter_, chrc0_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(_))
       .Times(4)
       .WillOnce(Return(static_cast<BluetoothDevice*>(NULL)))
       .WillRepeatedly(Return(device0_.get()));
 
   EXPECT_CALL(*device0_, GetGattService(kTestServiceId0))
       .Times(3)
-      .WillOnce(Return(static_cast<BluetoothGattService*>(NULL)))
+      .WillOnce(Return(static_cast<BluetoothRemoteGattService*>(NULL)))
       .WillRepeatedly(Return(service0_.get()));
 
   EXPECT_CALL(*service0_, GetCharacteristic(kTestCharacteristicId0))
       .Times(2)
-      .WillOnce(Return(static_cast<BluetoothGattCharacteristic*>(NULL)))
+      .WillOnce(Return(static_cast<BluetoothRemoteGattCharacteristic*>(NULL)))
       .WillOnce(Return(chrc0_.get()));
 
   // Load the extension and wait for first test.
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("bluetooth_low_energy/get_characteristic")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
@@ skipping 17 matching lines @@
       .Times(12)
       .WillRepeatedly(Return(device0_.get()));
   EXPECT_CALL(*device0_, GetGattService(kTestServiceId0))
       .Times(12)
       .WillRepeatedly(Return(service0_.get()));
   EXPECT_CALL(*service0_, GetCharacteristic(kTestCharacteristicId0))
       .Times(12)
       .WillRepeatedly(Return(chrc0_.get()));
   EXPECT_CALL(*chrc0_, GetProperties())
       .Times(12)
-      .WillOnce(Return(BluetoothGattCharacteristic::PROPERTY_NONE))
-      .WillOnce(Return(BluetoothGattCharacteristic::PROPERTY_BROADCAST))
-      .WillOnce(Return(BluetoothGattCharacteristic::PROPERTY_READ))
+      .WillOnce(Return(BluetoothRemoteGattCharacteristic::PROPERTY_NONE))
+      .WillOnce(Return(BluetoothRemoteGattCharacteristic::PROPERTY_BROADCAST))
+      .WillOnce(Return(BluetoothRemoteGattCharacteristic::PROPERTY_READ))
+      .WillOnce(Return(
+          BluetoothRemoteGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE))
+      .WillOnce(Return(BluetoothRemoteGattCharacteristic::PROPERTY_WRITE))
+      .WillOnce(Return(BluetoothRemoteGattCharacteristic::PROPERTY_NOTIFY))
+      .WillOnce(Return(BluetoothRemoteGattCharacteristic::PROPERTY_INDICATE))
+      .WillOnce(Return(BluetoothRemoteGattCharacteristic::
+                           PROPERTY_AUTHENTICATED_SIGNED_WRITES))
+      .WillOnce(Return(
+          BluetoothRemoteGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES))
       .WillOnce(
-           Return(BluetoothGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE))
-      .WillOnce(Return(BluetoothGattCharacteristic::PROPERTY_WRITE))
-      .WillOnce(Return(BluetoothGattCharacteristic::PROPERTY_NOTIFY))
-      .WillOnce(Return(BluetoothGattCharacteristic::PROPERTY_INDICATE))
+          Return(BluetoothRemoteGattCharacteristic::PROPERTY_RELIABLE_WRITE))
       .WillOnce(Return(
-          BluetoothGattCharacteristic::PROPERTY_AUTHENTICATED_SIGNED_WRITES))
-      .WillOnce(
-           Return(BluetoothGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES))
-      .WillOnce(Return(BluetoothGattCharacteristic::PROPERTY_RELIABLE_WRITE))
-      .WillOnce(
-           Return(BluetoothGattCharacteristic::PROPERTY_WRITABLE_AUXILIARIES))
+          BluetoothRemoteGattCharacteristic::PROPERTY_WRITABLE_AUXILIARIES))
       .WillOnce(Return(
-          BluetoothGattCharacteristic::PROPERTY_BROADCAST |
-          BluetoothGattCharacteristic::PROPERTY_READ |
-          BluetoothGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE |
-          BluetoothGattCharacteristic::PROPERTY_WRITE |
-          BluetoothGattCharacteristic::PROPERTY_NOTIFY |
-          BluetoothGattCharacteristic::PROPERTY_INDICATE |
-          BluetoothGattCharacteristic::PROPERTY_AUTHENTICATED_SIGNED_WRITES |
-          BluetoothGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES |
-          BluetoothGattCharacteristic::PROPERTY_RELIABLE_WRITE |
-          BluetoothGattCharacteristic::PROPERTY_WRITABLE_AUXILIARIES));
+          BluetoothRemoteGattCharacteristic::PROPERTY_BROADCAST |
+          BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+          BluetoothRemoteGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE |
+          BluetoothRemoteGattCharacteristic::PROPERTY_WRITE |
+          BluetoothRemoteGattCharacteristic::PROPERTY_NOTIFY |
+          BluetoothRemoteGattCharacteristic::PROPERTY_INDICATE |
+          BluetoothRemoteGattCharacteristic::
+              PROPERTY_AUTHENTICATED_SIGNED_WRITES |
+          BluetoothRemoteGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES |
+          BluetoothRemoteGattCharacteristic::PROPERTY_RELIABLE_WRITE |
+          BluetoothRemoteGattCharacteristic::PROPERTY_WRITABLE_AUXILIARIES));
 
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(
       "bluetooth_low_energy/characteristic_properties")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
@@ skipping 134 matching lines @@
       .Times(3)
       .WillRepeatedly(Return(service0_.get()));
 
   EXPECT_CALL(*service0_, GetCharacteristic(kTestCharacteristicId0))
       .Times(3)
       .WillRepeatedly(Return(chrc0_.get()));
 
   std::vector<uint8_t> value;
   EXPECT_CALL(*chrc0_, ReadRemoteCharacteristic(_, _))
       .Times(2)
-      .WillOnce(
-           InvokeCallbackArgument<1>(BluetoothGattService::GATT_ERROR_FAILED))
+      .WillOnce(InvokeCallbackArgument<1>(
+          BluetoothRemoteGattService::GATT_ERROR_FAILED))
       .WillOnce(InvokeCallbackArgument<0>(value));
 
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(
       "bluetooth_low_energy/read_characteristic_value")));
   listener.WaitUntilSatisfied();
 
   listener.Reply("go");
 
@@ skipping 20 matching lines @@
       .Times(3)
       .WillRepeatedly(Return(service0_.get()));
 
   EXPECT_CALL(*service0_, GetCharacteristic(kTestCharacteristicId0))
       .Times(3)
       .WillRepeatedly(Return(chrc0_.get()));
 
   std::vector<uint8_t> write_value;
   EXPECT_CALL(*chrc0_, WriteRemoteCharacteristic(_, _, _))
       .Times(2)
-      .WillOnce(
-           InvokeCallbackArgument<2>(BluetoothGattService::GATT_ERROR_FAILED))
+      .WillOnce(InvokeCallbackArgument<2>(
+          BluetoothRemoteGattService::GATT_ERROR_FAILED))
       .WillOnce(DoAll(SaveArg<0>(&write_value), InvokeCallbackArgument<1>()));
 
   EXPECT_CALL(*chrc0_, GetValue()).Times(1).WillOnce(ReturnRef(write_value));
 
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(
       "bluetooth_low_energy/write_characteristic_value")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   event_router()->GattCharacteristicRemoved(mock_adapter_, chrc0_.get());
   event_router()->GattServiceRemoved(
       mock_adapter_, device0_.get(), service0_.get());
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothLowEnergyApiTest, GetDescriptors) {
   ResultCatcher catcher;
   catcher.RestrictToBrowserContext(browser()->profile());
 
-  std::vector<BluetoothGattDescriptor*> descriptors;
+  std::vector<BluetoothRemoteGattDescriptor*> descriptors;
   descriptors.push_back(desc0_.get());
   descriptors.push_back(desc1_.get());
 
   event_router()->GattServiceAdded(
       mock_adapter_, device0_.get(), service0_.get());
   event_router()->GattCharacteristicAdded(mock_adapter_, chrc0_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(_))
       .Times(3)
       .WillRepeatedly(Return(device0_.get()));
   EXPECT_CALL(*device0_, GetGattService(kTestServiceId0))
       .Times(3)
       .WillRepeatedly(Return(service0_.get()));
   EXPECT_CALL(*service0_, GetCharacteristic(kTestCharacteristicId0))
       .Times(3)
-      .WillOnce(Return(static_cast<BluetoothGattCharacteristic*>(NULL)))
+      .WillOnce(Return(static_cast<BluetoothRemoteGattCharacteristic*>(NULL)))
       .WillRepeatedly(Return(chrc0_.get()));
   EXPECT_CALL(*chrc0_, GetDescriptors())
       .Times(2)
-      .WillOnce(Return(std::vector<BluetoothGattDescriptor*>()))
+      .WillOnce(Return(std::vector<BluetoothRemoteGattDescriptor*>()))
       .WillOnce(Return(descriptors));
 
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("bluetooth_low_energy/get_descriptors")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
@@ skipping 13 matching lines @@
   event_router()->GattCharacteristicAdded(mock_adapter_, chrc0_.get());
   event_router()->GattDescriptorAdded(mock_adapter_, desc0_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(_))
       .Times(5)
       .WillOnce(Return(static_cast<BluetoothDevice*>(NULL)))
       .WillRepeatedly(Return(device0_.get()));
 
   EXPECT_CALL(*device0_, GetGattService(kTestServiceId0))
       .Times(4)
-      .WillOnce(Return(static_cast<BluetoothGattService*>(NULL)))
+      .WillOnce(Return(static_cast<BluetoothRemoteGattService*>(NULL)))
       .WillRepeatedly(Return(service0_.get()));
 
   EXPECT_CALL(*service0_, GetCharacteristic(kTestCharacteristicId0))
       .Times(3)
-      .WillOnce(Return(static_cast<BluetoothGattCharacteristic*>(NULL)))
+      .WillOnce(Return(static_cast<BluetoothRemoteGattCharacteristic*>(NULL)))
       .WillRepeatedly(Return(chrc0_.get()));
 
   EXPECT_CALL(*chrc0_, GetDescriptor(kTestDescriptorId0))
       .Times(2)
-      .WillOnce(Return(static_cast<BluetoothGattDescriptor*>(NULL)))
+      .WillOnce(Return(static_cast<BluetoothRemoteGattDescriptor*>(NULL)))
       .WillOnce(Return(desc0_.get()));
 
   // Load the extension and wait for first test.
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("bluetooth_low_energy/get_descriptor")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
@@ skipping 113 matching lines @@
       .Times(9)
       .WillRepeatedly(Return(chrc0_.get()));
 
   EXPECT_CALL(*chrc0_, GetDescriptor(kTestDescriptorId0))
       .Times(9)
       .WillRepeatedly(Return(desc0_.get()));
 
   std::vector<uint8_t> value;
   EXPECT_CALL(*desc0_, ReadRemoteDescriptor(_, _))
       .Times(8)
-      .WillOnce(
-           InvokeCallbackArgument<1>(BluetoothGattService::GATT_ERROR_FAILED))
       .WillOnce(InvokeCallbackArgument<1>(
-          BluetoothGattService::GATT_ERROR_INVALID_LENGTH))
+          BluetoothRemoteGattService::GATT_ERROR_FAILED))
       .WillOnce(InvokeCallbackArgument<1>(
-          BluetoothGattService::GATT_ERROR_NOT_PERMITTED))
+          BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH))
       .WillOnce(InvokeCallbackArgument<1>(
-          BluetoothGattService::GATT_ERROR_NOT_AUTHORIZED))
+          BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED))
       .WillOnce(InvokeCallbackArgument<1>(
-          BluetoothGattService::GATT_ERROR_NOT_PAIRED))
+          BluetoothRemoteGattService::GATT_ERROR_NOT_AUTHORIZED))
       .WillOnce(InvokeCallbackArgument<1>(
-          BluetoothGattService::GATT_ERROR_NOT_SUPPORTED))
+          BluetoothRemoteGattService::GATT_ERROR_NOT_PAIRED))
       .WillOnce(InvokeCallbackArgument<1>(
-          BluetoothGattService::GATT_ERROR_IN_PROGRESS))
+          BluetoothRemoteGattService::GATT_ERROR_NOT_SUPPORTED))
+      .WillOnce(InvokeCallbackArgument<1>(
+          BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS))
       .WillOnce(InvokeCallbackArgument<0>(value));
 
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(
       "bluetooth_low_energy/read_descriptor_value")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
@@ skipping 26 matching lines @@
       .Times(3)
       .WillRepeatedly(Return(chrc0_.get()));
 
   EXPECT_CALL(*chrc0_, GetDescriptor(kTestDescriptorId0))
       .Times(3)
       .WillRepeatedly(Return(desc0_.get()));
 
   std::vector<uint8_t> write_value;
   EXPECT_CALL(*desc0_, WriteRemoteDescriptor(_, _, _))
       .Times(2)
-      .WillOnce(
-           InvokeCallbackArgument<2>(BluetoothGattService::GATT_ERROR_FAILED))
+      .WillOnce(InvokeCallbackArgument<2>(
+          BluetoothRemoteGattService::GATT_ERROR_FAILED))
       .WillOnce(DoAll(SaveArg<0>(&write_value), InvokeCallbackArgument<1>()));
 
   EXPECT_CALL(*desc0_, GetValue()).Times(1).WillOnce(ReturnRef(write_value));
 
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(
       "bluetooth_low_energy/write_descriptor_value")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
@@ skipping 18 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(BluetoothLowEnergyApiTest, UuidPermissionMethods) {
   ResultCatcher catcher;
   catcher.RestrictToBrowserContext(browser()->profile());
 
   event_router()->GattServiceAdded(
       mock_adapter_, device0_.get(), service0_.get());
   event_router()->GattCharacteristicAdded(mock_adapter_, chrc0_.get());
   event_router()->GattDescriptorAdded(mock_adapter_, desc0_.get());
 
-  std::vector<BluetoothGattService*> services;
+  std::vector<BluetoothRemoteGattService*> services;
   services.push_back(service0_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(_))
       .WillRepeatedly(Return(device0_.get()));
   EXPECT_CALL(*device0_, GetGattServices()).WillOnce(Return(services));
   EXPECT_CALL(*device0_, GetGattService(kTestServiceId0))
       .WillRepeatedly(Return(service0_.get()));
   EXPECT_CALL(*service0_, GetCharacteristic(kTestCharacteristicId0))
       .WillRepeatedly(Return(chrc0_.get()));
   EXPECT_CALL(*chrc0_, GetDescriptor(kTestDescriptorId0))
@@ skipping 193 matching lines @@
   MockBluetoothGattNotifySession* session1 =
       new testing::NiceMock<MockBluetoothGattNotifySession>(
           kTestCharacteristicId1);
 
   EXPECT_CALL(*session1, Stop(_))
       .Times(1)
       .WillOnce(InvokeCallbackArgument<0>());
 
   EXPECT_CALL(*chrc0_, StartNotifySession(_, _))
       .Times(2)
-      .WillOnce(
-           InvokeCallbackArgument<1>(BluetoothGattService::GATT_ERROR_FAILED))
+      .WillOnce(InvokeCallbackArgument<1>(
+          BluetoothRemoteGattService::GATT_ERROR_FAILED))
       .WillOnce(InvokeCallbackWithScopedPtrArg<0, BluetoothGattNotifySession>(
           session0));
   EXPECT_CALL(*chrc1_, StartNotifySession(_, _))
       .Times(1)
       .WillOnce(
           InvokeCallbackWithScopedPtrArg<0, BluetoothGattNotifySession>(
               session1));
 
   ExtensionTestMessageListener listener("ready", true);
   listener.set_failure_message("fail");
@@ skipping 50 matching lines @@
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   event_router()->GattServiceRemoved(mock_adapter_, device0_.get(),
                                      service0_.get());
 }
 
 }  // namespace