bluetooth: Post a task when sending GATT events to simulate another thread.

device/bluetooth/bluetooth_remote_gatt_descriptor_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 "base/run_loop.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "device/bluetooth/test/bluetooth_test_android.h"
 #elif defined(OS_MACOSX)
 #include "device/bluetooth/test/bluetooth_test_mac.h"
 #endif
 
 namespace device {
 
 #if defined(OS_ANDROID) || defined(OS_MACOSX)
 class BluetoothRemoteGattDescriptorTest : public BluetoothTest {
  public:
   // Creates adapter_, device_, service_, characteristic_,
   // descriptor1_, & descriptor2_.
   void FakeDescriptorBoilerplate() {
     InitWithFakeAdapter();
     StartLowEnergyDiscoverySession();
     device_ = SimulateLowEnergyDevice(3);
     device_->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                   GetConnectErrorCallback(Call::NOT_EXPECTED));
     SimulateGattConnection(device_);
+    base::RunLoop().RunUntilIdle();
     std::vector<std::string> services;
     std::string uuid("00000000-0000-1000-8000-00805f9b34fb");
     services.push_back(uuid);
     SimulateGattServicesDiscovered(device_, services);
+    base::RunLoop().RunUntilIdle();
     ASSERT_EQ(1u, device_->GetGattServices().size());
     service_ = device_->GetGattServices()[0];
     SimulateGattCharacteristic(service_, uuid, 0);
     ASSERT_EQ(1u, service_->GetCharacteristics().size());
     characteristic_ = service_->GetCharacteristics()[0];
     SimulateGattDescriptor(characteristic_,
                            "00000001-0000-1000-8000-00805f9b34fb");
     SimulateGattDescriptor(characteristic_,
                            "00000002-0000-1000-8000-00805f9b34fb");
     ASSERT_EQ(2u, characteristic_->GetDescriptors().size());
@@ skipping 20 matching lines @@
   StartLowEnergyDiscoverySession();
   // 2 devices to verify that descriptors on them have distinct IDs.
   BluetoothDevice* device1 = SimulateLowEnergyDevice(3);
   BluetoothDevice* device2 = SimulateLowEnergyDevice(4);
   device1->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                 GetConnectErrorCallback(Call::NOT_EXPECTED));
   device2->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                 GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device1);
   SimulateGattConnection(device2);
+  base::RunLoop().RunUntilIdle();
 
   // 3 services (all with same UUID).
   //   1 on the first device (to test characteristic instances across devices).
   //   2 on the second device (to test same device, multiple service instances).
   std::vector<std::string> services;
   std::string uuid = "00000000-0000-1000-8000-00805f9b34fb";
   services.push_back(uuid);
   SimulateGattServicesDiscovered(device1, services);
+  base::RunLoop().RunUntilIdle();
   services.push_back(uuid);
   SimulateGattServicesDiscovered(device2, services);
+  base::RunLoop().RunUntilIdle();
   BluetoothRemoteGattService* service1 = device1->GetGattServices()[0];
   BluetoothRemoteGattService* service2 = device2->GetGattServices()[0];
   BluetoothRemoteGattService* service3 = device2->GetGattServices()[1];
   // 6 characteristics (same UUID), 2 on each service.
   SimulateGattCharacteristic(service1, uuid, /* properties */ 0);
   SimulateGattCharacteristic(service1, uuid, /* properties */ 0);
   SimulateGattCharacteristic(service2, uuid, /* properties */ 0);
   SimulateGattCharacteristic(service2, uuid, /* properties */ 0);
   SimulateGattCharacteristic(service3, uuid, /* properties */ 0);
   SimulateGattCharacteristic(service3, uuid, /* properties */ 0);
@@ skipping 50 matching lines @@
   }
   InitWithFakeAdapter();
   StartLowEnergyDiscoverySession();
   BluetoothDevice* device = SimulateLowEnergyDevice(3);
   device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device);
   std::vector<std::string> services;
   services.push_back("00000000-0000-1000-8000-00805f9b34fb");
   SimulateGattServicesDiscovered(device, services);
+  base::RunLoop().RunUntilIdle();
   ASSERT_EQ(1u, device->GetGattServices().size());
   BluetoothRemoteGattService* service = device->GetGattServices()[0];
 
   SimulateGattCharacteristic(service, "00000000-0000-1000-8000-00805f9b34fb",
                              /* properties */ 0);
   ASSERT_EQ(1u, service->GetCharacteristics().size());
   BluetoothRemoteGattCharacteristic* characteristic =
       service->GetCharacteristics()[0];
 
   // Create 2 descriptors.
@@ skipping 21 matching lines @@
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor and GetValue with empty value buffer.
 TEST_F(BluetoothRemoteGattDescriptorTest, ReadRemoteDescriptor_Empty) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_read_descriptor_attempts_);
   std::vector<uint8_t> empty_vector;
   SimulateGattDescriptorRead(descriptor1_, empty_vector);
+  base::RunLoop().RunUntilIdle();
 
   // Duplicate read reported from OS shouldn't cause a problem:
   SimulateGattDescriptorRead(descriptor1_, empty_vector);
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(empty_vector, last_read_value_);
   EXPECT_EQ(empty_vector, descriptor1_->GetValue());
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests WriteRemoteDescriptor with empty value buffer.
 TEST_F(BluetoothRemoteGattDescriptorTest, WriteRemoteDescriptor_Empty) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   std::vector<uint8_t> empty_vector;
   descriptor1_->WriteRemoteDescriptor(empty_vector, GetCallback(Call::EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_write_descriptor_attempts_);
   SimulateGattDescriptorWrite(descriptor1_);
+  base::RunLoop().RunUntilIdle();
 
   // Duplicate write reported from OS shouldn't cause a problem:
   SimulateGattDescriptorWrite(descriptor1_);
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(empty_vector, last_write_value_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor completing after Chrome objects are deleted.
 TEST_F(BluetoothRemoteGattDescriptorTest, ReadRemoteDescriptor_AfterDeleted) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::NOT_EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
 
   RememberDescriptorForSubsequentAction(descriptor1_);
   DeleteDevice(device_);  // TODO(576906) delete only the descriptor.
 
   std::vector<uint8_t> empty_vector;
   SimulateGattDescriptorRead(/* use remembered descriptor */ nullptr,
                              empty_vector);
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE("Did not crash!");
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests WriteRemoteDescriptor completing after Chrome objects are deleted.
 TEST_F(BluetoothRemoteGattDescriptorTest, WriteRemoteDescriptor_AfterDeleted) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   std::vector<uint8_t> empty_vector;
   descriptor1_->WriteRemoteDescriptor(empty_vector,
                                       GetCallback(Call::NOT_EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
 
   RememberDescriptorForSubsequentAction(descriptor1_);
   DeleteDevice(device_);  // TODO(576906) delete only the descriptor.
 
   SimulateGattDescriptorWrite(/* use remembered descriptor */ nullptr);
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE("Did not crash!");
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor and GetValue with non-empty value buffer.
 TEST_F(BluetoothRemoteGattDescriptorTest, ReadRemoteDescriptor) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_read_descriptor_attempts_);
 
   uint8_t values[] = {0, 1, 2, 3, 4, 0xf, 0xf0, 0xff};
   std::vector<uint8_t> test_vector(values, values + arraysize(values));
   SimulateGattDescriptorRead(descriptor1_, test_vector);
+  base::RunLoop().RunUntilIdle();
 
   // Duplicate read reported from OS shouldn't cause a problem:
   std::vector<uint8_t> empty_vector;
   SimulateGattDescriptorRead(descriptor1_, empty_vector);
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(test_vector, last_read_value_);
   EXPECT_EQ(test_vector, descriptor1_->GetValue());
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests WriteRemoteDescriptor with non-empty value buffer.
 TEST_F(BluetoothRemoteGattDescriptorTest, WriteRemoteDescriptor) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   uint8_t values[] = {0, 1, 2, 3, 4, 0xf, 0xf0, 0xff};
   std::vector<uint8_t> test_vector(values, values + arraysize(values));
   descriptor1_->WriteRemoteDescriptor(test_vector, GetCallback(Call::EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_write_descriptor_attempts_);
 
   SimulateGattDescriptorWrite(descriptor1_);
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(test_vector, last_write_value_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor and GetValue multiple times.
 TEST_F(BluetoothRemoteGattDescriptorTest, ReadRemoteDescriptor_Twice) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_read_descriptor_attempts_);
 
   uint8_t values[] = {0, 1, 2, 3, 4, 0xf, 0xf0, 0xff};
   std::vector<uint8_t> test_vector(values, values + arraysize(values));
   SimulateGattDescriptorRead(descriptor1_, test_vector);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(test_vector, last_read_value_);
   EXPECT_EQ(test_vector, descriptor1_->GetValue());
 
   // Read again, with different value:
   ResetEventCounts();
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_read_descriptor_attempts_);
   std::vector<uint8_t> empty_vector;
   SimulateGattDescriptorRead(descriptor1_, empty_vector);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(empty_vector, last_read_value_);
   EXPECT_EQ(empty_vector, descriptor1_->GetValue());
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests WriteRemoteDescriptor multiple times.
 TEST_F(BluetoothRemoteGattDescriptorTest, WriteRemoteDescriptor_Twice) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   uint8_t values[] = {0, 1, 2, 3, 4, 0xf, 0xf0, 0xff};
   std::vector<uint8_t> test_vector(values, values + arraysize(values));
   descriptor1_->WriteRemoteDescriptor(test_vector, GetCallback(Call::EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_write_descriptor_attempts_);
 
   SimulateGattDescriptorWrite(descriptor1_);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(test_vector, last_write_value_);
 
   // Write again, with different value:
   ResetEventCounts();
   std::vector<uint8_t> empty_vector;
   descriptor1_->WriteRemoteDescriptor(empty_vector, GetCallback(Call::EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_write_descriptor_attempts_);
   SimulateGattDescriptorWrite(descriptor1_);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(empty_vector, last_write_value_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor on two descriptors.
 TEST_F(BluetoothRemoteGattDescriptorTest,
        ReadRemoteDescriptor_MultipleDescriptors) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   descriptor2_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(2, gatt_read_descriptor_attempts_);
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   std::vector<uint8_t> test_vector1;
   test_vector1.push_back(111);
   SimulateGattDescriptorRead(descriptor1_, test_vector1);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(test_vector1, last_read_value_);
 
   std::vector<uint8_t> test_vector2;
   test_vector2.push_back(222);
   SimulateGattDescriptorRead(descriptor2_, test_vector2);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(test_vector2, last_read_value_);
 
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(test_vector1, descriptor1_->GetValue());
   EXPECT_EQ(test_vector2, descriptor2_->GetValue());
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
@@ skipping 13 matching lines @@
   descriptor2_->WriteRemoteDescriptor(test_vector2, GetCallback(Call::EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(test_vector2, last_write_value_);
 
   EXPECT_EQ(2, gatt_write_descriptor_attempts_);
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   SimulateGattDescriptorWrite(descriptor1_);
   SimulateGattDescriptorWrite(descriptor2_);
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor asynchronous error.
 TEST_F(BluetoothRemoteGattDescriptorTest, ReadError) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::NOT_EXPECTED),
                                      GetGattErrorCallback(Call::EXPECTED));
   SimulateGattDescriptorReadError(
       descriptor1_, BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH);
   SimulateGattDescriptorReadError(
       descriptor1_, BluetoothRemoteGattService::GATT_ERROR_FAILED);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH,
             last_gatt_error_code_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests WriteRemoteDescriptor asynchronous error.
 TEST_F(BluetoothRemoteGattDescriptorTest, WriteError) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   std::vector<uint8_t> empty_vector;
   descriptor1_->WriteRemoteDescriptor(empty_vector,
                                       GetCallback(Call::NOT_EXPECTED),
                                       GetGattErrorCallback(Call::EXPECTED));
   SimulateGattDescriptorWriteError(
       descriptor1_, BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH);
   SimulateGattDescriptorWriteError(
       descriptor1_, BluetoothRemoteGattService::GATT_ERROR_FAILED);
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH,
             last_gatt_error_code_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor synchronous error.
 TEST_F(BluetoothRemoteGattDescriptorTest, ReadSynchronousError) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   SimulateGattDescriptorReadWillFailSynchronouslyOnce(descriptor1_);
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::NOT_EXPECTED),
                                      GetGattErrorCallback(Call::EXPECTED));
   EXPECT_EQ(0, gatt_read_descriptor_attempts_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothRemoteGattService::GATT_ERROR_FAILED,
             last_gatt_error_code_);
 
   // After failing once, can succeed:
   ResetEventCounts();
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_read_descriptor_attempts_);
   std::vector<uint8_t> empty_vector;
   SimulateGattDescriptorRead(descriptor1_, empty_vector);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests WriteRemoteDescriptor synchronous error.
 TEST_F(BluetoothRemoteGattDescriptorTest, WriteSynchronousError) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   SimulateGattDescriptorWriteWillFailSynchronouslyOnce(descriptor1_);
   std::vector<uint8_t> empty_vector;
   descriptor1_->WriteRemoteDescriptor(empty_vector,
                                       GetCallback(Call::NOT_EXPECTED),
                                       GetGattErrorCallback(Call::EXPECTED));
   EXPECT_EQ(0, gatt_write_descriptor_attempts_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothRemoteGattService::GATT_ERROR_FAILED,
             last_gatt_error_code_);
 
   // After failing once, can succeed:
   ResetEventCounts();
   descriptor1_->WriteRemoteDescriptor(empty_vector, GetCallback(Call::EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
   EXPECT_EQ(1, gatt_write_descriptor_attempts_);
   SimulateGattDescriptorWrite(descriptor1_);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor error with a pending read operation.
 TEST_F(BluetoothRemoteGattDescriptorTest, ReadRemoteDescriptor_ReadPending) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::NOT_EXPECTED),
                                      GetGattErrorCallback(Call::EXPECTED));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS,
             last_gatt_error_code_);
 
   // Initial read should still succeed:
   ResetEventCounts();
   std::vector<uint8_t> empty_vector;
   SimulateGattDescriptorRead(descriptor1_, empty_vector);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests WriteRemoteDescriptor error with a pending write operation.
 TEST_F(BluetoothRemoteGattDescriptorTest, WriteRemoteDescriptor_WritePending) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   std::vector<uint8_t> empty_vector;
   descriptor1_->WriteRemoteDescriptor(empty_vector, GetCallback(Call::EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
   descriptor1_->WriteRemoteDescriptor(empty_vector,
                                       GetCallback(Call::NOT_EXPECTED),
                                       GetGattErrorCallback(Call::EXPECTED));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS,
             last_gatt_error_code_);
 
   // Initial write should still succeed:
   ResetEventCounts();
   SimulateGattDescriptorWrite(descriptor1_);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests ReadRemoteDescriptor error with a pending write operation.
 TEST_F(BluetoothRemoteGattDescriptorTest, ReadRemoteDescriptor_WritePending) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   std::vector<uint8_t> empty_vector;
   descriptor1_->WriteRemoteDescriptor(empty_vector, GetCallback(Call::EXPECTED),
                                       GetGattErrorCallback(Call::NOT_EXPECTED));
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::NOT_EXPECTED),
                                      GetGattErrorCallback(Call::EXPECTED));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS,
             last_gatt_error_code_);
 
   // Initial write should still succeed:
   ResetEventCounts();
   SimulateGattDescriptorWrite(descriptor1_);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID)
 // Tests WriteRemoteDescriptor error with a pending Read operation.
 TEST_F(BluetoothRemoteGattDescriptorTest, WriteRemoteDescriptor_ReadPending) {
   ASSERT_NO_FATAL_FAILURE(FakeDescriptorBoilerplate());
 
   std::vector<uint8_t> empty_vector;
   descriptor1_->ReadRemoteDescriptor(GetReadValueCallback(Call::EXPECTED),
                                      GetGattErrorCallback(Call::NOT_EXPECTED));
   descriptor1_->WriteRemoteDescriptor(empty_vector,
                                       GetCallback(Call::NOT_EXPECTED),
                                       GetGattErrorCallback(Call::EXPECTED));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS,
             last_gatt_error_code_);
 
   // Initial read should still succeed:
   ResetEventCounts();
   SimulateGattDescriptorRead(descriptor1_, empty_vector);
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace device