[Nearby] Create concrete BluetoothAdapter.

Partially implement a concrete location::nearby::api::BluetoothAdapter,
using the shared bluetooth::mojom::Adapter reference in Chrome's Nearby
Connections.

Only implement the methods on BluetoothAdapter which are required to
act as a 'Sender' device (discovery and connection initiation), and
basic methods like GetName().

A subsequent CL will finish this implementation; more methods need to
be made available on bluetooth::mojom::Adapter first.

api::BluetoothAdapter is a synchronous interface, so this CL converts
the bluetooth::mojom::Adapter::GetInfo() method it consumes to [Sync].

Please see design doc go/nearby-chrome-bt for more details.

Bug: b:154849033, b:158848873
Change-Id: Ia787f2890c42629a78c5d6e5caac6a73f9784a96
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2313998
Commit-Queue: Ryan Hansberry <hansberry@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Alex Chau <alexchau@chromium.org>
Reviewed-by: James Vecore <vecore@google.com>
Cr-Commit-Position: refs/heads/master@{#795552}

chrome/services/sharing/nearby/nearby_connections.h

@@ -48,7 +48,10 @@ class NearbyConnections : public mojom::NearbyConnections {
   // Should only be used by objects within lifetime of NearbyConnections.
   static NearbyConnections& GetInstance();
 
+  // May return null if Nearby Connections was not provided an Adapter (likely
+  // because this device does not support Bluetooth).
   bluetooth::mojom::Adapter* GetBluetoothAdapter();
+
   network::mojom::P2PSocketManager* GetWebRtcP2PSocketManager();
   network::mojom::MdnsResponder* GetWebRtcMdnsResponder();
   sharing::mojom::IceConfigFetcher* GetWebRtcIceConfigFetcher();

chrome/services/sharing/nearby/nearby_connections_unittest.cc

@@ -107,7 +107,7 @@ class NearbyConnectionsTest : public testing::Test {
         webrtc_dependencies_.ice_config_fetcher_.BindNewPipeAndPassRemote(),
         webrtc_dependencies_.messenger_.BindNewPipeAndPassRemote());
     auto dependencies = mojom::NearbyConnectionsDependencies::New(
-        bluetooth_adapter_.adapter.BindNewPipeAndPassRemote(),
+        bluetooth_adapter_.adapter_.BindNewPipeAndPassRemote(),
         std::move(webrtc_dependencies));
     service_controller_ =
         std::make_unique<testing::NiceMock<MockServiceController>>();
@@ -141,7 +141,7 @@ TEST_F(NearbyConnectionsTest, RemoteDisconnect) {
 }
 
 TEST_F(NearbyConnectionsTest, BluetoothDisconnect) {
-  bluetooth_adapter_.adapter.reset();
+  bluetooth_adapter_.adapter_.reset();
   disconnect_run_loop_.Run();
 }
 

chrome/services/sharing/nearby/platform_v2/BUILD.gn

@@ -8,6 +8,8 @@ source_set("platform_v2") {
     "atomic_boolean.h",
     "atomic_uint32.cc",
     "atomic_uint32.h",
+    "bluetooth_adapter.cc",
+    "bluetooth_adapter.h",
     "condition_variable.cc",
     "condition_variable.h",
     "count_down_latch.cc",
@@ -51,6 +53,7 @@ source_set("unit_tests") {
   sources = [
     "atomic_boolean_unittest.cc",
     "atomic_uint32_unittest.cc",
+    "bluetooth_adapter_unittest.cc",
     "condition_variable_unittest.cc",
     "count_down_latch_unittest.cc",
     "crypto_unittest.cc",

chrome/services/sharing/nearby/platform_v2/bluetooth_adapter.cc

+// Copyright 2020 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 "chrome/services/sharing/nearby/platform_v2/bluetooth_adapter.h"
+
+namespace location {
+namespace nearby {
+namespace chrome {
+
+BluetoothAdapter::BluetoothAdapter(bluetooth::mojom::Adapter* adapter)
+    : adapter_(adapter) {}
+
+BluetoothAdapter::~BluetoothAdapter() = default;
+
+bool BluetoothAdapter::SetStatus(Status status) {
+  // TODO(b/154848416): Implement this method.
+  NOTIMPLEMENTED();
+  return true;
+}
+
+bool BluetoothAdapter::IsEnabled() const {
+  bluetooth::mojom::AdapterInfoPtr info;
+  bool success = adapter_->GetInfo(&info);
+  return success && info->present && info->powered;
+}
+
+BluetoothAdapter::ScanMode BluetoothAdapter::GetScanMode() const {
+  bluetooth::mojom::AdapterInfoPtr info;
+  bool success = adapter_->GetInfo(&info);
+
+  if (!success || !info->present)
+    return ScanMode::kUnknown;
+  else if (!info->powered)
+    return ScanMode::kNone;
+  else if (!info->discoverable)
+    return ScanMode::kConnectable;
+
+  return ScanMode::kConnectableDiscoverable;
+}
+
+bool BluetoothAdapter::SetScanMode(BluetoothAdapter::ScanMode scan_mode) {
+  // TODO(b/154848416): Add SetDiscoverable call to bluetooth::mojom::Adapter
+  // and invoke it.
+  NOTIMPLEMENTED();
+  return false;
+}
+
+std::string BluetoothAdapter::GetName() const {
+  bluetooth::mojom::AdapterInfoPtr info;
+  bool success = adapter_->GetInfo(&info);
+  return success ? info->name : "";
+}
+
+bool BluetoothAdapter::SetName(absl::string_view name) {
+  // TODO(b/154848416): Add SetName call to bluetooth::mojom::Adapter and
+  // invoke it.
+  NOTIMPLEMENTED();
+  return false;
+}
+
+}  // namespace chrome
+}  // namespace nearby
+}  // namespace location

chrome/services/sharing/nearby/platform_v2/bluetooth_adapter.h

+// Copyright 2020 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.
+
+#ifndef CHROME_SERVICES_SHARING_NEARBY_PLATFORM_V2_BLUETOOTH_ADAPTER_H_
+#define CHROME_SERVICES_SHARING_NEARBY_PLATFORM_V2_BLUETOOTH_ADAPTER_H_
+
+#include <string>
+
+#include "device/bluetooth/public/mojom/adapter.mojom.h"
+#include "third_party/nearby/src/cpp/platform_v2/api/bluetooth_adapter.h"
+
+namespace location {
+namespace nearby {
+namespace chrome {
+
+// Concrete BluetoothAdapter implementation.
+// api::BluetoothAdapter is a synchronous interface, so this implementation of
+// consumes the synchronous signatures of bluetooth::mojom::Adapter methods.
+class BluetoothAdapter : public api::BluetoothAdapter {
+ public:
+  explicit BluetoothAdapter(bluetooth::mojom::Adapter* adapter);
+  ~BluetoothAdapter() override;
+
+  BluetoothAdapter(const BluetoothAdapter&) = delete;
+  BluetoothAdapter& operator=(const BluetoothAdapter&) = delete;
+
+  // api::BluetoothAdapter:
+  bool SetStatus(Status status) override;
+  bool IsEnabled() const override;
+  ScanMode GetScanMode() const override;
+  bool SetScanMode(ScanMode scan_mode) override;
+  std::string GetName() const override;
+  bool SetName(absl::string_view name) override;
+
+ private:
+  // This reference is owned by the top-level Nearby Connections interface and
+  // will always outlive this object.
+  bluetooth::mojom::Adapter* adapter_;
+};
+
+}  // namespace chrome
+}  // namespace nearby
+}  // namespace location
+
+#endif  // CHROME_SERVICES_SHARING_NEARBY_PLATFORM_V2_BLUETOOTH_ADAPTER_H_

chrome/services/sharing/nearby/platform_v2/bluetooth_adapter_unittest.cc

+// Copyright 2020 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 "chrome/services/sharing/nearby/platform_v2/bluetooth_adapter.h"
+
+#include <memory>
+
+#include "base/run_loop.h"
+#include "base/test/bind_test_util.h"
+#include "base/test/task_environment.h"
+#include "chrome/services/sharing/nearby/test_support/fake_adapter.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
+#include "mojo/public/cpp/bindings/shared_remote.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace location {
+namespace nearby {
+namespace chrome {
+
+class BluetoothAdapterTest : public testing::Test {
+ public:
+  BluetoothAdapterTest() = default;
+  ~BluetoothAdapterTest() override = default;
+  BluetoothAdapterTest(const BluetoothAdapterTest&) = delete;
+  BluetoothAdapterTest& operator=(const BluetoothAdapterTest&) = delete;
+
+  void SetUp() override {
+    auto fake_adapter = std::make_unique<bluetooth::FakeAdapter>();
+    fake_adapter_ = fake_adapter.get();
+
+    mojo::PendingRemote<bluetooth::mojom::Adapter> pending_adapter;
+
+    mojo::MakeSelfOwnedReceiver(
+        std::move(fake_adapter),
+        pending_adapter.InitWithNewPipeAndPassReceiver());
+
+    remote_adapter_.Bind(std::move(pending_adapter),
+                         /*bind_task_runner=*/nullptr);
+
+    bluetooth_adapter_ =
+        std::make_unique<BluetoothAdapter>(remote_adapter_.get());
+  }
+
+ protected:
+  bluetooth::FakeAdapter* fake_adapter_;
+  std::unique_ptr<BluetoothAdapter> bluetooth_adapter_;
+
+ private:
+  mojo::SharedRemote<bluetooth::mojom::Adapter> remote_adapter_;
+  base::test::TaskEnvironment task_environment_;
+};
+
+TEST_F(BluetoothAdapterTest, TestIsEnabled) {
+  fake_adapter_->present_ = false;
+  fake_adapter_->powered_ = false;
+  EXPECT_FALSE(bluetooth_adapter_->IsEnabled());
+
+  fake_adapter_->present_ = true;
+  fake_adapter_->powered_ = false;
+  EXPECT_FALSE(bluetooth_adapter_->IsEnabled());
+
+  fake_adapter_->present_ = false;
+  fake_adapter_->powered_ = true;
+  EXPECT_FALSE(bluetooth_adapter_->IsEnabled());
+
+  fake_adapter_->present_ = true;
+  fake_adapter_->powered_ = true;
+  EXPECT_TRUE(bluetooth_adapter_->IsEnabled());
+}
+
+TEST_F(BluetoothAdapterTest, TestGetScanMode) {
+  fake_adapter_->present_ = false;
+  fake_adapter_->powered_ = false;
+  fake_adapter_->discoverable_ = false;
+  EXPECT_EQ(BluetoothAdapter::ScanMode::kUnknown,
+            bluetooth_adapter_->GetScanMode());
+
+  fake_adapter_->present_ = true;
+  EXPECT_EQ(BluetoothAdapter::ScanMode::kNone,
+            bluetooth_adapter_->GetScanMode());
+
+  fake_adapter_->powered_ = true;
+  EXPECT_EQ(BluetoothAdapter::ScanMode::kConnectable,
+            bluetooth_adapter_->GetScanMode());
+
+  fake_adapter_->discoverable_ = true;
+  EXPECT_EQ(BluetoothAdapter::ScanMode::kConnectableDiscoverable,
+            bluetooth_adapter_->GetScanMode());
+}
+
+TEST_F(BluetoothAdapterTest, TestGetName) {
+  EXPECT_EQ(fake_adapter_->name_, bluetooth_adapter_->GetName());
+}
+
+}  // namespace chrome
+}  // namespace nearby
+}  // namespace location

chrome/services/sharing/nearby/platform_v2/platform.cc

@@ -9,6 +9,7 @@
 #include "chrome/services/sharing/nearby/nearby_connections.h"
 #include "chrome/services/sharing/nearby/platform_v2/atomic_boolean.h"
 #include "chrome/services/sharing/nearby/platform_v2/atomic_uint32.h"
+#include "chrome/services/sharing/nearby/platform_v2/bluetooth_adapter.h"
 #include "chrome/services/sharing/nearby/platform_v2/condition_variable.h"
 #include "chrome/services/sharing/nearby/platform_v2/count_down_latch.h"
 #include "chrome/services/sharing/nearby/platform_v2/log_message.h"
@@ -17,6 +18,7 @@
 #include "chrome/services/sharing/nearby/platform_v2/scheduled_executor.h"
 #include "chrome/services/sharing/nearby/platform_v2/submittable_executor.h"
 #include "chrome/services/sharing/nearby/platform_v2/webrtc.h"
+#include "device/bluetooth/public/mojom/adapter.mojom.h"
 #include "third_party/nearby/src/cpp/platform_v2/api/atomic_boolean.h"
 #include "third_party/nearby/src/cpp/platform_v2/api/atomic_reference.h"
 #include "third_party/nearby/src/cpp/platform_v2/api/ble.h"
@@ -78,7 +80,14 @@ std::unique_ptr<AtomicUint32> ImplementationPlatform::CreateAtomicUint32(
 
 std::unique_ptr<BluetoothAdapter>
 ImplementationPlatform::CreateBluetoothAdapter() {
-  return nullptr;
+  auto& connections = connections::NearbyConnections::GetInstance();
+  bluetooth::mojom::Adapter* bluetooth_adapter =
+      connections.GetBluetoothAdapter();
+
+  if (!bluetooth_adapter)
+    return nullptr;
+
+  return std::make_unique<chrome::BluetoothAdapter>(bluetooth_adapter);
 }
 
 std::unique_ptr<CountDownLatch> ImplementationPlatform::CreateCountDownLatch(

chrome/services/sharing/nearby/test_support/fake_adapter.cc

@@ -17,7 +17,11 @@ void FakeAdapter::GetDevices(GetDevicesCallback callback) {}
 
 void FakeAdapter::GetInfo(GetInfoCallback callback) {
   mojom::AdapterInfoPtr adapter_info = mojom::AdapterInfo::New();
-  adapter_info->present = present;
+  adapter_info->name = name_;
+  adapter_info->present = present_;
+  adapter_info->powered = powered_;
+  adapter_info->discoverable = discoverable_;
+  adapter_info->discovering = discovering_;
   std::move(callback).Run(std::move(adapter_info));
 }
 

chrome/services/sharing/nearby/test_support/fake_adapter.h

@@ -29,8 +29,12 @@ class FakeAdapter : public mojom::Adapter {
       const device::BluetoothUUID& service_uuid,
       ConnectToServiceInsecurelyCallback callback) override;
 
-  mojo::Receiver<mojom::Adapter> adapter{this};
-  bool present = true;
+  mojo::Receiver<mojom::Adapter> adapter_{this};
+  std::string name_ = "AdapterName";
+  bool present_ = true;
+  bool powered_ = true;
+  bool discoverable_ = false;
+  bool discovering_ = false;
 };
 
 }  // namespace bluetooth

chrome/services/sharing/sharing_impl_unittest.cc

@@ -131,7 +131,7 @@ TEST_F(SharingImplTest, NearbyConnections_Create) {
   bluetooth::FakeAdapter bluetooth_adapter;
   sharing::MockWebRtcDependencies webrtc_dependencies;
   mojo::Remote<NearbyConnectionsMojom> connections = CreateNearbyConnections(
-      bluetooth_adapter.adapter.BindNewPipeAndPassRemote(),
+      bluetooth_adapter.adapter_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.socket_manager_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.mdns_responder_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.ice_config_fetcher_.BindNewPipeAndPassRemote(),
@@ -144,7 +144,7 @@ TEST_F(SharingImplTest, NearbyConnections_CreateMultiple) {
   bluetooth::FakeAdapter bluetooth_adapter_1;
   sharing::MockWebRtcDependencies webrtc_dependencies_1;
   mojo::Remote<NearbyConnectionsMojom> connections_1 = CreateNearbyConnections(
-      bluetooth_adapter_1.adapter.BindNewPipeAndPassRemote(),
+      bluetooth_adapter_1.adapter_.BindNewPipeAndPassRemote(),
       webrtc_dependencies_1.socket_manager_.BindNewPipeAndPassRemote(),
       webrtc_dependencies_1.mdns_responder_.BindNewPipeAndPassRemote(),
       webrtc_dependencies_1.ice_config_fetcher_.BindNewPipeAndPassRemote(),
@@ -155,7 +155,7 @@ TEST_F(SharingImplTest, NearbyConnections_CreateMultiple) {
   bluetooth::FakeAdapter bluetooth_adapter_2;
   sharing::MockWebRtcDependencies webrtc_dependencies_2;
   mojo::Remote<NearbyConnectionsMojom> connections_2 = CreateNearbyConnections(
-      bluetooth_adapter_2.adapter.BindNewPipeAndPassRemote(),
+      bluetooth_adapter_2.adapter_.BindNewPipeAndPassRemote(),
       webrtc_dependencies_2.socket_manager_.BindNewPipeAndPassRemote(),
       webrtc_dependencies_2.mdns_responder_.BindNewPipeAndPassRemote(),
       webrtc_dependencies_2.ice_config_fetcher_.BindNewPipeAndPassRemote(),
@@ -172,7 +172,7 @@ TEST_F(SharingImplTest, NearbyConnections_BluetoothDisconnects) {
   bluetooth::FakeAdapter bluetooth_adapter;
   sharing::MockWebRtcDependencies webrtc_dependencies;
   mojo::Remote<NearbyConnectionsMojom> connections = CreateNearbyConnections(
-      bluetooth_adapter.adapter.BindNewPipeAndPassRemote(),
+      bluetooth_adapter.adapter_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.socket_manager_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.mdns_responder_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.ice_config_fetcher_.BindNewPipeAndPassRemote(),
@@ -181,7 +181,7 @@ TEST_F(SharingImplTest, NearbyConnections_BluetoothDisconnects) {
 
   // Disconnecting the |bluetooth_adapter| interface should also
   // disconnect and destroy the |connections| interface.
-  bluetooth_adapter.adapter.reset();
+  bluetooth_adapter.adapter_.reset();
 
   // Run mojo disconnect handlers.
   base::RunLoop().RunUntilIdle();
@@ -193,7 +193,7 @@ TEST_F(SharingImplTest, NearbyConnections_WebRtcSignalingMessengerDisconnects) {
   bluetooth::FakeAdapter bluetooth_adapter;
   sharing::MockWebRtcDependencies webrtc_dependencies;
   mojo::Remote<NearbyConnectionsMojom> connections = CreateNearbyConnections(
-      bluetooth_adapter.adapter.BindNewPipeAndPassRemote(),
+      bluetooth_adapter.adapter_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.socket_manager_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.mdns_responder_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.ice_config_fetcher_.BindNewPipeAndPassRemote(),
@@ -214,7 +214,7 @@ TEST_F(SharingImplTest, NearbyConnections_WebRtcMdnsResponderDisconnects) {
   bluetooth::FakeAdapter bluetooth_adapter;
   sharing::MockWebRtcDependencies webrtc_dependencies;
   mojo::Remote<NearbyConnectionsMojom> connections = CreateNearbyConnections(
-      bluetooth_adapter.adapter.BindNewPipeAndPassRemote(),
+      bluetooth_adapter.adapter_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.socket_manager_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.mdns_responder_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.ice_config_fetcher_.BindNewPipeAndPassRemote(),
@@ -235,7 +235,7 @@ TEST_F(SharingImplTest, NearbyConnections_WebRtcP2PSocketManagerDisconnects) {
   bluetooth::FakeAdapter bluetooth_adapter;
   sharing::MockWebRtcDependencies webrtc_dependencies;
   mojo::Remote<NearbyConnectionsMojom> connections = CreateNearbyConnections(
-      bluetooth_adapter.adapter.BindNewPipeAndPassRemote(),
+      bluetooth_adapter.adapter_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.socket_manager_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.mdns_responder_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.ice_config_fetcher_.BindNewPipeAndPassRemote(),
@@ -256,7 +256,7 @@ TEST_F(SharingImplTest, NearbyConnections_WebRtcIceConfigFetcherDisconnects) {
   bluetooth::FakeAdapter bluetooth_adapter;
   sharing::MockWebRtcDependencies webrtc_dependencies;
   mojo::Remote<NearbyConnectionsMojom> connections = CreateNearbyConnections(
-      bluetooth_adapter.adapter.BindNewPipeAndPassRemote(),
+      bluetooth_adapter.adapter_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.socket_manager_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.mdns_responder_.BindNewPipeAndPassRemote(),
       webrtc_dependencies.ice_config_fetcher_.BindNewPipeAndPassRemote(),

device/bluetooth/public/mojom/adapter.mojom

@@ -89,6 +89,7 @@ interface Adapter {
   GetDevices() => (array<DeviceInfo> devices);
 
   // Gets basic information about the adapter.
+  [Sync]
   GetInfo() => (AdapterInfo info);
 
   // Sets the client that listens for the adapter's events.