components/arc: implement multi advertising

components/arc/bluetooth/arc_bluetooth_bridge_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 "components/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/arc/bluetooth/bluetooth_type_converters.h"
 #include "components/arc/common/bluetooth.mojom.h"
 #include "components/arc/test/fake_arc_bridge_service.h"
 #include "components/arc/test/fake_bluetooth_instance.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "device/bluetooth/dbus/fake_bluetooth_adapter_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_le_advertising_manager_client.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace arc {
 
+constexpr int kFailureAdvHandle = -1;
+
 class ArcBluetoothBridgeTest : public testing::Test {
  protected:
   void AddTestDevice() {
     bluez::BluezDBusManager* dbus_manager = bluez::BluezDBusManager::Get();
     auto* fake_bluetooth_device_client =
         static_cast<bluez::FakeBluetoothDeviceClient*>(
             dbus_manager->GetBluetoothDeviceClient());
     auto* fake_bluetooth_gatt_service_client =
         static_cast<bluez::FakeBluetoothGattServiceClient*>(
             dbus_manager->GetBluetoothGattServiceClient());
@@ skipping 36 matching lines @@
         fake_bluetooth_instance_.get(), 2);
     arc_bluetooth_bridge_.reset(
         new ArcBluetoothBridge(fake_arc_bridge_service_.get()));
 
     device::BluetoothAdapterFactory::GetAdapter(base::Bind(
         &ArcBluetoothBridgeTest::OnAdapterInitialized, base::Unretained(this)));
     // We will quit the loop once we get the adapter.
     get_adapter_run_loop_.Run();
   }
 
+  // Helper methods for multi advertisement tests.
+  int32_t ReserveAdvertisementHandle() {
+    constexpr int kSentinelHandle = -2;
+    last_adv_handle_ = kSentinelHandle;
+    arc_bluetooth_bridge_->ReserveAdvertisementHandle(base::Bind(
+        &ArcBluetoothBridgeTest::ReserveAdvertisementHandleCallback,
+        base::Unretained(this)));
+
+    base::RunLoop().RunUntilIdle();
+    // Make sure the callback was called.
+    EXPECT_NE(kSentinelHandle, last_adv_handle_);
+    return last_adv_handle_;
+  }
+
+  mojom::BluetoothGattStatus BroadcastAdvertisement(
+      int adv_handle,
+      std::unique_ptr<device::BluetoothAdvertisement::Data> data) {
+    last_status_ = mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED;
+    arc_bluetooth_bridge_->BroadcastAdvertisement(
+        adv_handle, std::move(data),
+        base::Bind(&ArcBluetoothBridgeTest::StatusSetterCallback,
+                   base::Unretained(this)));
+
+    base::RunLoop().RunUntilIdle();
+    EXPECT_NE(mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED,
+             last_status_);
+    return last_status_;
+  }
+
+  mojom::BluetoothGattStatus ReleaseAdvertisementHandle(int adv_handle) {
+    last_status_ = mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED;
+    arc_bluetooth_bridge_->ReleaseAdvertisementHandle(
+        adv_handle,
+        base::Bind(&ArcBluetoothBridgeTest::StatusSetterCallback,
+                   base::Unretained(this)));
+
+    base::RunLoop().RunUntilIdle();
+    EXPECT_NE(mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED,
+             last_status_);
+    return last_status_;
+  }
+
+  void ReserveAdvertisementHandleCallback(mojom::BluetoothGattStatus status,
+                                          int32_t adv_handle) {
+    if (status == mojom::BluetoothGattStatus::GATT_FAILURE)
+      last_adv_handle_ = kFailureAdvHandle;
+    else
+      last_adv_handle_ = adv_handle;
+  }
+
+  void StatusSetterCallback(mojom::BluetoothGattStatus status) {
+    last_status_ = status;
+  }
+
+  int NumActiveAdvertisements() {
+    bluez::FakeBluetoothLEAdvertisingManagerClient* adv_client =
+        static_cast<bluez::FakeBluetoothLEAdvertisingManagerClient*>(
+            bluez::BluezDBusManager::Get()
+                ->GetBluetoothLEAdvertisingManagerClient());
+    return adv_client->currently_registered();
+  }
+
+  int last_adv_handle_;
+  mojom::BluetoothGattStatus last_status_;
+
   std::unique_ptr<FakeArcBridgeService> fake_arc_bridge_service_;
   std::unique_ptr<FakeBluetoothInstance> fake_bluetooth_instance_;
   std::unique_ptr<ArcBluetoothBridge> arc_bluetooth_bridge_;
   scoped_refptr<device::BluetoothAdapter> adapter_;
   base::MessageLoop message_loop_;
   base::RunLoop get_adapter_run_loop_;
 };
 
 // When we add device to bluez::FakeBluetoothDeviceClient, ArcBluetoothBridge
 // should send new device data to Android. This test will then check
@@ skipping 109 matching lines @@
 
   EXPECT_EQ(device::BluetoothUUID(bluez::FakeBluetoothGattCharacteristicClient::
                                       kHeartRateControlPointUUID),
             db[4]->uuid);
   EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_CHARACTERISTIC,
             db[4]->type);
   EXPECT_EQ(device::BluetoothGattCharacteristic::PROPERTY_WRITE,
             db[4]->properties);
 }
 
+// Invoke multi advertisement methods and make sure they are going down to the
+// D-Bus clients.
+TEST_F(ArcBluetoothBridgeTest, SingleAdvertisement) {
+  int32_t handle = ReserveAdvertisementHandle();
+  EXPECT_NE(kFailureAdvHandle, handle);
+  EXPECT_EQ(0, NumActiveAdvertisements());
+
+  auto adv_data = base::MakeUnique<device::BluetoothAdvertisement::Data>(
+      device::BluetoothAdvertisement::ADVERTISEMENT_TYPE_BROADCAST);
+  mojom::BluetoothGattStatus status =
+      BroadcastAdvertisement(handle, std::move(adv_data));
+  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
+  EXPECT_EQ(1, NumActiveAdvertisements());
+
+  status = ReleaseAdvertisementHandle(handle);
+  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
+  EXPECT_EQ(0, NumActiveAdvertisements());
+}
+
+// Invoke multi advertisement methods and make sure they are going down to the
+// D-Bus clients.
+TEST_F(ArcBluetoothBridgeTest, MultiAdvertisement) {

[Rahul Chaturvedi, 2016/09/30 19:51:08]

Please also add a test that tests the condition where you run out of handles.
Feel free to add an additional test for it, or extend this test to handle that
condition. Either will work.

+  int32_t handle = ReserveAdvertisementHandle();
+  EXPECT_NE(kFailureAdvHandle, handle);
+  EXPECT_EQ(0, NumActiveAdvertisements());
+
+  auto adv_data = base::MakeUnique<device::BluetoothAdvertisement::Data>(
+      device::BluetoothAdvertisement::ADVERTISEMENT_TYPE_BROADCAST);
+  mojom::BluetoothGattStatus status =
+      BroadcastAdvertisement(handle, std::move(adv_data));
+  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
+  EXPECT_EQ(1, NumActiveAdvertisements());
+
+  int32_t handle2 = ReserveAdvertisementHandle();
+  EXPECT_NE(kFailureAdvHandle, handle2);
+  auto adv_data2 = base::MakeUnique<device::BluetoothAdvertisement::Data>(
+      device::BluetoothAdvertisement::ADVERTISEMENT_TYPE_PERIPHERAL);
+  status = BroadcastAdvertisement(handle2, std::move(adv_data2));
+  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
+  EXPECT_EQ(2, NumActiveAdvertisements());
+
+  status = ReleaseAdvertisementHandle(handle);
+  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
+  EXPECT_EQ(1, NumActiveAdvertisements());
+
+  status = ReleaseAdvertisementHandle(handle2);
+  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
+  EXPECT_EQ(0, NumActiveAdvertisements());
+
+}
+
+// This tests that we support releasing reserved but unused handles.
+// TODO(ejcaruso): When Chrome supports more handles, make sure we
+// will stop reserving handles before we use all of Chrome's.
+TEST_F(ArcBluetoothBridgeTest, ReleaseUnusedHandles) {
+  const size_t kChromeMaxAdvertisements = 5;
+  std::vector<int32_t> reserved_handles;
+
+  for (size_t i = 0; i < kChromeMaxAdvertisements; i++) {
+    int32_t handle = ReserveAdvertisementHandle();
+    if (handle == kFailureAdvHandle)
+      break;
+    reserved_handles.push_back(handle);
+  }
+  EXPECT_GT(reserved_handles.size(), 1Ul);
+  EXPECT_LE(reserved_handles.size(), kChromeMaxAdvertisements);
+  EXPECT_EQ(0, NumActiveAdvertisements());
+
+  for (int32_t handle : reserved_handles) {
+    EXPECT_EQ(ReleaseAdvertisementHandle(handle),
+              mojom::BluetoothGattStatus::GATT_SUCCESS);
+  }
+}
+
 }  // namespace arc