device/bluetooth: Improvements to GATT descriptor access API.

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/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"
 #include "chromeos/dbus/fake_bluetooth_gatt_characteristic_client.h"
@@ skipping 114 matching lines @@
 
 class TestGattServiceObserver : public BluetoothGattService::Observer {
  public:
   TestGattServiceObserver(scoped_refptr<BluetoothAdapter> adapter,
                           BluetoothDevice* device,
                           BluetoothGattService* service)
       : gatt_service_changed_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)
@@ skipping 48 matching lines @@
 
   virtual void GattCharacteristicValueChanged(
       BluetoothGattService* service,
       BluetoothGattCharacteristic* characteristic,
       const std::vector<uint8>& value) OVERRIDE {
     ASSERT_EQ(gatt_service_id_, service->GetIdentifier());
 
     ++gatt_characteristic_value_changed_count_;
     last_gatt_characteristic_id_ = characteristic->GetIdentifier();
     last_gatt_characteristic_uuid_ = characteristic->GetUUID();
-    last_changed_characteristic_value_ = characteristic->GetValue();
+    last_changed_characteristic_value_ = value;
 
     EXPECT_EQ(service->GetCharacteristic(last_gatt_characteristic_id_),
               characteristic);
+    EXPECT_EQ(service, characteristic->GetService());
 
     QuitMessageLoop();
   }
+
+  virtual void GattDescriptorAdded(
+      BluetoothGattCharacteristic* characteristic,
+      BluetoothGattDescriptor* descriptor) OVERRIDE {
+    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());
+
+    ++gatt_descriptor_added_count_;
+    last_gatt_descriptor_id_ = descriptor->GetIdentifier();
+    last_gatt_descriptor_uuid_ = descriptor->GetUUID();
+
+    EXPECT_EQ(characteristic->GetDescriptor(last_gatt_descriptor_id_),
+              descriptor);
+    EXPECT_EQ(characteristic, descriptor->GetCharacteristic());
+
+    QuitMessageLoop();
+  }
+
+  virtual void GattDescriptorRemoved(
+      BluetoothGattCharacteristic* characteristic,
+      BluetoothGattDescriptor* descriptor) OVERRIDE {
+    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());
+
+    ++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());
+
+    QuitMessageLoop();
+  }
+
+  virtual void GattDescriptorValueChanged(
+      BluetoothGattCharacteristic* characteristic,
+      BluetoothGattDescriptor* descriptor,
+      const std::vector<uint8>& value) OVERRIDE {
+    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());
+
+    ++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_),
+              descriptor);
+    EXPECT_EQ(characteristic, descriptor->GetCharacteristic());
+
+    QuitMessageLoop();
+  }
 
   int gatt_service_changed_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_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();
   }
 
@@ skipping 266 matching lines @@
   // 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_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
   EXPECT_EQ(4, service_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_);
+
   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_);
 
   // Hide the descriptor.
   fake_bluetooth_gatt_descriptor_client_->HideDescriptor(
       dbus::ObjectPath(descriptor->GetIdentifier()));
   EXPECT_TRUE(characteristic->GetDescriptors().empty());
   EXPECT_EQ(5, 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_);
 
   // Expose the descriptor again.
+  service_observer.last_gatt_descriptor_id_.clear();
+  service_observer.last_gatt_descriptor_uuid_ = BluetoothUUID();
   fake_bluetooth_gatt_descriptor_client_->ExposeDescriptor(
       dbus::ObjectPath(characteristic->GetIdentifier()),
       FakeBluetoothGattDescriptorClient::
           kClientCharacteristicConfigurationUUID);
   EXPECT_EQ(6, service_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_);
 
   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_);
 }
 
 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;
   EXPECT_FALSE(device::BluetoothAdapterFactory::HasSharedInstanceForTesting());
 
   // Create the fake D-Bus objects.
   fake_bluetooth_device_client_->CreateDevice(
@@ skipping 229 matching lines @@
   // 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_value_changed_count_);
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
   EXPECT_EQ(4, service_observer.gatt_service_changed_count_);
 
   // Only the Heart Rate Measurement characteristic has a descriptor.
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->
           GetHeartRateMeasurementPath().value());
@@ skipping 16 matching lines @@
 
   // Read value.
   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_EQ(4, service_observer.gatt_service_changed_count_);
+  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);
 
   // Write value.
   desc_value[0] = 0x03;
   descriptor->WriteRemoteDescriptor(
       desc_value,
       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_TRUE(ValuesEqual(desc_value, descriptor->GetValue()));
+  EXPECT_EQ(4, service_observer.gatt_service_changed_count_);
+  EXPECT_EQ(1, service_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(3, 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(4, service_observer.gatt_service_changed_count_);
+  EXPECT_EQ(1, service_observer.gatt_descriptor_value_changed_count_);
 }
 
 }  // namespace chromeos