device/bluetooth: Move GATT observer methods to BluetoothAdapter::Observer.

device/bluetooth/bluetooth_remote_gatt_service_chromeos.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 "device/bluetooth/bluetooth_remote_gatt_service_chromeos.h"
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/dbus/bluetooth_gatt_service_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ skipping 36 matching lines @@
   DBusThreadManager::Get()->GetBluetoothGattCharacteristicClient()->
       RemoveObserver(this);
 
   // Clean up all the characteristics. Copy the characteristics list here and
   // clear the original so that when we send GattCharacteristicRemoved(),
   // GetCharacteristics() returns no characteristics.
   CharacteristicMap characteristics = characteristics_;
   characteristics_.clear();
   for (CharacteristicMap::iterator iter = characteristics.begin();
        iter != characteristics.end(); ++iter) {
-    FOR_EACH_OBSERVER(device::BluetoothGattService::Observer, observers_,
-                      GattCharacteristicRemoved(this, iter->second));
+    DCHECK(adapter_);
+    adapter_->NotifyGattCharacteristicRemoved(iter->second);
+
     delete iter->second;
   }
 }
 
-void BluetoothRemoteGattServiceChromeOS::AddObserver(
-    device::BluetoothGattService::Observer* observer) {
-  DCHECK(observer);
-  observers_.AddObserver(observer);
-}
-
-void BluetoothRemoteGattServiceChromeOS::RemoveObserver(
-    device::BluetoothGattService::Observer* observer) {
-  DCHECK(observer);
-  observers_.RemoveObserver(observer);
-}
-
 std::string BluetoothRemoteGattServiceChromeOS::GetIdentifier() const {
   return object_path_.value();
 }
 
 device::BluetoothUUID BluetoothRemoteGattServiceChromeOS::GetUUID() const {
   BluetoothGattServiceClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothGattServiceClient()->
           GetProperties(object_path_);
   DCHECK(properties);
   return device::BluetoothUUID(properties->uuid.value());
@@ skipping 60 matching lines @@
   error_callback.Run();
 }
 
 void BluetoothRemoteGattServiceChromeOS::Unregister(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "A remote GATT service cannot be unregistered.";
   error_callback.Run();
 }
 
-scoped_refptr<device::BluetoothAdapter>
+BluetoothAdapterChromeOS*
 BluetoothRemoteGattServiceChromeOS::GetAdapter() const {
   return adapter_;
 }
 
 void BluetoothRemoteGattServiceChromeOS::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;
 
-  FOR_EACH_OBSERVER(device::BluetoothGattService::Observer, observers_,
-                    GattServiceChanged(this));
+  DCHECK(adapter_);
+  adapter_->NotifyGattServiceChanged(this);
 }
 
 void BluetoothRemoteGattServiceChromeOS::NotifyCharacteristicValueChanged(
     BluetoothRemoteGattCharacteristicChromeOS* characteristic,
     const std::vector<uint8>& value) {
   DCHECK(characteristic->GetService() == this);
-  FOR_EACH_OBSERVER(
-      device::BluetoothGattService::Observer,
-      observers_,
-      GattCharacteristicValueChanged(this, characteristic, value));
+  DCHECK(adapter_);
+  adapter_->NotifyGattCharacteristicValueChanged(characteristic, value);
 }
 
 void BluetoothRemoteGattServiceChromeOS::NotifyDescriptorAddedOrRemoved(
     BluetoothRemoteGattCharacteristicChromeOS* characteristic,
     BluetoothRemoteGattDescriptorChromeOS* descriptor,
     bool added) {
   DCHECK(characteristic->GetService() == this);
   DCHECK(descriptor->GetCharacteristic() == characteristic);
+  DCHECK(adapter_);
+
   if (added) {
-    FOR_EACH_OBSERVER(device::BluetoothGattService::Observer, observers_,
-                      GattDescriptorAdded(characteristic, descriptor));
+    adapter_->NotifyGattDescriptorAdded(descriptor);
     return;
   }
-  FOR_EACH_OBSERVER(device::BluetoothGattService::Observer, observers_,
-                    GattDescriptorRemoved(characteristic, descriptor));
+
+  adapter_->NotifyGattDescriptorRemoved(descriptor);
 }
 
 void BluetoothRemoteGattServiceChromeOS::NotifyDescriptorValueChanged(
     BluetoothRemoteGattCharacteristicChromeOS* characteristic,
     BluetoothRemoteGattDescriptorChromeOS* descriptor,
     const std::vector<uint8>& value) {
   DCHECK(characteristic->GetService() == this);
   DCHECK(descriptor->GetCharacteristic() == characteristic);
-  FOR_EACH_OBSERVER(
-      device::BluetoothGattService::Observer, observers_,
-      GattDescriptorValueChanged(characteristic, descriptor, value));
+  DCHECK(adapter_);
+  adapter_->NotifyGattDescriptorValueChanged(descriptor, value);
 }
 
 void BluetoothRemoteGattServiceChromeOS::GattServicePropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name){
   if (object_path != object_path_)
     return;
 
   VLOG(1) << "Service property changed: \"" << property_name << "\", "
           << object_path.value();
   BluetoothGattServiceClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothGattServiceClient()->GetProperties(
           object_path);
   DCHECK(properties);
 
   if (property_name != properties->characteristics.name()) {
     NotifyServiceChanged();
     return;
   }
 
   if (discovery_complete_)
     return;
 
   VLOG(1) << "All characteristics were discovered for service: "
           << object_path.value();
   discovery_complete_ = true;
-  FOR_EACH_OBSERVER(device::BluetoothGattService::Observer,
-                    observers_,
-                    GattDiscoveryCompleteForService(this));
+  DCHECK(adapter_);
+  adapter_->NotifyGattDiscoveryComplete(this);
 }
 
 void BluetoothRemoteGattServiceChromeOS::GattCharacteristicAdded(
     const dbus::ObjectPath& object_path) {
   if (characteristics_.find(object_path) != characteristics_.end()) {
     VLOG(1) << "Remote GATT characteristic already exists: "
             << object_path.value();
     return;
   }
 
   BluetoothGattCharacteristicClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothGattCharacteristicClient()->
           GetProperties(object_path);
   DCHECK(properties);
   if (properties->service.value() != object_path_) {
     VLOG(2) << "Remote GATT characteristic does not belong to this service.";
     return;
   }
 
   VLOG(1) << "Adding new remote GATT characteristic for GATT service: "
           << GetIdentifier() << ", UUID: " << GetUUID().canonical_value();
 
   BluetoothRemoteGattCharacteristicChromeOS* characteristic =
       new BluetoothRemoteGattCharacteristicChromeOS(this, object_path);
   characteristics_[object_path] = characteristic;
   DCHECK(characteristic->GetIdentifier() == object_path.value());
   DCHECK(characteristic->GetUUID().IsValid());
 
-  FOR_EACH_OBSERVER(device::BluetoothGattService::Observer, observers_,
-                    GattCharacteristicAdded(this, characteristic));
+  DCHECK(adapter_);
+  adapter_->NotifyGattCharacteristicAdded(characteristic);
 }
 
 void BluetoothRemoteGattServiceChromeOS::GattCharacteristicRemoved(
     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();
 
   BluetoothRemoteGattCharacteristicChromeOS* characteristic = iter->second;
   DCHECK(characteristic->object_path() == object_path);
   characteristics_.erase(iter);
 
-  FOR_EACH_OBSERVER(device::BluetoothGattService::Observer, observers_,
-                    GattCharacteristicRemoved(this, characteristic));
+  DCHECK(adapter_);
+  adapter_->NotifyGattCharacteristicRemoved(characteristic);
 
   delete characteristic;
 }
 
 void BluetoothRemoteGattServiceChromeOS::GattCharacteristicPropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   if (characteristics_.find(object_path) == characteristics_.end()) {
     VLOG(3) << "Properties of unknown characteristic changed";
     return;
   }
 
   // We may receive a property changed event in certain cases, e.g. when the
   // characteristic "Flags" property has been updated with values from the
   // "Characteristic Extended Properties" descriptor. In this case, kick off
   // a service changed observer event to let observers refresh the
   // characteristics.
   BluetoothGattCharacteristicClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothGattCharacteristicClient()->
           GetProperties(object_path);
   DCHECK(properties);
   if (property_name != properties->flags.name())
     return;
 
   NotifyServiceChanged();
 }
 
 }  // namespace chromeos