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