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

device/bluetooth/bluetooth_gatt_chromeos_unittest.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 "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/fake_bluetooth_device_client.h"
@@ skipping 39 matching lines @@
 bool ValuesEqual(const std::vector<uint8>& value0,
                  const std::vector<uint8>& value1) {
   if (value0.size() != value1.size())
     return false;
   for (size_t i = 0; i < value0.size(); ++i)
     if (value0[i] != value1[i])
       return false;
   return true;
 }
 
-class TestDeviceObserver : public BluetoothDevice::Observer {
+class TestObserver : public BluetoothAdapter::Observer {
  public:
-  TestDeviceObserver(scoped_refptr<BluetoothAdapter> adapter,
-                     BluetoothDevice* device)
+  TestObserver(scoped_refptr<BluetoothAdapter> adapter)
       : gatt_service_added_count_(0),
         gatt_service_removed_count_(0),
-        device_address_(device->GetAddress()),
+        gatt_service_changed_count_(0),
+        gatt_discovery_complete_count_(0),
+        gatt_characteristic_added_count_(0),
+        gatt_characteristic_removed_count_(0),
+        gatt_characteristic_value_changed_count_(0),
+        gatt_descriptor_added_count_(0),
+        gatt_descriptor_removed_count_(0),
+        gatt_descriptor_value_changed_count_(0),
         adapter_(adapter) {
-    device->AddObserver(this);
+    adapter_->AddObserver(this);
   }
 
-  virtual ~TestDeviceObserver() {
-    BluetoothDevice* device = adapter_->GetDevice(device_address_);
-    if (device)
-      device->RemoveObserver(this);
+  virtual ~TestObserver() {
+    adapter_->RemoveObserver(this);
   }
 
-  // BluetoothDevice::Observer overrides.
-  virtual void GattServiceAdded(
-      BluetoothDevice* device,
-      BluetoothGattService* service) OVERRIDE {
-    ASSERT_EQ(device_address_, device->GetAddress());
+  // BluetoothAdapter::Observer overrides.
+  virtual void GattServiceAdded(BluetoothAdapter* adapter,
+                                BluetoothDevice* device,
+                                BluetoothGattService* service) OVERRIDE {
+    ASSERT_EQ(adapter_.get(), adapter);
+    ASSERT_EQ(service->GetDevice(), device);
 
     ++gatt_service_added_count_;
     last_gatt_service_id_ = service->GetIdentifier();
     last_gatt_service_uuid_ = service->GetUUID();
 
     EXPECT_FALSE(service->IsLocal());
     EXPECT_TRUE(service->IsPrimary());
 
     EXPECT_EQ(device->GetGattService(last_gatt_service_id_), service);
 
     QuitMessageLoop();
   }
 
-  virtual void GattServiceRemoved(
-      BluetoothDevice* device,
-      BluetoothGattService* service) OVERRIDE {
-    ASSERT_EQ(device_address_, device->GetAddress());
+  virtual void GattServiceRemoved(BluetoothAdapter* adapter,
+                                  BluetoothDevice* device,
+                                  BluetoothGattService* service) OVERRIDE {
+    ASSERT_EQ(adapter_.get(), adapter);
+    ASSERT_EQ(service->GetDevice(), device);
 
     ++gatt_service_removed_count_;
     last_gatt_service_id_ = service->GetIdentifier();
     last_gatt_service_uuid_ = service->GetUUID();
 
     EXPECT_FALSE(service->IsLocal());
     EXPECT_TRUE(service->IsPrimary());
 
     // The device should return NULL for this service.
     EXPECT_FALSE(device->GetGattService(last_gatt_service_id_));
 
     QuitMessageLoop();
   }
 
-  int gatt_service_added_count_;
-  int gatt_service_removed_count_;
-  std::string last_gatt_service_id_;
-  BluetoothUUID last_gatt_service_uuid_;
-
- private:
-  // Some tests use a message loop since background processing is simulated;
-  // break out of those loops.
-  void QuitMessageLoop() {
-    if (base::MessageLoop::current() &&
-        base::MessageLoop::current()->is_running())
-      base::MessageLoop::current()->Quit();
-  }
-
-  std::string device_address_;
-  scoped_refptr<BluetoothAdapter> adapter_;
-};
-
-class TestGattServiceObserver : public BluetoothGattService::Observer {
- public:
-  TestGattServiceObserver(scoped_refptr<BluetoothAdapter> adapter,
-                          BluetoothDevice* device,
-                          BluetoothGattService* service)
-      : gatt_service_changed_count_(0),
-        gatt_discovery_complete_count_(0),
-        gatt_characteristic_added_count_(0),
-        gatt_characteristic_removed_count_(0),
-        gatt_characteristic_value_changed_count_(0),
-        gatt_descriptor_added_count_(0),
-        gatt_descriptor_removed_count_(0),
-        gatt_descriptor_value_changed_count_(0),
-        device_address_(device->GetAddress()),
-        gatt_service_id_(service->GetIdentifier()),
-        adapter_(adapter) {
-    service->AddObserver(this);
-  }
-
-  virtual ~TestGattServiceObserver() {
-    // See if either the device or the service even exist.
-    BluetoothDevice* device = adapter_->GetDevice(device_address_);
-    if (!device)
-      return;
-
-    BluetoothGattService* service = device->GetGattService(gatt_service_id_);
-    if (!service)
-      return;
-
-    service->RemoveObserver(this);
-  }
-
-  // BluetoothGattService::Observer overrides.
   virtual void GattDiscoveryCompleteForService(
+      BluetoothAdapter* adapter,
       BluetoothGattService* service) OVERRIDE {
-    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());
+    ASSERT_EQ(adapter_.get(), adapter);
     ++gatt_discovery_complete_count_;
 
     QuitMessageLoop();
   }
 
-  virtual void GattServiceChanged(BluetoothGattService* service) OVERRIDE {
-    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());
+  virtual void GattServiceChanged(BluetoothAdapter* adapter,
+                                  BluetoothGattService* service) OVERRIDE {
+    ASSERT_EQ(adapter_.get(), adapter);
     ++gatt_service_changed_count_;
 
     QuitMessageLoop();
   }
 
   virtual void GattCharacteristicAdded(
-      BluetoothGattService* service,
+      BluetoothAdapter* adapter,
       BluetoothGattCharacteristic* characteristic) OVERRIDE {
-    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());
+    ASSERT_EQ(adapter_.get(), adapter);
 
     ++gatt_characteristic_added_count_;
     last_gatt_characteristic_id_ = characteristic->GetIdentifier();
     last_gatt_characteristic_uuid_ = characteristic->GetUUID();
 
-    EXPECT_EQ(service->GetCharacteristic(last_gatt_characteristic_id_),
+    ASSERT_TRUE(characteristic->GetService());
+    EXPECT_EQ(characteristic->GetService()->GetCharacteristic(
+                  last_gatt_characteristic_id_),
               characteristic);
-    EXPECT_EQ(service, characteristic->GetService());
 
     QuitMessageLoop();
   }
 
   virtual void GattCharacteristicRemoved(
-      BluetoothGattService* service,
+      BluetoothAdapter* adapter,
       BluetoothGattCharacteristic* characteristic) OVERRIDE {
-    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());
+    ASSERT_EQ(adapter_.get(), adapter);
 
     ++gatt_characteristic_removed_count_;
     last_gatt_characteristic_id_ = characteristic->GetIdentifier();
     last_gatt_characteristic_uuid_ = characteristic->GetUUID();
 
     // The service should return NULL for this characteristic.
-    EXPECT_FALSE(service->GetCharacteristic(last_gatt_characteristic_id_));
-    EXPECT_EQ(service, characteristic->GetService());
+    ASSERT_TRUE(characteristic->GetService());
+    EXPECT_FALSE(characteristic->GetService()->GetCharacteristic(
+        last_gatt_characteristic_id_));
 
     QuitMessageLoop();
   }
 
   virtual void GattCharacteristicValueChanged(
-      BluetoothGattService* service,
+      BluetoothAdapter* adapter,
       BluetoothGattCharacteristic* characteristic,
       const std::vector<uint8>& value) OVERRIDE {
-    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());
+    ASSERT_EQ(adapter_.get(), adapter);
 
     ++gatt_characteristic_value_changed_count_;
     last_gatt_characteristic_id_ = characteristic->GetIdentifier();
     last_gatt_characteristic_uuid_ = characteristic->GetUUID();
     last_changed_characteristic_value_ = value;
 
-    EXPECT_EQ(service->GetCharacteristic(last_gatt_characteristic_id_),
+    ASSERT_TRUE(characteristic->GetService());
+    EXPECT_EQ(characteristic->GetService()->GetCharacteristic(
+                  last_gatt_characteristic_id_),
               characteristic);
-    EXPECT_EQ(service, characteristic->GetService());
 
     QuitMessageLoop();
   }
 
   virtual void GattDescriptorAdded(
-      BluetoothGattCharacteristic* characteristic,
+      BluetoothAdapter* adapter,
       BluetoothGattDescriptor* descriptor) OVERRIDE {
-    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());
+    ASSERT_EQ(adapter_.get(), adapter);
 
     ++gatt_descriptor_added_count_;
     last_gatt_descriptor_id_ = descriptor->GetIdentifier();
     last_gatt_descriptor_uuid_ = descriptor->GetUUID();
 
-    EXPECT_EQ(characteristic->GetDescriptor(last_gatt_descriptor_id_),
+    ASSERT_TRUE(descriptor->GetCharacteristic());
+    EXPECT_EQ(descriptor->GetCharacteristic()->GetDescriptor(
+                  last_gatt_descriptor_id_),
               descriptor);
-    EXPECT_EQ(characteristic, descriptor->GetCharacteristic());
 
     QuitMessageLoop();
   }
 
   virtual void GattDescriptorRemoved(
-      BluetoothGattCharacteristic* characteristic,
+      BluetoothAdapter* adapter,
       BluetoothGattDescriptor* descriptor) OVERRIDE {
-    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());
+    ASSERT_EQ(adapter_.get(), adapter);
 
     ++gatt_descriptor_removed_count_;
     last_gatt_descriptor_id_ = descriptor->GetIdentifier();
     last_gatt_descriptor_uuid_ = descriptor->GetUUID();
 
     // The characteristic should return NULL for this descriptor..
-    EXPECT_FALSE(characteristic->GetDescriptor(last_gatt_descriptor_id_));
-    EXPECT_EQ(characteristic, descriptor->GetCharacteristic());
+    ASSERT_TRUE(descriptor->GetCharacteristic());
+    EXPECT_FALSE(descriptor->GetCharacteristic()->GetDescriptor(
+        last_gatt_descriptor_id_));
 
     QuitMessageLoop();
   }
 
   virtual void GattDescriptorValueChanged(
-      BluetoothGattCharacteristic* characteristic,
+      BluetoothAdapter* adapter,
       BluetoothGattDescriptor* descriptor,
       const std::vector<uint8>& value) OVERRIDE {
-    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());
+    ASSERT_EQ(adapter_.get(), adapter);
 
     ++gatt_descriptor_value_changed_count_;
     last_gatt_descriptor_id_ = descriptor->GetIdentifier();
     last_gatt_descriptor_uuid_ = descriptor->GetUUID();
     last_changed_descriptor_value_ = value;
 
-    EXPECT_EQ(characteristic->GetDescriptor(last_gatt_descriptor_id_),
+    ASSERT_TRUE(descriptor->GetCharacteristic());
+    EXPECT_EQ(descriptor->GetCharacteristic()->GetDescriptor(
+                  last_gatt_descriptor_id_),
               descriptor);
-    EXPECT_EQ(characteristic, descriptor->GetCharacteristic());
 
     QuitMessageLoop();
   }
 
+  int gatt_service_added_count_;
+  int gatt_service_removed_count_;
   int gatt_service_changed_count_;
   int gatt_discovery_complete_count_;
   int gatt_characteristic_added_count_;
   int gatt_characteristic_removed_count_;
   int gatt_characteristic_value_changed_count_;
   int gatt_descriptor_added_count_;
   int gatt_descriptor_removed_count_;
   int gatt_descriptor_value_changed_count_;
+  std::string last_gatt_service_id_;
+  BluetoothUUID last_gatt_service_uuid_;
   std::string last_gatt_characteristic_id_;
   BluetoothUUID last_gatt_characteristic_uuid_;
   std::vector<uint8> last_changed_characteristic_value_;
   std::string last_gatt_descriptor_id_;
   BluetoothUUID last_gatt_descriptor_uuid_;
   std::vector<uint8> last_changed_descriptor_value_;
 
  private:
   // Some tests use a message loop since background processing is simulated;
   // break out of those loops.
   void QuitMessageLoop() {
     if (base::MessageLoop::current() &&
         base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
   }
 
-  std::string device_address_;
-  std::string gatt_service_id_;
   scoped_refptr<BluetoothAdapter> adapter_;
 };
 
 }  // namespace
 
 class BluetoothGattChromeOSTest : public testing::Test {
  public:
   BluetoothGattChromeOSTest()
       : fake_bluetooth_gatt_service_client_(NULL),
         success_callback_count_(0),
@@ skipping 193 matching lines @@
 TEST_F(BluetoothGattChromeOSTest, GattServiceAddedAndRemoved) {
   // Create a fake LE device. We store the device pointer here because this is a
   // test. It's unsafe to do this in production as the device might get deleted.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
-  TestDeviceObserver observer(adapter_, device);
+  TestObserver observer(adapter_);
+
   EXPECT_EQ(0, observer.gatt_service_added_count_);
   EXPECT_EQ(0, observer.gatt_service_removed_count_);
   EXPECT_TRUE(observer.last_gatt_service_id_.empty());
   EXPECT_FALSE(observer.last_gatt_service_uuid_.IsValid());
   EXPECT_TRUE(device->GetGattServices().empty());
 
   // Expose the fake Heart Rate Service.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   EXPECT_EQ(1, observer.gatt_service_added_count_);
@@ skipping 69 matching lines @@
 }
 
 TEST_F(BluetoothGattChromeOSTest, GattCharacteristicAddedAndRemoved) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
-  TestDeviceObserver observer(adapter_, device);
+  TestObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_EQ(1, observer.gatt_service_added_count_);
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id_);
 
-  TestGattServiceObserver service_observer(adapter_, device, service);
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(0, service_observer.gatt_discovery_complete_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_added_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(0, observer.gatt_discovery_complete_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_added_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_removed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
 
   // 3 characteristics should appear. Only 1 of the characteristics sends
   // value changed signals. Service changed should be fired once for
   // descriptor added.
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(1, service_observer.gatt_discovery_complete_count_);
-  EXPECT_EQ(3, service_observer.gatt_characteristic_added_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(1, observer.gatt_discovery_complete_count_);
+  EXPECT_EQ(3, observer.gatt_characteristic_added_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_removed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
   EXPECT_EQ(3U, service->GetCharacteristics().size());
 
   // Hide the characteristics. 3 removed signals should be received.
   fake_bluetooth_gatt_characteristic_client_->HideHeartRateCharacteristics();
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(3, service_observer.gatt_characteristic_added_count_);
-  EXPECT_EQ(3, service_observer.gatt_characteristic_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(3, observer.gatt_characteristic_added_count_);
+  EXPECT_EQ(3, observer.gatt_characteristic_removed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Re-expose the heart rate characteristics. We shouldn't get another
   // GattDiscoveryCompleteForService call, since the service thinks that
   // discovery is done. On the bluetoothd side, characteristics will be removed
   // only if the service will also be subsequently removed.
   fake_bluetooth_gatt_characteristic_client_->ExposeHeartRateCharacteristics(
       fake_bluetooth_gatt_service_client_->GetHeartRateServicePath());
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(1, service_observer.gatt_discovery_complete_count_);
-  EXPECT_EQ(6, service_observer.gatt_characteristic_added_count_);
-  EXPECT_EQ(3, service_observer.gatt_characteristic_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(1, observer.gatt_discovery_complete_count_);
+  EXPECT_EQ(6, observer.gatt_characteristic_added_count_);
+  EXPECT_EQ(3, observer.gatt_characteristic_removed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
   EXPECT_EQ(3U, service->GetCharacteristics().size());
 
   // Hide the service. All characteristics should disappear.
   fake_bluetooth_gatt_service_client_->HideHeartRateService();
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(6, service_observer.gatt_characteristic_added_count_);
-  EXPECT_EQ(6, service_observer.gatt_characteristic_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(6, observer.gatt_characteristic_added_count_);
+  EXPECT_EQ(6, observer.gatt_characteristic_removed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
 }
 
 TEST_F(BluetoothGattChromeOSTest, GattDescriptorAddedAndRemoved) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
-  TestDeviceObserver observer(adapter_, device);
+  TestObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_EQ(1, observer.gatt_service_added_count_);
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id_);
 
-  TestGattServiceObserver service_observer(adapter_, device, service);
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(0, service_observer.gatt_descriptor_added_count_);
-  EXPECT_EQ(0, service_observer.gatt_descriptor_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(0, observer.gatt_descriptor_added_count_);
+  EXPECT_EQ(0, observer.gatt_descriptor_removed_count_);
+  EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
 
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
 
   // Only the Heart Rate Measurement characteristic has a descriptor.
-  EXPECT_EQ(1, service_observer.gatt_descriptor_added_count_);
-  EXPECT_EQ(0, service_observer.gatt_descriptor_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_descriptor_added_count_);
+  EXPECT_EQ(0, observer.gatt_descriptor_removed_count_);
+  EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
 
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetBodySensorLocationPath().value());
   ASSERT_TRUE(characteristic);
   EXPECT_TRUE(characteristic->GetDescriptors().empty());
 
   characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetHeartRateControlPointPath().value());
   ASSERT_TRUE(characteristic);
   EXPECT_TRUE(characteristic->GetDescriptors().empty());
 
   characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetHeartRateMeasurementPath().value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
 
   BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
   EXPECT_FALSE(descriptor->IsLocal());
   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
             descriptor->GetUUID());
-  EXPECT_EQ(descriptor->GetUUID(),
-            service_observer.last_gatt_descriptor_uuid_);
-  EXPECT_EQ(descriptor->GetIdentifier(),
-            service_observer.last_gatt_descriptor_id_);
+  EXPECT_EQ(descriptor->GetUUID(), observer.last_gatt_descriptor_uuid_);
+  EXPECT_EQ(descriptor->GetIdentifier(), observer.last_gatt_descriptor_id_);
 
   // Hide the descriptor.
   fake_bluetooth_gatt_descriptor_client_->HideDescriptor(
       dbus::ObjectPath(descriptor->GetIdentifier()));
   EXPECT_TRUE(characteristic->GetDescriptors().empty());
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(1, service_observer.gatt_descriptor_added_count_);
-  EXPECT_EQ(1, service_observer.gatt_descriptor_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(1, observer.gatt_descriptor_added_count_);
+  EXPECT_EQ(1, observer.gatt_descriptor_removed_count_);
+  EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
 
   // Expose the descriptor again.
-  service_observer.last_gatt_descriptor_id_.clear();
-  service_observer.last_gatt_descriptor_uuid_ = BluetoothUUID();
+  observer.last_gatt_descriptor_id_.clear();
+  observer.last_gatt_descriptor_uuid_ = BluetoothUUID();
   fake_bluetooth_gatt_descriptor_client_->ExposeDescriptor(
       dbus::ObjectPath(characteristic->GetIdentifier()),
       FakeBluetoothGattDescriptorClient::
           kClientCharacteristicConfigurationUUID);
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
-  EXPECT_EQ(2, service_observer.gatt_descriptor_added_count_);
-  EXPECT_EQ(1, service_observer.gatt_descriptor_removed_count_);
-  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);
+  EXPECT_EQ(2, observer.gatt_descriptor_added_count_);
+  EXPECT_EQ(1, observer.gatt_descriptor_removed_count_);
+  EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
 
   descriptor = characteristic->GetDescriptors()[0];
   EXPECT_FALSE(descriptor->IsLocal());
   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
             descriptor->GetUUID());
-  EXPECT_EQ(descriptor->GetUUID(), service_observer.last_gatt_descriptor_uuid_);
-  EXPECT_EQ(descriptor->GetIdentifier(),
-            service_observer.last_gatt_descriptor_id_);
+  EXPECT_EQ(descriptor->GetUUID(), observer.last_gatt_descriptor_uuid_);
+  EXPECT_EQ(descriptor->GetIdentifier(), observer.last_gatt_descriptor_id_);
 }
 
 TEST_F(BluetoothGattChromeOSTest, AdapterAddedAfterGattService) {
   // This unit test tests that all remote GATT objects are created for D-Bus
   // objects that were already exposed.
   adapter_ = NULL;
   ASSERT_FALSE(device::BluetoothAdapterFactory::HasSharedInstanceForTesting());
 
   // Create the fake D-Bus objects.
   fake_bluetooth_device_client_->CreateDevice(
@@ skipping 66 matching lines @@
 }
 
 TEST_F(BluetoothGattChromeOSTest, GattCharacteristicValue) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
-  TestDeviceObserver observer(adapter_, device);
+  TestObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_EQ(1, observer.gatt_service_added_count_);
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id_);
 
-  TestGattServiceObserver service_observer(adapter_, device, service);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
 
   // Issue write request to non-writeable characteristics.
-  service_observer.last_gatt_characteristic_id_.clear();
-  service_observer.last_gatt_characteristic_uuid_ = BluetoothUUID();
+  observer.last_gatt_characteristic_id_.clear();
+  observer.last_gatt_characteristic_uuid_ = BluetoothUUID();
 
   std::vector<uint8> write_value;
   write_value.push_back(0x01);
   BluetoothGattCharacteristic* characteristic =
       service->GetCharacteristic(fake_bluetooth_gatt_characteristic_client_->
           GetHeartRateMeasurementPath().value());
   ASSERT_TRUE(characteristic);
   EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
                 GetHeartRateMeasurementPath().value(),
             characteristic->GetIdentifier());
   EXPECT_EQ(kHeartRateMeasurementUUID, characteristic->GetUUID());
   characteristic->WriteRemoteCharacteristic(
       write_value,
       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
-  EXPECT_TRUE(service_observer.last_gatt_characteristic_id_.empty());
-  EXPECT_FALSE(service_observer.last_gatt_characteristic_uuid_.IsValid());
+  EXPECT_TRUE(observer.last_gatt_characteristic_id_.empty());
+  EXPECT_FALSE(observer.last_gatt_characteristic_uuid_.IsValid());
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
 
   characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetBodySensorLocationPath().value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
                 GetBodySensorLocationPath().value(),
             characteristic->GetIdentifier());
   EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
   characteristic->WriteRemoteCharacteristic(
       write_value,
       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
-  EXPECT_TRUE(service_observer.last_gatt_characteristic_id_.empty());
-  EXPECT_FALSE(service_observer.last_gatt_characteristic_uuid_.IsValid());
+  EXPECT_TRUE(observer.last_gatt_characteristic_id_.empty());
+  EXPECT_FALSE(observer.last_gatt_characteristic_uuid_.IsValid());
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(2, error_callback_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
 
   // Issue write request to writeable characteristic. The "Body Sensor Location"
   // characteristic does not send notifications and WriteValue does not result
   // in a CharacteristicValueChanged event, thus no such event should be
   // received.
   characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetHeartRateControlPointPath().value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
                 GetHeartRateControlPointPath().value(),
             characteristic->GetIdentifier());
   EXPECT_EQ(kHeartRateControlPointUUID, characteristic->GetUUID());
   characteristic->WriteRemoteCharacteristic(
       write_value,
       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
-  EXPECT_TRUE(service_observer.last_gatt_characteristic_id_.empty());
-  EXPECT_FALSE(service_observer.last_gatt_characteristic_uuid_.IsValid());
+  EXPECT_TRUE(observer.last_gatt_characteristic_id_.empty());
+  EXPECT_FALSE(observer.last_gatt_characteristic_uuid_.IsValid());
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(2, error_callback_count_);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
 
   // Issue a read request. A successful read results in a
   // CharacteristicValueChanged notification.
   characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetBodySensorLocationPath().value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
                 GetBodySensorLocationPath().value(),
             characteristic->GetIdentifier());
   EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
   characteristic->ReadRemoteCharacteristic(
       base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(2, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(ValuesEqual(characteristic->GetValue(), last_read_value_));
 }
 
 TEST_F(BluetoothGattChromeOSTest, GattCharacteristicProperties) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
-  TestDeviceObserver observer(adapter_, device);
+  TestObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id_);
 
-  TestGattServiceObserver service_observer(adapter_, device, service);
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
 
   BluetoothGattCharacteristic *characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetBodySensorLocationPath().value());
   EXPECT_EQ(BluetoothGattCharacteristic::kPropertyRead,
             characteristic->GetProperties());
@@ skipping 12 matching lines @@
 }
 
 TEST_F(BluetoothGattChromeOSTest, GattDescriptorValue) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
-  TestDeviceObserver observer(adapter_, device);
+  TestObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_EQ(1, observer.gatt_service_added_count_);
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id_);
 
-  TestGattServiceObserver service_observer(adapter_, device, service);
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(0, service_observer.gatt_discovery_complete_count_);
-  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(0, observer.gatt_discovery_complete_count_);
+  EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(1, service_observer.gatt_discovery_complete_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(1, observer.gatt_discovery_complete_count_);
 
   // Only the Heart Rate Measurement characteristic has a descriptor.
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetHeartRateMeasurementPath().value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
 
   BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
   EXPECT_FALSE(descriptor->IsLocal());
@@ skipping 16 matching lines @@
   // successful read.
   descriptor->ReadRemoteDescriptor(
       base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_TRUE(ValuesEqual(desc_value, descriptor->GetValue()));
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(1, service_observer.gatt_descriptor_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(1, observer.gatt_descriptor_value_changed_count_);
 
   // Write value. Writes to this descriptor will fail.
   desc_value[0] = 0x03;
   descriptor->WriteRemoteDescriptor(
       desc_value,
       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(1, service_observer.gatt_descriptor_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(1, observer.gatt_descriptor_value_changed_count_);
 
   // Read new value.
   descriptor->ReadRemoteDescriptor(
       base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
-  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
-  EXPECT_EQ(2, service_observer.gatt_descriptor_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_service_changed_count_);
+  EXPECT_EQ(2, observer.gatt_descriptor_value_changed_count_);
 }
 
 TEST_F(BluetoothGattChromeOSTest, NotifySessions) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
-  TestDeviceObserver observer(adapter_, device);
+  TestObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_EQ(1, observer.gatt_service_added_count_);
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id_);
 
-  TestGattServiceObserver service_observer(adapter_, device, service);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
 
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
           .value());
   ASSERT_TRUE(characteristic);
   EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   // Request to start notifications.
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
 
   // The operation still hasn't completed but we should have received the first
   // notification.
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(update_sessions_.empty());
 
   // Send a two more requests, which should get queued.
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(update_sessions_.empty());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Run the main loop. The initial call should complete. The queued call should
   // succeed immediately.
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_EQ(3U, update_sessions_.size());
 
   // Notifications should be getting sent regularly now.
   base::MessageLoop::current()->Run();
-  EXPECT_GT(service_observer.gatt_characteristic_value_changed_count_, 1);
+  EXPECT_GT(observer.gatt_characteristic_value_changed_count_, 1);
 
   // Stop one of the sessions. The session should become inactive but the
   // characteristic should still be notifying.
   BluetoothGattNotifySession* session = update_sessions_[0];
   EXPECT_TRUE(session->IsActive());
   session->Stop(base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                            base::Unretained(this)));
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(session->IsActive());
   EXPECT_EQ(characteristic->GetIdentifier(),
             session->GetCharacteristicIdentifier());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Delete another session. Characteristic should still be notifying.
   update_sessions_.pop_back();
   EXPECT_EQ(2U, update_sessions_.size());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_FALSE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(update_sessions_[1]->IsActive());
 
   // Clear the last session.
   update_sessions_.clear();
   EXPECT_TRUE(update_sessions_.empty());
   EXPECT_FALSE(characteristic->IsNotifying());
 
   success_callback_count_ = 0;
-  service_observer.gatt_characteristic_value_changed_count_ = 0;
+  observer.gatt_characteristic_value_changed_count_ = 0;
 
   // Enable notifications again.
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(update_sessions_.empty());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Run the message loop. Notifications should begin.
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Check that notifications are happening.
   base::MessageLoop::current()->Run();
-  EXPECT_GT(service_observer.gatt_characteristic_value_changed_count_, 1);
+  EXPECT_GT(observer.gatt_characteristic_value_changed_count_, 1);
 
   // Request another session. This should return immediately.
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(2U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(update_sessions_[1]->IsActive());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Hide the characteristic. The sessions should become inactive.
   fake_bluetooth_gatt_characteristic_client_->HideHeartRateCharacteristics();
   EXPECT_EQ(2U, update_sessions_.size());
   EXPECT_FALSE(update_sessions_[0]->IsActive());
   EXPECT_FALSE(update_sessions_[1]->IsActive());
 }
 
 TEST_F(BluetoothGattChromeOSTest, NotifySessionsMadeInactive) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
-  TestDeviceObserver observer(adapter_, device);
+  TestObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_EQ(1, observer.gatt_service_added_count_);
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id_);
 
-  TestGattServiceObserver service_observer(adapter_, device, service);
-  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
 
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
           .value());
   ASSERT_TRUE(characteristic);
   EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
@@ skipping 17 matching lines @@
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
 
   // The operation still hasn't completed but we should have received the first
   // notification.
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   // Run the main loop. The initial call should complete. The queued calls
   // should succeed immediately.
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(4U, update_sessions_.size());
 
   for (int i = 0; i < 4; i++)
     EXPECT_TRUE(update_sessions_[0]->IsActive());
 
   // Stop notifications directly through the client. The sessions should get
   // marked as inactive.
   fake_bluetooth_gatt_characteristic_client_->StopNotify(
       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath(),
       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(5, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_EQ(4U, update_sessions_.size());
 
   for (int i = 0; i < 4; i++)
     EXPECT_FALSE(update_sessions_[0]->IsActive());
 
   // It should be possible to restart notifications and the call should reset
   // the session count and make a request through the client.
   update_sessions_.clear();
   success_callback_count_ = 0;
-  service_observer.gatt_characteristic_value_changed_count_ = 0;
+  observer.gatt_characteristic_value_changed_count_ = 0;
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
-  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
+  EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
 }
 
 }  // namespace chromeos