[CrOS PhoneHub] Add NearbyConnectionManager

This class is responsible for handling connection requests as well as
requests to cancel an ongoing Nearby Connections attempt. This CL
creates the a base class a a fake, as well as a skeleton implementation
class. The implementation will be completed in a follow-up CL.

Bug: 1106937
Change-Id: I45d997192f5a055de1206f283676c7d490cd81b5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2415224
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Commit-Queue: James Vecore <vecore@google.com>
Auto-Submit: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: James Vecore <vecore@google.com>
Cr-Commit-Position: refs/heads/master@{#808081}

chromeos/services/secure_channel/BUILD.gn

@@ -104,6 +104,10 @@ static_library("secure_channel") {
     "multiplexed_channel.h",
     "multiplexed_channel_impl.cc",
     "multiplexed_channel_impl.h",
+    "nearby_connection_manager.cc",
+    "nearby_connection_manager.h",
+    "nearby_connection_manager_impl.cc",
+    "nearby_connection_manager_impl.h",
     "nearby_initiator_failure_type.cc",
     "nearby_initiator_failure_type.h",
     "pending_ble_connection_request_base.h",
@@ -219,6 +223,8 @@ static_library("test_support") {
     "fake_message_receiver.h",
     "fake_multiplexed_channel.cc",
     "fake_multiplexed_channel.h",
+    "fake_nearby_connection_manager.cc",
+    "fake_nearby_connection_manager.h",
     "fake_one_shot_timer.cc",
     "fake_one_shot_timer.h",
     "fake_pending_connection_manager.cc",
@@ -287,6 +293,7 @@ source_set("unit_tests") {
     "error_tolerant_ble_advertisement_impl_unittest.cc",
     "foreground_eid_generator_unittest.cc",
     "multiplexed_channel_impl_unittest.cc",
+    "nearby_connection_manager_impl_unittest.cc",
     "pending_ble_connection_request_base_unittest.cc",
     "pending_ble_initiator_connection_request_unittest.cc",
     "pending_ble_listener_connection_request_unittest.cc",

chromeos/services/secure_channel/fake_nearby_connection_manager.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 "chromeos/services/secure_channel/fake_nearby_connection_manager.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+FakeNearbyConnectionManager::FakeNearbyConnectionManager() = default;
+
+FakeNearbyConnectionManager::~FakeNearbyConnectionManager() = default;
+
+void FakeNearbyConnectionManager::PerformAttemptNearbyInitiatorConnection(
+    const DeviceIdPair& device_id_pair) {}
+
+void FakeNearbyConnectionManager::PerformCancelNearbyInitiatorConnectionAttempt(
+    const DeviceIdPair& device_id_pair) {}
+
+}  // namespace secure_channel
+
+}  // namespace chromeos

chromeos/services/secure_channel/fake_nearby_connection_manager.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 CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_NEARBY_CONNECTION_MANAGER_H_
+#define CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_NEARBY_CONNECTION_MANAGER_H_
+
+#include "chromeos/services/secure_channel/nearby_connection_manager.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+class FakeNearbyConnectionManager : public NearbyConnectionManager {
+ public:
+  FakeNearbyConnectionManager();
+  FakeNearbyConnectionManager(const FakeNearbyConnectionManager&) = delete;
+  FakeNearbyConnectionManager& operator=(const FakeNearbyConnectionManager&) =
+      delete;
+  ~FakeNearbyConnectionManager() override;
+
+  using NearbyConnectionManager::DoesAttemptExist;
+  using NearbyConnectionManager::GetDeviceIdPairsForRemoteDevice;
+  using NearbyConnectionManager::NotifyNearbyInitiatorConnectionSuccess;
+  using NearbyConnectionManager::NotifyNearbyInitiatorFailure;
+
+ private:
+  // NearbyConnectionManager:
+  void PerformAttemptNearbyInitiatorConnection(
+      const DeviceIdPair& device_id_pair) override;
+  void PerformCancelNearbyInitiatorConnectionAttempt(
+      const DeviceIdPair& device_id_pair) override;
+};
+
+}  // namespace secure_channel
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_NEARBY_CONNECTION_MANAGER_H_

chromeos/services/secure_channel/nearby_connection_manager.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 "chromeos/services/secure_channel/nearby_connection_manager.h"
+
+#include "base/stl_util.h"
+#include "chromeos/components/multidevice/logging/logging.h"
+#include "chromeos/services/secure_channel/authenticated_channel.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+NearbyConnectionManager::InitiatorConnectionAttemptMetadata::
+    InitiatorConnectionAttemptMetadata(
+        ConnectionSuccessCallback success_callback,
+        const FailureCallback& failure_callback)
+    : success_callback(std::move(success_callback)),
+      failure_callback(failure_callback) {}
+
+NearbyConnectionManager::InitiatorConnectionAttemptMetadata::
+    ~InitiatorConnectionAttemptMetadata() = default;
+
+NearbyConnectionManager::NearbyConnectionManager() = default;
+
+NearbyConnectionManager::~NearbyConnectionManager() = default;
+
+void NearbyConnectionManager::AttemptNearbyInitiatorConnection(
+    const DeviceIdPair& device_id_pair,
+    ConnectionSuccessCallback success_callback,
+    const FailureCallback& failure_callback) {
+  if (base::Contains(id_pair_to_initiator_metadata_map_, device_id_pair)) {
+    PA_LOG(ERROR) << "Tried to add Nearby initiator connection attempt, but "
+                  << "one was already active. Device IDs: " << device_id_pair;
+    NOTREACHED();
+    return;
+  }
+
+  id_pair_to_initiator_metadata_map_.emplace(std::make_pair(
+      device_id_pair, std::make_unique<InitiatorConnectionAttemptMetadata>(
+                          std::move(success_callback), failure_callback)));
+  remote_device_id_to_id_pair_map_[device_id_pair.remote_device_id()].insert(
+      device_id_pair);
+
+  PA_LOG(VERBOSE) << "Attempting Nearby connection for: " << device_id_pair;
+  PerformAttemptNearbyInitiatorConnection(device_id_pair);
+}
+
+void NearbyConnectionManager::CancelNearbyInitiatorConnectionAttempt(
+    const DeviceIdPair& device_id_pair) {
+  RemoveRequestMetadata(device_id_pair);
+
+  PA_LOG(VERBOSE) << "Canceling Nearby connection attempt for: "
+                  << device_id_pair;
+  PerformCancelNearbyInitiatorConnectionAttempt(device_id_pair);
+}
+
+const base::flat_set<DeviceIdPair>&
+NearbyConnectionManager::GetDeviceIdPairsForRemoteDevice(
+    const std::string& remote_device_id) const {
+  return remote_device_id_to_id_pair_map_.find(remote_device_id)->second;
+}
+
+bool NearbyConnectionManager::DoesAttemptExist(
+    const DeviceIdPair& device_id_pair) {
+  return base::Contains(id_pair_to_initiator_metadata_map_, device_id_pair);
+}
+
+void NearbyConnectionManager::NotifyNearbyInitiatorFailure(
+    const DeviceIdPair& device_id_pair,
+    NearbyInitiatorFailureType failure_type) {
+  PA_LOG(VERBOSE) << "Notifying client of Nearby initiator failure: "
+                  << device_id_pair;
+  GetInitiatorEntry(device_id_pair).failure_callback.Run(failure_type);
+}
+
+void NearbyConnectionManager::NotifyNearbyInitiatorConnectionSuccess(
+    const DeviceIdPair& device_id_pair,
+    std::unique_ptr<AuthenticatedChannel> authenticated_channel) {
+  PA_LOG(VERBOSE) << "Notifying client of successful Neraby connection for: "
+                  << device_id_pair;
+
+  // Retrieve the success callback out of the map first, then remove the
+  // associated metadata before invoking the callback.
+  ConnectionSuccessCallback success_callback =
+      std::move(GetInitiatorEntry(device_id_pair).success_callback);
+  RemoveRequestMetadata(device_id_pair);
+  std::move(success_callback).Run(std::move(authenticated_channel));
+}
+
+NearbyConnectionManager::InitiatorConnectionAttemptMetadata&
+NearbyConnectionManager::GetInitiatorEntry(const DeviceIdPair& device_id_pair) {
+  std::unique_ptr<InitiatorConnectionAttemptMetadata>& entry =
+      id_pair_to_initiator_metadata_map_[device_id_pair];
+  DCHECK(entry);
+  return *entry;
+}
+
+void NearbyConnectionManager::RemoveRequestMetadata(
+    const DeviceIdPair& device_id_pair) {
+  auto metadata_it = id_pair_to_initiator_metadata_map_.find(device_id_pair);
+  if (metadata_it == id_pair_to_initiator_metadata_map_.end()) {
+    PA_LOG(ERROR) << "Tried to remove Nearby initiator metadata, but none "
+                  << "existed. Device IDs: " << device_id_pair;
+    NOTREACHED();
+  } else {
+    id_pair_to_initiator_metadata_map_.erase(metadata_it);
+  }
+
+  auto id_pair_it =
+      remote_device_id_to_id_pair_map_.find(device_id_pair.remote_device_id());
+  if (id_pair_it == remote_device_id_to_id_pair_map_.end()) {
+    PA_LOG(ERROR) << "Tried to remove Nearby initiator attempt, but no attempt "
+                  << "existed. Device IDs: " << device_id_pair;
+    NOTREACHED();
+  } else {
+    id_pair_it->second.erase(device_id_pair);
+  }
+}
+
+}  // namespace secure_channel
+
+}  // namespace chromeos

chromeos/services/secure_channel/nearby_connection_manager.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 CHROMEOS_SERVICES_SECURE_CHANNEL_NEARBY_CONNECTION_MANAGER_H_
+#define CHROMEOS_SERVICES_SECURE_CHANNEL_NEARBY_CONNECTION_MANAGER_H_
+
+#include <memory>
+
+#include "base/callback.h"
+#include "base/containers/flat_map.h"
+#include "base/containers/flat_set.h"
+#include "base/macros.h"
+#include "chromeos/services/secure_channel/device_id_pair.h"
+#include "chromeos/services/secure_channel/nearby_initiator_failure_type.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+class AuthenticatedChannel;
+
+// Attempts connects to remote devices via the Nearby Connections library.
+class NearbyConnectionManager {
+ public:
+  NearbyConnectionManager(const NearbyConnectionManager&) = delete;
+  NearbyConnectionManager& operator=(const NearbyConnectionManager&) = delete;
+  virtual ~NearbyConnectionManager();
+
+  using ConnectionSuccessCallback =
+      base::OnceCallback<void(std::unique_ptr<AuthenticatedChannel>)>;
+  using FailureCallback =
+      base::RepeatingCallback<void(NearbyInitiatorFailureType)>;
+
+  // Attempts a connection, invoking the success/failure callback when the
+  // attempt has finished.
+  void AttemptNearbyInitiatorConnection(
+      const DeviceIdPair& device_id_pair,
+      ConnectionSuccessCallback success_callback,
+      const FailureCallback& failure_callback);
+
+  // Cancels an active connection attempt; the success/failure callback for this
+  // attempt will not be invoked.
+  void CancelNearbyInitiatorConnectionAttempt(
+      const DeviceIdPair& device_id_pair);
+
+ protected:
+  NearbyConnectionManager();
+
+  virtual void PerformAttemptNearbyInitiatorConnection(
+      const DeviceIdPair& device_id_pair) = 0;
+  virtual void PerformCancelNearbyInitiatorConnectionAttempt(
+      const DeviceIdPair& device_id_pair) = 0;
+
+  const base::flat_set<DeviceIdPair>& GetDeviceIdPairsForRemoteDevice(
+      const std::string& remote_device_id) const;
+  bool DoesAttemptExist(const DeviceIdPair& device_id_pair);
+
+  void NotifyNearbyInitiatorFailure(const DeviceIdPair& device_id_pair,
+                                    NearbyInitiatorFailureType failure_type);
+  void NotifyNearbyInitiatorConnectionSuccess(
+      const DeviceIdPair& device_id_pair,
+      std::unique_ptr<AuthenticatedChannel> authenticated_channel);
+
+ private:
+  struct InitiatorConnectionAttemptMetadata {
+    InitiatorConnectionAttemptMetadata(
+        ConnectionSuccessCallback success_callback,
+        const FailureCallback& failure_callback);
+    ~InitiatorConnectionAttemptMetadata();
+
+    ConnectionSuccessCallback success_callback;
+    FailureCallback failure_callback;
+  };
+
+  InitiatorConnectionAttemptMetadata& GetInitiatorEntry(
+      const DeviceIdPair& device_id_pair);
+  void RemoveRequestMetadata(const DeviceIdPair& device_id_pair);
+
+  base::flat_map<std::string, base::flat_set<DeviceIdPair>>
+      remote_device_id_to_id_pair_map_;
+  base::flat_map<DeviceIdPair,
+                 std::unique_ptr<InitiatorConnectionAttemptMetadata>>
+      id_pair_to_initiator_metadata_map_;
+};
+
+}  // namespace secure_channel
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_SECURE_CHANNEL_NEARBY_CONNECTION_MANAGER_H_

chromeos/services/secure_channel/nearby_connection_manager_impl.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 "chromeos/services/secure_channel/nearby_connection_manager_impl.h"
+
+#include "base/memory/ptr_util.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+// static
+NearbyConnectionManagerImpl::Factory*
+    NearbyConnectionManagerImpl::Factory::test_factory_ = nullptr;
+
+// static
+std::unique_ptr<NearbyConnectionManager>
+NearbyConnectionManagerImpl::Factory::Create() {
+  if (test_factory_)
+    return test_factory_->CreateInstance();
+
+  return base::WrapUnique(new NearbyConnectionManagerImpl());
+}
+
+// static
+void NearbyConnectionManagerImpl::Factory::SetFactoryForTesting(
+    Factory* test_factory) {
+  test_factory_ = test_factory;
+}
+
+NearbyConnectionManagerImpl::Factory::~Factory() = default;
+
+NearbyConnectionManagerImpl::NearbyConnectionManagerImpl() = default;
+
+NearbyConnectionManagerImpl::~NearbyConnectionManagerImpl() = default;
+
+void NearbyConnectionManagerImpl::PerformAttemptNearbyInitiatorConnection(
+    const DeviceIdPair& device_id_pair) {}
+
+void NearbyConnectionManagerImpl::PerformCancelNearbyInitiatorConnectionAttempt(
+    const DeviceIdPair& device_id_pair) {}
+
+}  // namespace secure_channel
+
+}  // namespace chromeos

chromeos/services/secure_channel/nearby_connection_manager_impl.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 CHROMEOS_SERVICES_SECURE_CHANNEL_NEARBY_CONNECTION_MANAGER_IMPL_H_
+#define CHROMEOS_SERVICES_SECURE_CHANNEL_NEARBY_CONNECTION_MANAGER_IMPL_H_
+
+#include "chromeos/services/secure_channel/nearby_connection_manager.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+// TODO(https://crbug.com/1106937): Add real implementation.
+class NearbyConnectionManagerImpl : public NearbyConnectionManager {
+ public:
+  class Factory {
+   public:
+    static std::unique_ptr<NearbyConnectionManager> Create();
+    static void SetFactoryForTesting(Factory* test_factory);
+
+   protected:
+    virtual ~Factory();
+    virtual std::unique_ptr<NearbyConnectionManager> CreateInstance() = 0;
+
+   private:
+    static Factory* test_factory_;
+  };
+
+  NearbyConnectionManagerImpl(const NearbyConnectionManagerImpl&) = delete;
+  NearbyConnectionManagerImpl& operator=(const NearbyConnectionManagerImpl&) =
+      delete;
+  ~NearbyConnectionManagerImpl() override;
+
+ private:
+  NearbyConnectionManagerImpl();
+
+  // NearbyConnectionManager:
+  void PerformAttemptNearbyInitiatorConnection(
+      const DeviceIdPair& device_id_pair) override;
+  void PerformCancelNearbyInitiatorConnectionAttempt(
+      const DeviceIdPair& device_id_pair) override;
+};
+
+}  // namespace secure_channel
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_SECURE_CHANNEL_NEARBY_CONNECTION_MANAGER_IMPL_H_

chromeos/services/secure_channel/nearby_connection_manager_impl_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 "chromeos/services/secure_channel/nearby_connection_manager_impl.h"
+
+#include <memory>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+class SecureChannelNearbyConnectionManagerImplTest : public testing::Test {
+ protected:
+  SecureChannelNearbyConnectionManagerImplTest() = default;
+  SecureChannelNearbyConnectionManagerImplTest(
+      const SecureChannelNearbyConnectionManagerImplTest&) = delete;
+  SecureChannelNearbyConnectionManagerImplTest& operator=(
+      const SecureChannelNearbyConnectionManagerImplTest&) = delete;
+  ~SecureChannelNearbyConnectionManagerImplTest() override = default;
+
+  // testing::Test:
+  void SetUp() override {
+    manager_ = NearbyConnectionManagerImpl::Factory::Create();
+  }
+
+  std::unique_ptr<NearbyConnectionManager> manager_;
+};
+
+// TODO(https://crbug.com/1106937): Delete when a real test is added.
+TEST_F(SecureChannelNearbyConnectionManagerImplTest, Create) {
+  EXPECT_TRUE(manager_);
+}
+
+}  // namespace secure_channel
+
+}  // namespace chromeos