Invoke GattDiscoveryCompleteForService by observing ServicesResolved property

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 250 matching lines @@
   EXPECT_TRUE(device->IsConnected());
   EXPECT_TRUE(gatt_conn_->IsConnected());
 
   fake_bluetooth_device_client_->RemoveDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_FALSE(gatt_conn_->IsConnected());
 }
 
 TEST_F(BluetoothGattBlueZTest, GattServiceAddedAndRemoved) {

[scheib, 2016/05/16 20:22:26]

Lots of test code here. Please point out code, or make new code, that has
services discovered before a BluetoothDeviceBlueZ is constructed -- testing the
BluetoothDeviceBlueZ::BluetoothDeviceBlueZ call to InitializeGattServiceMap
after services exist and services_resolved==true.

[Miao, 2016/05/17 18:08:27]

Removed the added lines in other tests and created two separated two tests for
two path to NotifyGattDiscoveryComplete.

   // Create a fake LE device. We store the device pointer here because this is a
   // test. It's unsafe to do this in production as the device might get deleted.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
+  bluez::FakeBluetoothDeviceClient::Properties* properties =
+      fake_bluetooth_device_client_->GetProperties(
+          dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.gatt_service_added_count());
   EXPECT_EQ(0, observer.gatt_service_removed_count());
+  EXPECT_EQ(0, observer.gatt_discovery_complete_count());
+  EXPECT_TRUE(device->GetGattServices().empty());
   EXPECT_TRUE(observer.last_gatt_service_id().empty());
   EXPECT_FALSE(observer.last_gatt_service_uuid().IsValid());
   EXPECT_TRUE(device->GetGattServices().empty());
 
   // Expose the fake Heart Rate Service.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+  // Notify that all services have been discovered.
+  properties->services_resolved.ReplaceValue(true);
   EXPECT_EQ(1, observer.gatt_service_added_count());
   EXPECT_EQ(0, observer.gatt_service_removed_count());
+  EXPECT_EQ(1, observer.gatt_discovery_complete_count());
   EXPECT_FALSE(observer.last_gatt_service_id().empty());
   EXPECT_EQ(1U, device->GetGattServices().size());
   EXPECT_EQ(BluetoothUUID(
                 bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
             observer.last_gatt_service_uuid());
 
   BluetoothRemoteGattService* service =
       device->GetGattService(observer.last_gatt_service_id());
   EXPECT_TRUE(service->IsPrimary());
   EXPECT_EQ(service, device->GetGattServices()[0]);
   EXPECT_EQ(service, device->GetGattService(service->GetIdentifier()));
 
   EXPECT_EQ(observer.last_gatt_service_uuid(), service->GetUUID());
 
   // Hide the service.
   observer.last_gatt_service_uuid() = BluetoothUUID();
   observer.last_gatt_service_id().clear();
   fake_bluetooth_gatt_service_client_->HideHeartRateService();
 
   EXPECT_EQ(1, observer.gatt_service_added_count());
   EXPECT_EQ(1, observer.gatt_service_removed_count());
+  EXPECT_EQ(1, observer.gatt_discovery_complete_count());
   EXPECT_FALSE(observer.last_gatt_service_id().empty());
   EXPECT_TRUE(device->GetGattServices().empty());
   EXPECT_EQ(BluetoothUUID(
                 bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
             observer.last_gatt_service_uuid());
 
   EXPECT_EQ(NULL, device->GetGattService(observer.last_gatt_service_id()));
 
   // Expose the service again.
   observer.last_gatt_service_uuid() = BluetoothUUID();
   observer.last_gatt_service_id().clear();
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+  // Notify that all services have been discovered.
+  properties->services_resolved.ReplaceValue(true);
+
   EXPECT_EQ(2, observer.gatt_service_added_count());
   EXPECT_EQ(1, observer.gatt_service_removed_count());
+  EXPECT_EQ(2, observer.gatt_discovery_complete_count());
   EXPECT_FALSE(observer.last_gatt_service_id().empty());
   EXPECT_EQ(1U, device->GetGattServices().size());
   EXPECT_EQ(BluetoothUUID(
                 bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
             observer.last_gatt_service_uuid());
 
   // The object |service| points to should have been deallocated. |device|
   // should contain a brand new instance.
   service = device->GetGattService(observer.last_gatt_service_id());
   EXPECT_EQ(service, device->GetGattServices()[0]);
   EXPECT_TRUE(service->IsPrimary());
 
   EXPECT_EQ(observer.last_gatt_service_uuid(), service->GetUUID());
 
   // Remove the device. The observer should be notified of the removed service.
   // |device| becomes invalid after this.
   observer.last_gatt_service_uuid() = BluetoothUUID();
   observer.last_gatt_service_id().clear();
   fake_bluetooth_device_client_->RemoveDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
 
   EXPECT_EQ(2, observer.gatt_service_added_count());
   EXPECT_EQ(2, observer.gatt_service_removed_count());
+  EXPECT_EQ(2, observer.gatt_discovery_complete_count());
   EXPECT_FALSE(observer.last_gatt_service_id().empty());
   EXPECT_EQ(BluetoothUUID(
                 bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
             observer.last_gatt_service_uuid());
   EXPECT_EQ(NULL, adapter_->GetDevice(
                       bluez::FakeBluetoothDeviceClient::kLowEnergyAddress));
 }
 
 TEST_F(BluetoothGattBlueZTest, ServicesDiscovered) {
   // Create a fake LE device. We store the device pointer here because this is a
   // test. It's unsafe to do this in production as the device might get deleted.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
 
   ASSERT_TRUE(device);
 
+  device->CreateGattConnection(
+      base::Bind(&BluetoothGattBlueZTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattBlueZTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(1, success_callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  EXPECT_TRUE(device->IsConnected());
+  ASSERT_TRUE(gatt_conn_.get());
+  EXPECT_TRUE(gatt_conn_->IsConnected());
+  EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress,
+            gatt_conn_->GetDeviceAddress());
+
   TestBluetoothAdapterObserver observer(adapter_);
 
+  EXPECT_EQ(0, observer.gatt_discovery_complete_count());
+  EXPECT_TRUE(device->GetGattServices().empty());
+
   // Expose the fake Heart Rate Service.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   // Notify that all services have been discovered.
   properties->services_resolved.ReplaceValue(true);
-
   EXPECT_TRUE(device->IsGattServicesDiscoveryComplete());
   EXPECT_EQ(1u, device->GetGattServices().size());
   EXPECT_EQ(device, observer.last_device());
+  EXPECT_EQ(1, observer.gatt_discovery_complete_count());
   EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress,
             observer.last_device_address());
 
   // Disconnect from the device:
   device->Disconnect(base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
                                 base::Unretained(this)),
                      base::Bind(&BluetoothGattBlueZTest::ErrorCallback,
                                 base::Unretained(this)));
   fake_bluetooth_gatt_service_client_->HideHeartRateService();
   properties->connected.ReplaceValue(false);
   properties->services_resolved.ReplaceValue(false);
 
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsGattServicesDiscoveryComplete());
+  EXPECT_EQ(1, observer.gatt_discovery_complete_count());
   EXPECT_EQ(0u, device->GetGattServices().size());
 
   // Verify that the device can be connected to again:
   device->CreateGattConnection(
       base::Bind(&BluetoothGattBlueZTest::GattConnectionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattBlueZTest::ConnectErrorCallback,
                  base::Unretained(this)));
   properties->connected.ReplaceValue(true);
   EXPECT_TRUE(device->IsConnected());
 
   // Verify that service discovery can be done again:
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+  // Notify that all services have been discovered.
   properties->services_resolved.ReplaceValue(true);
   EXPECT_TRUE(device->IsGattServicesDiscoveryComplete());
   EXPECT_EQ(1u, device->GetGattServices().size());
+  EXPECT_EQ(2, observer.gatt_discovery_complete_count());
+  EXPECT_FALSE(device->GetGattServices().empty());
+  EXPECT_EQ(1u, device->GetGattServices().size());
 }
 
 TEST_F(BluetoothGattBlueZTest, GattCharacteristicAddedAndRemoved) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
+  bluez::FakeBluetoothDeviceClient::Properties* properties =
+      fake_bluetooth_device_client_->GetProperties(
+          dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+  // Notify that all services have been discovered.
+  properties->services_resolved.ReplaceValue(true);
   ASSERT_EQ(1, observer.gatt_service_added_count());
 
   BluetoothRemoteGattService* service =
       device->GetGattService(observer.last_gatt_service_id());
 
   EXPECT_EQ(0, observer.gatt_service_changed_count());
-  EXPECT_EQ(0, observer.gatt_discovery_complete_count());
+  EXPECT_EQ(1, observer.gatt_discovery_complete_count());
   EXPECT_EQ(0, observer.gatt_characteristic_added_count());
   EXPECT_EQ(0, observer.gatt_characteristic_removed_count());
   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
 
   // 3 characteristics should appear. Only 1 of the characteristics sends
   // value changed signals. Service changed should be fired once for
@@ skipping 129 matching lines @@
   // objects that were already exposed.
   adapter_ = NULL;
   ASSERT_FALSE(device::BluetoothAdapterFactory::HasSharedInstanceForTesting());
 
   // Create the fake D-Bus objects.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+  bluez::FakeBluetoothDeviceClient::Properties* properties =
+      fake_bluetooth_device_client_->GetProperties(
+          dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+  // Notify that all services have been discovered.
+  properties->services_resolved.ReplaceValue(true);
   while (!fake_bluetooth_gatt_characteristic_client_->IsHeartRateVisible())
     base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_bluetooth_gatt_service_client_->IsHeartRateVisible());
   ASSERT_TRUE(fake_bluetooth_gatt_characteristic_client_->IsHeartRateVisible());
 
   // Create the adapter. This should create all the GATT objects.
   GetAdapter();
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
@@ skipping 689 matching lines @@
 
   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