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) {

[scheib, 2016/04/20 17:50:35]

This request of mine will make the code diff larger -- but will make the code
easier to read. Please make the code ordering follow the chronological order.
The first response of false and adding services should be before the return
true. That way the comment that describes what happens and the code read
chronologically. aka make this
  if (services.size() == 0)
  ...
  else return true.

[ortuno, 2016/04/20 18:03:19]

Done.

-          return services;
+          return true;
         }
 
         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 false;
       }));
 
   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