[CrOS MultiDevice] Implement PendingConnectionManagerImpl.

This class creates one ConnectionAttempt per ConnectionAttemptDetails
requested; if more than one request shares the same
ConnectionAttemptDetails, a single ConnectionAttempt attempts a
connection for all associated requests.

If a ConnectionAttempt successfully creates a channel, this class
extracts client data from all requests to the same remote device and
alerts its delegate, deleting all associated ConnectionAttempts when it
is finished.

Bug: 824568, 752273
Change-Id: If9790549157919209e3e96f4a0b11d04fda2870c
Reviewed-on: https://chromium-review.googlesource.com/1103669
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Ryan Hansberry <hansberry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#568352}

chromeos/services/secure_channel/pending_connection_manager_impl.h

@@ -8,8 +8,14 @@
 #include <memory>
 #include <vector>
 
+#include "base/containers/flat_map.h"
+#include "base/containers/flat_set.h"
 #include "base/macros.h"
+#include "chromeos/services/secure_channel/ble_initiator_failure_type.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/connection_attempt.h"
+#include "chromeos/services/secure_channel/connection_attempt_delegate.h"
 #include "chromeos/services/secure_channel/connection_medium.h"
 #include "chromeos/services/secure_channel/connection_role.h"
 #include "chromeos/services/secure_channel/device_id_pair.h"
@@ -20,9 +26,18 @@ namespace chromeos {
 
 namespace secure_channel {
 
-// Concrete PendingConnectionManager implementation.
-// TODO(khorimoto): Implement.
-class PendingConnectionManagerImpl : public PendingConnectionManager {
+class BleConnectionManager;
+
+// Concrete PendingConnectionManager implementation. This class creates one
+// ConnectionAttempt per ConnectionAttemptDetails requested; if more than one
+// request shares the same ConnectionAttemptDetails, a single ConnectionAttempt
+// attempts a connection for all associated requests.
+//
+// If a ConnectionAttempt successfully creates a channel, this class extracts
+// client data from all requests to the same remote device and alerts its
+// delegate, deleting all associated ConnectionAttempts when it is finished.
+class PendingConnectionManagerImpl : public PendingConnectionManager,
+                                     public ConnectionAttemptDelegate {
  public:
   class Factory {
    public:
@@ -30,7 +45,8 @@ class PendingConnectionManagerImpl : public PendingConnectionManager {
     static void SetFactoryForTesting(Factory* test_factory);
     virtual ~Factory();
     virtual std::unique_ptr<PendingConnectionManager> BuildInstance(
-        Delegate* delegate);
+        Delegate* delegate,
+        BleConnectionManager* ble_connection_manager);
 
    private:
     static Factory* test_factory_;
@@ -39,13 +55,47 @@ class PendingConnectionManagerImpl : public PendingConnectionManager {
   ~PendingConnectionManagerImpl() override;
 
  private:
-  PendingConnectionManagerImpl(Delegate* delegate);
+  PendingConnectionManagerImpl(Delegate* delegate,
+                               BleConnectionManager* ble_connection_manager);
 
+  // PendingConnectionManager:
   void HandleConnectionRequest(
       const ConnectionAttemptDetails& connection_attempt_details,
       std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
       ConnectionPriority connection_priority) override;
 
+  // ConnectionAttemptDelegate:
+  void OnConnectionAttemptSucceeded(
+      const ConnectionDetails& connection_details,
+      std::unique_ptr<AuthenticatedChannel> authenticated_channel) override;
+  void OnConnectionAttemptFinishedWithoutConnection(
+      const ConnectionAttemptDetails& connection_attempt_details) override;
+
+  void HandleBleInitiatorRequest(
+      const ConnectionAttemptDetails& connection_attempt_details,
+      std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
+      ConnectionPriority connection_priority);
+  void HandleBleListenerRequest(
+      const ConnectionAttemptDetails& connection_attempt_details,
+      std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
+      ConnectionPriority connection_priority);
+
+  void RemoveMapEntriesForFinishedConnectionAttempt(
+      const ConnectionAttemptDetails& connection_attempt_details);
+
+  base::flat_map<DeviceIdPair,
+                 std::unique_ptr<ConnectionAttempt<BleInitiatorFailureType>>>
+      id_pair_to_ble_initiator_connection_attempts_;
+
+  base::flat_map<DeviceIdPair,
+                 std::unique_ptr<ConnectionAttempt<BleListenerFailureType>>>
+      id_pair_to_ble_listener_connection_attempts_;
+
+  base::flat_map<ConnectionDetails, base::flat_set<ConnectionAttemptDetails>>
+      details_to_attempt_details_map_;
+
+  BleConnectionManager* ble_connection_manager_;
+
   DISALLOW_COPY_AND_ASSIGN(PendingConnectionManagerImpl);
 };
 

chromeos/services/secure_channel/secure_channel_impl.cc

@@ -70,7 +70,9 @@ SecureChannelImpl::SecureChannelImpl()
               this /* delegate */)),
       pending_connection_manager_(
           PendingConnectionManagerImpl::Factory::Get()->BuildInstance(
-              this /* delegate */)),
+              this /* delegate */,
+              // TODO(khorimoto): Pass the actual BleConnectionManager here.
+              nullptr /* ble_connection_manager */)),
       remote_device_cache_(
           cryptauth::RemoteDeviceCache::Factory::Get()->BuildInstance()) {}
 

chromeos/services/secure_channel/secure_channel_service_unittest.cc

@@ -68,7 +68,10 @@ class FakePendingConnectionManagerFactory
 
  private:
   std::unique_ptr<PendingConnectionManager> BuildInstance(
-      PendingConnectionManager::Delegate* delegate) override {
+      PendingConnectionManager::Delegate* delegate,
+      BleConnectionManager* ble_connection_manager) override {
+    // TODO(khorimoto): Verify that |ble_connection_manager| is correctly passed
+    // to this factory.
     EXPECT_FALSE(instance_);
     auto instance = std::make_unique<FakePendingConnectionManager>(delegate);
     instance_ = instance.get();