[CrOS MultiDevice] Handle removed/disabled BluetoothAdapter on pending.

SecureChannel previously had no handlers for when the BluetoothAdapter
is disabled or removed while a connection request is pending.

This CL adds observer methods to PendingConnectionRequestBase that will
fire when device::BluetoothAdapter detects that the adapter has been
disabled or removed, causing the request to be cancelled.

Bug: 854366
Change-Id: Ice45c373f42a6e9065d8c3564988904e02e7fa9e
Reviewed-on: https://chromium-review.googlesource.com/1195099
Commit-Queue: Kyle Qian <kyleqian@google.com>
Reviewed-by: Ryan Hansberry <hansberry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589407}

chromeos/services/secure_channel/BUILD.gn

@@ -78,6 +78,7 @@ static_library("secure_channel") {
     "multiplexed_channel.h",
     "multiplexed_channel_impl.cc",
     "multiplexed_channel_impl.h",
+    "pending_ble_connection_request_base.h",
     "pending_ble_initiator_connection_request.cc",
     "pending_ble_initiator_connection_request.h",
     "pending_ble_listener_connection_request.cc",
@@ -210,6 +211,7 @@ source_set("unit_tests") {
     "connection_attempt_base_unittest.cc",
     "error_tolerant_ble_advertisement_impl_unittest.cc",
     "multiplexed_channel_impl_unittest.cc",
+    "pending_ble_connection_request_base_unittest.cc",
     "pending_ble_initiator_connection_request_unittest.cc",
     "pending_ble_listener_connection_request_unittest.cc",
     "pending_connection_manager_impl_unittest.cc",

chromeos/services/secure_channel/pending_ble_connection_request_base.h

+// Copyright 2018 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 CHROMEOS_SERVICES_SECURE_CHANNEL_PENDING_BLE_CONNECTION_REQUEST_BASE_H_
+#define CHROMEOS_SERVICES_SECURE_CHANNEL_PENDING_BLE_CONNECTION_REQUEST_BASE_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "base/macros.h"
+#include "chromeos/services/secure_channel/pending_connection_request_base.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+template <typename BleFailureDetailType>
+class PendingBleConnectionRequestBase
+    : public PendingConnectionRequestBase<BleFailureDetailType>,
+      public device::BluetoothAdapter::Observer {
+ public:
+  ~PendingBleConnectionRequestBase() override {
+    bluetooth_adapter_->RemoveObserver(this);
+  }
+
+ protected:
+  PendingBleConnectionRequestBase(
+      std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
+      ConnectionPriority connection_priority,
+      const std::string& readable_request_type_for_logging,
+      PendingConnectionRequestDelegate* delegate,
+      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter)
+      : PendingConnectionRequestBase<BleFailureDetailType>(
+            std::move(client_connection_parameters),
+            connection_priority,
+            readable_request_type_for_logging,
+            delegate),
+        bluetooth_adapter_(std::move(bluetooth_adapter)) {
+    bluetooth_adapter_->AddObserver(this);
+  }
+
+ private:
+  friend class SecureChannelPendingBleConnectionRequestBaseTest;
+
+  // device::BluetoothAdapter::Observer:
+  void AdapterPoweredChanged(device::BluetoothAdapter* adapter,
+                             bool powered) override {
+    DCHECK_EQ(bluetooth_adapter_, adapter);
+    if (powered)
+      return;
+
+    this->StopRequestDueToConnectionFailures(
+        mojom::ConnectionAttemptFailureReason::ADAPTER_DISABLED);
+  }
+
+  void AdapterPresentChanged(device::BluetoothAdapter* adapter,
+                             bool present) override {
+    DCHECK_EQ(bluetooth_adapter_, adapter);
+    if (present)
+      return;
+
+    this->StopRequestDueToConnectionFailures(
+        mojom::ConnectionAttemptFailureReason::ADAPTER_NOT_PRESENT);
+  }
+
+  scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
+
+  DISALLOW_COPY_AND_ASSIGN(PendingBleConnectionRequestBase);
+};
+
+}  // namespace secure_channel
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_SECURE_CHANNEL_PENDING_BLE_CONNECTION_REQUEST_BASE_H_

chromeos/services/secure_channel/pending_ble_connection_request_base_unittest.cc

+// Copyright 2018 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 "chromeos/services/secure_channel/pending_ble_connection_request_base.h"
+
+#include <memory>
+
+#include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
+#include "chromeos/services/secure_channel/fake_client_connection_parameters.h"
+#include "chromeos/services/secure_channel/fake_connection_delegate.h"
+#include "chromeos/services/secure_channel/fake_pending_connection_request_delegate.h"
+#include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+namespace {
+
+const char kTestReadableRequestTypeForLogging[] = "Test Request Type";
+const char kTestFeature[] = "testFeature";
+enum class TestFailureDetail { kTestFailureReason };
+
+// Since PendingBleConnectionRequestBase is templatized, a concrete
+// implementation is needed for its test.
+class TestPendingBleConnectionRequestBase
+    : public PendingBleConnectionRequestBase<TestFailureDetail> {
+ public:
+  TestPendingBleConnectionRequestBase(
+      std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
+      ConnectionPriority connection_priority,
+      PendingConnectionRequestDelegate* delegate,
+      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter)
+      : PendingBleConnectionRequestBase<TestFailureDetail>(
+            std::move(client_connection_parameters),
+            connection_priority,
+            kTestReadableRequestTypeForLogging,
+            delegate,
+            std::move(bluetooth_adapter)) {}
+  ~TestPendingBleConnectionRequestBase() override = default;
+
+  // PendingConnectionRequest<TestFailureDetailType>:
+  void HandleConnectionFailure(TestFailureDetail failure_detail) override {}
+};
+
+}  // namespace
+
+class SecureChannelPendingBleConnectionRequestBaseTest : public testing::Test {
+ protected:
+  SecureChannelPendingBleConnectionRequestBaseTest() = default;
+  ~SecureChannelPendingBleConnectionRequestBaseTest() override = default;
+
+  void SetUp() override {
+    auto fake_client_connection_parameters =
+        std::make_unique<FakeClientConnectionParameters>(kTestFeature);
+    fake_client_connection_parameters_ =
+        fake_client_connection_parameters.get();
+
+    mock_adapter_ =
+        base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
+
+    fake_pending_connection_request_delegate_ =
+        std::make_unique<FakePendingConnectionRequestDelegate>();
+
+    test_pending_ble_connection_request_ =
+        std::make_unique<TestPendingBleConnectionRequestBase>(
+            std::move(fake_client_connection_parameters),
+            ConnectionPriority::kLow,
+            fake_pending_connection_request_delegate_.get(), mock_adapter_);
+
+    EXPECT_TRUE(mock_adapter_->GetObservers().HasObserver(
+        test_pending_ble_connection_request_.get()));
+  }
+
+  const base::Optional<
+      PendingConnectionRequestDelegate::FailedConnectionReason>&
+  GetFailedConnectionReason() {
+    return fake_pending_connection_request_delegate_
+        ->GetFailedConnectionReasonForId(
+            test_pending_ble_connection_request_->GetRequestId());
+  }
+
+  const base::Optional<mojom::ConnectionAttemptFailureReason>&
+  GetConnectionAttemptFailureReason() const {
+    return fake_client_connection_parameters_->failure_reason();
+  }
+
+  void SimulateAdapterPoweredChanged(bool powered) {
+    test_pending_ble_connection_request_->AdapterPoweredChanged(
+        mock_adapter_.get(), powered);
+  }
+
+  void SimulateAdapterPresentChanged(bool present) {
+    test_pending_ble_connection_request_->AdapterPresentChanged(
+        mock_adapter_.get(), present);
+  }
+
+ private:
+  FakeClientConnectionParameters* fake_client_connection_parameters_;
+  std::unique_ptr<FakePendingConnectionRequestDelegate>
+      fake_pending_connection_request_delegate_;
+  scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
+
+  std::unique_ptr<TestPendingBleConnectionRequestBase>
+      test_pending_ble_connection_request_;
+
+  DISALLOW_COPY_AND_ASSIGN(SecureChannelPendingBleConnectionRequestBaseTest);
+};
+
+TEST_F(SecureChannelPendingBleConnectionRequestBaseTest,
+       HandleAdapterPoweredChanged) {
+  // Turning the adapter on should do nothing.
+  SimulateAdapterPoweredChanged(true /* powered */);
+  EXPECT_FALSE(GetFailedConnectionReason());
+  EXPECT_FALSE(GetConnectionAttemptFailureReason());
+
+  // Turning the adapter off should trigger a failure.
+  SimulateAdapterPoweredChanged(false /* powered */);
+  EXPECT_EQ(
+      PendingConnectionRequestDelegate::FailedConnectionReason::kRequestFailed,
+      *GetFailedConnectionReason());
+  EXPECT_EQ(mojom::ConnectionAttemptFailureReason::ADAPTER_DISABLED,
+            *GetConnectionAttemptFailureReason());
+}
+
+TEST_F(SecureChannelPendingBleConnectionRequestBaseTest,
+       HandleAdapterPresentChanged) {
+  // The adapter appearing should do nothing.
+  SimulateAdapterPresentChanged(true /* present */);
+  EXPECT_FALSE(GetFailedConnectionReason());
+  EXPECT_FALSE(GetConnectionAttemptFailureReason());
+
+  // The adapter disappearing should trigger a failure.
+  SimulateAdapterPresentChanged(false /* present */);
+  EXPECT_EQ(
+      PendingConnectionRequestDelegate::FailedConnectionReason::kRequestFailed,
+      *GetFailedConnectionReason());
+  EXPECT_EQ(mojom::ConnectionAttemptFailureReason::ADAPTER_NOT_PRESENT,
+            *GetConnectionAttemptFailureReason());
+}
+
+}  // namespace secure_channel
+
+}  // namespace chromeos

chromeos/services/secure_channel/pending_ble_initiator_connection_request.cc

@@ -4,6 +4,8 @@
 
 #include "chromeos/services/secure_channel/pending_ble_initiator_connection_request.h"
 
+#include <utility>
+
 #include "base/memory/ptr_util.h"
 #include "base/no_destructor.h"
 #include "chromeos/components/proximity_auth/logging/logging.h"
@@ -13,7 +15,9 @@ namespace chromeos {
 namespace secure_channel {
 
 namespace {
+
 const char kBleInitiatorReadableRequestTypeForLogging[] = "BLE Initiator";
+
 }  // namespace
 
 // The number of times to attempt to connect to a device without receiving any
@@ -60,20 +64,24 @@ std::unique_ptr<PendingConnectionRequest<BleInitiatorFailureType>>
 PendingBleInitiatorConnectionRequest::Factory::BuildInstance(
     std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
     ConnectionPriority connection_priority,
-    PendingConnectionRequestDelegate* delegate) {
+    PendingConnectionRequestDelegate* delegate,
+    scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) {
   return base::WrapUnique(new PendingBleInitiatorConnectionRequest(
-      std::move(client_connection_parameters), connection_priority, delegate));
+      std::move(client_connection_parameters), connection_priority, delegate,
+      bluetooth_adapter));
 }
 
 PendingBleInitiatorConnectionRequest::PendingBleInitiatorConnectionRequest(
     std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
     ConnectionPriority connection_priority,
-    PendingConnectionRequestDelegate* delegate)
-    : PendingConnectionRequestBase<BleInitiatorFailureType>(
+    PendingConnectionRequestDelegate* delegate,
+    scoped_refptr<device::BluetoothAdapter> bluetooth_adapter)
+    : PendingBleConnectionRequestBase<BleInitiatorFailureType>(
           std::move(client_connection_parameters),
           connection_priority,
           kBleInitiatorReadableRequestTypeForLogging,
-          delegate) {}
+          delegate,
+          std::move(bluetooth_adapter)) {}
 
 PendingBleInitiatorConnectionRequest::~PendingBleInitiatorConnectionRequest() =
     default;

chromeos/services/secure_channel/pending_ble_initiator_connection_request.h

@@ -5,10 +5,12 @@
 #ifndef CHROMEOS_SERVICES_SECURE_CHANNEL_PENDING_BLE_INITIATOR_CONNECTION_REQUEST_H_
 #define CHROMEOS_SERVICES_SECURE_CHANNEL_PENDING_BLE_INITIATOR_CONNECTION_REQUEST_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "chromeos/services/secure_channel/ble_initiator_failure_type.h"
 #include "chromeos/services/secure_channel/client_connection_parameters.h"
-#include "chromeos/services/secure_channel/pending_connection_request_base.h"
+#include "chromeos/services/secure_channel/pending_ble_connection_request_base.h"
 #include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
 
 namespace chromeos {
@@ -17,7 +19,7 @@ namespace secure_channel {
 
 // ConnectionRequest corresponding to BLE connections in the initiator role.
 class PendingBleInitiatorConnectionRequest
-    : public PendingConnectionRequestBase<BleInitiatorFailureType> {
+    : public PendingBleConnectionRequestBase<BleInitiatorFailureType> {
  public:
   class Factory {
    public:
@@ -28,7 +30,8 @@ class PendingBleInitiatorConnectionRequest
     BuildInstance(std::unique_ptr<ClientConnectionParameters>
                       client_connection_parameters,
                   ConnectionPriority connection_priority,
-                  PendingConnectionRequestDelegate* delegate);
+                  PendingConnectionRequestDelegate* delegate,
+                  scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
 
    private:
     static Factory* test_factory_;
@@ -43,7 +46,8 @@ class PendingBleInitiatorConnectionRequest
   PendingBleInitiatorConnectionRequest(
       std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
       ConnectionPriority connection_priority,
-      PendingConnectionRequestDelegate* delegate);
+      PendingConnectionRequestDelegate* delegate,
+      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
 
   // PendingConnectionRequest<BleInitiatorFailureType>:
   void HandleConnectionFailure(BleInitiatorFailureType failure_detail) override;

chromeos/services/secure_channel/pending_ble_initiator_connection_request_unittest.cc

@@ -5,6 +5,7 @@
 #include "chromeos/services/secure_channel/pending_ble_initiator_connection_request.h"
 
 #include <memory>
+#include <utility>
 
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
@@ -12,6 +13,7 @@
 #include "chromeos/services/secure_channel/fake_client_connection_parameters.h"
 #include "chromeos/services/secure_channel/fake_pending_connection_request_delegate.h"
 #include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
@@ -36,12 +38,14 @@ class SecureChannelPendingBleInitiatorConnectionRequestTest
         std::make_unique<FakeClientConnectionParameters>(kTestFeature);
     fake_client_connection_parameters_ =
         fake_client_connection_parameters.get();
+    mock_adapter_ =
+        base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
 
     pending_ble_initiator_request_ =
         PendingBleInitiatorConnectionRequest::Factory::Get()->BuildInstance(
             std::move(fake_client_connection_parameters),
             ConnectionPriority::kLow,
-            fake_pending_connection_request_delegate_.get());
+            fake_pending_connection_request_delegate_.get(), mock_adapter_);
   }
 
   const base::Optional<
@@ -67,6 +71,7 @@ class SecureChannelPendingBleInitiatorConnectionRequestTest
   std::unique_ptr<FakePendingConnectionRequestDelegate>
       fake_pending_connection_request_delegate_;
   FakeClientConnectionParameters* fake_client_connection_parameters_;
+  scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
 
   std::unique_ptr<PendingConnectionRequest<BleInitiatorFailureType>>
       pending_ble_initiator_request_;

chromeos/services/secure_channel/pending_ble_listener_connection_request.cc

@@ -4,6 +4,8 @@
 
 #include "chromeos/services/secure_channel/pending_ble_listener_connection_request.h"
 
+#include <utility>
+
 #include "base/memory/ptr_util.h"
 #include "base/no_destructor.h"
 #include "chromeos/components/proximity_auth/logging/logging.h"
@@ -43,20 +45,24 @@ std::unique_ptr<PendingConnectionRequest<BleListenerFailureType>>
 PendingBleListenerConnectionRequest::Factory::BuildInstance(
     std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
     ConnectionPriority connection_priority,
-    PendingConnectionRequestDelegate* delegate) {
+    PendingConnectionRequestDelegate* delegate,
+    scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) {
   return base::WrapUnique(new PendingBleListenerConnectionRequest(
-      std::move(client_connection_parameters), connection_priority, delegate));
+      std::move(client_connection_parameters), connection_priority, delegate,
+      bluetooth_adapter));
 }
 
 PendingBleListenerConnectionRequest::PendingBleListenerConnectionRequest(
     std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
     ConnectionPriority connection_priority,
-    PendingConnectionRequestDelegate* delegate)
-    : PendingConnectionRequestBase<BleListenerFailureType>(
+    PendingConnectionRequestDelegate* delegate,
+    scoped_refptr<device::BluetoothAdapter> bluetooth_adapter)
+    : PendingBleConnectionRequestBase<BleListenerFailureType>(
           std::move(client_connection_parameters),
           connection_priority,
           kBleListenerReadableRequestTypeForLogging,
-          delegate) {}
+          delegate,
+          std::move(bluetooth_adapter)) {}
 
 PendingBleListenerConnectionRequest::~PendingBleListenerConnectionRequest() =
     default;

chromeos/services/secure_channel/pending_ble_listener_connection_request.h

@@ -5,10 +5,12 @@
 #ifndef CHROMEOS_SERVICES_SECURE_CHANNEL_PENDING_BLE_LISTENER_CONNECTION_REQUEST_H_
 #define CHROMEOS_SERVICES_SECURE_CHANNEL_PENDING_BLE_LISTENER_CONNECTION_REQUEST_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "chromeos/services/secure_channel/ble_listener_failure_type.h"
 #include "chromeos/services/secure_channel/client_connection_parameters.h"
-#include "chromeos/services/secure_channel/pending_connection_request_base.h"
+#include "chromeos/services/secure_channel/pending_ble_connection_request_base.h"
 #include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
 
 namespace chromeos {
@@ -17,7 +19,7 @@ namespace secure_channel {
 
 // ConnectionRequest corresponding to BLE connections in the listener role.
 class PendingBleListenerConnectionRequest
-    : public PendingConnectionRequestBase<BleListenerFailureType> {
+    : public PendingBleConnectionRequestBase<BleListenerFailureType> {
  public:
   class Factory {
    public:
@@ -28,7 +30,8 @@ class PendingBleListenerConnectionRequest
     BuildInstance(std::unique_ptr<ClientConnectionParameters>
                       client_connection_parameters,
                   ConnectionPriority connection_priority,
-                  PendingConnectionRequestDelegate* delegate);
+                  PendingConnectionRequestDelegate* delegate,
+                  scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
 
    private:
     static Factory* test_factory_;
@@ -40,7 +43,8 @@ class PendingBleListenerConnectionRequest
   PendingBleListenerConnectionRequest(
       std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
       ConnectionPriority connection_priority,
-      PendingConnectionRequestDelegate* delegate);
+      PendingConnectionRequestDelegate* delegate,
+      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
 
   // PendingConnectionRequest<BleListenerFailureType>:
   void HandleConnectionFailure(BleListenerFailureType failure_detail) override;

chromeos/services/secure_channel/pending_ble_listener_connection_request_unittest.cc

@@ -5,6 +5,7 @@
 #include "chromeos/services/secure_channel/pending_ble_listener_connection_request.h"
 
 #include <memory>
+#include <utility>
 
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
@@ -12,6 +13,7 @@
 #include "chromeos/services/secure_channel/fake_client_connection_parameters.h"
 #include "chromeos/services/secure_channel/fake_pending_connection_request_delegate.h"
 #include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
@@ -36,12 +38,14 @@ class SecureChannelPendingBleListenerConnectionRequestTest
         std::make_unique<FakeClientConnectionParameters>(kTestFeature);
     fake_client_connection_parameters_ =
         fake_client_connection_parameters.get();
+    mock_adapter_ =
+        base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
 
     pending_ble_listener_request_ =
         PendingBleListenerConnectionRequest::Factory::Get()->BuildInstance(
             std::move(fake_client_connection_parameters),
             ConnectionPriority::kLow,
-            fake_pending_connection_request_delegate_.get());
+            fake_pending_connection_request_delegate_.get(), mock_adapter_);
   }
 
   const base::Optional<
@@ -67,6 +71,7 @@ class SecureChannelPendingBleListenerConnectionRequestTest
   std::unique_ptr<FakePendingConnectionRequestDelegate>
       fake_pending_connection_request_delegate_;
   FakeClientConnectionParameters* fake_client_connection_parameters_;
+  scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
 
   std::unique_ptr<PendingConnectionRequest<BleListenerFailureType>>
       pending_ble_listener_request_;

chromeos/services/secure_channel/pending_connection_manager_impl.cc

@@ -43,16 +43,19 @@ PendingConnectionManagerImpl::Factory::~Factory() = default;
 std::unique_ptr<PendingConnectionManager>
 PendingConnectionManagerImpl::Factory::BuildInstance(
     Delegate* delegate,
-    BleConnectionManager* ble_connection_manager) {
-  return base::WrapUnique(
-      new PendingConnectionManagerImpl(delegate, ble_connection_manager));
+    BleConnectionManager* ble_connection_manager,
+    scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) {
+  return base::WrapUnique(new PendingConnectionManagerImpl(
+      delegate, ble_connection_manager, bluetooth_adapter));
 }
 
 PendingConnectionManagerImpl::PendingConnectionManagerImpl(
     Delegate* delegate,
-    BleConnectionManager* ble_connection_manager)
+    BleConnectionManager* ble_connection_manager,
+    scoped_refptr<device::BluetoothAdapter> bluetooth_adapter)
     : PendingConnectionManager(delegate),
-      ble_connection_manager_(ble_connection_manager) {}
+      ble_connection_manager_(ble_connection_manager),
+      bluetooth_adapter_(bluetooth_adapter) {}
 
 PendingConnectionManagerImpl::~PendingConnectionManagerImpl() = default;
 
@@ -174,7 +177,7 @@ void PendingConnectionManagerImpl::HandleBleInitiatorRequest(
   bool success = connection_attempt->AddPendingConnectionRequest(
       PendingBleInitiatorConnectionRequest::Factory::Get()->BuildInstance(
           std::move(client_connection_parameters), connection_priority,
-          connection_attempt.get() /* delegate */));
+          connection_attempt.get() /* delegate */, bluetooth_adapter_));
 
   if (!success) {
     PA_LOG(ERROR) << "PendingConnectionManagerImpl::"
@@ -207,7 +210,7 @@ void PendingConnectionManagerImpl::HandleBleListenerRequest(
   bool success = connection_attempt->AddPendingConnectionRequest(
       PendingBleListenerConnectionRequest::Factory::Get()->BuildInstance(
           std::move(client_connection_parameters), connection_priority,
-          connection_attempt.get() /* delegate */));
+          connection_attempt.get() /* delegate */, bluetooth_adapter_));
 
   if (!success) {
     PA_LOG(ERROR) << "PendingConnectionManagerImpl::"

chromeos/services/secure_channel/pending_connection_manager_impl.h

@@ -21,6 +21,7 @@
 #include "chromeos/services/secure_channel/device_id_pair.h"
 #include "chromeos/services/secure_channel/pending_connection_manager.h"
 #include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
+#include "device/bluetooth/bluetooth_adapter.h"
 
 namespace chromeos {
 
@@ -46,7 +47,8 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
     virtual ~Factory();
     virtual std::unique_ptr<PendingConnectionManager> BuildInstance(
         Delegate* delegate,
-        BleConnectionManager* ble_connection_manager);
+        BleConnectionManager* ble_connection_manager,
+        scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
 
    private:
     static Factory* test_factory_;
@@ -55,8 +57,10 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
   ~PendingConnectionManagerImpl() override;
 
  private:
-  PendingConnectionManagerImpl(Delegate* delegate,
-                               BleConnectionManager* ble_connection_manager);
+  PendingConnectionManagerImpl(
+      Delegate* delegate,
+      BleConnectionManager* ble_connection_manager,
+      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
 
   // PendingConnectionManager:
   void HandleConnectionRequest(
@@ -95,6 +99,7 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
       details_to_attempt_details_map_;
 
   BleConnectionManager* ble_connection_manager_;
+  scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingConnectionManagerImpl);
 };

chromeos/services/secure_channel/pending_connection_manager_impl_unittest.cc

@@ -22,6 +22,7 @@
 #include "chromeos/services/secure_channel/fake_pending_connection_request.h"
 #include "chromeos/services/secure_channel/pending_ble_initiator_connection_request.h"
 #include "chromeos/services/secure_channel/pending_ble_listener_connection_request.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
@@ -211,7 +212,8 @@ class FakePendingBleInitiatorConnectionRequestFactory
   BuildInstance(
       std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
       ConnectionPriority connection_priority,
-      PendingConnectionRequestDelegate* delegate) override {
+      PendingConnectionRequestDelegate* delegate,
+      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) override {
     EXPECT_EQ(expected_client_connection_parameters_,
               client_connection_parameters.get());
     EXPECT_EQ(*expected_connection_priority_, connection_priority);
@@ -257,7 +259,8 @@ class FakePendingBleListenerConnectionRequestFactory
   BuildInstance(
       std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
       ConnectionPriority connection_priority,
-      PendingConnectionRequestDelegate* delegate) override {
+      PendingConnectionRequestDelegate* delegate,
+      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) override {
     EXPECT_EQ(expected_client_connection_parameters_,
               client_connection_parameters.get());
     EXPECT_EQ(*expected_connection_priority_, connection_priority);
@@ -337,8 +340,12 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
     PendingBleListenerConnectionRequest::Factory::SetFactoryForTesting(
         fake_pending_ble_listener_connection_request_factory_.get());
 
+    mock_adapter_ =
+        base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
+
     manager_ = PendingConnectionManagerImpl::Factory::Get()->BuildInstance(
-        fake_delegate_.get(), fake_ble_connection_manager_.get());
+        fake_delegate_.get(), fake_ble_connection_manager_.get(),
+        mock_adapter_);
   }
 
   void TearDown() override {
@@ -592,6 +599,7 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
       fake_pending_ble_initiator_connection_request_factory_;
   std::unique_ptr<FakePendingBleListenerConnectionRequestFactory>
       fake_pending_ble_listener_connection_request_factory_;
+  scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
 
   std::unique_ptr<PendingConnectionManager> manager_;
 

chromeos/services/secure_channel/secure_channel_impl.cc

@@ -86,7 +86,8 @@ SecureChannelImpl::SecureChannelImpl(
       pending_connection_manager_(
           PendingConnectionManagerImpl::Factory::Get()->BuildInstance(
               this /* delegate */,
-              ble_connection_manager_.get())),
+              ble_connection_manager_.get(),
+              bluetooth_adapter_)),
       active_connection_manager_(
           ActiveConnectionManagerImpl::Factory::Get()->BuildInstance(
               this /* delegate */)) {}

chromeos/services/secure_channel/secure_channel_service_unittest.cc

@@ -178,7 +178,8 @@ class FakePendingConnectionManagerFactory
   // PendingConnectionManagerImpl::Factory:
   std::unique_ptr<PendingConnectionManager> BuildInstance(
       PendingConnectionManager::Delegate* delegate,
-      BleConnectionManager* ble_connection_manager) override {
+      BleConnectionManager* ble_connection_manager,
+      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) override {
     EXPECT_FALSE(instance_);
     EXPECT_EQ(fake_ble_connection_manager_factory_->instance(),
               ble_connection_manager);