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

chromeos/components/tether/tether_host_fetcher_unittest.cc

 // Copyright 2016 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 <memory>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 72 matching lines @@
   std::vector<cryptauth::ExternalDeviceInfo> device_infos;
   for (const auto& remote_device : remote_devices) {
     // Add an ExternalDeviceInfo with the same public key as the RemoteDevice.
     cryptauth::ExternalDeviceInfo info;
     info.set_public_key(remote_device.public_key);
     device_infos.push_back(info);
   }
   return device_infos;
 }
 
+class TestTetherHostFetcher : public TetherHostFetcher {
+ public:
+  TestTetherHostFetcher(const std::string& user_id,
+                        const std::string& user_private_key,
+                        cryptauth::CryptAuthService* cryptauth_service,
+                        cryptauth::CryptAuthDeviceManager* device_manager)
+      : TetherHostFetcher(user_id,
+                          user_private_key,
+                          cryptauth_service,
+                          device_manager) {}
+};
+
 }  // namespace
 
 class TetherHostFetcherTest : public testing::Test {
  public:
   class TestRemoteDeviceLoaderFactory
       : public cryptauth::RemoteDeviceLoader::Factory {
    public:
-    TestRemoteDeviceLoaderFactory(TetherHostFetcherTest* test) : test_(test) {}
+    explicit TestRemoteDeviceLoaderFactory(TetherHostFetcherTest* test)
+        : test_(test) {}
 
     std::unique_ptr<cryptauth::RemoteDeviceLoader> BuildInstance(
         const std::vector<cryptauth::ExternalDeviceInfo>& device_info_list,
         const std::string& user_id,
         const std::string& user_private_key,
         std::unique_ptr<cryptauth::SecureMessageDelegate>
             secure_message_delegate) override {
       EXPECT_EQ(test_->test_device_infos_.size(), device_info_list.size());
       EXPECT_EQ(std::string(kTestUserId), user_id);
       EXPECT_EQ(std::string(kTestUserPrivateKey), user_private_key);
@@ skipping 39 matching lines @@
 
     mock_device_manager_ = base::WrapUnique(new NiceMock<MockDeviceManager>());
     ON_CALL(*mock_device_manager_, GetTetherHosts())
         .WillByDefault(Return(test_device_infos_));
 
     test_device_loader_factory_ =
         base::WrapUnique(new TestRemoteDeviceLoaderFactory(this));
     cryptauth::RemoteDeviceLoader::Factory::SetInstanceForTesting(
         test_device_loader_factory_.get());
 
-    tether_host_fetcher_ = base::MakeUnique<TetherHostFetcher>(
+    tether_host_fetcher_ = base::WrapUnique(new TestTetherHostFetcher(
         std::string(kTestUserId), std::string(kTestUserPrivateKey),
-        fake_cryptauth_service_.get(), mock_device_manager_.get());
+        fake_cryptauth_service_.get(), mock_device_manager_.get()));
   }
 
   void OnTetherHostListFetched(const cryptauth::RemoteDeviceList& device_list) {
     device_list_list_.push_back(device_list);
   }
 
   void OnSingleTetherHostFetched(
       std::unique_ptr<cryptauth::RemoteDevice> device) {
     single_device_list_.push_back(std::move(device));
   }
 
   const std::vector<cryptauth::RemoteDevice> test_devices_;
   const std::vector<cryptauth::ExternalDeviceInfo> test_device_infos_;
 
   std::vector<cryptauth::RemoteDeviceList> device_list_list_;
   std::vector<std::shared_ptr<cryptauth::RemoteDevice>> single_device_list_;
 
   std::unique_ptr<FakeCryptAuthServiceWithTracking> fake_cryptauth_service_;
   std::unique_ptr<NiceMock<MockDeviceManager>> mock_device_manager_;
   std::unique_ptr<TestRemoteDeviceLoaderFactory> test_device_loader_factory_;
 
-  std::unique_ptr<TetherHostFetcher> tether_host_fetcher_;
+  std::unique_ptr<TestTetherHostFetcher> tether_host_fetcher_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TetherHostFetcherTest);
 };
 
 TEST_F(TetherHostFetcherTest, TestFetchAllTetherHosts) {
   tether_host_fetcher_->FetchAllTetherHosts(base::Bind(
       &TetherHostFetcherTest::OnTetherHostListFetched, base::Unretained(this)));
 
   // Nothing should load until the callback is invoked.
@@ skipping 63 matching lines @@
 
   EXPECT_EQ(1u, device_list_list_.size());
   EXPECT_EQ(test_devices_, device_list_list_[0]);
   EXPECT_EQ(2u, single_device_list_.size());
   EXPECT_EQ(test_devices_[0], *single_device_list_[0]);
   EXPECT_EQ(nullptr, single_device_list_[1]);
 }
 
 }  // namespace tether
 
-}  // namespace cryptauth
+}  // namespace chromeos