[CrOS Tether] Update SecureChannel and BleConnectionManager to use CryptAuthService instead of a Del

components/cryptauth/secure_channel.cc

 // Copyright 2017 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 "components/cryptauth/secure_channel.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
+#include "components/cryptauth/cryptauth_service.h"
 #include "components/cryptauth/wire_message.h"
 #include "components/proximity_auth/logging/logging.h"
 
 namespace cryptauth {
 
 // static
 SecureChannel::Factory* SecureChannel::Factory::factory_instance_ = nullptr;
 
 // static
 std::unique_ptr<SecureChannel> SecureChannel::Factory::NewInstance(
     std::unique_ptr<Connection> connection,
-    std::unique_ptr<Delegate> delegate) {
+    CryptAuthService* cryptauth_service) {
   if (!factory_instance_) {
     factory_instance_ = new Factory();
   }
   return factory_instance_->BuildInstance(std::move(connection),
-                                          std::move(delegate));
+                                          cryptauth_service);
 }
 
 // static
 void SecureChannel::Factory::SetInstanceForTesting(Factory* factory) {
   factory_instance_ = factory;
 }
 
 std::unique_ptr<SecureChannel> SecureChannel::Factory::BuildInstance(
     std::unique_ptr<Connection> connection,
-    std::unique_ptr<Delegate> delegate) {
+    CryptAuthService* cryptauth_service) {
   return base::WrapUnique(
-      new SecureChannel(std::move(connection), std::move(delegate)));
+      new SecureChannel(std::move(connection), cryptauth_service));
 }
 
 // static
 std::string SecureChannel::StatusToString(const Status& status) {
   switch (status) {
     case Status::DISCONNECTED:
       return "[disconnected]";
     case Status::CONNECTING:
       return "[connecting]";
     case Status::CONNECTED:
       return "[connected]";
     case Status::AUTHENTICATING:
       return "[authenticating]";
     case Status::AUTHENTICATED:
       return "[authenticated]";
     default:
       return "[unknown status]";
   }
 }
 
-SecureChannel::Delegate::~Delegate() {}
-
 SecureChannel::PendingMessage::PendingMessage() {}
 
 SecureChannel::PendingMessage::PendingMessage(
     const std::string& feature, const std::string& payload)
     : feature(feature), payload(payload) {}
 
 SecureChannel::PendingMessage::~PendingMessage() {}
 
 SecureChannel::SecureChannel(std::unique_ptr<Connection> connection,
-                             std::unique_ptr<Delegate> delegate)
+                             CryptAuthService* cryptauth_service)
     : status_(Status::DISCONNECTED),
       connection_(std::move(connection)),
-      delegate_(std::move(delegate)),
+      cryptauth_service_(cryptauth_service),
       weak_ptr_factory_(this) {
   DCHECK(connection_);
   DCHECK(!connection_->IsConnected());
   DCHECK(!connection_->remote_device().user_id.empty());
-  DCHECK(delegate_);
+  DCHECK(cryptauth_service);
 
   connection_->AddObserver(this);
 }
 
 SecureChannel::~SecureChannel() {
   connection_->RemoveObserver(this);
 }
 
 void SecureChannel::Initialize() {
   DCHECK(status_ == Status::DISCONNECTED);
@@ skipping 106 matching lines @@
   for (auto& observer : observer_list_) {
     observer.OnSecureChannelStatusChanged(this, old_status, status_);
   }
 }
 
 void SecureChannel::Authenticate() {
   DCHECK(status_ == Status::CONNECTED);
   DCHECK(!authenticator_);
 
   authenticator_ = DeviceToDeviceAuthenticator::Factory::NewInstance(
-      connection_.get(),
-      connection_->remote_device().user_id,
-      delegate_->CreateSecureMessageDelegate());
+      connection_.get(), connection_->remote_device().user_id,
+      cryptauth_service_->CreateSecureMessageDelegate());
   authenticator_->Authenticate(
       base::Bind(&SecureChannel::OnAuthenticationResult,
                  weak_ptr_factory_.GetWeakPtr()));
 
   TransitionToStatus(Status::AUTHENTICATING);
 }
 
 void SecureChannel::ProcessMessageQueue() {
   if (pending_message_ || queued_messages_.empty())  {
     return;
@@ skipping 46 matching lines @@
         << connection_->remote_device().GetTruncatedDeviceIdForLogs();
     Disconnect();
     return;
   }
 
   secure_context_ = std::move(secure_context);
   TransitionToStatus(Status::AUTHENTICATED);
 }
 
 }  // namespace cryptauth