bluetooth: android: Implement RetrieveGattConnectedDevicesWithFilter

device/bluetooth/bluetooth_adapter_unittest.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/bluetooth_adapter.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 18 matching lines @@
 #include "device/bluetooth/test/bluetooth_test_android.h"
 #elif defined(OS_MACOSX)
 #include "device/bluetooth/test/bluetooth_test_mac.h"
 #elif defined(OS_WIN)
 #include "device/bluetooth/test/bluetooth_test_win.h"
 #elif defined(OS_CHROMEOS) || defined(OS_LINUX)
 #include "device/bluetooth/test/bluetooth_test_bluez.h"
 #endif
 
 using device::BluetoothDevice;
+using UUIDSet = BluetoothDevice::UUIDSet;
+using DeviceToUUIDs = std::unordered_map<BluetoothDevice*, UUIDSet>;
 
 namespace device {
 
 class TestBluetoothAdapter : public BluetoothAdapter {
  public:
   TestBluetoothAdapter() {
   }
 
   std::string GetAddress() const override { return ""; }
 
@@ skipping 809 matching lines @@
   device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device);
   EXPECT_EQ(1u, adapter_->GetDevices().size());
   RemoveTimedOutDevices();
   EXPECT_EQ(0, observer.device_removed_count());
   EXPECT_EQ(1u, adapter_->GetDevices().size());
 }
 #endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
-#if defined(OS_MACOSX)
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
+// Make sure devices have a timestamp when they are added.
+TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDevice_Timestamp) {
+  if (!PlatformSupportsLowEnergy()) {
+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
+  InitWithFakeAdapter();
+  TestBluetoothAdapterObserver observer(adapter_);
+
+  SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
+  SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
+  BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
+      adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
+          discovery_filter);
+
+  EXPECT_EQ(2, observer.device_added_count());
+  EXPECT_EQ(0, observer.device_removed_count());
+  EXPECT_EQ(2u, adapter_->GetDevices().size());
+
+  observer.Reset();
+  RemoveTimedOutDevices();
+
+  EXPECT_EQ(0, observer.device_removed_count());
+  EXPECT_EQ(2u, adapter_->GetDevices().size());
+}
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
+
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with no service filter.
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceWithNoFilter) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_EQ(2u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    EXPECT_TRUE(pair.second.empty());
-  }
-  EXPECT_EQ(BluetoothDevice::UUIDSet({BluetoothUUID(kTestUUIDGenericAccess)}),
-            RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(2, observer.device_added_count());
   EXPECT_EQ(2u, adapter_->GetDevices().size());
+
+  BluetoothDevice* device1 = adapter_->GetDevice(kTestDeviceAddress1);
+  ASSERT_TRUE(device1);
+  BluetoothDevice* device2 = adapter_->GetDevice(kTestDeviceAddress2);
+  ASSERT_TRUE(device2);
+
+  EXPECT_EQ(DeviceToUUIDs({{device1, UUIDSet()}, {device2, UUIDSet()}}),
+            result);
+
+#if defined(OS_MACOSX)

[scheib, 2016/11/28 20:42:22]

RetrieveConnectedPeripheralServiceUUIDs is confusing to me, and I don't see why
Mac and Android need to differ in the mechanism used to validate that calls were
made all the way to the Mock OS components. Let's pick one of either returning
the set of UUIDs requested, or just counts of calls (as
manager_get_connected_devices_attempts_ does). Or, explain in code why these are
different.

+  EXPECT_EQ(UUIDSet({BluetoothUUID(kTestUUIDGenericAccess)}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with one service filter.
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceWithFilter) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
   device::BluetoothUUID heart_service_uuid =
       device::BluetoothUUID(kTestUUIDHeartRate);
   discovery_filter.AddUUID(heart_service_uuid);
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_EQ(1u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_EQ(kTestDeviceAddress2, pair.first->GetAddress());
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}), pair.second);
-  }
-  EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}),
-            RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(1, observer.device_added_count());
   EXPECT_EQ(1u, adapter_->GetDevices().size());
+
+  BluetoothDevice* device = adapter_->GetDevice(kTestDeviceAddress2);
+  ASSERT_TRUE(device);
+  EXPECT_EQ(DeviceToUUIDs({{device, UUIDSet({heart_service_uuid})}}), result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({heart_service_uuid}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with one service filter
 // that doesn't match.
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceWithWrongFilter) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
   discovery_filter.AddUUID(device::BluetoothUUID(kTestUUIDLinkLoss));
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_TRUE(result.empty());
-  EXPECT_EQ(
-      BluetoothDevice::UUIDSet({device::BluetoothUUID(kTestUUIDLinkLoss)}),
-      RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(0, observer.device_added_count());
   EXPECT_EQ(0u, adapter_->GetDevices().size());
+
+  EXPECT_TRUE(result.empty());
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({device::BluetoothUUID(kTestUUIDLinkLoss)}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with two service filters
 // that both match.
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceWithTwoFilters) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
   device::BluetoothUUID heart_service_uuid =
       device::BluetoothUUID(kTestUUIDHeartRate);
   discovery_filter.AddUUID(heart_service_uuid);
   device::BluetoothUUID generic_service_uuid =
       device::BluetoothUUID(kTestUUIDGenericAccess);
   discovery_filter.AddUUID(generic_service_uuid);
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_EQ(2u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    if (pair.first->GetAddress() == kTestDeviceAddress2) {
-      EXPECT_EQ(
-          BluetoothDevice::UUIDSet({heart_service_uuid, generic_service_uuid}),
-          pair.second);
-    } else if (pair.first->GetAddress() == kTestDeviceAddress1) {
-      EXPECT_EQ(BluetoothDevice::UUIDSet({generic_service_uuid}), pair.second);
-    } else {
-      // Unknown device.
-      EXPECT_TRUE(false);
-    }
-  }
-  EXPECT_EQ(
-      BluetoothDevice::UUIDSet({generic_service_uuid, heart_service_uuid}),
-      RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(2, observer.device_added_count());
   EXPECT_EQ(2u, adapter_->GetDevices().size());
+
+  BluetoothDevice* device1 = adapter_->GetDevice(kTestDeviceAddress1);
+  ASSERT_TRUE(device1);
+  BluetoothDevice* device2 = adapter_->GetDevice(kTestDeviceAddress2);
+  ASSERT_TRUE(device2);
+
+  EXPECT_EQ(
+      DeviceToUUIDs(
+          {{device1, UUIDSet({generic_service_uuid})},
+           {device2, UUIDSet({heart_service_uuid, generic_service_uuid})}}),
+      result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({generic_service_uuid, heart_service_uuid}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with one service filter
 // that one match device, and then
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() again.
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceTwice) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
   device::BluetoothUUID heart_service_uuid =
       device::BluetoothUUID(kTestUUIDHeartRate);
   discovery_filter.AddUUID(heart_service_uuid);
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_EQ(1u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_EQ(kTestDeviceAddress2, pair.first->GetAddress());
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}), pair.second);
-  }
-  EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}),
-            RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(1, observer.device_added_count());
   EXPECT_EQ(1u, adapter_->GetDevices().size());
 
+  BluetoothDevice* device = adapter_->GetDevice(kTestDeviceAddress2);
+  ASSERT_TRUE(device);
+  EXPECT_EQ(DeviceToUUIDs({{device, UUIDSet({heart_service_uuid})}}), result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({heart_service_uuid}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
+
   observer.Reset();
+#if defined(OS_MACOSX)
   ResetRetrieveConnectedPeripheralServiceUUIDs();
+#endif  // defined(OS_MACOSX)
+
   result = adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
       discovery_filter);
 
-  EXPECT_EQ(1u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_EQ(kTestDeviceAddress2, pair.first->GetAddress());
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}), pair.second);
-  }
-  EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}),
-            RetrieveConnectedPeripheralServiceUUIDs());
-
   EXPECT_EQ(0, observer.device_added_count());
   EXPECT_EQ(1u, adapter_->GetDevices().size());
+
+  EXPECT_EQ(DeviceToUUIDs({{device, UUIDSet({heart_service_uuid})}}), result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({heart_service_uuid}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(2, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
-#endif  // defined(OS_MACOSX)
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 }  // namespace device