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

device/bluetooth/bluez/bluetooth_remote_gatt_service_bluez.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2016 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/bluetooth_remote_gatt_service_bluez.h"
-
 #include <iterator>
 
-#include "base/callback.h"
-#include "base/callback_forward.h"
 #include "base/logging.h"
 #include "dbus/property.h"
-#include "device/bluetooth/bluetooth_adapter_bluez.h"
-#include "device/bluetooth/bluetooth_device_bluez.h"
-#include "device/bluetooth/bluetooth_gatt_characteristic_bluez.h"
-#include "device/bluetooth/bluetooth_gatt_descriptor_bluez.h"
-#include "device/bluetooth/bluetooth_gatt_service.h"
-#include "device/bluetooth/bluetooth_remote_gatt_characteristic_bluez.h"
+#include "device/bluetooth/bluez/bluetooth_adapter_bluez.h"
+#include "device/bluetooth/bluez/bluetooth_device_bluez.h"
+#include "device/bluetooth/bluez/bluetooth_gatt_characteristic_bluez.h"
+#include "device/bluetooth/bluez/bluetooth_remote_gatt_characteristic_bluez.h"
+#include "device/bluetooth/bluez/bluetooth_remote_gatt_descriptor_bluez.h"
+#include "device/bluetooth/bluez/bluetooth_remote_gatt_service_bluez.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 
 namespace bluez {
 
 BluetoothRemoteGattServiceBlueZ::BluetoothRemoteGattServiceBlueZ(
     BluetoothAdapterBlueZ* adapter,
     BluetoothDeviceBlueZ* device,
     const dbus::ObjectPath& object_path)
     : BluetoothGattServiceBlueZ(adapter, object_path),
       device_(device),
@@ skipping 43 matching lines @@
 
 device::BluetoothUUID BluetoothRemoteGattServiceBlueZ::GetUUID() const {
   bluez::BluetoothGattServiceClient::Properties* properties =
       bluez::BluezDBusManager::Get()
           ->GetBluetoothGattServiceClient()
           ->GetProperties(object_path());
   DCHECK(properties);
   return device::BluetoothUUID(properties->uuid.value());
 }
 
-bool BluetoothRemoteGattServiceBlueZ::IsLocal() const {
-  return false;
-}
-
 bool BluetoothRemoteGattServiceBlueZ::IsPrimary() const {
   bluez::BluetoothGattServiceClient::Properties* properties =
       bluez::BluezDBusManager::Get()
           ->GetBluetoothGattServiceClient()
           ->GetProperties(object_path());
   DCHECK(properties);
   return properties->primary.value();
 }
 
 device::BluetoothDevice* BluetoothRemoteGattServiceBlueZ::GetDevice() const {
   return device_;
 }
 
-bool BluetoothRemoteGattServiceBlueZ::AddCharacteristic(
-    device::BluetoothGattCharacteristic* characteristic) {
-  VLOG(1) << "Characteristics cannot be added to a remote GATT service.";
-  return false;
+std::vector<device::BluetoothRemoteGattCharacteristic*>
+BluetoothRemoteGattServiceBlueZ::GetCharacteristics() const {
+  std::vector<device::BluetoothRemoteGattCharacteristic*> characteristics;
+  for (CharacteristicMap::const_iterator iter = characteristics_.begin();
+       iter != characteristics_.end(); ++iter) {
+    characteristics.push_back(iter->second);
+  }
+  return characteristics;
 }
 
-bool BluetoothRemoteGattServiceBlueZ::AddIncludedService(
-    device::BluetoothGattService* service) {
-  VLOG(1) << "Included services cannot be added to a remote GATT service.";
-  return false;
+std::vector<device::BluetoothRemoteGattService*>
+BluetoothRemoteGattServiceBlueZ::GetIncludedServices() const {
+  // TODO(armansito): Return the actual included services here.
+  return std::vector<device::BluetoothRemoteGattService*>();
 }
 
-void BluetoothRemoteGattServiceBlueZ::Register(
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
-  VLOG(1) << "A remote GATT service cannot be registered.";
-  error_callback.Run(GATT_ERROR_NOT_SUPPORTED);
-}
-
-void BluetoothRemoteGattServiceBlueZ::Unregister(
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
-  VLOG(1) << "A remote GATT service cannot be unregistered.";
-  error_callback.Run(GATT_ERROR_NOT_SUPPORTED);
+device::BluetoothRemoteGattCharacteristic*
+BluetoothRemoteGattServiceBlueZ::GetCharacteristic(
+    const std::string& identifier) const {
+  CharacteristicMap::const_iterator iter =
+      characteristics_.find(dbus::ObjectPath(identifier));
+  if (iter == characteristics_.end())
+    return nullptr;
+  return iter->second;
 }
 
 void BluetoothRemoteGattServiceBlueZ::NotifyServiceChanged() {
   // Don't send service changed unless we know that all characteristics have
   // already been discovered. This is to prevent spammy events before sending
   // out the first Gatt
   if (!discovery_complete_)
     return;
 
   DCHECK(GetAdapter());
   GetAdapter()->NotifyGattServiceChanged(this);
 }
 
 void BluetoothRemoteGattServiceBlueZ::NotifyDescriptorAddedOrRemoved(
     BluetoothRemoteGattCharacteristicBlueZ* characteristic,
-    BluetoothGattDescriptorBlueZ* descriptor,
+    BluetoothRemoteGattDescriptorBlueZ* descriptor,
     bool added) {
   DCHECK(characteristic->GetService() == this);
   DCHECK(descriptor->GetCharacteristic() == characteristic);
   DCHECK(GetAdapter());
 
   if (added) {
     GetAdapter()->NotifyGattDescriptorAdded(descriptor);
     return;
   }
 
   GetAdapter()->NotifyGattDescriptorRemoved(descriptor);
 }
 
 void BluetoothRemoteGattServiceBlueZ::NotifyDescriptorValueChanged(
     BluetoothRemoteGattCharacteristicBlueZ* characteristic,
-    BluetoothGattDescriptorBlueZ* descriptor,
+    BluetoothRemoteGattDescriptorBlueZ* descriptor,
     const std::vector<uint8_t>& value) {
   DCHECK(characteristic->GetService() == this);
   DCHECK(descriptor->GetCharacteristic() == characteristic);
   DCHECK(GetAdapter());
   GetAdapter()->NotifyGattDescriptorValueChanged(descriptor, value);
 }
 
 void BluetoothRemoteGattServiceBlueZ::GattServicePropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
@@ skipping 58 matching lines @@
     const dbus::ObjectPath& object_path) {
   CharacteristicMap::iterator iter = characteristics_.find(object_path);
   if (iter == characteristics_.end()) {
     VLOG(2) << "Unknown GATT characteristic removed: " << object_path.value();
     return;
   }
 
   VLOG(1) << "Removing remote GATT characteristic from service: "
           << GetIdentifier() << ", UUID: " << GetUUID().canonical_value();
 
-  BluetoothGattCharacteristicBlueZ* characteristic = iter->second;
+  BluetoothRemoteGattCharacteristicBlueZ* characteristic = iter->second;
   DCHECK(characteristic->object_path() == object_path);
   characteristics_.erase(iter);
 
   DCHECK(GetAdapter());
   GetAdapter()->NotifyGattCharacteristicRemoved(characteristic);
 
   delete characteristic;
 }
 
 void BluetoothRemoteGattServiceBlueZ::GattCharacteristicPropertyChanged(
@@ skipping 19 matching lines @@
   DCHECK(GetAdapter());
 
   if (property_name == properties->flags.name())
     NotifyServiceChanged();
   else if (property_name == properties->value.name())
     GetAdapter()->NotifyGattCharacteristicValueChanged(
         iter->second, properties->value.value());
 }
 
 }  // namespace bluez