[CrOS PhoneHub] Add SetNearbyConnector() Mojo API

This function allows clients to set a NearbyConnector to be used when
attempting a Nearby Connection.

Within the SecureChannel implementation, connection requests are
rejected with the newly-added MISSING_NEARBY_CONNECTOR failure reason if
a connection is requested when a NearbyConnector has not been set. A
future CL will use the provided NearbyConnector when initiating a
connection.

On the client side, NearbyConnectorFactory now sets the NearbyConnector
instance when it is created. PhoneHubManagerFactory adds a dependency on
NearbyConnectorFactory to ensure that the NearbyConnector is set before
Phone Hub starts up.

Bug: 1106937
Change-Id: I6f25aa9be817c0bb15c19045d2c4e9494b674368
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2513748
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Ryan Hansberry <hansberry@chromium.org>
Reviewed-by: James Vecore <vecore@google.com>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#825047}

chrome/browser/chromeos/phonehub/phone_hub_manager_factory.cc

@@ -10,6 +10,7 @@
 #include "chrome/browser/chromeos/phonehub/browser_tabs_metadata_fetcher_impl.h"
 #include "chrome/browser/chromeos/phonehub/browser_tabs_model_provider_impl.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/chromeos/secure_channel/nearby_connector_factory.h"
 #include "chrome/browser/chromeos/secure_channel/secure_channel_client_provider.h"
 #include "chrome/browser/favicon/history_ui_favicon_request_handler_factory.h"
 #include "chrome/browser/profiles/profile.h"
@@ -65,6 +66,7 @@ PhoneHubManagerFactory::PhoneHubManagerFactory()
           BrowserContextDependencyManager::GetInstance()) {
   DependsOn(device_sync::DeviceSyncClientFactory::GetInstance());
   DependsOn(multidevice_setup::MultiDeviceSetupClientFactory::GetInstance());
+  DependsOn(secure_channel::NearbyConnectorFactory::GetInstance());
   DependsOn(SessionSyncServiceFactory::GetInstance());
   DependsOn(HistoryUiFaviconRequestHandlerFactory::GetInstance());
 }

chrome/browser/chromeos/secure_channel/nearby_connector_factory.cc

@@ -6,7 +6,9 @@
 
 #include "chrome/browser/chromeos/nearby/nearby_process_manager_factory.h"
 #include "chrome/browser/chromeos/secure_channel/nearby_connector_impl.h"
+#include "chrome/browser/chromeos/secure_channel/secure_channel_client_provider.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chromeos/services/secure_channel/public/cpp/client/secure_channel_client.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 
 namespace chromeos {
@@ -44,7 +46,11 @@ KeyedService* NearbyConnectorFactory::BuildServiceInstanceFor(
   if (!nearby_process_manager)
     return nullptr;
 
-  return new NearbyConnectorImpl(nearby_process_manager);
+  auto nearby_connector =
+      std::make_unique<NearbyConnectorImpl>(nearby_process_manager);
+  SecureChannelClientProvider::GetInstance()->GetClient()->SetNearbyConnector(
+      nearby_connector.get());
+  return nearby_connector.release();
 }
 
 bool NearbyConnectorFactory::ServiceIsCreatedWithBrowserContext() const {

chromeos/services/secure_channel/BUILD.gn

@@ -327,6 +327,7 @@ source_set("unit_tests") {
     "//chromeos/components/multidevice",
     "//chromeos/components/multidevice:test_support",
     "//chromeos/components/multidevice/logging",
+    "//chromeos/services/secure_channel/public/cpp/client:test_support",
     "//chromeos/services/secure_channel/public/cpp/client:unit_tests",
     "//chromeos/services/secure_channel/public/cpp/shared",
     "//chromeos/services/secure_channel/public/mojom",

chromeos/services/secure_channel/fake_secure_channel.h

@@ -51,6 +51,8 @@ class FakeSecureChannel : public SecureChannelBase {
       ConnectionMedium connection_medium,
       ConnectionPriority connection_priority,
       mojo::PendingRemote<mojom::ConnectionDelegate> delegate) override;
+  void SetNearbyConnector(
+      mojo::PendingRemote<mojom::NearbyConnector> nearby_connector) override {}
 
   mojo::Remote<mojom::ConnectionDelegate> delegate_from_last_listen_call_;
   mojo::Remote<mojom::ConnectionDelegate> delegate_from_last_initiate_call_;

chromeos/services/secure_channel/nearby_connection.cc

@@ -4,6 +4,7 @@
 
 #include "chromeos/services/secure_channel/nearby_connection.h"
 
+#include "base/check.h"
 #include "base/memory/ptr_util.h"
 
 namespace chromeos {
@@ -16,11 +17,13 @@ NearbyConnection::Factory* NearbyConnection::Factory::factory_instance_ =
 
 // static
 std::unique_ptr<Connection> NearbyConnection::Factory::Create(
-    multidevice::RemoteDeviceRef remote_device) {
+    multidevice::RemoteDeviceRef remote_device,
+    mojom::NearbyConnector* nearby_connector) {
   if (factory_instance_)
-    return factory_instance_->CreateInstance(remote_device);
+    return factory_instance_->CreateInstance(remote_device, nearby_connector);
 
-  return base::WrapUnique(new NearbyConnection(remote_device));
+  return base::WrapUnique(
+      new NearbyConnection(remote_device, nearby_connector));
 }
 
 // static
@@ -28,8 +31,11 @@ void NearbyConnection::Factory::SetFactoryForTesting(Factory* factory) {
   factory_instance_ = factory;
 }
 
-NearbyConnection::NearbyConnection(multidevice::RemoteDeviceRef remote_device)
-    : Connection(remote_device) {}
+NearbyConnection::NearbyConnection(multidevice::RemoteDeviceRef remote_device,
+                                   mojom::NearbyConnector* nearby_connector)
+    : Connection(remote_device), nearby_connector_(nearby_connector) {
+  DCHECK(nearby_connector_);
+}
 
 NearbyConnection::~NearbyConnection() {
   // TODO(https://crbug.com/1106937): Clean up potentially-lingering connection.

chromeos/services/secure_channel/nearby_connection.h

@@ -6,6 +6,7 @@
 #define CHROMEOS_SERVICES_SECURE_CHANNEL_NEARBY_CONNECTION_H_
 
 #include "chromeos/services/secure_channel/connection.h"
+#include "chromeos/services/secure_channel/public/mojom/nearby_connector.mojom.h"
 
 namespace chromeos {
 
@@ -19,13 +20,15 @@ class NearbyConnection : public Connection {
   class Factory {
    public:
     static std::unique_ptr<Connection> Create(
-        multidevice::RemoteDeviceRef remote_device);
+        multidevice::RemoteDeviceRef remote_device,
+        mojom::NearbyConnector* nearby_connector);
     static void SetFactoryForTesting(Factory* factory);
     virtual ~Factory() = default;
 
    protected:
     virtual std::unique_ptr<Connection> CreateInstance(
-        multidevice::RemoteDeviceRef remote_device) = 0;
+        multidevice::RemoteDeviceRef remote_device,
+        mojom::NearbyConnector* nearby_connector) = 0;
 
    private:
     static Factory* factory_instance_;
@@ -34,13 +37,16 @@ class NearbyConnection : public Connection {
   ~NearbyConnection() override;
 
  private:
-  NearbyConnection(multidevice::RemoteDeviceRef remote_device);
+  NearbyConnection(multidevice::RemoteDeviceRef remote_device,
+                   mojom::NearbyConnector* nearby_connector);
 
   // Connection:
   void Connect() override;
   void Disconnect() override;
   std::string GetDeviceAddress() override;
   void SendMessageImpl(std::unique_ptr<WireMessage> message) override;
+
+  mojom::NearbyConnector* nearby_connector_;
 };
 
 }  // namespace secure_channel

chromeos/services/secure_channel/nearby_connection_manager.cc

@@ -26,6 +26,18 @@ NearbyConnectionManager::NearbyConnectionManager() = default;
 
 NearbyConnectionManager::~NearbyConnectionManager() = default;
 
+void NearbyConnectionManager::SetNearbyConnector(
+    mojo::PendingRemote<mojom::NearbyConnector> nearby_connector) {
+  if (nearby_connector_)
+    nearby_connector_.reset();
+
+  nearby_connector_.Bind(std::move(nearby_connector));
+}
+
+bool NearbyConnectionManager::IsNearbyConnectorSet() const {
+  return nearby_connector_.is_bound();
+}
+
 void NearbyConnectionManager::AttemptNearbyInitiatorConnection(
     const DeviceIdPair& device_id_pair,
     ConnectionSuccessCallback success_callback,
@@ -56,6 +68,12 @@ void NearbyConnectionManager::CancelNearbyInitiatorConnectionAttempt(
   PerformCancelNearbyInitiatorConnectionAttempt(device_id_pair);
 }
 
+mojom::NearbyConnector* NearbyConnectionManager::GetNearbyConnector() {
+  if (!nearby_connector_.is_bound())
+    return nullptr;
+  return nearby_connector_.get();
+}
+
 const base::flat_set<DeviceIdPair>&
 NearbyConnectionManager::GetDeviceIdPairsForRemoteDevice(
     const std::string& remote_device_id) const {

chromeos/services/secure_channel/nearby_connection_manager.h

@@ -13,6 +13,9 @@
 #include "base/macros.h"
 #include "chromeos/services/secure_channel/device_id_pair.h"
 #include "chromeos/services/secure_channel/nearby_initiator_failure_type.h"
+#include "chromeos/services/secure_channel/public/mojom/nearby_connector.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace chromeos {
 
@@ -27,6 +30,11 @@ class NearbyConnectionManager {
   NearbyConnectionManager& operator=(const NearbyConnectionManager&) = delete;
   virtual ~NearbyConnectionManager();
 
+  // Note: NearbyConnector must be set before connections can be requested.
+  void SetNearbyConnector(
+      mojo::PendingRemote<mojom::NearbyConnector> nearby_connector);
+  bool IsNearbyConnectorSet() const;
+
   using ConnectionSuccessCallback =
       base::OnceCallback<void(std::unique_ptr<AuthenticatedChannel>)>;
   using FailureCallback =
@@ -52,6 +60,8 @@ class NearbyConnectionManager {
   virtual void PerformCancelNearbyInitiatorConnectionAttempt(
       const DeviceIdPair& device_id_pair) = 0;
 
+  mojom::NearbyConnector* GetNearbyConnector();
+
   const base::flat_set<DeviceIdPair>& GetDeviceIdPairsForRemoteDevice(
       const std::string& remote_device_id) const;
   bool DoesAttemptExist(const DeviceIdPair& device_id_pair);
@@ -77,6 +87,7 @@ class NearbyConnectionManager {
       const DeviceIdPair& device_id_pair);
   void RemoveRequestMetadata(const DeviceIdPair& device_id_pair);
 
+  mojo::Remote<mojom::NearbyConnector> nearby_connector_;
   base::flat_map<std::string, base::flat_set<DeviceIdPair>>
       remote_device_id_to_id_pair_map_;
   base::flat_map<DeviceIdPair,

chromeos/services/secure_channel/nearby_connection_manager_impl.cc

@@ -93,7 +93,7 @@ void NearbyConnectionManagerImpl::OnReceivedAdvertisement(
 
   // Create a connection to the device.
   std::unique_ptr<Connection> connection =
-      NearbyConnection::Factory::Create(remote_device);
+      NearbyConnection::Factory::Create(remote_device, GetNearbyConnector());
 
   SetAuthenticatingChannel(
       remote_device.GetDeviceId(),

chromeos/services/secure_channel/nearby_connection_manager_impl_unittest.cc

@@ -15,6 +15,7 @@
 #include "chromeos/services/secure_channel/fake_secure_channel_connection.h"
 #include "chromeos/services/secure_channel/fake_secure_channel_disconnector.h"
 #include "chromeos/services/secure_channel/nearby_connection.h"
+#include "chromeos/services/secure_channel/public/cpp/client/fake_nearby_connector.h"
 #include "chromeos/services/secure_channel/secure_channel.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -39,7 +40,8 @@ class FakeNearbyConnectionFactory : public NearbyConnection::Factory {
  private:
   // cryptauth::NearbyConnection::Factory:
   std::unique_ptr<Connection> CreateInstance(
-      multidevice::RemoteDeviceRef remote_device) override {
+      multidevice::RemoteDeviceRef remote_device,
+      mojom::NearbyConnector* nearby_connector) override {
     auto instance = std::make_unique<FakeConnection>(remote_device);
     last_created_instance_ = instance.get();
     return instance;
@@ -146,6 +148,12 @@ class SecureChannelNearbyConnectionManagerImplTest : public testing::Test {
 
     manager_ = NearbyConnectionManagerImpl::Factory::Create(
         fake_ble_scanner_.get(), fake_secure_channel_disconnector_.get());
+
+    EXPECT_FALSE(manager_->IsNearbyConnectorSet());
+    fake_nearby_connector_ = std::make_unique<FakeNearbyConnector>();
+    manager_->SetNearbyConnector(
+        fake_nearby_connector_->GeneratePendingRemote());
+    EXPECT_TRUE(manager_->IsNearbyConnectorSet());
   }
 
   void TearDown() override {
@@ -361,6 +369,7 @@ class SecureChannelNearbyConnectionManagerImplTest : public testing::Test {
   std::unique_ptr<FakeBleScanner> fake_ble_scanner_;
   std::unique_ptr<FakeSecureChannelDisconnector>
       fake_secure_channel_disconnector_;
+  std::unique_ptr<FakeNearbyConnector> fake_nearby_connector_;
 
   std::unique_ptr<NearbyConnectionManager> manager_;
 };

chromeos/services/secure_channel/public/cpp/client/fake_secure_channel_client.h

@@ -131,6 +131,7 @@ class FakeSecureChannelClient : public SecureChannelClient {
       const std::string& feature,
       ConnectionMedium connection_medium,
       ConnectionPriority connection_priority) override;
+  void SetNearbyConnector(NearbyConnector* nearby_connector) override {}
 
  private:
   // First element of pair is remote device, second is local device.

chromeos/services/secure_channel/public/cpp/client/secure_channel_client.h

@@ -18,6 +18,7 @@ namespace chromeos {
 namespace secure_channel {
 
 class ConnectionAttempt;
+class NearbyConnector;
 
 // Provides clients access to the SecureChannel API.
 //
@@ -67,6 +68,7 @@ class SecureChannelClient {
       const std::string& feature,
       ConnectionMedium connection_medium,
       ConnectionPriority connection_priority) = 0;
+  virtual void SetNearbyConnector(NearbyConnector* nearby_connector) = 0;
 
  protected:
   SecureChannelClient() = default;

chromeos/services/secure_channel/public/cpp/client/secure_channel_client_impl.cc

@@ -8,6 +8,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/task_runner.h"
 #include "chromeos/services/secure_channel/public/cpp/client/connection_attempt_impl.h"
+#include "chromeos/services/secure_channel/public/cpp/client/nearby_connector.h"
 
 namespace chromeos {
 
@@ -90,6 +91,12 @@ SecureChannelClientImpl::ListenForConnectionFromDevice(
   return connection_attempt;
 }
 
+void SecureChannelClientImpl::SetNearbyConnector(
+    NearbyConnector* nearby_connector) {
+  secure_channel_remote_->SetNearbyConnector(
+      nearby_connector->GeneratePendingRemote());
+}
+
 void SecureChannelClientImpl::PerformInitiateConnectionToDevice(
     multidevice::RemoteDeviceRef device_to_connect,
     multidevice::RemoteDeviceRef local_device,

chromeos/services/secure_channel/public/cpp/client/secure_channel_client_impl.h

@@ -61,6 +61,7 @@ class SecureChannelClientImpl : public SecureChannelClient {
       const std::string& feature,
       ConnectionMedium connection_medium,
       ConnectionPriority connection_priority) override;
+  void SetNearbyConnector(NearbyConnector* nearby_connector) override;
 
   void PerformInitiateConnectionToDevice(
       multidevice::RemoteDeviceRef device_to_connect,

chromeos/services/secure_channel/public/mojom/secure_channel.mojom

@@ -5,6 +5,7 @@
 module chromeos.secure_channel.mojom;
 
 import "chromeos/components/multidevice/mojom/multidevice_types.mojom";
+import "chromeos/services/secure_channel/public/mojom/nearby_connector.mojom";
 
 enum ConnectionAttemptFailureReason {
   // The local device could not authenticate with the remote device. This likely
@@ -55,7 +56,11 @@ enum ConnectionAttemptFailureReason {
   // Tried to connect using a role which is unsupported for the connection
   // medium (e.g., Nearby Connections only supports the listener role, not the
   // initiator role).
-  UNSUPPORTED_ROLE_FOR_MEDIUM
+  UNSUPPORTED_ROLE_FOR_MEDIUM,
+
+  // Tried requesting a connection via Nearby Connections, but no
+  // NearbyConnector was provided.
+  MISSING_NEARBY_CONNECTOR
 };
 
 enum ConnectionCreationDetail {
@@ -183,6 +188,9 @@ interface ConnectionDelegate {
 // establish connections to phones belonging to each account on the device, so
 // each of these connection attempts uses a different local device.
 //
+// If a Nearby-based connection is requested, clients must first invoke
+// SetNearbyConnector().
+//
 // Note: Each API function results in either one connection (success case)
 // or zero connections (failure case). Clients wishing to initiate another
 // connection after the first one has completed should invoke the API again.
@@ -216,4 +224,9 @@ interface SecureChannel {
       ConnectionMedium connection_medium,
       ConnectionPriority connection_priority,
       pending_remote<ConnectionDelegate> delegate);
+
+  // Sets a NearbyConnector to be used by future connection requests. Must be
+  // called before requesting a connection with
+  // ConnectionMedium::kNearbyConnections. Should only be called once.
+  SetNearbyConnector(pending_remote<NearbyConnector> nearby_connector);
 };

chromeos/services/secure_channel/secure_channel_impl.cc

@@ -126,6 +126,11 @@ void SecureChannelImpl::InitiateConnectionToDevice(
       ConnectionRole::kInitiatorRole, connection_priority, connection_medium);
 }
 
+void SecureChannelImpl::SetNearbyConnector(
+    mojo::PendingRemote<mojom::NearbyConnector> nearby_connector) {
+  nearby_connection_manager_->SetNearbyConnector(std::move(nearby_connector));
+}
+
 void SecureChannelImpl::OnDisconnected(
     const ConnectionDetails& connection_details) {
   auto pending_requests_it =
@@ -218,9 +223,9 @@ void SecureChannelImpl::ProcessConnectionRequest(
   switch (connection_medium) {
     case ConnectionMedium::kNearbyConnections:
       // Nearby Connections only supports certain roles.
-      if (CheckForInvalidNearbyRole(api_fn_name,
-                                    client_connection_parameters.get(),
-                                    connection_role)) {
+      if (CheckForInvalidNearbyRequest(api_fn_name,
+                                       client_connection_parameters.get(),
+                                       connection_role)) {
         return;
       }
 
@@ -362,7 +367,7 @@ bool SecureChannelImpl::CheckForInvalidInputDevice(
   return true;
 }
 
-bool SecureChannelImpl::CheckForInvalidNearbyRole(
+bool SecureChannelImpl::CheckForInvalidNearbyRequest(
     ApiFunctionName api_fn_name,
     ClientConnectionParameters* client_connection_parameters,
     ConnectionRole connection_role) {
@@ -374,6 +379,14 @@ bool SecureChannelImpl::CheckForInvalidNearbyRole(
     return true;
   }
 
+  if (!nearby_connection_manager_->IsNearbyConnectorSet()) {
+    RejectRequestForReason(
+        api_fn_name,
+        mojom::ConnectionAttemptFailureReason::MISSING_NEARBY_CONNECTOR,
+        client_connection_parameters);
+    return true;
+  }
+
   return false;
 }
 

chromeos/services/secure_channel/secure_channel_impl.h

@@ -114,6 +114,8 @@ class SecureChannelImpl : public mojom::SecureChannel,
       ConnectionMedium connection_medium,
       ConnectionPriority connection_priority,
       mojo::PendingRemote<mojom::ConnectionDelegate> delegate) override;
+  void SetNearbyConnector(
+      mojo::PendingRemote<mojom::NearbyConnector> nearby_connector) override;
 
   // ActiveConnectionManager::Delegate:
   void OnDisconnected(const ConnectionDetails& connection_details) override;
@@ -154,7 +156,7 @@ class SecureChannelImpl : public mojom::SecureChannel,
 
   // Checks for whether |connection_role| is valid for a connection via the
   // Nearby Connections library.
-  bool CheckForInvalidNearbyRole(
+  bool CheckForInvalidNearbyRequest(
       ApiFunctionName api_fn_name,
       ClientConnectionParameters* client_connection_parameters,
       ConnectionRole connection_role);

chromeos/services/secure_channel/secure_channel_initializer.cc

@@ -9,6 +9,7 @@
 #include "chromeos/components/multidevice/logging/logging.h"
 #include "chromeos/services/secure_channel/secure_channel_impl.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
 
 namespace chromeos {
 
@@ -56,6 +57,10 @@ SecureChannelInitializer::ConnectionRequestArgs::~ConnectionRequestArgs() =
 
 SecureChannelInitializer::SecureChannelInitializer(
     scoped_refptr<base::TaskRunner> task_runner) {
+  // May not be initialized in tests.
+  if (!bluez::BluezDBusManager::IsInitialized())
+    return;
+
   PA_LOG(VERBOSE) << "SecureChannelInitializer::SecureChannelInitializer(): "
                   << "Fetching Bluetooth adapter. All requests received before "
                   << "the adapter is fetched will be queued.";
@@ -113,6 +118,16 @@ void SecureChannelInitializer::InitiateConnectionToDevice(
       connection_priority, std::move(delegate), false /* is_listen_request */));
 }
 
+void SecureChannelInitializer::SetNearbyConnector(
+    mojo::PendingRemote<mojom::NearbyConnector> nearby_connector) {
+  if (secure_channel_impl_) {
+    secure_channel_impl_->SetNearbyConnector(std::move(nearby_connector));
+    return;
+  }
+
+  nearby_connector_ = std::move(nearby_connector);
+}
+
 void SecureChannelInitializer::OnBluetoothAdapterReceived(
     scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) {
   PA_LOG(VERBOSE) << "SecureChannelInitializer::OnBluetoothAdapterReceived(): "
@@ -121,6 +136,9 @@ void SecureChannelInitializer::OnBluetoothAdapterReceived(
 
   secure_channel_impl_ = SecureChannelImpl::Factory::Create(bluetooth_adapter);
 
+  if (nearby_connector_)
+    secure_channel_impl_->SetNearbyConnector(std::move(nearby_connector_));
+
   while (!pending_args_.empty()) {
     std::unique_ptr<ConnectionRequestArgs> args_to_pass =
         std::move(pending_args_.front());

chromeos/services/secure_channel/secure_channel_initializer.h

@@ -13,6 +13,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "chromeos/services/secure_channel/public/mojom/nearby_connector.mojom.h"
 #include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
 #include "chromeos/services/secure_channel/secure_channel_base.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -90,10 +91,13 @@ class SecureChannelInitializer : public SecureChannelBase {
       ConnectionMedium connection_medium,
       ConnectionPriority connection_priority,
       mojo::PendingRemote<mojom::ConnectionDelegate> delegate) override;
+  void SetNearbyConnector(
+      mojo::PendingRemote<mojom::NearbyConnector> nearby_connector) override;
 
   void OnBluetoothAdapterReceived(
       scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
 
+  mojo::PendingRemote<mojom::NearbyConnector> nearby_connector_;
   std::queue<std::unique_ptr<ConnectionRequestArgs>> pending_args_;
   std::unique_ptr<mojom::SecureChannel> secure_channel_impl_;
 

chromeos/services/secure_channel/secure_channel_service_unittest.cc

@@ -34,12 +34,14 @@
 #include "chromeos/services/secure_channel/fake_timer_factory.h"
 #include "chromeos/services/secure_channel/nearby_connection_manager_impl.h"
 #include "chromeos/services/secure_channel/pending_connection_manager_impl.h"
+#include "chromeos/services/secure_channel/public/cpp/client/fake_nearby_connector.h"
 #include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
 #include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
 #include "chromeos/services/secure_channel/secure_channel_disconnector_impl.h"
 #include "chromeos/services/secure_channel/secure_channel_initializer.h"
 #include "chromeos/services/secure_channel/timer_factory_impl.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
@@ -480,6 +482,8 @@ class SecureChannelServiceTest : public testing::Test {
 
   // testing::Test:
   void SetUp() override {
+    bluez::BluezDBusManager::GetSetterForTesting();
+    bluez::BluezDBusManager::InitializeFake();
     mock_adapter_ =
         base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
     is_adapter_powered_ = true;
@@ -494,6 +498,8 @@ class SecureChannelServiceTest : public testing::Test {
 
     test_task_runner_ = base::MakeRefCounted<base::TestSimpleTaskRunner>();
 
+    fake_nearby_connector_ = std::make_unique<FakeNearbyConnector>();
+
     fake_timer_factory_factory_ = std::make_unique<FakeTimerFactoryFactory>();
     TimerFactoryImpl::Factory::SetFactoryForTesting(
         fake_timer_factory_factory_.get());
@@ -778,10 +784,16 @@ class SecureChannelServiceTest : public testing::Test {
         ->CancelClientRequest();
   }
 
-  void FinishInitialization() {
+  void FinishInitialization(bool set_nearby_connector = true) {
     // The PendingConnectionManager should not have yet been created.
     EXPECT_FALSE(fake_pending_connection_manager());
 
+    if (set_nearby_connector) {
+      secure_channel_remote_->SetNearbyConnector(
+          fake_nearby_connector_->GeneratePendingRemote());
+      secure_channel_remote_.FlushForTesting();
+    }
+
     EXPECT_TRUE(test_task_runner_->HasPendingTask());
     test_task_runner_->RunUntilIdle();
 
@@ -1046,6 +1058,7 @@ class SecureChannelServiceTest : public testing::Test {
 
   scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner_;
+  std::unique_ptr<FakeNearbyConnector> fake_nearby_connector_;
 
   std::unique_ptr<FakeTimerFactoryFactory> fake_timer_factory_factory_;
   std::unique_ptr<TestRemoteDeviceCacheFactory>
@@ -1248,17 +1261,13 @@ TEST_F(SecureChannelServiceTest,
 }
 
 TEST_F(SecureChannelServiceTest,
-       InitiateConnection_Nearby_LocalDeviceMissingBluetoothAddress) {
-  FinishInitialization();
-
-  multidevice::RemoteDevice local_device = test_devices()[1];
-  local_device.bluetooth_public_address.clear();
+       InitiateConnection_Nearby_MissingNearbyConnector) {
+  FinishInitialization(/*set_nearby_connector=*/false);
 
   CallInitiateConnectionToDeviceAndVerifyRejection(
-      test_devices()[0], local_device, "feature",
+      test_devices()[0], test_devices()[1], "feature",
       ConnectionMedium::kNearbyConnections, ConnectionPriority::kLow,
-      mojom::ConnectionAttemptFailureReason::
-          LOCAL_DEVICE_INVALID_BLUETOOTH_ADDRESS);
+      mojom::ConnectionAttemptFailureReason::MISSING_NEARBY_CONNECTOR);
 }
 
 TEST_F(SecureChannelServiceTest, ListenForConnection_Nearby) {