Home | History | Annotate | Download | only in bluetooth 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/memory/scoped_vector.h"
      6 #include "base/message_loop/message_loop.h"
      7 #include "base/run_loop.h"
      8 #include "chromeos/dbus/dbus_thread_manager.h"
      9 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
     10 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
     11 #include "chromeos/dbus/fake_bluetooth_device_client.h"
     12 #include "chromeos/dbus/fake_bluetooth_gatt_characteristic_client.h"
     13 #include "chromeos/dbus/fake_bluetooth_gatt_descriptor_client.h"
     14 #include "chromeos/dbus/fake_bluetooth_gatt_service_client.h"
     15 #include "chromeos/dbus/fake_bluetooth_input_client.h"
     16 #include "dbus/object_path.h"
     17 #include "device/bluetooth/bluetooth_adapter.h"
     18 #include "device/bluetooth/bluetooth_adapter_factory.h"
     19 #include "device/bluetooth/bluetooth_device.h"
     20 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
     21 #include "device/bluetooth/bluetooth_gatt_connection.h"
     22 #include "device/bluetooth/bluetooth_gatt_descriptor.h"
     23 #include "device/bluetooth/bluetooth_gatt_notify_session.h"
     24 #include "device/bluetooth/bluetooth_gatt_service.h"
     25 #include "device/bluetooth/bluetooth_uuid.h"
     26 #include "testing/gtest/include/gtest/gtest.h"
     27 
     28 using device::BluetoothAdapter;
     29 using device::BluetoothDevice;
     30 using device::BluetoothGattCharacteristic;
     31 using device::BluetoothGattConnection;
     32 using device::BluetoothGattDescriptor;
     33 using device::BluetoothGattService;
     34 using device::BluetoothGattNotifySession;
     35 using device::BluetoothUUID;
     36 
     37 namespace chromeos {
     38 
     39 namespace {
     40 
     41 const BluetoothUUID kHeartRateMeasurementUUID(
     42     FakeBluetoothGattCharacteristicClient::kHeartRateMeasurementUUID);
     43 const BluetoothUUID kBodySensorLocationUUID(
     44     FakeBluetoothGattCharacteristicClient::kBodySensorLocationUUID);
     45 const BluetoothUUID kHeartRateControlPointUUID(
     46     FakeBluetoothGattCharacteristicClient::kHeartRateControlPointUUID);
     47 
     48 // Compares GATT characteristic/descriptor values. Returns true, if the values
     49 // are equal.
     50 bool ValuesEqual(const std::vector<uint8>& value0,
     51                  const std::vector<uint8>& value1) {
     52   if (value0.size() != value1.size())
     53     return false;
     54   for (size_t i = 0; i < value0.size(); ++i)
     55     if (value0[i] != value1[i])
     56       return false;
     57   return true;
     58 }
     59 
     60 class TestObserver : public BluetoothAdapter::Observer {
     61  public:
     62   TestObserver(scoped_refptr<BluetoothAdapter> adapter)
     63       : gatt_service_added_count_(0),
     64         gatt_service_removed_count_(0),
     65         gatt_service_changed_count_(0),
     66         gatt_discovery_complete_count_(0),
     67         gatt_characteristic_added_count_(0),
     68         gatt_characteristic_removed_count_(0),
     69         gatt_characteristic_value_changed_count_(0),
     70         gatt_descriptor_added_count_(0),
     71         gatt_descriptor_removed_count_(0),
     72         gatt_descriptor_value_changed_count_(0),
     73         adapter_(adapter) {
     74     adapter_->AddObserver(this);
     75   }
     76 
     77   virtual ~TestObserver() {
     78     adapter_->RemoveObserver(this);
     79   }
     80 
     81   // BluetoothAdapter::Observer overrides.
     82   virtual void GattServiceAdded(BluetoothAdapter* adapter,
     83                                 BluetoothDevice* device,
     84                                 BluetoothGattService* service) OVERRIDE {
     85     ASSERT_EQ(adapter_.get(), adapter);
     86     ASSERT_EQ(service->GetDevice(), device);
     87 
     88     ++gatt_service_added_count_;
     89     last_gatt_service_id_ = service->GetIdentifier();
     90     last_gatt_service_uuid_ = service->GetUUID();
     91 
     92     EXPECT_FALSE(service->IsLocal());
     93     EXPECT_TRUE(service->IsPrimary());
     94 
     95     EXPECT_EQ(device->GetGattService(last_gatt_service_id_), service);
     96 
     97     QuitMessageLoop();
     98   }
     99 
    100   virtual void GattServiceRemoved(BluetoothAdapter* adapter,
    101                                   BluetoothDevice* device,
    102                                   BluetoothGattService* service) OVERRIDE {
    103     ASSERT_EQ(adapter_.get(), adapter);
    104     ASSERT_EQ(service->GetDevice(), device);
    105 
    106     ++gatt_service_removed_count_;
    107     last_gatt_service_id_ = service->GetIdentifier();
    108     last_gatt_service_uuid_ = service->GetUUID();
    109 
    110     EXPECT_FALSE(service->IsLocal());
    111     EXPECT_TRUE(service->IsPrimary());
    112 
    113     // The device should return NULL for this service.
    114     EXPECT_FALSE(device->GetGattService(last_gatt_service_id_));
    115 
    116     QuitMessageLoop();
    117   }
    118 
    119   virtual void GattDiscoveryCompleteForService(
    120       BluetoothAdapter* adapter,
    121       BluetoothGattService* service) OVERRIDE {
    122     ASSERT_EQ(adapter_.get(), adapter);
    123     ++gatt_discovery_complete_count_;
    124 
    125     QuitMessageLoop();
    126   }
    127 
    128   virtual void GattServiceChanged(BluetoothAdapter* adapter,
    129                                   BluetoothGattService* service) OVERRIDE {
    130     ASSERT_EQ(adapter_.get(), adapter);
    131     ++gatt_service_changed_count_;
    132 
    133     QuitMessageLoop();
    134   }
    135 
    136   virtual void GattCharacteristicAdded(
    137       BluetoothAdapter* adapter,
    138       BluetoothGattCharacteristic* characteristic) OVERRIDE {
    139     ASSERT_EQ(adapter_.get(), adapter);
    140 
    141     ++gatt_characteristic_added_count_;
    142     last_gatt_characteristic_id_ = characteristic->GetIdentifier();
    143     last_gatt_characteristic_uuid_ = characteristic->GetUUID();
    144 
    145     ASSERT_TRUE(characteristic->GetService());
    146     EXPECT_EQ(characteristic->GetService()->GetCharacteristic(
    147                   last_gatt_characteristic_id_),
    148               characteristic);
    149 
    150     QuitMessageLoop();
    151   }
    152 
    153   virtual void GattCharacteristicRemoved(
    154       BluetoothAdapter* adapter,
    155       BluetoothGattCharacteristic* characteristic) OVERRIDE {
    156     ASSERT_EQ(adapter_.get(), adapter);
    157 
    158     ++gatt_characteristic_removed_count_;
    159     last_gatt_characteristic_id_ = characteristic->GetIdentifier();
    160     last_gatt_characteristic_uuid_ = characteristic->GetUUID();
    161 
    162     // The service should return NULL for this characteristic.
    163     ASSERT_TRUE(characteristic->GetService());
    164     EXPECT_FALSE(characteristic->GetService()->GetCharacteristic(
    165         last_gatt_characteristic_id_));
    166 
    167     QuitMessageLoop();
    168   }
    169 
    170   virtual void GattCharacteristicValueChanged(
    171       BluetoothAdapter* adapter,
    172       BluetoothGattCharacteristic* characteristic,
    173       const std::vector<uint8>& value) OVERRIDE {
    174     ASSERT_EQ(adapter_.get(), adapter);
    175 
    176     ++gatt_characteristic_value_changed_count_;
    177     last_gatt_characteristic_id_ = characteristic->GetIdentifier();
    178     last_gatt_characteristic_uuid_ = characteristic->GetUUID();
    179     last_changed_characteristic_value_ = value;
    180 
    181     ASSERT_TRUE(characteristic->GetService());
    182     EXPECT_EQ(characteristic->GetService()->GetCharacteristic(
    183                   last_gatt_characteristic_id_),
    184               characteristic);
    185 
    186     QuitMessageLoop();
    187   }
    188 
    189   virtual void GattDescriptorAdded(
    190       BluetoothAdapter* adapter,
    191       BluetoothGattDescriptor* descriptor) OVERRIDE {
    192     ASSERT_EQ(adapter_.get(), adapter);
    193 
    194     ++gatt_descriptor_added_count_;
    195     last_gatt_descriptor_id_ = descriptor->GetIdentifier();
    196     last_gatt_descriptor_uuid_ = descriptor->GetUUID();
    197 
    198     ASSERT_TRUE(descriptor->GetCharacteristic());
    199     EXPECT_EQ(descriptor->GetCharacteristic()->GetDescriptor(
    200                   last_gatt_descriptor_id_),
    201               descriptor);
    202 
    203     QuitMessageLoop();
    204   }
    205 
    206   virtual void GattDescriptorRemoved(
    207       BluetoothAdapter* adapter,
    208       BluetoothGattDescriptor* descriptor) OVERRIDE {
    209     ASSERT_EQ(adapter_.get(), adapter);
    210 
    211     ++gatt_descriptor_removed_count_;
    212     last_gatt_descriptor_id_ = descriptor->GetIdentifier();
    213     last_gatt_descriptor_uuid_ = descriptor->GetUUID();
    214 
    215     // The characteristic should return NULL for this descriptor..
    216     ASSERT_TRUE(descriptor->GetCharacteristic());
    217     EXPECT_FALSE(descriptor->GetCharacteristic()->GetDescriptor(
    218         last_gatt_descriptor_id_));
    219 
    220     QuitMessageLoop();
    221   }
    222 
    223   virtual void GattDescriptorValueChanged(
    224       BluetoothAdapter* adapter,
    225       BluetoothGattDescriptor* descriptor,
    226       const std::vector<uint8>& value) OVERRIDE {
    227     ASSERT_EQ(adapter_.get(), adapter);
    228 
    229     ++gatt_descriptor_value_changed_count_;
    230     last_gatt_descriptor_id_ = descriptor->GetIdentifier();
    231     last_gatt_descriptor_uuid_ = descriptor->GetUUID();
    232     last_changed_descriptor_value_ = value;
    233 
    234     ASSERT_TRUE(descriptor->GetCharacteristic());
    235     EXPECT_EQ(descriptor->GetCharacteristic()->GetDescriptor(
    236                   last_gatt_descriptor_id_),
    237               descriptor);
    238 
    239     QuitMessageLoop();
    240   }
    241 
    242   int gatt_service_added_count_;
    243   int gatt_service_removed_count_;
    244   int gatt_service_changed_count_;
    245   int gatt_discovery_complete_count_;
    246   int gatt_characteristic_added_count_;
    247   int gatt_characteristic_removed_count_;
    248   int gatt_characteristic_value_changed_count_;
    249   int gatt_descriptor_added_count_;
    250   int gatt_descriptor_removed_count_;
    251   int gatt_descriptor_value_changed_count_;
    252   std::string last_gatt_service_id_;
    253   BluetoothUUID last_gatt_service_uuid_;
    254   std::string last_gatt_characteristic_id_;
    255   BluetoothUUID last_gatt_characteristic_uuid_;
    256   std::vector<uint8> last_changed_characteristic_value_;
    257   std::string last_gatt_descriptor_id_;
    258   BluetoothUUID last_gatt_descriptor_uuid_;
    259   std::vector<uint8> last_changed_descriptor_value_;
    260 
    261  private:
    262   // Some tests use a message loop since background processing is simulated;
    263   // break out of those loops.
    264   void QuitMessageLoop() {
    265     if (base::MessageLoop::current() &&
    266         base::MessageLoop::current()->is_running())
    267       base::MessageLoop::current()->Quit();
    268   }
    269 
    270   scoped_refptr<BluetoothAdapter> adapter_;
    271 };
    272 
    273 }  // namespace
    274 
    275 class BluetoothGattChromeOSTest : public testing::Test {
    276  public:
    277   BluetoothGattChromeOSTest()
    278       : fake_bluetooth_gatt_service_client_(NULL),
    279         success_callback_count_(0),
    280         error_callback_count_(0) {
    281   }
    282 
    283   virtual void SetUp() {
    284     scoped_ptr<DBusThreadManagerSetter> dbus_setter =
    285         chromeos::DBusThreadManager::GetSetterForTesting();
    286     fake_bluetooth_device_client_ = new FakeBluetoothDeviceClient;
    287     fake_bluetooth_gatt_service_client_ =
    288         new FakeBluetoothGattServiceClient;
    289     fake_bluetooth_gatt_characteristic_client_ =
    290         new FakeBluetoothGattCharacteristicClient;
    291     fake_bluetooth_gatt_descriptor_client_ =
    292         new FakeBluetoothGattDescriptorClient;
    293     dbus_setter->SetBluetoothDeviceClient(
    294         scoped_ptr<BluetoothDeviceClient>(
    295             fake_bluetooth_device_client_));
    296     dbus_setter->SetBluetoothGattServiceClient(
    297         scoped_ptr<BluetoothGattServiceClient>(
    298             fake_bluetooth_gatt_service_client_));
    299     dbus_setter->SetBluetoothGattCharacteristicClient(
    300         scoped_ptr<BluetoothGattCharacteristicClient>(
    301             fake_bluetooth_gatt_characteristic_client_));
    302     dbus_setter->SetBluetoothGattDescriptorClient(
    303         scoped_ptr<BluetoothGattDescriptorClient>(
    304             fake_bluetooth_gatt_descriptor_client_));
    305     dbus_setter->SetBluetoothAdapterClient(
    306         scoped_ptr<BluetoothAdapterClient>(new FakeBluetoothAdapterClient));
    307     dbus_setter->SetBluetoothInputClient(
    308         scoped_ptr<BluetoothInputClient>(new FakeBluetoothInputClient));
    309     dbus_setter->SetBluetoothAgentManagerClient(
    310         scoped_ptr<BluetoothAgentManagerClient>(
    311             new FakeBluetoothAgentManagerClient));
    312 
    313     GetAdapter();
    314 
    315     adapter_->SetPowered(
    316         true,
    317         base::Bind(&base::DoNothing),
    318         base::Bind(&base::DoNothing));
    319     ASSERT_TRUE(adapter_->IsPowered());
    320   }
    321 
    322   virtual void TearDown() {
    323     adapter_ = NULL;
    324     update_sessions_.clear();
    325     gatt_conn_.reset();
    326     DBusThreadManager::Shutdown();
    327   }
    328 
    329   void GetAdapter() {
    330     device::BluetoothAdapterFactory::GetAdapter(
    331         base::Bind(&BluetoothGattChromeOSTest::AdapterCallback,
    332                    base::Unretained(this)));
    333     ASSERT_TRUE(adapter_.get() != NULL);
    334     ASSERT_TRUE(adapter_->IsInitialized());
    335     ASSERT_TRUE(adapter_->IsPresent());
    336   }
    337 
    338   void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) {
    339     adapter_ = adapter;
    340   }
    341 
    342   void SuccessCallback() {
    343     ++success_callback_count_;
    344   }
    345 
    346   void ValueCallback(const std::vector<uint8>& value) {
    347     ++success_callback_count_;
    348     last_read_value_ = value;
    349   }
    350 
    351   void GattConnectionCallback(scoped_ptr<BluetoothGattConnection> conn) {
    352     ++success_callback_count_;
    353     gatt_conn_ = conn.Pass();
    354   }
    355 
    356   void NotifySessionCallback(scoped_ptr<BluetoothGattNotifySession> session) {
    357     ++success_callback_count_;
    358     update_sessions_.push_back(session.release());
    359     QuitMessageLoop();
    360   }
    361 
    362   void ErrorCallback() {
    363     ++error_callback_count_;
    364   }
    365 
    366   void DBusErrorCallback(const std::string& error_name,
    367                          const std::string& error_message) {
    368     ++error_callback_count_;
    369   }
    370 
    371   void ConnectErrorCallback(BluetoothDevice::ConnectErrorCode error) {
    372     ++error_callback_count_;
    373   }
    374 
    375  protected:
    376   void QuitMessageLoop() {
    377     if (base::MessageLoop::current() &&
    378         base::MessageLoop::current()->is_running())
    379       base::MessageLoop::current()->Quit();
    380   }
    381 
    382   base::MessageLoop message_loop_;
    383 
    384   FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
    385   FakeBluetoothGattServiceClient* fake_bluetooth_gatt_service_client_;
    386   FakeBluetoothGattCharacteristicClient*
    387       fake_bluetooth_gatt_characteristic_client_;
    388   FakeBluetoothGattDescriptorClient* fake_bluetooth_gatt_descriptor_client_;
    389   scoped_ptr<device::BluetoothGattConnection> gatt_conn_;
    390   ScopedVector<BluetoothGattNotifySession> update_sessions_;
    391   scoped_refptr<BluetoothAdapter> adapter_;
    392 
    393   int success_callback_count_;
    394   int error_callback_count_;
    395   std::vector<uint8> last_read_value_;
    396 };
    397 
    398 TEST_F(BluetoothGattChromeOSTest, GattConnection) {
    399   fake_bluetooth_device_client_->CreateDevice(
    400       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    401       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    402   BluetoothDevice* device = adapter_->GetDevice(
    403       FakeBluetoothDeviceClient::kLowEnergyAddress);
    404   ASSERT_TRUE(device);
    405   ASSERT_FALSE(device->IsConnected());
    406   ASSERT_FALSE(gatt_conn_.get());
    407   ASSERT_EQ(0, success_callback_count_);
    408   ASSERT_EQ(0, error_callback_count_);
    409 
    410   device->CreateGattConnection(
    411       base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
    412                  base::Unretained(this)),
    413       base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
    414                  base::Unretained(this)));
    415 
    416   EXPECT_EQ(1, success_callback_count_);
    417   EXPECT_EQ(0, error_callback_count_);
    418   EXPECT_TRUE(device->IsConnected());
    419   ASSERT_TRUE(gatt_conn_.get());
    420   EXPECT_TRUE(gatt_conn_->IsConnected());
    421   EXPECT_EQ(FakeBluetoothDeviceClient::kLowEnergyAddress,
    422             gatt_conn_->GetDeviceAddress());
    423 
    424   gatt_conn_->Disconnect(
    425       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
    426                  base::Unretained(this)));
    427   EXPECT_EQ(2, success_callback_count_);
    428   EXPECT_EQ(0, error_callback_count_);
    429   EXPECT_TRUE(device->IsConnected());
    430   EXPECT_FALSE(gatt_conn_->IsConnected());
    431 
    432   device->CreateGattConnection(
    433       base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
    434                  base::Unretained(this)),
    435       base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
    436                  base::Unretained(this)));
    437 
    438   EXPECT_EQ(3, success_callback_count_);
    439   EXPECT_EQ(0, error_callback_count_);
    440   EXPECT_TRUE(device->IsConnected());
    441   ASSERT_TRUE(gatt_conn_.get());
    442   EXPECT_TRUE(gatt_conn_->IsConnected());
    443 
    444   device->Disconnect(
    445       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
    446                  base::Unretained(this)),
    447       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
    448                  base::Unretained(this)));
    449 
    450   EXPECT_EQ(4, success_callback_count_);
    451   EXPECT_EQ(0, error_callback_count_);
    452   ASSERT_TRUE(gatt_conn_.get());
    453   EXPECT_FALSE(gatt_conn_->IsConnected());
    454 
    455   device->CreateGattConnection(
    456       base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
    457                  base::Unretained(this)),
    458       base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
    459                  base::Unretained(this)));
    460 
    461   EXPECT_EQ(5, success_callback_count_);
    462   EXPECT_EQ(0, error_callback_count_);
    463   EXPECT_TRUE(device->IsConnected());
    464   EXPECT_TRUE(gatt_conn_->IsConnected());
    465 
    466   fake_bluetooth_device_client_->RemoveDevice(
    467       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    468       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    469   ASSERT_TRUE(gatt_conn_.get());
    470   EXPECT_FALSE(gatt_conn_->IsConnected());
    471 }
    472 
    473 TEST_F(BluetoothGattChromeOSTest, GattServiceAddedAndRemoved) {
    474   // Create a fake LE device. We store the device pointer here because this is a
    475   // test. It's unsafe to do this in production as the device might get deleted.
    476   fake_bluetooth_device_client_->CreateDevice(
    477       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    478       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    479   BluetoothDevice* device = adapter_->GetDevice(
    480       FakeBluetoothDeviceClient::kLowEnergyAddress);
    481   ASSERT_TRUE(device);
    482 
    483   TestObserver observer(adapter_);
    484 
    485   EXPECT_EQ(0, observer.gatt_service_added_count_);
    486   EXPECT_EQ(0, observer.gatt_service_removed_count_);
    487   EXPECT_TRUE(observer.last_gatt_service_id_.empty());
    488   EXPECT_FALSE(observer.last_gatt_service_uuid_.IsValid());
    489   EXPECT_TRUE(device->GetGattServices().empty());
    490 
    491   // Expose the fake Heart Rate Service.
    492   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
    493       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    494   EXPECT_EQ(1, observer.gatt_service_added_count_);
    495   EXPECT_EQ(0, observer.gatt_service_removed_count_);
    496   EXPECT_FALSE(observer.last_gatt_service_id_.empty());
    497   EXPECT_EQ(1U, device->GetGattServices().size());
    498   EXPECT_EQ(
    499       BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
    500       observer.last_gatt_service_uuid_);
    501 
    502   BluetoothGattService* service =
    503       device->GetGattService(observer.last_gatt_service_id_);
    504   EXPECT_FALSE(service->IsLocal());
    505   EXPECT_TRUE(service->IsPrimary());
    506   EXPECT_EQ(service, device->GetGattServices()[0]);
    507   EXPECT_EQ(service, device->GetGattService(service->GetIdentifier()));
    508 
    509   EXPECT_EQ(observer.last_gatt_service_uuid_, service->GetUUID());
    510 
    511   // Hide the service.
    512   observer.last_gatt_service_uuid_ = BluetoothUUID();
    513   observer.last_gatt_service_id_.clear();
    514   fake_bluetooth_gatt_service_client_->HideHeartRateService();
    515 
    516   EXPECT_EQ(1, observer.gatt_service_added_count_);
    517   EXPECT_EQ(1, observer.gatt_service_removed_count_);
    518   EXPECT_FALSE(observer.last_gatt_service_id_.empty());
    519   EXPECT_TRUE(device->GetGattServices().empty());
    520   EXPECT_EQ(
    521       BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
    522       observer.last_gatt_service_uuid_);
    523 
    524   EXPECT_EQ(NULL, device->GetGattService(observer.last_gatt_service_id_));
    525 
    526   // Expose the service again.
    527   observer.last_gatt_service_uuid_ = BluetoothUUID();
    528   observer.last_gatt_service_id_.clear();
    529   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
    530       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    531   EXPECT_EQ(2, observer.gatt_service_added_count_);
    532   EXPECT_EQ(1, observer.gatt_service_removed_count_);
    533   EXPECT_FALSE(observer.last_gatt_service_id_.empty());
    534   EXPECT_EQ(1U, device->GetGattServices().size());
    535   EXPECT_EQ(
    536       BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
    537       observer.last_gatt_service_uuid_);
    538 
    539   // The object |service| points to should have been deallocated. |device|
    540   // should contain a brand new instance.
    541   service = device->GetGattService(observer.last_gatt_service_id_);
    542   EXPECT_EQ(service, device->GetGattServices()[0]);
    543   EXPECT_FALSE(service->IsLocal());
    544   EXPECT_TRUE(service->IsPrimary());
    545 
    546   EXPECT_EQ(observer.last_gatt_service_uuid_, service->GetUUID());
    547 
    548   // Remove the device. The observer should be notified of the removed service.
    549   // |device| becomes invalid after this.
    550   observer.last_gatt_service_uuid_ = BluetoothUUID();
    551   observer.last_gatt_service_id_.clear();
    552   fake_bluetooth_device_client_->RemoveDevice(
    553       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    554       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    555 
    556   EXPECT_EQ(2, observer.gatt_service_added_count_);
    557   EXPECT_EQ(2, observer.gatt_service_removed_count_);
    558   EXPECT_FALSE(observer.last_gatt_service_id_.empty());
    559   EXPECT_EQ(
    560       BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
    561       observer.last_gatt_service_uuid_);
    562   EXPECT_EQ(
    563       NULL, adapter_->GetDevice(FakeBluetoothDeviceClient::kLowEnergyAddress));
    564 }
    565 
    566 TEST_F(BluetoothGattChromeOSTest, GattCharacteristicAddedAndRemoved) {
    567   fake_bluetooth_device_client_->CreateDevice(
    568       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    569       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    570   BluetoothDevice* device = adapter_->GetDevice(
    571       FakeBluetoothDeviceClient::kLowEnergyAddress);
    572   ASSERT_TRUE(device);
    573 
    574   TestObserver observer(adapter_);
    575 
    576   // Expose the fake Heart Rate service. This will asynchronously expose
    577   // characteristics.
    578   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
    579       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    580   ASSERT_EQ(1, observer.gatt_service_added_count_);
    581 
    582   BluetoothGattService* service =
    583       device->GetGattService(observer.last_gatt_service_id_);
    584 
    585   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    586   EXPECT_EQ(0, observer.gatt_discovery_complete_count_);
    587   EXPECT_EQ(0, observer.gatt_characteristic_added_count_);
    588   EXPECT_EQ(0, observer.gatt_characteristic_removed_count_);
    589   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    590   EXPECT_TRUE(service->GetCharacteristics().empty());
    591 
    592   // Run the message loop so that the characteristics appear.
    593   base::MessageLoop::current()->Run();
    594 
    595   // 3 characteristics should appear. Only 1 of the characteristics sends
    596   // value changed signals. Service changed should be fired once for
    597   // descriptor added.
    598   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    599   EXPECT_EQ(1, observer.gatt_discovery_complete_count_);
    600   EXPECT_EQ(3, observer.gatt_characteristic_added_count_);
    601   EXPECT_EQ(0, observer.gatt_characteristic_removed_count_);
    602   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    603   EXPECT_EQ(3U, service->GetCharacteristics().size());
    604 
    605   // Hide the characteristics. 3 removed signals should be received.
    606   fake_bluetooth_gatt_characteristic_client_->HideHeartRateCharacteristics();
    607   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    608   EXPECT_EQ(3, observer.gatt_characteristic_added_count_);
    609   EXPECT_EQ(3, observer.gatt_characteristic_removed_count_);
    610   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    611   EXPECT_TRUE(service->GetCharacteristics().empty());
    612 
    613   // Re-expose the heart rate characteristics. We shouldn't get another
    614   // GattDiscoveryCompleteForService call, since the service thinks that
    615   // discovery is done. On the bluetoothd side, characteristics will be removed
    616   // only if the service will also be subsequently removed.
    617   fake_bluetooth_gatt_characteristic_client_->ExposeHeartRateCharacteristics(
    618       fake_bluetooth_gatt_service_client_->GetHeartRateServicePath());
    619   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    620   EXPECT_EQ(1, observer.gatt_discovery_complete_count_);
    621   EXPECT_EQ(6, observer.gatt_characteristic_added_count_);
    622   EXPECT_EQ(3, observer.gatt_characteristic_removed_count_);
    623   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    624   EXPECT_EQ(3U, service->GetCharacteristics().size());
    625 
    626   // Hide the service. All characteristics should disappear.
    627   fake_bluetooth_gatt_service_client_->HideHeartRateService();
    628   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    629   EXPECT_EQ(6, observer.gatt_characteristic_added_count_);
    630   EXPECT_EQ(6, observer.gatt_characteristic_removed_count_);
    631   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    632 }
    633 
    634 TEST_F(BluetoothGattChromeOSTest, GattDescriptorAddedAndRemoved) {
    635   fake_bluetooth_device_client_->CreateDevice(
    636       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    637       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    638   BluetoothDevice* device = adapter_->GetDevice(
    639       FakeBluetoothDeviceClient::kLowEnergyAddress);
    640   ASSERT_TRUE(device);
    641 
    642   TestObserver observer(adapter_);
    643 
    644   // Expose the fake Heart Rate service. This will asynchronously expose
    645   // characteristics.
    646   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
    647       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    648   ASSERT_EQ(1, observer.gatt_service_added_count_);
    649 
    650   BluetoothGattService* service =
    651       device->GetGattService(observer.last_gatt_service_id_);
    652 
    653   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    654   EXPECT_EQ(0, observer.gatt_descriptor_added_count_);
    655   EXPECT_EQ(0, observer.gatt_descriptor_removed_count_);
    656   EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
    657 
    658   EXPECT_TRUE(service->GetCharacteristics().empty());
    659 
    660   // Run the message loop so that the characteristics appear.
    661   base::MessageLoop::current()->Run();
    662   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    663 
    664   // Only the Heart Rate Measurement characteristic has a descriptor.
    665   EXPECT_EQ(1, observer.gatt_descriptor_added_count_);
    666   EXPECT_EQ(0, observer.gatt_descriptor_removed_count_);
    667   EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
    668 
    669   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
    670       fake_bluetooth_gatt_characteristic_client_->
    671           GetBodySensorLocationPath().value());
    672   ASSERT_TRUE(characteristic);
    673   EXPECT_TRUE(characteristic->GetDescriptors().empty());
    674 
    675   characteristic = service->GetCharacteristic(
    676       fake_bluetooth_gatt_characteristic_client_->
    677           GetHeartRateControlPointPath().value());
    678   ASSERT_TRUE(characteristic);
    679   EXPECT_TRUE(characteristic->GetDescriptors().empty());
    680 
    681   characteristic = service->GetCharacteristic(
    682       fake_bluetooth_gatt_characteristic_client_->
    683           GetHeartRateMeasurementPath().value());
    684   ASSERT_TRUE(characteristic);
    685   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
    686 
    687   BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
    688   EXPECT_FALSE(descriptor->IsLocal());
    689   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
    690             descriptor->GetUUID());
    691   EXPECT_EQ(descriptor->GetUUID(), observer.last_gatt_descriptor_uuid_);
    692   EXPECT_EQ(descriptor->GetIdentifier(), observer.last_gatt_descriptor_id_);
    693 
    694   // Hide the descriptor.
    695   fake_bluetooth_gatt_descriptor_client_->HideDescriptor(
    696       dbus::ObjectPath(descriptor->GetIdentifier()));
    697   EXPECT_TRUE(characteristic->GetDescriptors().empty());
    698   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    699   EXPECT_EQ(1, observer.gatt_descriptor_added_count_);
    700   EXPECT_EQ(1, observer.gatt_descriptor_removed_count_);
    701   EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
    702 
    703   // Expose the descriptor again.
    704   observer.last_gatt_descriptor_id_.clear();
    705   observer.last_gatt_descriptor_uuid_ = BluetoothUUID();
    706   fake_bluetooth_gatt_descriptor_client_->ExposeDescriptor(
    707       dbus::ObjectPath(characteristic->GetIdentifier()),
    708       FakeBluetoothGattDescriptorClient::
    709           kClientCharacteristicConfigurationUUID);
    710   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    711   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
    712   EXPECT_EQ(2, observer.gatt_descriptor_added_count_);
    713   EXPECT_EQ(1, observer.gatt_descriptor_removed_count_);
    714   EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
    715 
    716   descriptor = characteristic->GetDescriptors()[0];
    717   EXPECT_FALSE(descriptor->IsLocal());
    718   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
    719             descriptor->GetUUID());
    720   EXPECT_EQ(descriptor->GetUUID(), observer.last_gatt_descriptor_uuid_);
    721   EXPECT_EQ(descriptor->GetIdentifier(), observer.last_gatt_descriptor_id_);
    722 }
    723 
    724 TEST_F(BluetoothGattChromeOSTest, AdapterAddedAfterGattService) {
    725   // This unit test tests that all remote GATT objects are created for D-Bus
    726   // objects that were already exposed.
    727   adapter_ = NULL;
    728   ASSERT_FALSE(device::BluetoothAdapterFactory::HasSharedInstanceForTesting());
    729 
    730   // Create the fake D-Bus objects.
    731   fake_bluetooth_device_client_->CreateDevice(
    732       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    733       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    734   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
    735       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    736   while (!fake_bluetooth_gatt_characteristic_client_->IsHeartRateVisible())
    737     base::RunLoop().RunUntilIdle();
    738   ASSERT_TRUE(fake_bluetooth_gatt_service_client_->IsHeartRateVisible());
    739   ASSERT_TRUE(fake_bluetooth_gatt_characteristic_client_->IsHeartRateVisible());
    740 
    741   // Create the adapter. This should create all the GATT objects.
    742   GetAdapter();
    743   BluetoothDevice* device = adapter_->GetDevice(
    744       FakeBluetoothDeviceClient::kLowEnergyAddress);
    745   ASSERT_TRUE(device);
    746   EXPECT_EQ(1U, device->GetGattServices().size());
    747 
    748   BluetoothGattService* service = device->GetGattServices()[0];
    749   ASSERT_TRUE(service);
    750   EXPECT_FALSE(service->IsLocal());
    751   EXPECT_TRUE(service->IsPrimary());
    752   EXPECT_EQ(
    753       BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
    754       service->GetUUID());
    755   EXPECT_EQ(service, device->GetGattServices()[0]);
    756   EXPECT_EQ(service, device->GetGattService(service->GetIdentifier()));
    757   EXPECT_FALSE(service->IsLocal());
    758   EXPECT_EQ(3U, service->GetCharacteristics().size());
    759 
    760   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
    761       fake_bluetooth_gatt_characteristic_client_->
    762           GetBodySensorLocationPath().value());
    763   ASSERT_TRUE(characteristic);
    764   EXPECT_EQ(
    765       BluetoothUUID(FakeBluetoothGattCharacteristicClient::
    766           kBodySensorLocationUUID),
    767       characteristic->GetUUID());
    768   EXPECT_FALSE(characteristic->IsLocal());
    769   EXPECT_TRUE(characteristic->GetDescriptors().empty());
    770 
    771   characteristic = service->GetCharacteristic(
    772       fake_bluetooth_gatt_characteristic_client_->
    773           GetHeartRateControlPointPath().value());
    774   ASSERT_TRUE(characteristic);
    775   EXPECT_EQ(
    776       BluetoothUUID(FakeBluetoothGattCharacteristicClient::
    777           kHeartRateControlPointUUID),
    778       characteristic->GetUUID());
    779   EXPECT_FALSE(characteristic->IsLocal());
    780   EXPECT_TRUE(characteristic->GetDescriptors().empty());
    781 
    782   characteristic = service->GetCharacteristic(
    783       fake_bluetooth_gatt_characteristic_client_->
    784           GetHeartRateMeasurementPath().value());
    785   ASSERT_TRUE(characteristic);
    786   EXPECT_EQ(
    787       BluetoothUUID(FakeBluetoothGattCharacteristicClient::
    788           kHeartRateMeasurementUUID),
    789       characteristic->GetUUID());
    790   EXPECT_FALSE(characteristic->IsLocal());
    791   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
    792 
    793   BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
    794   ASSERT_TRUE(descriptor);
    795   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
    796             descriptor->GetUUID());
    797   EXPECT_FALSE(descriptor->IsLocal());
    798 }
    799 
    800 TEST_F(BluetoothGattChromeOSTest, GattCharacteristicValue) {
    801   fake_bluetooth_device_client_->CreateDevice(
    802       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    803       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    804   BluetoothDevice* device = adapter_->GetDevice(
    805       FakeBluetoothDeviceClient::kLowEnergyAddress);
    806   ASSERT_TRUE(device);
    807 
    808   TestObserver observer(adapter_);
    809 
    810   // Expose the fake Heart Rate service. This will asynchronously expose
    811   // characteristics.
    812   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
    813       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    814   ASSERT_EQ(1, observer.gatt_service_added_count_);
    815 
    816   BluetoothGattService* service =
    817       device->GetGattService(observer.last_gatt_service_id_);
    818 
    819   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    820 
    821   // Run the message loop so that the characteristics appear.
    822   base::MessageLoop::current()->Run();
    823 
    824   // Issue write request to non-writeable characteristics.
    825   observer.last_gatt_characteristic_id_.clear();
    826   observer.last_gatt_characteristic_uuid_ = BluetoothUUID();
    827 
    828   std::vector<uint8> write_value;
    829   write_value.push_back(0x01);
    830   BluetoothGattCharacteristic* characteristic =
    831       service->GetCharacteristic(fake_bluetooth_gatt_characteristic_client_->
    832           GetHeartRateMeasurementPath().value());
    833   ASSERT_TRUE(characteristic);
    834   EXPECT_FALSE(characteristic->IsNotifying());
    835   EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
    836                 GetHeartRateMeasurementPath().value(),
    837             characteristic->GetIdentifier());
    838   EXPECT_EQ(kHeartRateMeasurementUUID, characteristic->GetUUID());
    839   characteristic->WriteRemoteCharacteristic(
    840       write_value,
    841       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
    842                  base::Unretained(this)),
    843       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
    844                  base::Unretained(this)));
    845   EXPECT_TRUE(observer.last_gatt_characteristic_id_.empty());
    846   EXPECT_FALSE(observer.last_gatt_characteristic_uuid_.IsValid());
    847   EXPECT_EQ(0, success_callback_count_);
    848   EXPECT_EQ(1, error_callback_count_);
    849   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    850 
    851   characteristic = service->GetCharacteristic(
    852       fake_bluetooth_gatt_characteristic_client_->
    853           GetBodySensorLocationPath().value());
    854   ASSERT_TRUE(characteristic);
    855   EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
    856                 GetBodySensorLocationPath().value(),
    857             characteristic->GetIdentifier());
    858   EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
    859   characteristic->WriteRemoteCharacteristic(
    860       write_value,
    861       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
    862                  base::Unretained(this)),
    863       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
    864                  base::Unretained(this)));
    865   EXPECT_TRUE(observer.last_gatt_characteristic_id_.empty());
    866   EXPECT_FALSE(observer.last_gatt_characteristic_uuid_.IsValid());
    867   EXPECT_EQ(0, success_callback_count_);
    868   EXPECT_EQ(2, error_callback_count_);
    869   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    870 
    871   // Issue write request to writeable characteristic. The "Body Sensor Location"
    872   // characteristic does not send notifications and WriteValue does not result
    873   // in a CharacteristicValueChanged event, thus no such event should be
    874   // received.
    875   characteristic = service->GetCharacteristic(
    876       fake_bluetooth_gatt_characteristic_client_->
    877           GetHeartRateControlPointPath().value());
    878   ASSERT_TRUE(characteristic);
    879   EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
    880                 GetHeartRateControlPointPath().value(),
    881             characteristic->GetIdentifier());
    882   EXPECT_EQ(kHeartRateControlPointUUID, characteristic->GetUUID());
    883   characteristic->WriteRemoteCharacteristic(
    884       write_value,
    885       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
    886                  base::Unretained(this)),
    887       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
    888                  base::Unretained(this)));
    889   EXPECT_TRUE(observer.last_gatt_characteristic_id_.empty());
    890   EXPECT_FALSE(observer.last_gatt_characteristic_uuid_.IsValid());
    891   EXPECT_EQ(1, success_callback_count_);
    892   EXPECT_EQ(2, error_callback_count_);
    893   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
    894 
    895   // Issue a read request. A successful read results in a
    896   // CharacteristicValueChanged notification.
    897   characteristic = service->GetCharacteristic(
    898       fake_bluetooth_gatt_characteristic_client_->
    899           GetBodySensorLocationPath().value());
    900   ASSERT_TRUE(characteristic);
    901   EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
    902                 GetBodySensorLocationPath().value(),
    903             characteristic->GetIdentifier());
    904   EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
    905   characteristic->ReadRemoteCharacteristic(
    906       base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
    907                  base::Unretained(this)),
    908       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
    909                  base::Unretained(this)));
    910   EXPECT_EQ(2, success_callback_count_);
    911   EXPECT_EQ(2, error_callback_count_);
    912   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
    913   EXPECT_TRUE(ValuesEqual(characteristic->GetValue(), last_read_value_));
    914 }
    915 
    916 TEST_F(BluetoothGattChromeOSTest, GattCharacteristicProperties) {
    917   fake_bluetooth_device_client_->CreateDevice(
    918       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    919       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    920   BluetoothDevice* device = adapter_->GetDevice(
    921       FakeBluetoothDeviceClient::kLowEnergyAddress);
    922   ASSERT_TRUE(device);
    923 
    924   TestObserver observer(adapter_);
    925 
    926   // Expose the fake Heart Rate service. This will asynchronously expose
    927   // characteristics.
    928   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
    929       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    930 
    931   BluetoothGattService* service =
    932       device->GetGattService(observer.last_gatt_service_id_);
    933 
    934   EXPECT_TRUE(service->GetCharacteristics().empty());
    935 
    936   // Run the message loop so that the characteristics appear.
    937   base::MessageLoop::current()->Run();
    938 
    939   BluetoothGattCharacteristic *characteristic = service->GetCharacteristic(
    940       fake_bluetooth_gatt_characteristic_client_->
    941           GetBodySensorLocationPath().value());
    942   EXPECT_EQ(BluetoothGattCharacteristic::kPropertyRead,
    943             characteristic->GetProperties());
    944 
    945   characteristic = service->GetCharacteristic(
    946       fake_bluetooth_gatt_characteristic_client_->
    947           GetHeartRateControlPointPath().value());
    948   EXPECT_EQ(BluetoothGattCharacteristic::kPropertyWrite,
    949             characteristic->GetProperties());
    950 
    951   characteristic = service->GetCharacteristic(
    952       fake_bluetooth_gatt_characteristic_client_->
    953           GetHeartRateMeasurementPath().value());
    954   EXPECT_EQ(BluetoothGattCharacteristic::kPropertyNotify,
    955             characteristic->GetProperties());
    956 }
    957 
    958 TEST_F(BluetoothGattChromeOSTest, GattDescriptorValue) {
    959   fake_bluetooth_device_client_->CreateDevice(
    960       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    961       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    962   BluetoothDevice* device = adapter_->GetDevice(
    963       FakeBluetoothDeviceClient::kLowEnergyAddress);
    964   ASSERT_TRUE(device);
    965 
    966   TestObserver observer(adapter_);
    967 
    968   // Expose the fake Heart Rate service. This will asynchronously expose
    969   // characteristics.
    970   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
    971       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
    972   ASSERT_EQ(1, observer.gatt_service_added_count_);
    973 
    974   BluetoothGattService* service =
    975       device->GetGattService(observer.last_gatt_service_id_);
    976 
    977   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    978   EXPECT_EQ(0, observer.gatt_discovery_complete_count_);
    979   EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count_);
    980   EXPECT_TRUE(service->GetCharacteristics().empty());
    981 
    982   // Run the message loop so that the characteristics appear.
    983   base::MessageLoop::current()->Run();
    984   EXPECT_EQ(0, observer.gatt_service_changed_count_);
    985   EXPECT_EQ(1, observer.gatt_discovery_complete_count_);
    986 
    987   // Only the Heart Rate Measurement characteristic has a descriptor.
    988   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
    989       fake_bluetooth_gatt_characteristic_client_->
    990           GetHeartRateMeasurementPath().value());
    991   ASSERT_TRUE(characteristic);
    992   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
    993 
    994   BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
    995   EXPECT_FALSE(descriptor->IsLocal());
    996   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
    997             descriptor->GetUUID());
    998 
    999   std::vector<uint8> desc_value;
   1000   desc_value.push_back(1);
   1001   desc_value.push_back(0);
   1002 
   1003   /* The cached value will be empty until the first read request */
   1004   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
   1005   EXPECT_TRUE(descriptor->GetValue().empty());
   1006 
   1007   EXPECT_EQ(0, success_callback_count_);
   1008   EXPECT_EQ(0, error_callback_count_);
   1009   EXPECT_TRUE(last_read_value_.empty());
   1010 
   1011   // Read value. GattDescriptorValueChanged event will be sent after a
   1012   // successful read.
   1013   descriptor->ReadRemoteDescriptor(
   1014       base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
   1015                  base::Unretained(this)),
   1016       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1017                  base::Unretained(this)));
   1018   EXPECT_EQ(1, success_callback_count_);
   1019   EXPECT_EQ(0, error_callback_count_);
   1020   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   1021   EXPECT_TRUE(ValuesEqual(desc_value, descriptor->GetValue()));
   1022   EXPECT_EQ(0, observer.gatt_service_changed_count_);
   1023   EXPECT_EQ(1, observer.gatt_descriptor_value_changed_count_);
   1024 
   1025   // Write value. Writes to this descriptor will fail.
   1026   desc_value[0] = 0x03;
   1027   descriptor->WriteRemoteDescriptor(
   1028       desc_value,
   1029       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
   1030                  base::Unretained(this)),
   1031       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1032                  base::Unretained(this)));
   1033   EXPECT_EQ(1, success_callback_count_);
   1034   EXPECT_EQ(1, error_callback_count_);
   1035   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   1036   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
   1037   EXPECT_EQ(0, observer.gatt_service_changed_count_);
   1038   EXPECT_EQ(1, observer.gatt_descriptor_value_changed_count_);
   1039 
   1040   // Read new value.
   1041   descriptor->ReadRemoteDescriptor(
   1042       base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
   1043                  base::Unretained(this)),
   1044       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1045                  base::Unretained(this)));
   1046   EXPECT_EQ(2, success_callback_count_);
   1047   EXPECT_EQ(1, error_callback_count_);
   1048   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   1049   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
   1050   EXPECT_EQ(0, observer.gatt_service_changed_count_);
   1051   EXPECT_EQ(2, observer.gatt_descriptor_value_changed_count_);
   1052 }
   1053 
   1054 TEST_F(BluetoothGattChromeOSTest, NotifySessions) {
   1055   fake_bluetooth_device_client_->CreateDevice(
   1056       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
   1057       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   1058   BluetoothDevice* device =
   1059       adapter_->GetDevice(FakeBluetoothDeviceClient::kLowEnergyAddress);
   1060   ASSERT_TRUE(device);
   1061 
   1062   TestObserver observer(adapter_);
   1063 
   1064   // Expose the fake Heart Rate service. This will asynchronously expose
   1065   // characteristics.
   1066   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
   1067       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   1068   ASSERT_EQ(1, observer.gatt_service_added_count_);
   1069 
   1070   BluetoothGattService* service =
   1071       device->GetGattService(observer.last_gatt_service_id_);
   1072 
   1073   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
   1074 
   1075   // Run the message loop so that the characteristics appear.
   1076   base::MessageLoop::current()->Run();
   1077 
   1078   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
   1079       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
   1080           .value());
   1081   ASSERT_TRUE(characteristic);
   1082   EXPECT_FALSE(characteristic->IsNotifying());
   1083   EXPECT_TRUE(update_sessions_.empty());
   1084 
   1085   // Request to start notifications.
   1086   characteristic->StartNotifySession(
   1087       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1088                  base::Unretained(this)),
   1089       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1090                  base::Unretained(this)));
   1091 
   1092   // The operation still hasn't completed but we should have received the first
   1093   // notification.
   1094   EXPECT_EQ(0, success_callback_count_);
   1095   EXPECT_EQ(0, error_callback_count_);
   1096   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1097   EXPECT_TRUE(update_sessions_.empty());
   1098 
   1099   // Send a two more requests, which should get queued.
   1100   characteristic->StartNotifySession(
   1101       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1102                  base::Unretained(this)),
   1103       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1104                  base::Unretained(this)));
   1105   characteristic->StartNotifySession(
   1106       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1107                  base::Unretained(this)),
   1108       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1109                  base::Unretained(this)));
   1110   EXPECT_EQ(0, success_callback_count_);
   1111   EXPECT_EQ(0, error_callback_count_);
   1112   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1113   EXPECT_TRUE(update_sessions_.empty());
   1114   EXPECT_TRUE(characteristic->IsNotifying());
   1115 
   1116   // Run the main loop. The initial call should complete. The queued call should
   1117   // succeed immediately.
   1118   base::MessageLoop::current()->Run();
   1119 
   1120   EXPECT_EQ(3, success_callback_count_);
   1121   EXPECT_EQ(0, error_callback_count_);
   1122   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1123   EXPECT_EQ(3U, update_sessions_.size());
   1124 
   1125   // Notifications should be getting sent regularly now.
   1126   base::MessageLoop::current()->Run();
   1127   EXPECT_GT(observer.gatt_characteristic_value_changed_count_, 1);
   1128 
   1129   // Stop one of the sessions. The session should become inactive but the
   1130   // characteristic should still be notifying.
   1131   BluetoothGattNotifySession* session = update_sessions_[0];
   1132   EXPECT_TRUE(session->IsActive());
   1133   session->Stop(base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
   1134                            base::Unretained(this)));
   1135   EXPECT_EQ(4, success_callback_count_);
   1136   EXPECT_EQ(0, error_callback_count_);
   1137   EXPECT_FALSE(session->IsActive());
   1138   EXPECT_EQ(characteristic->GetIdentifier(),
   1139             session->GetCharacteristicIdentifier());
   1140   EXPECT_TRUE(characteristic->IsNotifying());
   1141 
   1142   // Delete another session. Characteristic should still be notifying.
   1143   update_sessions_.pop_back();
   1144   EXPECT_EQ(2U, update_sessions_.size());
   1145   EXPECT_TRUE(characteristic->IsNotifying());
   1146   EXPECT_FALSE(update_sessions_[0]->IsActive());
   1147   EXPECT_TRUE(update_sessions_[1]->IsActive());
   1148 
   1149   // Clear the last session.
   1150   update_sessions_.clear();
   1151   EXPECT_TRUE(update_sessions_.empty());
   1152   EXPECT_FALSE(characteristic->IsNotifying());
   1153 
   1154   success_callback_count_ = 0;
   1155   observer.gatt_characteristic_value_changed_count_ = 0;
   1156 
   1157   // Enable notifications again.
   1158   characteristic->StartNotifySession(
   1159       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1160                  base::Unretained(this)),
   1161       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1162                  base::Unretained(this)));
   1163   EXPECT_EQ(0, success_callback_count_);
   1164   EXPECT_EQ(0, error_callback_count_);
   1165   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1166   EXPECT_TRUE(update_sessions_.empty());
   1167   EXPECT_TRUE(characteristic->IsNotifying());
   1168 
   1169   // Run the message loop. Notifications should begin.
   1170   base::MessageLoop::current()->Run();
   1171 
   1172   EXPECT_EQ(1, success_callback_count_);
   1173   EXPECT_EQ(0, error_callback_count_);
   1174   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1175   EXPECT_EQ(1U, update_sessions_.size());
   1176   EXPECT_TRUE(update_sessions_[0]->IsActive());
   1177   EXPECT_TRUE(characteristic->IsNotifying());
   1178 
   1179   // Check that notifications are happening.
   1180   base::MessageLoop::current()->Run();
   1181   EXPECT_GT(observer.gatt_characteristic_value_changed_count_, 1);
   1182 
   1183   // Request another session. This should return immediately.
   1184   characteristic->StartNotifySession(
   1185       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1186                  base::Unretained(this)),
   1187       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1188                  base::Unretained(this)));
   1189   EXPECT_EQ(2, success_callback_count_);
   1190   EXPECT_EQ(0, error_callback_count_);
   1191   EXPECT_EQ(2U, update_sessions_.size());
   1192   EXPECT_TRUE(update_sessions_[0]->IsActive());
   1193   EXPECT_TRUE(update_sessions_[1]->IsActive());
   1194   EXPECT_TRUE(characteristic->IsNotifying());
   1195 
   1196   // Hide the characteristic. The sessions should become inactive.
   1197   fake_bluetooth_gatt_characteristic_client_->HideHeartRateCharacteristics();
   1198   EXPECT_EQ(2U, update_sessions_.size());
   1199   EXPECT_FALSE(update_sessions_[0]->IsActive());
   1200   EXPECT_FALSE(update_sessions_[1]->IsActive());
   1201 }
   1202 
   1203 TEST_F(BluetoothGattChromeOSTest, NotifySessionsMadeInactive) {
   1204   fake_bluetooth_device_client_->CreateDevice(
   1205       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
   1206       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   1207   BluetoothDevice* device =
   1208       adapter_->GetDevice(FakeBluetoothDeviceClient::kLowEnergyAddress);
   1209   ASSERT_TRUE(device);
   1210 
   1211   TestObserver observer(adapter_);
   1212 
   1213   // Expose the fake Heart Rate service. This will asynchronously expose
   1214   // characteristics.
   1215   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
   1216       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   1217   ASSERT_EQ(1, observer.gatt_service_added_count_);
   1218 
   1219   BluetoothGattService* service =
   1220       device->GetGattService(observer.last_gatt_service_id_);
   1221 
   1222   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count_);
   1223 
   1224   // Run the message loop so that the characteristics appear.
   1225   base::MessageLoop::current()->Run();
   1226 
   1227   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
   1228       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
   1229           .value());
   1230   ASSERT_TRUE(characteristic);
   1231   EXPECT_FALSE(characteristic->IsNotifying());
   1232   EXPECT_TRUE(update_sessions_.empty());
   1233 
   1234   // Send several requests to start notifications.
   1235   characteristic->StartNotifySession(
   1236       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1237                  base::Unretained(this)),
   1238       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1239                  base::Unretained(this)));
   1240   characteristic->StartNotifySession(
   1241       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1242                  base::Unretained(this)),
   1243       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1244                  base::Unretained(this)));
   1245   characteristic->StartNotifySession(
   1246       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1247                  base::Unretained(this)),
   1248       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1249                  base::Unretained(this)));
   1250   characteristic->StartNotifySession(
   1251       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1252                  base::Unretained(this)),
   1253       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1254                  base::Unretained(this)));
   1255 
   1256   // The operation still hasn't completed but we should have received the first
   1257   // notification.
   1258   EXPECT_EQ(0, success_callback_count_);
   1259   EXPECT_EQ(0, error_callback_count_);
   1260   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1261   EXPECT_TRUE(characteristic->IsNotifying());
   1262   EXPECT_TRUE(update_sessions_.empty());
   1263 
   1264   // Run the main loop. The initial call should complete. The queued calls
   1265   // should succeed immediately.
   1266   base::MessageLoop::current()->Run();
   1267 
   1268   EXPECT_EQ(4, success_callback_count_);
   1269   EXPECT_EQ(0, error_callback_count_);
   1270   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1271   EXPECT_TRUE(characteristic->IsNotifying());
   1272   EXPECT_EQ(4U, update_sessions_.size());
   1273 
   1274   for (int i = 0; i < 4; i++)
   1275     EXPECT_TRUE(update_sessions_[0]->IsActive());
   1276 
   1277   // Stop notifications directly through the client. The sessions should get
   1278   // marked as inactive.
   1279   fake_bluetooth_gatt_characteristic_client_->StopNotify(
   1280       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath(),
   1281       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
   1282                  base::Unretained(this)),
   1283       base::Bind(&BluetoothGattChromeOSTest::DBusErrorCallback,
   1284                  base::Unretained(this)));
   1285   EXPECT_EQ(5, success_callback_count_);
   1286   EXPECT_EQ(0, error_callback_count_);
   1287   EXPECT_FALSE(characteristic->IsNotifying());
   1288   EXPECT_EQ(4U, update_sessions_.size());
   1289 
   1290   for (int i = 0; i < 4; i++)
   1291     EXPECT_FALSE(update_sessions_[0]->IsActive());
   1292 
   1293   // It should be possible to restart notifications and the call should reset
   1294   // the session count and make a request through the client.
   1295   update_sessions_.clear();
   1296   success_callback_count_ = 0;
   1297   observer.gatt_characteristic_value_changed_count_ = 0;
   1298   characteristic->StartNotifySession(
   1299       base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
   1300                  base::Unretained(this)),
   1301       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
   1302                  base::Unretained(this)));
   1303 
   1304   EXPECT_EQ(0, success_callback_count_);
   1305   EXPECT_EQ(0, error_callback_count_);
   1306   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1307   EXPECT_TRUE(characteristic->IsNotifying());
   1308   EXPECT_TRUE(update_sessions_.empty());
   1309 
   1310   base::MessageLoop::current()->Run();
   1311 
   1312   EXPECT_EQ(1, success_callback_count_);
   1313   EXPECT_EQ(0, error_callback_count_);
   1314   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count_);
   1315   EXPECT_TRUE(characteristic->IsNotifying());
   1316   EXPECT_EQ(1U, update_sessions_.size());
   1317   EXPECT_TRUE(update_sessions_[0]->IsActive());
   1318 }
   1319 
   1320 }  // namespace chromeos
   1321