Invoke GattDiscoveryCompleteForService by observing ServicesResolved property

device/bluetooth/dbus/fake_bluetooth_gatt_service_client.cc

 // Copyright 2014 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 "device/bluetooth/dbus/fake_bluetooth_gatt_service_client.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
+#include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_characteristic_client.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
 
 namespace {
 
 const int kExposeCharacteristicsDelayIntervalMs = 100;
+const int kToggleServicesResolvedPropertyDelayIntervalMs = 100;
 
 }  // namespace
 
 // static
 const char FakeBluetoothGattServiceClient::kHeartRateServicePathComponent[] =
     "service0000";
 const char FakeBluetoothGattServiceClient::kHeartRateServiceUUID[] =
     "0000180d-0000-1000-8000-00805f9b34fb";
 
 FakeBluetoothGattServiceClient::Properties::Properties(
@@ skipping 73 matching lines @@
   heart_rate_service_properties_->primary.ReplaceValue(true);
 
   NotifyServiceAdded(dbus::ObjectPath(heart_rate_service_path_));
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &FakeBluetoothGattServiceClient::ExposeHeartRateCharacteristics,
           weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kExposeCharacteristicsDelayIntervalMs));
+
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(

[rkc, 2016/05/17 18:38:50]

Why does this need to be delayed at all? Can PostTask suffice?

In tests we try not to use actual timing for anything since they tend to
introduce flakiness. The idea is that a 100ms delay should give the same result
as a 10s delay as the same as a 0ms delay.

[Miao, 2016/05/18 03:26:58]

I think PostTask is sufficient. The reason is the same as the above code, I was
trying to emulate the delay here. Considering the flakines, the PostDelayedTask
of exposing characteristics should be changed to PostTask as well.

+      FROM_HERE,
+      base::Bind(
+          &FakeBluetoothGattServiceClient::ToggleServicesResolvedProperty,
+          weak_ptr_factory_.GetWeakPtr(), device_path, true),
+      base::TimeDelta::FromMilliseconds(
+          kToggleServicesResolvedPropertyDelayIntervalMs));
 }
 
 void FakeBluetoothGattServiceClient::HideHeartRateService() {
   if (!IsHeartRateVisible()) {
     DCHECK(heart_rate_service_path_.empty());
     VLOG(1) << "Fake Heart Rate Service already hidden.";
     return;
   }
   VLOG(2) << "Hiding fake Heart Rate Service.";
   FakeBluetoothGattCharacteristicClient* char_client =
       static_cast<FakeBluetoothGattCharacteristicClient*>(
           bluez::BluezDBusManager::Get()
               ->GetBluetoothGattCharacteristicClient());
   char_client->HideHeartRateCharacteristics();
 
   // Notify observers before deleting the properties structure so that it
   // can be accessed from the observer method.
   NotifyServiceRemoved(dbus::ObjectPath(heart_rate_service_path_));
 
   heart_rate_service_properties_.reset();
   heart_rate_service_path_.clear();
 }
 
+void FakeBluetoothGattServiceClient::ExposeHeartRateServiceWithoutDelay(
+    const dbus::ObjectPath& device_path) {
+  if (IsHeartRateVisible()) {
+    DCHECK(!heart_rate_service_path_.empty());
+    VLOG(1) << "Fake Heart Rate Service already exposed.";
+    return;
+  }
+  VLOG(2) << "Exposing fake Heart Rate Service.";
+  heart_rate_service_path_ =
+      device_path.value() + "/" + kHeartRateServicePathComponent;
+  heart_rate_service_properties_.reset(new Properties(base::Bind(
+      &FakeBluetoothGattServiceClient::OnPropertyChanged,
+      base::Unretained(this), dbus::ObjectPath(heart_rate_service_path_))));
+  heart_rate_service_properties_->uuid.ReplaceValue(kHeartRateServiceUUID);
+  heart_rate_service_properties_->device.ReplaceValue(device_path);
+  heart_rate_service_properties_->primary.ReplaceValue(true);
+
+  NotifyServiceAdded(dbus::ObjectPath(heart_rate_service_path_));
+
+  static_cast<FakeBluetoothGattCharacteristicClient*>(
+      bluez::BluezDBusManager::Get()->GetBluetoothGattCharacteristicClient())
+      ->ExposeHeartRateCharacteristics(
+          dbus::ObjectPath(heart_rate_service_path_));
+
+  ToggleServicesResolvedProperty(device_path, true);
+}
+
 bool FakeBluetoothGattServiceClient::IsHeartRateVisible() const {
   return !!heart_rate_service_properties_.get();
 }
 
 dbus::ObjectPath FakeBluetoothGattServiceClient::GetHeartRateServicePath()
     const {
   return dbus::ObjectPath(heart_rate_service_path_);
 }
 
 void FakeBluetoothGattServiceClient::OnPropertyChanged(
@@ skipping 25 matching lines @@
     return;
   }
   FakeBluetoothGattCharacteristicClient* char_client =
       static_cast<FakeBluetoothGattCharacteristicClient*>(
           bluez::BluezDBusManager::Get()
               ->GetBluetoothGattCharacteristicClient());
   char_client->ExposeHeartRateCharacteristics(
       dbus::ObjectPath(heart_rate_service_path_));
 }
 
+void FakeBluetoothGattServiceClient::ToggleServicesResolvedProperty(
+    const dbus::ObjectPath& object_path,
+    bool resolved) {
+  DCHECK(object_path.IsValid());
+
+  VLOG(2) << "Toggle the ServicesResolved property to " << resolved
+          << " of device " << object_path.value();
+  FakeBluetoothDeviceClient* device = static_cast<FakeBluetoothDeviceClient*>(
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient());
+  // Notify on service discovery complete.
+  device->GetProperties(object_path)->services_resolved.ReplaceValue(true);
+}
+
 }  // namespace bluez