bluetooth: bluez: Implement BluetoothRemoteGattCharacteristicBluez::SubscribeToNotifications and Un…

device/bluetooth/bluez/bluetooth_gatt_bluez_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 1398 matching lines @@
                  base::Unretained(this)));
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(update_sessions_.empty());
-  EXPECT_TRUE(characteristic->IsNotifying());
+  EXPECT_FALSE(characteristic->IsNotifying());
 
   // Run the main loop. The initial call should complete. The queued call should
   // succeed immediately.
   base::RunLoop().Run();
 
+  EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_EQ(3U, update_sessions_.size());
 
   // Notifications should be getting sent regularly now.
   base::RunLoop().Run();
   EXPECT_GT(observer.gatt_characteristic_value_changed_count(), 1);
 
   // Stop one of the sessions. The session should become inactive but the
   // characteristic should still be notifying.
   BluetoothGattNotifySession* session = update_sessions_[0];
   EXPECT_TRUE(session->IsActive());
   session->Stop(base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
                            base::Unretained(this)));
+
+  // Run message loop to stop the notify session.
+  base::RunLoop().Run();
+
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(session->IsActive());
   EXPECT_EQ(characteristic->GetIdentifier(),
             session->GetCharacteristicIdentifier());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Delete another session. Characteristic should still be notifying.
   update_sessions_.pop_back();
   EXPECT_EQ(2U, update_sessions_.size());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_FALSE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(update_sessions_[1]->IsActive());
 
   // Clear the last session.
   update_sessions_.clear();
   EXPECT_TRUE(update_sessions_.empty());
+
+  // Run message loop in order to do proper cleanup of sessions.
+  base::RunLoop().RunUntilIdle();
+
   EXPECT_FALSE(characteristic->IsNotifying());
 
   success_callback_count_ = 0;
   observer.Reset();
 
   // Enable notifications again.
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(update_sessions_.empty());
-  EXPECT_TRUE(characteristic->IsNotifying());
+  EXPECT_FALSE(characteristic->IsNotifying());
 
   // Run the message loop. Notifications should begin.
   base::RunLoop().Run();
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Check that notifications are happening.
   base::RunLoop().Run();
   EXPECT_GT(observer.gatt_characteristic_value_changed_count(), 1);
 
   // Request another session. This should return immediately.
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
+
+  // Run message loop to stop the notify session.
+  base::RunLoop().Run();
+
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(2U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(update_sessions_[1]->IsActive());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Hide the characteristic. The sessions should become inactive.
   fake_bluetooth_gatt_characteristic_client_->HideHeartRateCharacteristics();
   EXPECT_EQ(2U, update_sessions_.size());
@@ skipping 53 matching lines @@
       base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
 
   // The operation still hasn't completed but we should have received the first
   // notification.
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
-  EXPECT_TRUE(characteristic->IsNotifying());
+  EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   // Run the main loop. The initial call should complete. The queued calls
   // should succeed immediately.
   base::RunLoop().Run();
 
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(4U, update_sessions_.size());
 
   for (int i = 0; i < 4; i++)
     EXPECT_TRUE(update_sessions_[0]->IsActive());
 
   // Stop notifications directly through the client. The sessions should get
   // marked as inactive.
   fake_bluetooth_gatt_characteristic_client_->StopNotify(
       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath(),
       base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattBlueZTest::DBusErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(5, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
+
+  // Run message loop to stop the notify session.
+  base::RunLoop().RunUntilIdle();
+
   EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_EQ(4U, update_sessions_.size());
 
   for (int i = 0; i < 4; i++)
     EXPECT_FALSE(update_sessions_[0]->IsActive());
 
   // It should be possible to restart notifications and the call should reset
   // the session count and make a request through the client.
   update_sessions_.clear();
   success_callback_count_ = 0;
   observer.Reset();
   characteristic->StartNotifySession(
       base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
 
+  // Run message loop to start the notify session.
+  base::RunLoop().RunUntilIdle();
+
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
-  EXPECT_TRUE(characteristic->IsNotifying());
+  EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   base::RunLoop().Run();
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
 }
 
 }  // namespace bluez