bluetooth: Reject getPrimaryService(s) if frame is not connected

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 112 matching lines @@
   return result;
 }
 
 // Notifies the adapter's observers that the services have been discovered.
 void NotifyServicesDiscovered(MockBluetoothAdapter* adapter,
                               MockBluetoothDevice* device) {
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
                     GattServicesDiscovered(adapter, device));
 }
 
+// Notifies the adapter's observers that a device has changed.
+void NotifyDeviceChanged(MockBluetoothAdapter* adapter,
+                         MockBluetoothDevice* device) {
+  FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
+                    DeviceChanged(adapter, device));
+}
+
 }  // namespace
 
 namespace content {
 
 // static
 scoped_refptr<BluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetBluetoothAdapter(
     const std::string& fake_adapter_name) {
   if (fake_adapter_name == "BaseAdapter")
     return GetBaseAdapter();
@@ skipping 14 matching lines @@
   if (fake_adapter_name == "MissingServiceHeartRateAdapter")
     return GetMissingServiceHeartRateAdapter();
   if (fake_adapter_name == "MissingCharacteristicHeartRateAdapter")
     return GetMissingCharacteristicHeartRateAdapter();
   if (fake_adapter_name == "HeartRateAdapter")
     return GetHeartRateAdapter();
   if (fake_adapter_name == "TwoHeartRateServicesAdapter")
     return GetTwoHeartRateServicesAdapter();
   if (fake_adapter_name == "DisconnectingHeartRateAdapter")
     return GetDisconnectingHeartRateAdapter();
+  if (fake_adapter_name == "DisconnectingDuringServiceRetrievalAdapter")
+    return GetServicesDiscoveredAfterReconnectionAdapter(true /* disconnect */);
+  if (fake_adapter_name == "ServicesDiscoveredAfterReconnectionAdapter")
+    return GetServicesDiscoveredAfterReconnectionAdapter(
+        false /* disconnect */);
   if (fake_adapter_name == "BlacklistTestAdapter")
     return GetBlacklistTestAdapter();
   if (fake_adapter_name == "FailingConnectionsAdapter")
     return GetFailingConnectionsAdapter();
   if (fake_adapter_name == "FailingGATTOperationsAdapter")
     return GetFailingGATTOperationsAdapter();
   if (fake_adapter_name == "SecondDiscoveryFindsHeartRateAdapter")
     return GetSecondDiscoveryFindsHeartRateAdapter();
   if (fake_adapter_name == "DelayedServicesDiscoveryAdapter")
     return GetDelayedServicesDiscoveryAdapter();
@@ skipping 353 matching lines @@
 
   disconnection_service->AddMockCharacteristic(
       std::move(disconnection_characteristic));
   device->AddMockService(std::move(disconnection_service));
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
+scoped_refptr<NiceMockBluetoothAdapter> LayoutTestBluetoothAdapterProvider::
+    GetServicesDiscoveredAfterReconnectionAdapter(bool disconnect) {
+  scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
+  NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
+  std::unique_ptr<NiceMockBluetoothDevice> device(
+      GetHeartRateDevice(adapter.get()));
+  NiceMockBluetoothDevice* device_ptr = device.get();
+
+  // When called before IsGattDiscoveryComplete, run success callback with a new
+  // Gatt connection. When called after after IsGattDiscoveryComplete runs
+  // success callback with a new Gatt connection and notifies of services
+  // discovered.
+  ON_CALL(*device, CreateGattConnection(_, _))
+      .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
+          [adapter_ptr, device_ptr]() {
+            std::vector<BluetoothRemoteGattService*> services =
+                device_ptr->GetMockServices();
+
+            if (services.size() != 0) {
+              base::ThreadTaskRunnerHandle::Get()->PostTask(
+                  FROM_HERE,
+                  base::Bind(&NotifyServicesDiscovered,
+                             base::RetainedRef(adapter_ptr), device_ptr));
+            }
+
+            return base::MakeUnique<NiceMockBluetoothGattConnection>(
+                adapter_ptr, device_ptr->GetAddress());
+          }));
+
+  // The first time this function is called we:
+  // 1. Add a service (This indicates that this function has been called)
+  // 2. Disconnect the device.

[Jeffrey Yasskin, 2016/07/29 18:17:24]

*If |disconnect| is true, 

[ortuno, 2016/07/29 19:06:14]

Done.

+  // 3. Return false.
+  // The second time this function is called we just return true.
+  ON_CALL(*device, IsGattServicesDiscoveryComplete())
+      .WillByDefault(Invoke([adapter_ptr, device_ptr, disconnect] {
+        std::vector<BluetoothRemoteGattService*> services =
+            device_ptr->GetMockServices();
+        if (services.size() == 0) {
+          std::unique_ptr<NiceMockBluetoothGattService> heart_rate(
+              GetBaseGATTService("Heart Rate", device_ptr,
+                                 kHeartRateServiceUUID));
+
+          device_ptr->AddMockService(GetGenericAccessService(device_ptr));
+          device_ptr->AddMockService(
+              GetHeartRateService(adapter_ptr, device_ptr));
+
+          if (disconnect) {
+            device_ptr->SetConnected(false);
+            base::ThreadTaskRunnerHandle::Get()->PostTask(
+                FROM_HERE,
+                base::Bind(&NotifyDeviceChanged, base::RetainedRef(adapter_ptr),
+                           device_ptr));
+          }
+          DCHECK(services.size() == 0);
+          return false;
+        }
+
+        return true;
+      }));
+  adapter->AddMockDevice(std::move(device));
+
+  return adapter;
+}
+
+// static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetBlacklistTestAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kBlacklistTestServiceUUID));
   uuids.push_back(BluetoothUUID(kDeviceInformationServiceUUID));
   uuids.push_back(BluetoothUUID(kGenericAccessServiceUUID));
   uuids.push_back(BluetoothUUID(kHeartRateServiceUUID));
   uuids.push_back(BluetoothUUID(kHumanInterfaceDeviceServiceUUID));
@@ skipping 524 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content