[CrOS Tether] Fill out the Initializer class. Tether will now initialize fully once the flag is ena…

chromeos/components/tether/tether_host_fetcher.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 "chromeos/components/tether/tether_host_fetcher.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "components/cryptauth/cryptauth_device_manager.h"
+#include "components/cryptauth/cryptauth_enrollment_manager.h"
 #include "components/cryptauth/cryptauth_service.h"
 #include "components/cryptauth/remote_device_loader.h"
 #include "components/cryptauth/secure_message_delegate.h"
 
 namespace chromeos {
 
 namespace tether {
 
 TetherHostFetcher::TetherHostFetchRequest::TetherHostFetchRequest(
     const TetherHostListCallback& list_callback)
     : device_id(""), list_callback(list_callback) {}
 
 TetherHostFetcher::TetherHostFetchRequest::TetherHostFetchRequest(
     const std::string& device_id,
     const TetherHostCallback& single_callback)
     : device_id(device_id), single_callback(single_callback) {}
 
 TetherHostFetcher::TetherHostFetchRequest::TetherHostFetchRequest(
     const TetherHostFetchRequest& other)
     : device_id(other.device_id),
       list_callback(other.list_callback),
       single_callback(other.single_callback) {}
 
 TetherHostFetcher::TetherHostFetchRequest::~TetherHostFetchRequest() {}
 
 TetherHostFetcher::TetherHostFetcher(
-    const std::string& user_id,
-    const std::string& user_private_key,
-    cryptauth::CryptAuthService* cryptauth_service,
-    cryptauth::CryptAuthDeviceManager* device_manager)
-    : user_id_(user_id),
-      user_private_key_(user_private_key),
-      cryptauth_service_(cryptauth_service),
-      device_manager_(device_manager),
-      weak_ptr_factory_(this) {}
+    cryptauth::CryptAuthService* cryptauth_service)
+    : cryptauth_service_(cryptauth_service), weak_ptr_factory_(this) {}
 
 TetherHostFetcher::~TetherHostFetcher() {}
 
 void TetherHostFetcher::FetchAllTetherHosts(
     const TetherHostListCallback& callback) {
   requests_.push_back(TetherHostFetchRequest(callback));
   StartLoadingDevicesIfNeeded();
 }
 
 void TetherHostFetcher::FetchTetherHost(const std::string& device_id,
                                         const TetherHostCallback& callback) {
   requests_.push_back(TetherHostFetchRequest(device_id, callback));
   StartLoadingDevicesIfNeeded();
 }
 
 void TetherHostFetcher::StartLoadingDevicesIfNeeded() {
   if (remote_device_loader_) {
     // If the loader is already active, there is nothing to do.
     return;
   }
 
   remote_device_loader_ = cryptauth::RemoteDeviceLoader::Factory::NewInstance(
-      device_manager_->GetTetherHosts(), user_id_, user_private_key_,
+      cryptauth_service_->GetCryptAuthDeviceManager()->GetTetherHosts(),
+      cryptauth_service_->GetAccountId(),
+      cryptauth_service_->GetCryptAuthEnrollmentManager()->GetUserPrivateKey(),
       cryptauth_service_->CreateSecureMessageDelegate());
   remote_device_loader_->Load(
       base::Bind(&TetherHostFetcher::OnRemoteDevicesLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void TetherHostFetcher::OnRemoteDevicesLoaded(
     const cryptauth::RemoteDeviceList& remote_devices) {
   // Make a copy of the list before deleting |remote_device_loader_|.
   cryptauth::RemoteDeviceList remote_devices_copy = remote_devices;
@@ skipping 25 matching lines @@
 
     if (!has_run_callback) {
       request.single_callback.Run(nullptr);
     }
   }
 }
 
 }  // namespace tether
 
 }  // namespace chromeos