bluetooth: Only add new devices, connected devices and devices that changed.

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 105 matching lines @@
   return NULL;
 }
 
 std::set<BluetoothUUID> GetUUIDs(
     const device::BluetoothDiscoveryFilter* filter) {
   std::set<BluetoothUUID> result;
   filter->GetUUIDs(result);
   return result;
 }
 
+// Notifies the adapter's observers for each device id the adapter.
+void NotifyDevicesAdded(MockBluetoothAdapter* adapter) {
+  for (BluetoothDevice* device : adapter->GetMockDevices()) {
+    FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
+                      DeviceAdded(adapter, device));
+  }
+}
+
 // 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) {
@@ skipping 45 matching lines @@
     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 == "DeviceEventAdapter")
+    return GetDeviceEventAdapter();
   if (fake_adapter_name == "DelayedServicesDiscoveryAdapter")
     return GetDelayedServicesDiscoveryAdapter();
   if (fake_adapter_name.empty())
     return nullptr;
   // New adapters that can be used when fuzzing the Web Bluetooth API
   // should also be added to
   // src/third_party/WebKit/Source/modules/
   //   bluetooth/testing/clusterfuzz/constraints.py.
 
   NOTREACHED() << fake_adapter_name;
@@ skipping 55 matching lines @@
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPresentAdapter());
   ON_CALL(*adapter, IsPowered()).WillByDefault(Return(false));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetScanFilterCheckingAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
+  MockBluetoothAdapter* adapter_ptr = adapter.get();
 
   // This fails the test with an error message listing actual and expected UUIDs
   // if StartDiscoverySessionWithFilter() is called with the wrong argument.
   EXPECT_CALL(
       *adapter,
       StartDiscoverySessionWithFilterRaw(
           ResultOf(&GetUUIDs, ElementsAre(BluetoothUUID(kGlucoseServiceUUID),
                                           BluetoothUUID(kHeartRateServiceUUID),
                                           BluetoothUUID(kBatteryServiceUUID))),
           _, _))
-      .WillRepeatedly(RunCallbackWithResult<1 /* success_callback */>(
-          []() { return GetDiscoverySession(); }));
+      .WillRepeatedly(
+          RunCallbackWithResult<1 /* success_callback */>([adapter_ptr]() {
+            base::ThreadTaskRunnerHandle::Get()->PostTask(
+                FROM_HERE, base::Bind(&NotifyDevicesAdded,
+                                      base::RetainedRef(adapter_ptr)));
+
+            return GetDiscoverySession();
+          }));
 
   // Any unexpected call results in the failure callback.
   ON_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>());
 
   // We need to add a device otherwise requestDevice would reject.
   adapter->AddMockDevice(GetBatteryDevice(adapter.get()));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailStartDiscoveryAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
 
   ON_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>());
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetEmptyAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
 
+  MockBluetoothAdapter* adapter_ptr = adapter.get();
+
   ON_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
-      .WillByDefault(RunCallbackWithResult<1 /* success_callback */>(
-          []() { return GetDiscoverySession(); }));
+      .WillByDefault(
+          RunCallbackWithResult<1 /* success_callback */>([adapter_ptr]() {
+            base::ThreadTaskRunnerHandle::Get()->PostTask(
+                FROM_HERE, base::Bind(&NotifyDevicesAdded,
+                                      base::RetainedRef(adapter_ptr)));
+
+            return GetDiscoverySession();
+          }));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetGlucoseHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetHeartRateDevice(adapter.get()));
@@ skipping 31 matching lines @@
   EXPECT_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillOnce(RunCallbackWithResult<1 /* success_callback */>(
           []() { return GetDiscoverySession(); }))
       .WillOnce(
           RunCallbackWithResult<1 /* success_callback */>([adapter_ptr]() {
             // In the second discovery session, have the adapter discover a new
             // device, shortly after the session starts.
             base::ThreadTaskRunnerHandle::Get()->PostTask(
                 FROM_HERE,
                 base::Bind(&AddDevice, make_scoped_refptr(adapter_ptr),
-
                            base::Passed(GetHeartRateDevice(adapter_ptr))));
             return GetDiscoverySession();
           }));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
+LayoutTestBluetoothAdapterProvider::GetDeviceEventAdapter() {
+  scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
+  NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
+
+  // Add ConnectedHeartRateDevice.
+  std::unique_ptr<NiceMockBluetoothDevice> connected_hr(GetBaseDevice(
+      adapter.get(), "Connected Heart Rate Device",
+      {BluetoothUUID(kHeartRateServiceUUID)}, makeMACAddress(0x0)));
+  connected_hr->SetConnected(true);
+  adapter->AddMockDevice(std::move(connected_hr));
+
+  // Add ChangingBatteryDevice with no uuids.
+  std::unique_ptr<NiceMockBluetoothDevice> changing_battery(
+      GetBaseDevice(adapter.get(), "Changing Battery Device",
+                    BluetoothDevice::UUIDList(), makeMACAddress(0x1)));
+  changing_battery->SetConnected(false);
+
+  NiceMockBluetoothDevice* changing_battery_ptr = changing_battery.get();
+  adapter->AddMockDevice(std::move(changing_battery));
+
+  // Add Non Connected Tx Power Device.
+  std::unique_ptr<NiceMockBluetoothDevice> non_connected_tx_power(
+      GetBaseDevice(adapter.get(), "Non Connected Tx Power Device",
+                    {BluetoothUUID(kTxPowerServiceUUID)}, makeMACAddress(0x2)));
+  non_connected_tx_power->SetConnected(false);
+  adapter->AddMockDevice(std::move(non_connected_tx_power));
+
+  // Add Discovery Generic Access Device with no uuids.
+  std::unique_ptr<NiceMockBluetoothDevice> discovery_generic_access(
+      GetBaseDevice(adapter.get(), "Discovery Generic Access Device",
+                    BluetoothDevice::UUIDList(), makeMACAddress(0x3)));
+  discovery_generic_access->SetConnected(true);
+
+  NiceMockBluetoothDevice* discovery_generic_access_ptr =
+      discovery_generic_access.get();
+  adapter->AddMockDevice(std::move(discovery_generic_access));
+
+  ON_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
+      .WillByDefault(RunCallbackWithResult<1 /* success_callback */>(
+          [adapter_ptr, changing_battery_ptr, discovery_generic_access_ptr]() {
+            if (adapter_ptr->GetDevices().size() == 4) {
+              // Post task to add NewGlucoseDevice.
+              std::unique_ptr<NiceMockBluetoothDevice> glucose_device(
+                  GetBaseDevice(adapter_ptr, "New Glucose Device",
+                                {BluetoothUUID(kGlucoseServiceUUID)},
+                                makeMACAddress(0x4)));
+
+              base::ThreadTaskRunnerHandle::Get()->PostTask(
+                  FROM_HERE,
+                  base::Bind(&AddDevice, make_scoped_refptr(adapter_ptr),
+                             base::Passed(&glucose_device)));
+
+              // Add uuid and notify of device changed.
+              changing_battery_ptr->AddUUID(BluetoothUUID(kBatteryServiceUUID));
+              base::ThreadTaskRunnerHandle::Get()->PostTask(
+                  FROM_HERE, base::Bind(&NotifyDeviceChanged,
+                                        base::RetainedRef(adapter_ptr),
+                                        changing_battery_ptr));
+
+              // Add uuid and notify of services discovered.
+              discovery_generic_access_ptr->AddUUID(
+                  BluetoothUUID(kGenericAccessServiceUUID));
+              base::ThreadTaskRunnerHandle::Get()->PostTask(
+                  FROM_HERE, base::Bind(&NotifyServicesDiscovered,
+                                        base::RetainedRef(adapter_ptr),
+                                        discovery_generic_access_ptr));
+            }
+            return GetDiscoverySession();
+          }));
+
+  return adapter;
+}
+
+// static
+scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetMissingServiceHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetHeartRateDevice(adapter.get()));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
@@ skipping 367 matching lines @@
 
 // static
 std::unique_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetBaseDevice(
     MockBluetoothAdapter* adapter,
     const char* device_name,
     device::BluetoothDevice::UUIDList uuids,
     const std::string& address) {
   std::unique_ptr<NiceMockBluetoothDevice> device(new NiceMockBluetoothDevice(
       adapter, 0x1F00 /* Bluetooth class */, device_name, address,
-      true /* paired */, true /* connected */));
+      false /* paired */, false /* connected */));
 
-  ON_CALL(*device, GetUUIDs()).WillByDefault(Return(uuids));
+  for (const auto& uuid : uuids) {
+    device->AddUUID(uuid);
+  }
 
   // Using Invoke allows the device returned from this method to be futher
   // modified and have more services added to it. The call to ::GetGattServices
   // will invoke ::GetMockServices, returning all services added up to that
   // time.
   ON_CALL(*device, GetGattServices())
       .WillByDefault(
           Invoke(device.get(), &MockBluetoothDevice::GetMockServices));
   // The call to BluetoothDevice::GetGattService will invoke ::GetMockService
   // which returns a service matching the identifier provided if the service
@@ skipping 449 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content