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

device/bluetooth/test/bluetooth_test.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 "device/bluetooth/test/bluetooth_test.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 133 matching lines @@
   last_connect_error_code_ = error_code;
 
   if (expected == Call::EXPECTED)
     ++actual_error_callback_calls_;
   else
     unexpected_error_callback_ = true;
 }
 
 void BluetoothTestBase::GattErrorCallback(
     Call expected,
-    BluetoothGattService::GattErrorCode error_code) {
+    BluetoothRemoteGattService::GattErrorCode error_code) {
   ++error_callback_count_;
   last_gatt_error_code_ = error_code;
 
   if (expected == Call::EXPECTED)
     ++actual_error_callback_calls_;
   else
     unexpected_error_callback_ = true;
 }
 
 base::Closure BluetoothTestBase::GetCallback(Call expected) {
@@ skipping 12 matching lines @@
 }
 
 BluetoothDevice::GattConnectionCallback
 BluetoothTestBase::GetGattConnectionCallback(Call expected) {
   if (expected == Call::EXPECTED)
     ++expected_success_callback_calls_;
   return base::Bind(&BluetoothTestBase::GattConnectionCallback,
                     weak_factory_.GetWeakPtr(), expected);
 }
 
-BluetoothGattCharacteristic::NotifySessionCallback
+BluetoothRemoteGattCharacteristic::NotifySessionCallback
 BluetoothTestBase::GetNotifyCallback(Call expected) {
   if (expected == Call::EXPECTED)
     ++expected_success_callback_calls_;
   return base::Bind(&BluetoothTestBase::NotifyCallback,
                     weak_factory_.GetWeakPtr(), expected);
 }
 
-BluetoothGattCharacteristic::ValueCallback
+BluetoothRemoteGattCharacteristic::ValueCallback
 BluetoothTestBase::GetReadValueCallback(Call expected) {
   if (expected == Call::EXPECTED)
     ++expected_success_callback_calls_;
   return base::Bind(&BluetoothTestBase::ReadValueCallback,
                     weak_factory_.GetWeakPtr(), expected);
 }
 
 BluetoothAdapter::ErrorCallback BluetoothTestBase::GetErrorCallback(
     Call expected) {
   if (expected == Call::EXPECTED)
     ++expected_error_callback_calls_;
   return base::Bind(&BluetoothTestBase::ErrorCallback,
                     weak_factory_.GetWeakPtr(), expected);
 }
 
 BluetoothDevice::ConnectErrorCallback
 BluetoothTestBase::GetConnectErrorCallback(Call expected) {
   if (expected == Call::EXPECTED)
     ++expected_error_callback_calls_;
   return base::Bind(&BluetoothTestBase::ConnectErrorCallback,
                     weak_factory_.GetWeakPtr(), expected);
 }
 
-base::Callback<void(BluetoothGattService::GattErrorCode)>
+base::Callback<void(BluetoothRemoteGattService::GattErrorCode)>
 BluetoothTestBase::GetGattErrorCallback(Call expected) {
   if (expected == Call::EXPECTED)
     ++expected_error_callback_calls_;
   return base::Bind(&BluetoothTestBase::GattErrorCallback,
                     weak_factory_.GetWeakPtr(), expected);
 }
 
 void BluetoothTestBase::ResetEventCounts() {
   last_connect_error_code_ = BluetoothDevice::ERROR_UNKNOWN;
   callback_count_ = 0;
   error_callback_count_ = 0;
   gatt_connection_attempts_ = 0;
   gatt_disconnection_attempts_ = 0;
   gatt_discovery_attempts_ = 0;
   gatt_notify_characteristic_attempts_ = 0;
   gatt_read_characteristic_attempts_ = 0;
   gatt_write_characteristic_attempts_ = 0;
   gatt_read_descriptor_attempts_ = 0;
   gatt_write_descriptor_attempts_ = 0;
 }
 
 }  // namespace device