[CrOS MultiDevice] Add ClientConnectionParameters.

This class encapsulates the parameters passed by clients of
SecureChannel which are meant to be tightly coupled to an individual
connection request.

Encapulsulating these within a class makes clients of the relevant
classes much less complex and allows PendingConnectionRequest and
SingleClientMessageProxy to use the ID associated with the parameters.

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

chromeos/services/secure_channel/BUILD.gn

@@ -12,6 +12,8 @@ static_library("secure_channel") {
     "authenticated_channel_impl.h",
     "channel_impl.cc",
     "channel_impl.h",
+    "client_connection_parameters.cc",
+    "client_connection_parameters.h",
     "connect_to_device_operation.h",
     "connect_to_device_operation_base.h",
     "connect_to_device_operation_factory.h",

chromeos/services/secure_channel/client_connection_parameters.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/client_connection_parameters.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+ClientConnectionParameters::ClientConnectionParameters(
+    const std::string& feature,
+    mojom::ConnectionDelegatePtr connection_delegate_ptr)
+    : feature_(feature),
+      connection_delegate_ptr_(std::move(connection_delegate_ptr)),
+      id_(base::UnguessableToken::Create()) {
+  DCHECK(!feature_.empty());
+  DCHECK(connection_delegate_ptr_);
+}
+
+ClientConnectionParameters::ClientConnectionParameters(
+    ClientConnectionParameters&& other)
+    : feature_(other.feature_),
+      connection_delegate_ptr_(std::move(other.connection_delegate_ptr_)),
+      id_(other.id_) {}
+
+ClientConnectionParameters& ClientConnectionParameters::operator=(
+    ClientConnectionParameters&& other) {
+  feature_ = other.feature_;
+  connection_delegate_ptr_ = std::move(other.connection_delegate_ptr_);
+  id_ = other.id_;
+  return *this;
+}
+
+ClientConnectionParameters::~ClientConnectionParameters() = default;
+
+bool ClientConnectionParameters::operator==(
+    const ClientConnectionParameters& other) const {
+  return feature() == other.feature() && id() == other.id() &&
+         connection_delegate_ptr_.get() == other.connection_delegate_ptr_.get();
+}
+
+bool ClientConnectionParameters::operator<(
+    const ClientConnectionParameters& other) const {
+  if (feature() != other.feature())
+    return feature() < other.feature();
+
+  if (id() != other.id())
+    return id() < other.id();
+
+  // Use pointer comparison of proxies.
+  return connection_delegate_ptr_.get() < other.connection_delegate_ptr_.get();
+}
+
+std::ostream& operator<<(std::ostream& stream,
+                         const ClientConnectionParameters& details) {
+  stream << "{feature: \"" << details.feature() << "\", "
+         << "id: \"" << details.id().ToString() << "\"}";
+  return stream;
+}
+
+}  // namespace secure_channel
+
+}  // namespace chromeos

chromeos/services/secure_channel/client_connection_parameters.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_CLIENT_CONNECTION_PARAMETERS_H_
+#define CHROMEOS_SERVICES_SECURE_CHANNEL_CLIENT_CONNECTION_PARAMETERS_H_
+
+#include <ostream>
+#include <string>
+
+#include "base/macros.h"
+#include "base/unguessable_token.h"
+#include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
+
+namespace chromeos {
+
+namespace secure_channel {
+
+// Parameters associated with a client request, which should be tightly-coupled
+// to the associated communication channel.
+class ClientConnectionParameters {
+ public:
+  ClientConnectionParameters(
+      const std::string& feature,
+      mojom::ConnectionDelegatePtr connection_delegate_ptr);
+  ClientConnectionParameters(ClientConnectionParameters&& other);
+  ClientConnectionParameters& operator=(ClientConnectionParameters&& other);
+  virtual ~ClientConnectionParameters();
+
+  const base::UnguessableToken& id() const { return id_; }
+
+  const std::string& feature() const { return feature_; }
+
+  mojom::ConnectionDelegatePtr& connection_delegate_ptr() {
+    return connection_delegate_ptr_;
+  }
+
+  bool operator==(const ClientConnectionParameters& other) const;
+  bool operator<(const ClientConnectionParameters& other) const;
+
+ private:
+  std::string feature_;
+  mojom::ConnectionDelegatePtr connection_delegate_ptr_;
+  base::UnguessableToken id_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClientConnectionParameters);
+};
+
+std::ostream& operator<<(std::ostream& stream,
+                         const ClientConnectionParameters& details);
+
+}  // namespace secure_channel
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_SECURE_CHANNEL_CLIENT_CONNECTION_PARAMETERS_H_

chromeos/services/secure_channel/connection_attempt.h

@@ -12,6 +12,7 @@
 
 #include "base/macros.h"
 #include "chromeos/components/proximity_auth/logging/logging.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/connection_attempt_delegate.h"
 #include "chromeos/services/secure_channel/connection_details.h"
 #include "chromeos/services/secure_channel/pending_connection_request.h"
@@ -29,13 +30,13 @@ class AuthenticatedChannel;
 template <typename FailureDetailType>
 class ConnectionAttempt {
  public:
-  // Extracts all of the features and ConnectionDelegates owned by |attempt|'s
+  // Extracts all of the ClientConnectionParameters owned by |attempt|'s
   // PendingConnectionRequests. This function deletes |attempt| as part of this
   // process to ensure that it is no longer used after extraction is complete.
-  static std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-  ExtractClientData(
+  static std::vector<ClientConnectionParameters>
+  ExtractClientConnectionParameters(
       std::unique_ptr<ConnectionAttempt<FailureDetailType>> attempt) {
-    return attempt->ExtractClientData();
+    return attempt->ExtractClientConnectionParameters();
   }
 
   virtual ~ConnectionAttempt() = default;
@@ -78,10 +79,10 @@ class ConnectionAttempt {
   virtual void ProcessAddingNewConnectionRequest(
       std::unique_ptr<PendingConnectionRequest<FailureDetailType>> request) = 0;
 
-  // Extracts the features and ConnectionDelegates from all child
+  // Extracts the ClientConnectionParameters from all child
   // PendingConnectionRequests.
-  virtual std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-  ExtractClientData() = 0;
+  virtual std::vector<ClientConnectionParameters>
+  ExtractClientConnectionParameters() = 0;
 
   void OnConnectionAttemptSucceeded(
       std::unique_ptr<AuthenticatedChannel> authenticated_channel) {

chromeos/services/secure_channel/connection_attempt_base.h

@@ -71,7 +71,7 @@ class ConnectionAttemptBase : public ConnectionAttempt<FailureDetailType>,
   void ProcessAddingNewConnectionRequest(
       std::unique_ptr<PendingConnectionRequest<FailureDetailType>> request)
       override {
-    if (base::ContainsKey(id_to_request_map_, request->request_id())) {
+    if (base::ContainsKey(id_to_request_map_, request->GetRequestId())) {
       PA_LOG(ERROR) << "ConnectionAttemptBase::"
                     << "ProcessAddingNewConnectionRequest(): Processing "
                     << "request whose ID has already been processed.";
@@ -79,7 +79,7 @@ class ConnectionAttemptBase : public ConnectionAttempt<FailureDetailType>,
     }
 
     bool was_empty = id_to_request_map_.empty();
-    id_to_request_map_[request->request_id()] = std::move(request);
+    id_to_request_map_[request->GetRequestId()] = std::move(request);
 
     // In the case that this ConnectionAttempt was just created and had not yet
     // received a request yet, start up an operation.
@@ -87,13 +87,13 @@ class ConnectionAttemptBase : public ConnectionAttempt<FailureDetailType>,
       StartNextConnectToDeviceOperation();
   }
 
-  std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-  ExtractClientData() override {
-    std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>> data_list;
+  std::vector<ClientConnectionParameters> ExtractClientConnectionParameters()
+      override {
+    std::vector<ClientConnectionParameters> data_list;
     for (auto& map_entry : id_to_request_map_) {
       data_list.push_back(
-          PendingConnectionRequest<FailureDetailType>::ExtractClientData(
-              std::move(map_entry.second)));
+          PendingConnectionRequest<FailureDetailType>::
+              ExtractClientConnectionParameters(std::move(map_entry.second)));
     }
     return data_list;
   }

chromeos/services/secure_channel/connection_attempt_base_unittest.cc

@@ -69,8 +69,8 @@ class SecureChannelConnectionAttemptBaseTest : public testing::Test {
   }
 
   void TearDown() override {
-    // ExtractClientData() tests destroy |connection_attempt_|, so no additional
-    // verifications should be performed.
+    // ExtractClientConnectionParameters() tests destroy |connection_attempt_|,
+    // so no additional verifications should be performed.
     if (is_extract_client_data_test_)
       return;
 
@@ -138,7 +138,7 @@ class SecureChannelConnectionAttemptBaseTest : public testing::Test {
                        base::UnguessableTokenHash>
         id_to_num_details_map;
     for (const auto* request : active_requests_) {
-      id_to_num_details_map[request->request_id()] =
+      id_to_num_details_map[request->GetRequestId()] =
           request->handled_failure_details().size();
     }
 
@@ -149,7 +149,7 @@ class SecureChannelConnectionAttemptBaseTest : public testing::Test {
     // Now, ensure that each active request had one additional failure detail
     // added, and verify that it was |kTestFailureDetail|.
     for (const auto* request : active_requests_) {
-      EXPECT_EQ(id_to_num_details_map[request->request_id()] + 1,
+      EXPECT_EQ(id_to_num_details_map[request->GetRequestId()] + 1,
                 request->handled_failure_details().size());
       EXPECT_EQ(kTestFailureDetail, request->handled_failure_details().back());
     }
@@ -193,10 +193,9 @@ class SecureChannelConnectionAttemptBaseTest : public testing::Test {
     EXPECT_FALSE(fake_delegate_->authenticated_channel());
   }
 
-  std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-  ExtractClientData() {
+  std::vector<ClientConnectionParameters> ExtractClientConnectionParameters() {
     is_extract_client_data_test_ = true;
-    return ConnectionAttempt<std::string>::ExtractClientData(
+    return ConnectionAttempt<std::string>::ExtractClientConnectionParameters(
         std::move(connection_attempt_));
   }
 
@@ -360,13 +359,14 @@ TEST_F(SecureChannelConnectionAttemptBaseTest, TwoRequests_FailThenSuccess) {
   FinishOperationSuccessfully(operation3);
 }
 
-TEST_F(SecureChannelConnectionAttemptBaseTest, ExtractClientData) {
+TEST_F(SecureChannelConnectionAttemptBaseTest,
+       ExtractClientConnectionParameters) {
   FakePendingConnectionRequest* request1 = AddNewRequest();
   auto fake_connection_delegate_1 = std::make_unique<FakeConnectionDelegate>();
   auto fake_connection_delegate_ptr_1 =
       fake_connection_delegate_1->GenerateInterfacePtr();
   auto* fake_connection_delegate_proxy_1 = fake_connection_delegate_ptr_1.get();
-  request1->set_client_data_for_extraction(std::make_pair(
+  request1->set_client_data_for_extraction(ClientConnectionParameters(
       "request1Feature", std::move(fake_connection_delegate_ptr_1)));
 
   FakePendingConnectionRequest* request2 = AddNewRequest();
@@ -374,27 +374,24 @@ TEST_F(SecureChannelConnectionAttemptBaseTest, ExtractClientData) {
   auto fake_connection_delegate_ptr_2 =
       fake_connection_delegate_2->GenerateInterfacePtr();
   auto* fake_connection_delegate_proxy_2 = fake_connection_delegate_ptr_2.get();
-  request2->set_client_data_for_extraction(std::make_pair(
+  request2->set_client_data_for_extraction(ClientConnectionParameters(
       "request2Feature", std::move(fake_connection_delegate_ptr_2)));
 
-  auto extracted_client_data = ExtractClientData();
+  auto extracted_client_data = ExtractClientConnectionParameters();
   EXPECT_EQ(2u, extracted_client_data.size());
 
   // The extracted client data may not be returned in the same order that as the
   // associated requests were added to |conenction_attempt_|, since
   // ConnectionAttemptBase internally utilizes a std::unordered_map. Sort the
   // data before making verifications to ensure correctness.
-  std::sort(extracted_client_data.begin(), extracted_client_data.end(),
-            [](const auto& client_data_pair_1, const auto& client_data_pair_2) {
-              return client_data_pair_1.first < client_data_pair_2.first;
-            });
+  std::sort(extracted_client_data.begin(), extracted_client_data.end());
 
-  EXPECT_EQ("request1Feature", extracted_client_data[0].first);
+  EXPECT_EQ("request1Feature", extracted_client_data[0].feature());
   EXPECT_EQ(fake_connection_delegate_proxy_1,
-            extracted_client_data[0].second.get());
-  EXPECT_EQ("request2Feature", extracted_client_data[1].first);
+            extracted_client_data[0].connection_delegate_ptr().get());
+  EXPECT_EQ("request2Feature", extracted_client_data[1].feature());
   EXPECT_EQ(fake_connection_delegate_proxy_2,
-            extracted_client_data[1].second.get());
+            extracted_client_data[1].connection_delegate_ptr().get());
 }
 
 }  // namespace secure_channel

chromeos/services/secure_channel/fake_connection_attempt.cc

@@ -20,13 +20,13 @@ FakeConnectionAttempt::~FakeConnectionAttempt() = default;
 void FakeConnectionAttempt::ProcessAddingNewConnectionRequest(
     std::unique_ptr<PendingConnectionRequest<std::string>> request) {
   DCHECK(request);
-  DCHECK(!base::ContainsKey(id_to_request_map_, request->request_id()));
+  DCHECK(!base::ContainsKey(id_to_request_map_, request->GetRequestId()));
 
-  id_to_request_map_[request->request_id()] = std::move(request);
+  id_to_request_map_[request->GetRequestId()] = std::move(request);
 }
 
-std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-FakeConnectionAttempt::ExtractClientData() {
+std::vector<ClientConnectionParameters>
+FakeConnectionAttempt::ExtractClientConnectionParameters() {
   return std::move(client_data_for_extraction_);
 }
 

chromeos/services/secure_channel/fake_connection_attempt.h

@@ -10,6 +10,7 @@
 
 #include "base/macros.h"
 #include "base/unguessable_token.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/connection_attempt.h"
 #include "chromeos/services/secure_channel/pending_connection_request.h"
 
@@ -34,8 +35,7 @@ class FakeConnectionAttempt : public ConnectionAttempt<std::string> {
   const IdToRequestMap& id_to_request_map() const { return id_to_request_map_; }
 
   void set_client_data_for_extraction(
-      std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-          client_data_for_extraction) {
+      std::vector<ClientConnectionParameters> client_data_for_extraction) {
     client_data_for_extraction_ = std::move(client_data_for_extraction);
   }
 
@@ -49,13 +49,12 @@ class FakeConnectionAttempt : public ConnectionAttempt<std::string> {
   // ConnectionAttempt<std::string>:
   void ProcessAddingNewConnectionRequest(
       std::unique_ptr<PendingConnectionRequest<std::string>> request) override;
-  std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-  ExtractClientData() override;
+  std::vector<ClientConnectionParameters> ExtractClientConnectionParameters()
+      override;
 
   IdToRequestMap id_to_request_map_;
 
-  std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-      client_data_for_extraction_;
+  std::vector<ClientConnectionParameters> client_data_for_extraction_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeConnectionAttempt);
 };

chromeos/services/secure_channel/fake_multiplexed_channel.cc

@@ -36,10 +36,8 @@ bool FakeMultiplexedChannel::IsDisconnected() {
 }
 
 void FakeMultiplexedChannel::PerformAddClientToChannel(
-    const std::string& feature,
-    mojom::ConnectionDelegatePtr connection_delegate_ptr) {
-  added_clients_.push_back(
-      std::make_pair(feature, std::move(connection_delegate_ptr)));
+    ClientConnectionParameters client_connection_parameters) {
+  added_clients_.push_back(std::move(client_connection_parameters));
 }
 
 FakeMultiplexedChannelDelegate::FakeMultiplexedChannelDelegate() = default;

chromeos/services/secure_channel/fake_multiplexed_channel.h

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/macros.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/connection_details.h"
 #include "chromeos/services/secure_channel/multiplexed_channel.h"
 #include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
@@ -24,8 +25,7 @@ class FakeMultiplexedChannel : public MultiplexedChannel {
                          ConnectionDetails connection_details);
   ~FakeMultiplexedChannel() override;
 
-  std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>&
-  added_clients() {
+  std::vector<ClientConnectionParameters>& added_clients() {
     return added_clients_;
   }
 
@@ -40,14 +40,12 @@ class FakeMultiplexedChannel : public MultiplexedChannel {
   bool IsDisconnecting() override;
   bool IsDisconnected() override;
   void PerformAddClientToChannel(
-      const std::string& feature,
-      mojom::ConnectionDelegatePtr connection_delegate_ptr) override;
+      ClientConnectionParameters client_connection_parameters) override;
 
   bool is_disconnecting_ = false;
   bool is_disconnected_ = false;
 
-  std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>
-      added_clients_;
+  std::vector<ClientConnectionParameters> added_clients_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeMultiplexedChannel);
 };

chromeos/services/secure_channel/fake_pending_connection_request.cc

@@ -4,24 +4,33 @@
 
 #include "chromeos/services/secure_channel/fake_pending_connection_request.h"
 
+#include "base/logging.h"
+
 namespace chromeos {
 
 namespace secure_channel {
 
 FakePendingConnectionRequest::FakePendingConnectionRequest(
     PendingConnectionRequestDelegate* delegate)
-    : PendingConnectionRequest<std::string>(delegate) {}
+    : PendingConnectionRequest<std::string>(delegate),
+      id_(base::UnguessableToken::Create()) {}
 
 FakePendingConnectionRequest::~FakePendingConnectionRequest() = default;
 
+const base::UnguessableToken& FakePendingConnectionRequest::GetRequestId()
+    const {
+  return id_;
+}
+
 void FakePendingConnectionRequest::HandleConnectionFailure(
     std::string failure_detail) {
   handled_failure_details_.push_back(failure_detail);
 }
 
-std::pair<std::string, mojom::ConnectionDelegatePtr>
-FakePendingConnectionRequest::ExtractClientData() {
-  return std::move(client_data_for_extraction_);
+ClientConnectionParameters
+FakePendingConnectionRequest::ExtractClientConnectionParameters() {
+  DCHECK(client_data_for_extraction_);
+  return std::move(*client_data_for_extraction_);
 }
 
 }  // namespace secure_channel

chromeos/services/secure_channel/fake_pending_connection_request.h

@@ -10,6 +10,9 @@
 #include <vector>
 
 #include "base/macros.h"
+#include "base/optional.h"
+#include "base/unguessable_token.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/pending_connection_request.h"
 #include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
 
@@ -32,11 +35,13 @@ class FakePendingConnectionRequest
   }
 
   void set_client_data_for_extraction(
-      std::pair<std::string, mojom::ConnectionDelegatePtr>
-          client_data_for_extraction) {
+      ClientConnectionParameters client_data_for_extraction) {
     client_data_for_extraction_ = std::move(client_data_for_extraction);
   }
 
+  // PendingConnectionRequest<std::string>:
+  const base::UnguessableToken& GetRequestId() const override;
+
   // Make NotifyRequestFinishedWithoutConnection() public for testing.
   using PendingConnectionRequest<
       std::string>::NotifyRequestFinishedWithoutConnection;
@@ -44,14 +49,13 @@ class FakePendingConnectionRequest
  private:
   // PendingConnectionRequest<std::string>:
   void HandleConnectionFailure(std::string failure_detail) override;
+  ClientConnectionParameters ExtractClientConnectionParameters() override;
 
-  std::pair<std::string, mojom::ConnectionDelegatePtr> ExtractClientData()
-      override;
+  const base::UnguessableToken id_;
 
   std::vector<std::string> handled_failure_details_;
 
-  std::pair<std::string, mojom::ConnectionDelegatePtr>
-      client_data_for_extraction_;
+  base::Optional<ClientConnectionParameters> client_data_for_extraction_;
 
   DISALLOW_COPY_AND_ASSIGN(FakePendingConnectionRequest);
 };

chromeos/services/secure_channel/fake_single_client_message_proxy.cc

@@ -12,11 +12,16 @@ FakeSingleClientMessageProxy::FakeSingleClientMessageProxy(
     Delegate* delegate,
     base::OnceCallback<void(const base::UnguessableToken&)> destructor_callback)
     : SingleClientMessageProxy(delegate),
+      proxy_id_(base::UnguessableToken::Create()),
       destructor_callback_(std::move(destructor_callback)) {}
 
 FakeSingleClientMessageProxy::~FakeSingleClientMessageProxy() {
   if (destructor_callback_)
-    std::move(destructor_callback_).Run(proxy_id());
+    std::move(destructor_callback_).Run(GetProxyId());
+}
+
+const base::UnguessableToken& FakeSingleClientMessageProxy::GetProxyId() {
+  return proxy_id_;
 }
 
 void FakeSingleClientMessageProxy::HandleReceivedMessage(

chromeos/services/secure_channel/fake_single_client_message_proxy.h

@@ -35,6 +35,9 @@ class FakeSingleClientMessageProxy : public SingleClientMessageProxy {
     return processed_messages_;
   }
 
+  // SingleClientMessageProxy:
+  const base::UnguessableToken& GetProxyId() override;
+
   // Public for testing.
   using SingleClientMessageProxy::NotifySendMessageRequested;
   using SingleClientMessageProxy::NotifyClientDisconnected;
@@ -46,6 +49,7 @@ class FakeSingleClientMessageProxy : public SingleClientMessageProxy {
                              const std::string& payload) override;
   void HandleRemoteDeviceDisconnection() override;
 
+  const base::UnguessableToken proxy_id_;
   base::OnceCallback<void(const base::UnguessableToken&)> destructor_callback_;
 
   std::vector<std::pair<std::string, std::string>> processed_messages_;

chromeos/services/secure_channel/multiplexed_channel.cc

@@ -20,12 +20,11 @@ MultiplexedChannel::MultiplexedChannel(Delegate* delegate,
 MultiplexedChannel::~MultiplexedChannel() = default;
 
 bool MultiplexedChannel::AddClientToChannel(
-    const std::string& feature,
-    mojom::ConnectionDelegatePtr connection_delegate_ptr) {
+    ClientConnectionParameters client_connection_parameters) {
   if (IsDisconnecting() || IsDisconnected())
     return false;
 
-  PerformAddClientToChannel(feature, std::move(connection_delegate_ptr));
+  PerformAddClientToChannel(std::move(client_connection_parameters));
   return true;
 }
 

chromeos/services/secure_channel/multiplexed_channel.h

@@ -6,6 +6,7 @@
 #define CHROMEOS_SERVICES_SECURE_CHANNEL_MULTIPLEXED_CHANNEL_H_
 
 #include "base/macros.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/connection_details.h"
 #include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
 
@@ -35,8 +36,8 @@ class MultiplexedChannel {
   // Shares this channel with an additional client. Returns whether this action
   // was successful; all calls are expected to succeed unless the channel is
   // disconnected or disconnecting.
-  bool AddClientToChannel(const std::string& feature,
-                          mojom::ConnectionDelegatePtr connection_delegate_ptr);
+  bool AddClientToChannel(
+      ClientConnectionParameters client_connection_parameters);
 
   const ConnectionDetails& connection_details() { return connection_details_; }
 
@@ -44,8 +45,7 @@ class MultiplexedChannel {
   MultiplexedChannel(Delegate* delegate, ConnectionDetails connection_details);
 
   virtual void PerformAddClientToChannel(
-      const std::string& feature,
-      mojom::ConnectionDelegatePtr connection_delegate_ptr) = 0;
+      ClientConnectionParameters client_connection_parameters) = 0;
 
   void NotifyDisconnected();
 

chromeos/services/secure_channel/multiplexed_channel_impl.cc

@@ -40,7 +40,7 @@ MultiplexedChannelImpl::Factory::BuildInstance(
     std::unique_ptr<AuthenticatedChannel> authenticated_channel,
     MultiplexedChannel::Delegate* delegate,
     ConnectionDetails connection_details,
-    InitialClientList* initial_clients) {
+    std::vector<ClientConnectionParameters>* initial_clients) {
   DCHECK(authenticated_channel);
   DCHECK(!authenticated_channel->is_disconnected());
   DCHECK(delegate);
@@ -49,9 +49,9 @@ MultiplexedChannelImpl::Factory::BuildInstance(
 
   auto channel = base::WrapUnique(new MultiplexedChannelImpl(
       std::move(authenticated_channel), delegate, connection_details));
-  for (auto& client : *initial_clients) {
+  for (auto& client_connection_parameters : *initial_clients) {
     bool success =
-        channel->AddClientToChannel(client.first, std::move(client.second));
+        channel->AddClientToChannel(std::move(client_connection_parameters));
     if (!success) {
       PA_LOG(ERROR) << "MultiplexedChannelImpl::Factory::BuildInstance(): "
                     << "Failed to add initial client.";
@@ -84,15 +84,14 @@ bool MultiplexedChannelImpl::IsDisconnected() {
 }
 
 void MultiplexedChannelImpl::PerformAddClientToChannel(
-    const std::string& feature,
-    mojom::ConnectionDelegatePtr connection_delegate_ptr) {
-  DCHECK(!feature.empty());
-  DCHECK(connection_delegate_ptr);
+    ClientConnectionParameters client_connection_parameters) {
+  DCHECK(!client_connection_parameters.feature().empty());
+  DCHECK(client_connection_parameters.connection_delegate_ptr());
 
   auto proxy = SingleClientMessageProxyImpl::Factory::Get()->BuildInstance(
-      this /* delegate */, feature, std::move(connection_delegate_ptr));
-  DCHECK(!base::ContainsKey(id_to_proxy_map_, proxy->proxy_id()));
-  id_to_proxy_map_[proxy->proxy_id()] = std::move(proxy);
+      this /* delegate */, std::move(client_connection_parameters));
+  DCHECK(!base::ContainsKey(id_to_proxy_map_, proxy->GetProxyId()));
+  id_to_proxy_map_[proxy->GetProxyId()] = std::move(proxy);
 }
 
 void MultiplexedChannelImpl::OnDisconnected() {

chromeos/services/secure_channel/multiplexed_channel_impl.h

@@ -39,13 +39,11 @@ class MultiplexedChannelImpl : public MultiplexedChannel,
 
     virtual ~Factory();
 
-    using InitialClientList =
-        std::vector<std::pair<std::string, mojom::ConnectionDelegatePtr>>;
     virtual std::unique_ptr<MultiplexedChannel> BuildInstance(
         std::unique_ptr<AuthenticatedChannel> authenticated_channel,
         MultiplexedChannel::Delegate* delegate,
         ConnectionDetails connection_details,
-        InitialClientList* initial_clients);
+        std::vector<ClientConnectionParameters>* initial_clients);
 
    private:
     static Factory* test_factory_;
@@ -63,8 +61,7 @@ class MultiplexedChannelImpl : public MultiplexedChannel,
   bool IsDisconnecting() override;
   bool IsDisconnected() override;
   void PerformAddClientToChannel(
-      const std::string& feature,
-      mojom::ConnectionDelegatePtr connection_delegate_ptr) override;
+      ClientConnectionParameters client_connection_parameters) override;
 
   // AuthenticatedChannel::Observer:
   void OnDisconnected() override;

chromeos/services/secure_channel/multiplexed_channel_impl_unittest.cc

@@ -12,6 +12,7 @@
 
 #include "base/stl_util.h"
 #include "base/test/scoped_task_environment.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/connection_details.h"
 #include "chromeos/services/secure_channel/connection_medium.h"
 #include "chromeos/services/secure_channel/fake_authenticated_channel.h"
@@ -52,10 +53,9 @@ class FakeSingleClientMessageProxyImplFactory
  private:
   std::unique_ptr<SingleClientMessageProxy> BuildInstance(
       SingleClientMessageProxy::Delegate* delegate,
-      const std::string& feature,
-      mojom::ConnectionDelegatePtr connection_delegate_ptr) override {
-    EXPECT_EQ(kTestFeature, feature);
-    EXPECT_TRUE(connection_delegate_ptr);
+      ClientConnectionParameters client_connection_parameters) override {
+    EXPECT_EQ(kTestFeature, client_connection_parameters.feature());
+    EXPECT_TRUE(client_connection_parameters.connection_delegate_ptr());
 
     if (!expected_delegate_)
       expected_delegate_ = delegate;
@@ -70,7 +70,7 @@ class FakeSingleClientMessageProxyImplFactory
             base::Unretained(this)));
     FakeSingleClientMessageProxy* proxy_raw =
         static_cast<FakeSingleClientMessageProxy*>(proxy.get());
-    id_to_active_proxy_map_[proxy->proxy_id()] = proxy_raw;
+    id_to_active_proxy_map_[proxy->GetProxyId()] = proxy_raw;
 
     return proxy;
   }
@@ -108,7 +108,7 @@ class SecureChannelMultiplexedChannelImplTest : public testing::Test {
     // The default list contains one client.
     initial_fake_connection_delegate_ =
         std::make_unique<FakeConnectionDelegate>();
-    initial_client_list_.push_back(std::make_pair(
+    initial_client_list_.push_back(ClientConnectionParameters(
         kTestFeature,
         initial_fake_connection_delegate_->GenerateInterfacePtr()));
   }
@@ -196,7 +196,7 @@ class SecureChannelMultiplexedChannelImplTest : public testing::Test {
     bool is_last_client = id_to_active_proxy_map().size() == 1u;
     EXPECT_EQ(is_last_client, expected_to_be_last_client);
 
-    base::UnguessableToken proxy_id = sending_proxy->proxy_id();
+    base::UnguessableToken proxy_id = sending_proxy->GetProxyId();
 
     // All relevant parties should still indicate that the connection is valid.
     EXPECT_TRUE(base::ContainsKey(id_to_active_proxy_map(), proxy_id));
@@ -255,12 +255,13 @@ class SecureChannelMultiplexedChannelImplTest : public testing::Test {
   void AddClientToChannel(
       const std::string& feature,
       mojom::ConnectionDelegatePtr connection_delegate_ptr) {
-    bool success = multiplexed_channel_->AddClientToChannel(
-        feature, std::move(connection_delegate_ptr));
+    bool success =
+        multiplexed_channel_->AddClientToChannel(ClientConnectionParameters(
+            feature, std::move(connection_delegate_ptr)));
     EXPECT_TRUE(success);
   }
 
-  MultiplexedChannelImpl::Factory::InitialClientList& initial_client_list() {
+  std::vector<ClientConnectionParameters>& initial_client_list() {
     return initial_client_list_;
   }
 
@@ -292,7 +293,7 @@ class SecureChannelMultiplexedChannelImplTest : public testing::Test {
 
   std::unique_ptr<FakeSingleClientMessageProxyImplFactory> fake_proxy_factory_;
 
-  MultiplexedChannelImpl::Factory::InitialClientList initial_client_list_;
+  std::vector<ClientConnectionParameters> initial_client_list_;
   std::unique_ptr<FakeConnectionDelegate> initial_fake_connection_delegate_;
 
   FakeAuthenticatedChannel* fake_authenticated_channel_ = nullptr;
@@ -393,7 +394,7 @@ TEST_F(SecureChannelMultiplexedChannelImplTest,
   // Add a second initial client.
   std::unique_ptr<FakeConnectionDelegate> fake_connection_delegate_2 =
       std::make_unique<FakeConnectionDelegate>();
-  initial_client_list().push_back(std::make_pair(
+  initial_client_list().push_back(ClientConnectionParameters(
       kTestFeature, fake_connection_delegate_2->GenerateInterfacePtr()));
 
   CreateChannel();

chromeos/services/secure_channel/pending_connection_request.h

@@ -9,7 +9,7 @@
 #include <utility>
 
 #include "base/macros.h"
-#include "base/unguessable_token.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/pending_connection_request_delegate.h"
 #include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
 
@@ -26,12 +26,12 @@ namespace secure_channel {
 template <typename FailureDetailType>
 class PendingConnectionRequest {
  public:
-  // Extracts |request|'s feature and ConnectionDelegate. This function deletes
+  // Extracts |request|'s ClientConnectionParameters. This function deletes
   // |request| as part of this process to ensure that it is no longer used after
   // extraction is complete.
-  static std::pair<std::string, mojom::ConnectionDelegatePtr> ExtractClientData(
+  static ClientConnectionParameters ExtractClientConnectionParameters(
       std::unique_ptr<PendingConnectionRequest<FailureDetailType>> request) {
-    return request->ExtractClientData();
+    return request->ExtractClientConnectionParameters();
   }
 
   virtual ~PendingConnectionRequest() = default;
@@ -40,26 +40,24 @@ class PendingConnectionRequest {
   // trying to connect after some number of failures.
   virtual void HandleConnectionFailure(FailureDetailType failure_detail) = 0;
 
-  const base::UnguessableToken& request_id() const { return request_id_; }
+  virtual const base::UnguessableToken& GetRequestId() const = 0;
 
  protected:
   PendingConnectionRequest(PendingConnectionRequestDelegate* delegate)
-      : delegate_(delegate), request_id_(base::UnguessableToken::Create()) {
+      : delegate_(delegate) {
     DCHECK(delegate_);
   }
 
   // Extracts the feature and ConnectionDelegate from this request.
-  virtual std::pair<std::string, mojom::ConnectionDelegatePtr>
-  ExtractClientData() = 0;
+  virtual ClientConnectionParameters ExtractClientConnectionParameters() = 0;
 
   void NotifyRequestFinishedWithoutConnection(
       PendingConnectionRequestDelegate::FailedConnectionReason reason) {
-    delegate_->OnRequestFinishedWithoutConnection(request_id_, reason);
+    delegate_->OnRequestFinishedWithoutConnection(GetRequestId(), reason);
   }
 
  private:
   PendingConnectionRequestDelegate* delegate_;
-  const base::UnguessableToken request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingConnectionRequest);
 };

chromeos/services/secure_channel/pending_connection_request_base.h

@@ -11,6 +11,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chromeos/components/proximity_auth/logging/logging.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/pending_connection_request.h"
 #include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
 
@@ -33,27 +34,28 @@ class PendingConnectionRequestBase
  public:
   ~PendingConnectionRequestBase() override = default;
 
+  // PendingConnectionRequest<FailureDetailType>:
+  const base::UnguessableToken& GetRequestId() const override {
+    return client_connection_parameters_.id();
+  }
+
  protected:
   PendingConnectionRequestBase(
-      const std::string& feature,
+      ClientConnectionParameters client_connection_parameters,
       const std::string& readable_request_type_for_logging,
-      PendingConnectionRequestDelegate* delegate,
-      mojom::ConnectionDelegatePtr connection_delegate_ptr)
+      PendingConnectionRequestDelegate* delegate)
       : PendingConnectionRequest<FailureDetailType>(delegate),
-        feature_(feature),
+        client_connection_parameters_(std::move(client_connection_parameters)),
         readable_request_type_for_logging_(readable_request_type_for_logging),
-        connection_delegate_ptr_(std::move(connection_delegate_ptr)),
         weak_ptr_factory_(this) {
-    DCHECK(!feature_.empty());
-    DCHECK(connection_delegate_ptr_);
-
     // If the client disconnects its delegate, the client is signaling that the
     // connection request has been canceled.
-    connection_delegate_ptr_.set_connection_error_handler(base::BindOnce(
-        &PendingConnectionRequestBase::OnFinishedWithoutConnection,
-        weak_ptr_factory_.GetWeakPtr(),
-        PendingConnectionRequestDelegate::FailedConnectionReason::
-            kRequestCanceledByClient));
+    client_connection_parameters_.connection_delegate_ptr()
+        .set_connection_error_handler(base::BindOnce(
+            &PendingConnectionRequestBase::OnFinishedWithoutConnection,
+            weak_ptr_factory_.GetWeakPtr(),
+            PendingConnectionRequestDelegate::FailedConnectionReason::
+                kRequestCanceledByClient));
   }
 
   // Derived classes should invoke this function if they would like to give up
@@ -67,7 +69,8 @@ class PendingConnectionRequestBase
       return;
     }
 
-    connection_delegate_ptr_->OnConnectionAttemptFailure(failure_reason);
+    client_connection_parameters_.connection_delegate_ptr()
+        ->OnConnectionAttemptFailure(failure_reason);
 
     OnFinishedWithoutConnection(PendingConnectionRequestDelegate::
                                     FailedConnectionReason::kRequestFailed);
@@ -79,9 +82,9 @@ class PendingConnectionRequestBase
   using PendingConnectionRequest<
       FailureDetailType>::NotifyRequestFinishedWithoutConnection;
 
-  std::pair<std::string, mojom::ConnectionDelegatePtr> ExtractClientData()
-      override {
-    return std::make_pair(feature_, std::move(connection_delegate_ptr_));
+  // PendingConnectionRequest<FailureDetailType>:
+  ClientConnectionParameters ExtractClientConnectionParameters() override {
+    return std::move(client_connection_parameters_);
   }
 
   void OnFinishedWithoutConnection(
@@ -90,15 +93,14 @@ class PendingConnectionRequestBase
     has_finished_without_connection_ = true;
 
     PA_LOG(INFO) << "Request finished without connection; notifying delegate. "
-                 << "Feature: \"" << feature_ << "\""
-                 << ", Reason: " << reason << ", Request type: \""
-                 << readable_request_type_for_logging_ << "\"";
+                 << "Request type: \"" << readable_request_type_for_logging_
+                 << "\", Reason: " << reason
+                 << ", Client parameters: " << client_connection_parameters_;
     NotifyRequestFinishedWithoutConnection(reason);
   }
 
-  const std::string feature_;
+  ClientConnectionParameters client_connection_parameters_;
   const std::string readable_request_type_for_logging_;
-  mojom::ConnectionDelegatePtr connection_delegate_ptr_;
 
   bool has_finished_without_connection_ = false;
 

chromeos/services/secure_channel/pending_connection_request_base_unittest.cc

@@ -8,6 +8,7 @@
 
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
+#include "chromeos/services/secure_channel/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 "testing/gtest/include/gtest/gtest.h"
@@ -34,14 +35,12 @@ class TestPendingConnectionRequest
     : public PendingConnectionRequestBase<TestFailureDetail> {
  public:
   TestPendingConnectionRequest(
-      const std::string& feature,
-      mojom::ConnectionDelegatePtr connection_delegate_ptr,
+      ClientConnectionParameters client_connection_parameters,
       PendingConnectionRequestDelegate* delegate)
       : PendingConnectionRequestBase<TestFailureDetail>(
-            feature,
+            std::move(client_connection_parameters),
             kTestReadableRequestTypeForLogging,
-            delegate,
-            std::move(connection_delegate_ptr)) {}
+            delegate) {}
   ~TestPendingConnectionRequest() override = default;
 
   // PendingConnectionRequestBase<TestFailureDetail>:
@@ -72,9 +71,12 @@ class SecureChannelPendingConnectionRequestBaseTest : public testing::Test {
         fake_connection_delegate_->GenerateInterfacePtr();
     fake_connection_delegate_proxy_ =
         fake_connection_delegate_interface_ptr.get();
+
     test_pending_connection_request_ =
         std::make_unique<TestPendingConnectionRequest>(
-            kTestFeature, std::move(fake_connection_delegate_interface_ptr),
+            ClientConnectionParameters(
+                kTestFeature,
+                std::move(fake_connection_delegate_interface_ptr)),
             fake_pending_connection_request_delegate_.get());
   }
 
@@ -98,7 +100,7 @@ class SecureChannelPendingConnectionRequestBaseTest : public testing::Test {
   GetFailedConnectionReason() {
     return fake_pending_connection_request_delegate_
         ->GetFailedConnectionReasonForId(
-            test_pending_connection_request_->request_id());
+            test_pending_connection_request_->GetRequestId());
   }
 
   void DisconnectConnectionDelegatePtr() {
@@ -114,9 +116,10 @@ class SecureChannelPendingConnectionRequestBaseTest : public testing::Test {
     return fake_connection_delegate_->connection_attempt_failure_reason();
   }
 
-  std::pair<std::string, mojom::ConnectionDelegatePtr> ExtractClientData() {
-    return PendingConnectionRequest<TestFailureDetail>::ExtractClientData(
-        std::move(test_pending_connection_request_));
+  ClientConnectionParameters ExtractClientConnectionParameters() {
+    return PendingConnectionRequest<TestFailureDetail>::
+        ExtractClientConnectionParameters(
+            std::move(test_pending_connection_request_));
   }
 
   mojom::ConnectionDelegate::Proxy_* fake_connection_delegate_proxy() {
@@ -169,11 +172,12 @@ TEST_F(SecureChannelPendingConnectionRequestBaseTest,
             *GetFailedConnectionReason());
 }
 
-TEST_F(SecureChannelPendingConnectionRequestBaseTest, ExtractClientData) {
-  auto extracted_client_data = ExtractClientData();
-  EXPECT_EQ(kTestFeature, extracted_client_data.first);
+TEST_F(SecureChannelPendingConnectionRequestBaseTest,
+       ExtractClientConnectionParameters) {
+  auto extracted_client_data = ExtractClientConnectionParameters();
+  EXPECT_EQ(kTestFeature, extracted_client_data.feature());
   EXPECT_EQ(fake_connection_delegate_proxy(),
-            extracted_client_data.second.get());
+            extracted_client_data.connection_delegate_ptr().get());
 }
 
 }  // namespace secure_channel

chromeos/services/secure_channel/single_client_message_proxy.cc

@@ -9,7 +9,7 @@ namespace chromeos {
 namespace secure_channel {
 
 SingleClientMessageProxy::SingleClientMessageProxy(Delegate* delegate)
-    : delegate_(delegate), proxy_id_(base::UnguessableToken::Create()) {}
+    : delegate_(delegate) {}
 
 SingleClientMessageProxy::~SingleClientMessageProxy() = default;
 
@@ -22,7 +22,7 @@ void SingleClientMessageProxy::NotifySendMessageRequested(
 }
 
 void SingleClientMessageProxy::NotifyClientDisconnected() {
-  delegate_->OnClientDisconnected(proxy_id_);
+  delegate_->OnClientDisconnected(GetProxyId());
 }
 
 const mojom::ConnectionMetadata&

chromeos/services/secure_channel/single_client_message_proxy.h

@@ -44,7 +44,7 @@ class SingleClientMessageProxy {
   // because of instability on the communication channel).
   virtual void HandleRemoteDeviceDisconnection() = 0;
 
-  const base::UnguessableToken& proxy_id() { return proxy_id_; }
+  virtual const base::UnguessableToken& GetProxyId() = 0;
 
  protected:
   SingleClientMessageProxy(Delegate* delegate);
@@ -57,7 +57,6 @@ class SingleClientMessageProxy {
 
  private:
   Delegate* delegate_;
-  const base::UnguessableToken proxy_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SingleClientMessageProxy);
 };

chromeos/services/secure_channel/single_client_message_proxy_impl.cc

@@ -35,33 +35,34 @@ SingleClientMessageProxyImpl::Factory::~Factory() = default;
 std::unique_ptr<SingleClientMessageProxy>
 SingleClientMessageProxyImpl::Factory::BuildInstance(
     SingleClientMessageProxy::Delegate* delegate,
-    const std::string& feature,
-    mojom::ConnectionDelegatePtr connection_delegate_ptr) {
+    ClientConnectionParameters client_connection_parameters) {
   return base::WrapUnique(new SingleClientMessageProxyImpl(
-      delegate, feature, std::move(connection_delegate_ptr)));
+      delegate, std::move(client_connection_parameters)));
 }
 
 SingleClientMessageProxyImpl::SingleClientMessageProxyImpl(
     SingleClientMessageProxy::Delegate* delegate,
-    const std::string& feature,
-    mojom::ConnectionDelegatePtr connection_delegate_ptr)
+    ClientConnectionParameters client_connection_parameters)
     : SingleClientMessageProxy(delegate),
-      feature_(feature),
-      connection_delegate_ptr_(std::move(connection_delegate_ptr)),
+      client_connection_parameters_(std::move(client_connection_parameters)),
       channel_(std::make_unique<ChannelImpl>(this /* delegate */)) {
-  DCHECK(connection_delegate_ptr_);
-  connection_delegate_ptr_->OnConnection(
+  DCHECK(client_connection_parameters_.connection_delegate_ptr());
+  client_connection_parameters_.connection_delegate_ptr()->OnConnection(
       channel_->GenerateInterfacePtr(),
       mojo::MakeRequest(&message_receiver_ptr_));
 }
 
 SingleClientMessageProxyImpl::~SingleClientMessageProxyImpl() = default;
 
+const base::UnguessableToken& SingleClientMessageProxyImpl::GetProxyId() {
+  return client_connection_parameters_.id();
+}
+
 void SingleClientMessageProxyImpl::HandleReceivedMessage(
     const std::string& feature,
     const std::string& payload) {
   // Ignore messages intended for other clients.
-  if (feature != feature_)
+  if (feature != client_connection_parameters_.feature())
     return;
 
   message_receiver_ptr_->OnMessageReceived(payload);
@@ -74,7 +75,8 @@ void SingleClientMessageProxyImpl::HandleRemoteDeviceDisconnection() {
 void SingleClientMessageProxyImpl::OnSendMessageRequested(
     const std::string& message,
     base::OnceClosure on_sent_callback) {
-  NotifySendMessageRequested(feature_, message, std::move(on_sent_callback));
+  NotifySendMessageRequested(client_connection_parameters_.feature(), message,
+                             std::move(on_sent_callback));
 }
 
 const mojom::ConnectionMetadata&
@@ -87,8 +89,8 @@ void SingleClientMessageProxyImpl::OnClientDisconnected() {
 }
 
 void SingleClientMessageProxyImpl::FlushForTesting() {
-  DCHECK(connection_delegate_ptr_);
-  connection_delegate_ptr_.FlushForTesting();
+  DCHECK(client_connection_parameters_.connection_delegate_ptr());
+  client_connection_parameters_.connection_delegate_ptr().FlushForTesting();
 
   DCHECK(message_receiver_ptr_);
   message_receiver_ptr_.FlushForTesting();

chromeos/services/secure_channel/single_client_message_proxy_impl.h

@@ -9,6 +9,7 @@
 
 #include "base/macros.h"
 #include "chromeos/services/secure_channel/channel_impl.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
 #include "chromeos/services/secure_channel/single_client_message_proxy.h"
 #include "mojo/public/cpp/bindings/binding.h"
@@ -29,8 +30,7 @@ class SingleClientMessageProxyImpl : public SingleClientMessageProxy,
     virtual ~Factory();
     virtual std::unique_ptr<SingleClientMessageProxy> BuildInstance(
         SingleClientMessageProxy::Delegate* delegate,
-        const std::string& feature,
-        mojom::ConnectionDelegatePtr connection_delegate_ptr);
+        ClientConnectionParameters client_connection_parameters);
 
    private:
     static Factory* test_factory_;
@@ -38,13 +38,15 @@ class SingleClientMessageProxyImpl : public SingleClientMessageProxy,
 
   ~SingleClientMessageProxyImpl() override;
 
+  // SingleClientMessageProxy:
+  const base::UnguessableToken& GetProxyId() override;
+
  private:
   friend class SecureChannelSingleClientMessageProxyImplTest;
 
   SingleClientMessageProxyImpl(
       SingleClientMessageProxy::Delegate* delegate,
-      const std::string& feature,
-      mojom::ConnectionDelegatePtr connection_delegate_ptr);
+      ClientConnectionParameters client_connection_parameters);
 
   // SingleClientMessageProxy:
   void HandleReceivedMessage(const std::string& feature,
@@ -59,8 +61,7 @@ class SingleClientMessageProxyImpl : public SingleClientMessageProxy,
 
   void FlushForTesting();
 
-  const std::string feature_;
-  mojom::ConnectionDelegatePtr connection_delegate_ptr_;
+  ClientConnectionParameters client_connection_parameters_;
   std::unique_ptr<ChannelImpl> channel_;
   mojom::MessageReceiverPtr message_receiver_ptr_;
 

chromeos/services/secure_channel/single_client_message_proxy_impl_unittest.cc

@@ -13,6 +13,7 @@
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/test/scoped_task_environment.h"
+#include "chromeos/services/secure_channel/client_connection_parameters.h"
 #include "chromeos/services/secure_channel/fake_connection_delegate.h"
 #include "chromeos/services/secure_channel/fake_message_receiver.h"
 #include "chromeos/services/secure_channel/fake_single_client_message_proxy.h"
@@ -43,8 +44,9 @@ class SecureChannelSingleClientMessageProxyImplTest : public testing::Test {
         std::move(fake_message_receiver));
 
     proxy_ = SingleClientMessageProxyImpl::Factory::Get()->BuildInstance(
-        fake_proxy_delegate_.get(), kTestFeature,
-        fake_connection_delegate_->GenerateInterfacePtr());
+        fake_proxy_delegate_.get(),
+        ClientConnectionParameters(
+            kTestFeature, fake_connection_delegate_->GenerateInterfacePtr()));
 
     CompletePendingMojoCalls();
     EXPECT_TRUE(fake_connection_delegate_->channel());
@@ -152,7 +154,8 @@ class SecureChannelSingleClientMessageProxyImplTest : public testing::Test {
   }
 
   bool WasDelegateNotifiedOfDisconnection() {
-    return proxy_->proxy_id() == fake_proxy_delegate_->disconnected_proxy_id();
+    return proxy_->GetProxyId() ==
+           fake_proxy_delegate_->disconnected_proxy_id();
   }
 
   const mojom::ConnectionMetadata& GetConnectionMetadataFromChannel() {