bluetooth: bluez: Implement RetrieveGattConnectedDevicesWithDiscoveryFilter

device/bluetooth/bluez/bluetooth_gatt_bluez_unittest.cc

 // Copyright 2016 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
+#include "device/bluetooth/bluetooth_discovery_filter.h"
 #include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "device/bluetooth/dbus/fake_bluetooth_adapter_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_agent_manager_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_characteristic_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_descriptor_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_service_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_input_client.h"
 #include "device/bluetooth/test/test_bluetooth_adapter_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
+using device::BluetoothDiscoveryFilter;
 using device::BluetoothRemoteGattCharacteristic;
 using device::BluetoothGattConnection;
 using device::BluetoothRemoteGattDescriptor;
 using device::BluetoothRemoteGattService;
 using device::BluetoothGattNotifySession;
 using device::BluetoothUUID;
 using device::TestBluetoothAdapterObserver;
 
+using UUIDSet = device::BluetoothDevice::UUIDSet;
+
+typedef std::unordered_map<device::BluetoothDevice*,
+                           device::BluetoothDevice::UUIDSet>
+    DeviceToUUIDs;
+
 namespace bluez {
 
 namespace {
 
+const BluetoothUUID kGenericAccessServiceUUID(
+    bluez::FakeBluetoothGattServiceClient::kGenericAccessServiceUUID);
+const BluetoothUUID kBatteryServiceUUID(
+    bluez::FakeBluetoothGattServiceClient::kBatteryServiceUUID);
+const BluetoothUUID kHeartRateServiceUUID(
+    bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID);
 const BluetoothUUID kHeartRateMeasurementUUID(
     bluez::FakeBluetoothGattCharacteristicClient::kHeartRateMeasurementUUID);
 const BluetoothUUID kBodySensorLocationUUID(
     bluez::FakeBluetoothGattCharacteristicClient::kBodySensorLocationUUID);
 const BluetoothUUID kHeartRateControlPointUUID(
     bluez::FakeBluetoothGattCharacteristicClient::kHeartRateControlPointUUID);
 
 // Compares GATT characteristic/descriptor values. Returns true, if the values
 // are equal.
 bool ValuesEqual(const std::vector<uint8_t>& value0,
@@ skipping 63 matching lines @@
 
   void GetAdapter() {
     device::BluetoothAdapterFactory::GetAdapter(base::Bind(
         &BluetoothGattBlueZTest::AdapterCallback, base::Unretained(this)));
     base::RunLoop().Run();
     ASSERT_TRUE(adapter_.get() != NULL);
     ASSERT_TRUE(adapter_->IsInitialized());
     ASSERT_TRUE(adapter_->IsPresent());
   }
 
+  BluetoothDevice* AddLeDevice() {
+    fake_bluetooth_device_client_->CreateDevice(
+        dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
+        dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+    bluez::FakeBluetoothDeviceClient::Properties* properties1 =
+        fake_bluetooth_device_client_->GetProperties(
+            dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+    properties1->connected.ReplaceValue(true);
+
+    return adapter_->GetDevice(
+        bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
+  }
+
+  BluetoothDevice* AddDualDevice() {
+    fake_bluetooth_device_client_->CreateDevice(
+        dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
+        dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kDualPath));
+    bluez::FakeBluetoothDeviceClient::Properties* properties2 =
+        fake_bluetooth_device_client_->GetProperties(
+            dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kDualPath));
+    properties2->connected.ReplaceValue(true);
+
+    return adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kDualAddress);
+  };
+
   void BatteryServiceShouldBeComplete(BluetoothDevice* device) {
     ASSERT_TRUE(device);
     ASSERT_GE(device->GetGattServices().size(), 1u);
 
     BluetoothRemoteGattService* service = device->GetGattService(
         fake_bluetooth_gatt_service_client_->GetBatteryServicePath().value());
 
     ASSERT_TRUE(service);
     EXPECT_TRUE(service->IsPrimary());
     EXPECT_EQ(BluetoothUUID(
@@ skipping 116 matching lines @@
   std::unique_ptr<device::BluetoothGattConnection> gatt_conn_;
   ScopedVector<BluetoothGattNotifySession> update_sessions_;
   scoped_refptr<BluetoothAdapter> adapter_;
 
   int success_callback_count_;
   int error_callback_count_;
   std::vector<uint8_t> last_read_value_;
   BluetoothRemoteGattService::GattErrorCode last_service_error_;
 };
 
+TEST_F(BluetoothGattBlueZTest,
+       RetrieveGattConnectedDevicesWithDiscoveryFilter_NoFilter) {
+  BluetoothDevice* le = AddLeDevice();
+  BluetoothDevice* dual = AddDualDevice();
+
+  BluetoothDiscoveryFilter discovery_filter(device::BLUETOOTH_TRANSPORT_LE);
+  DeviceToUUIDs result =
+      adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
+          discovery_filter);
+
+  EXPECT_EQ(DeviceToUUIDs({{le, UUIDSet()}, {dual, UUIDSet()}}), result);
+}
+
+TEST_F(BluetoothGattBlueZTest,
+       RetrieveGattConnectedDevicesWithDiscoveryFilter_NonMatchingFilter) {
+  AddLeDevice();
+  AddDualDevice();
+
+  BluetoothDiscoveryFilter discovery_filter(device::BLUETOOTH_TRANSPORT_LE);
+  discovery_filter.AddUUID(kBatteryServiceUUID);
+
+  DeviceToUUIDs result =
+      adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
+          discovery_filter);
+
+  EXPECT_TRUE(result.empty());
+}
+
+TEST_F(
+    BluetoothGattBlueZTest,
+    RetrieveGattConnectedDevicesWithDiscoveryFilter_OneMatchingServiceOneDevice) {
+  AddLeDevice();
+  BluetoothDevice* dual = AddDualDevice();
+
+  BluetoothDiscoveryFilter discovery_filter(device::BLUETOOTH_TRANSPORT_LE);
+  discovery_filter.AddUUID(kGenericAccessServiceUUID);
+
+  DeviceToUUIDs result =
+      adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
+          discovery_filter);
+
+  EXPECT_EQ(DeviceToUUIDs({{dual, UUIDSet({kGenericAccessServiceUUID})}}),
+            result);
+}
+
+TEST_F(
+    BluetoothGattBlueZTest,
+    RetrieveGattConnectedDevicesWithDiscoveryFilter_OneMatchingServiceTwoDevices) {
+  BluetoothDevice* le = AddLeDevice();
+  BluetoothDevice* dual = AddDualDevice();
+
+  BluetoothDiscoveryFilter discovery_filter(device::BLUETOOTH_TRANSPORT_LE);
+  discovery_filter.AddUUID(kHeartRateServiceUUID);
+
+  DeviceToUUIDs result =
+      adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
+          discovery_filter);
+
+  EXPECT_EQ(DeviceToUUIDs({{le, UUIDSet({kHeartRateServiceUUID})},
+                           {dual, UUIDSet({kHeartRateServiceUUID})}}),
+            result);
+}
+
+TEST_F(BluetoothGattBlueZTest,
+       RetrieveGattConnectedDevicesWithDiscoveryFilter_TwoServicesTwoDevices) {
+  BluetoothDevice* le = AddLeDevice();
+  BluetoothDevice* dual = AddDualDevice();
+
+  BluetoothDiscoveryFilter discovery_filter(device::BLUETOOTH_TRANSPORT_LE);
+  discovery_filter.AddUUID(kGenericAccessServiceUUID);
+  discovery_filter.AddUUID(kHeartRateServiceUUID);
+
+  DeviceToUUIDs result =
+      adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
+          discovery_filter);
+
+  EXPECT_EQ(DeviceToUUIDs({{le, UUIDSet({kHeartRateServiceUUID})},
+                           {dual, UUIDSet({kHeartRateServiceUUID,
+                                           kGenericAccessServiceUUID})}}),
+            result);
+}
+
+TEST_F(
+    BluetoothGattBlueZTest,
+    RetrieveGattConnectedDevicesWithDiscoveryFilter_OneMatchingServiceOneNonMatchingService) {
+  AddLeDevice();
+  BluetoothDevice* dual = AddDualDevice();
+  BluetoothDiscoveryFilter discovery_filter(device::BLUETOOTH_TRANSPORT_LE);
+  discovery_filter.AddUUID(kGenericAccessServiceUUID);
+  discovery_filter.AddUUID(kBatteryServiceUUID);
+
+  DeviceToUUIDs result =
+      adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
+          discovery_filter);
+
+  EXPECT_EQ(DeviceToUUIDs({{dual, UUIDSet({kGenericAccessServiceUUID})}}),
+            result);
+}
+
 TEST_F(BluetoothGattBlueZTest, GattConnection) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
   ASSERT_FALSE(device->IsConnected());
   ASSERT_FALSE(device->IsGattConnected());
   ASSERT_FALSE(gatt_conn_.get());
@@ skipping 1201 matching lines @@
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
 }
 
 }  // namespace bluez