bluetooth: Make IsGattServicesDiscoveryComplete virtual

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.cc

 // Copyright 2015 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 "content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 108 matching lines @@
 std::set<BluetoothUUID> GetUUIDs(
     const device::BluetoothDiscoveryFilter* filter) {
   std::set<BluetoothUUID> result;
   filter->GetUUIDs(result);
   return result;
 }
 
 // Notifies the adapter's observers that the services have been discovered.
 void NotifyServicesDiscovered(MockBluetoothAdapter* adapter,
                               MockBluetoothDevice* device) {
-  device->SetGattServicesDiscoveryComplete(true);
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
                     GattServicesDiscovered(adapter, device));
 }
 
 }  // namespace
 
 namespace content {
 
 // static
 scoped_refptr<BluetoothAdapter>
@@ skipping 300 matching lines @@
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetDelayedServicesDiscoveryAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   std::unique_ptr<NiceMockBluetoothDevice> device(
       GetHeartRateDevice(adapter.get()));
 
   MockBluetoothAdapter* adapter_ptr = adapter.get();
   MockBluetoothDevice* device_ptr = device.get();
 
-  // Override the previous mock implementation of CreateGattConnection that
-  // this a NotifyServicesDiscovered task. Instead thsi adapter will not post
-  // that task until GetGattServices is called.
-  ON_CALL(*device, CreateGattConnection(_, _))
-      .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
-          [adapter_ptr, device_ptr]() {
-            return base::WrapUnique(new NiceMockBluetoothGattConnection(
-                adapter_ptr, device_ptr->GetAddress()));
-          }));
-
-  ON_CALL(*device, GetGattServices())
+  // Override the previous mock implementation of
+  // IsGattServicesDiscoveryComplete so that the first time the function is
+  // called it returns false, adds a service and posts a task to notify
+  // the services have been discovered. Subsequent calls to the function
+  // will return true.
+  ON_CALL(*device, IsGattServicesDiscoveryComplete())
       .WillByDefault(Invoke([adapter_ptr, device_ptr] {
         std::vector<BluetoothGattService*> services =
             device_ptr->GetMockServices();
 
-        if (services.size() > 0) {
-          return services;
+        if (services.size() == 0) {
+          std::unique_ptr<NiceMockBluetoothGattService> heart_rate(
+              GetBaseGATTService(device_ptr, kHeartRateServiceUUID));
+
+          device_ptr->AddMockService(std::move(heart_rate));
+          base::ThreadTaskRunnerHandle::Get()->PostTask(
+              FROM_HERE,
+              base::Bind(&NotifyServicesDiscovered,
+                         base::RetainedRef(adapter_ptr), device_ptr));
+
+          DCHECK(services.size() == 0);
+          return false;
         }
 
-        std::unique_ptr<NiceMockBluetoothGattService> heart_rate(
-            GetBaseGATTService(device_ptr, kHeartRateServiceUUID));
-
-        device_ptr->AddMockService(std::move(heart_rate));
-        base::ThreadTaskRunnerHandle::Get()->PostTask(
-            FROM_HERE, base::Bind(&NotifyServicesDiscovered,
-                                  base::RetainedRef(adapter_ptr), device_ptr));
-
-        DCHECK(services.size() == 0);
-        return services;
+        return true;
       }));
 
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetHeartRateAdapter() {
@@ skipping 162 matching lines @@
     BluetoothDevice::UUIDList uuids,
     const std::string& address) {
   std::unique_ptr<NiceMockBluetoothDevice> device(
       GetBaseDevice(adapter, device_name, uuids, address));
 
   MockBluetoothDevice* device_ptr = device.get();
 
   ON_CALL(*device, CreateGattConnection(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, device_ptr]() {
-            base::ThreadTaskRunnerHandle::Get()->PostTask(
-                FROM_HERE, base::Bind(&NotifyServicesDiscovered,
-                                      base::RetainedRef(adapter), device_ptr));
             return base::WrapUnique(new NiceMockBluetoothGattConnection(
                 adapter, device_ptr->GetAddress()));
           }));
 
+  ON_CALL(*device, IsGattServicesDiscoveryComplete())
+      .WillByDefault(Return(true));
+
   return device;
 }
 
 // static
 std::unique_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetUnconnectableDevice(
     MockBluetoothAdapter* adapter,
     BluetoothDevice::ConnectErrorCode error_code,
     const std::string& device_name) {
   BluetoothDevice::UUIDList uuids;
@@ skipping 362 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content