[CrOS Multidevice] Inject concrete AuthTokenValidator into MultiDeviceSetupService.

Create a concrete implementation of AuthTokenValidator, using QuickUnlockStorage
as its underlying logic. It is retrieved via a AuthTokenValidatorFactory in order
to make browser the owner of the AuthTokenValidatorImpl, not //chromeos.

Bug: 870122
Change-Id: I880f6ca519fe2e7ccc6c857cc08927eaf9ac3e32
Reviewed-on: https://chromium-review.googlesource.com/1176436
Commit-Queue: Ryan Hansberry <hansberry@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Bernhard Bauer <bauerb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#583763}

chrome/browser/chromeos/BUILD.gn

@@ -83,6 +83,7 @@ source_set("chromeos") {
     "//chromeos/components/tether",
     "//chromeos/services/device_sync/public/cpp",
     "//chromeos/services/multidevice_setup/public/cpp",
+    "//chromeos/services/multidevice_setup/public/cpp:auth_token_validator",
     "//chromeos/services/multidevice_setup/public/cpp:prefs",
     "//chromeos/services/secure_channel/public/cpp/client",
     "//components/arc",
@@ -1288,6 +1289,10 @@ source_set("chromeos") {
     "mobile/mobile_activator.h",
     "mobile_config.cc",
     "mobile_config.h",
+    "multidevice_setup/auth_token_validator_factory.cc",
+    "multidevice_setup/auth_token_validator_factory.h",
+    "multidevice_setup/auth_token_validator_impl.cc",
+    "multidevice_setup/auth_token_validator_impl.h",
     "multidevice_setup/multidevice_setup_client_factory.cc",
     "multidevice_setup/multidevice_setup_client_factory.h",
     "net/cert_verify_proc_chromeos.cc",

chrome/browser/chromeos/multidevice_setup/auth_token_validator_factory.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 "chrome/browser/chromeos/multidevice_setup/auth_token_validator_factory.h"
+
+#include "base/macros.h"
+#include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_factory.h"
+#include "chrome/browser/chromeos/multidevice_setup/auth_token_validator_impl.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "components/keyed_service/core/keyed_service.h"
+#include "content/public/browser/browser_context.h"
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+// static
+AuthTokenValidator* AuthTokenValidatorFactory::GetForProfile(Profile* profile) {
+  return static_cast<AuthTokenValidatorImpl*>(
+      GetInstance()->GetServiceForBrowserContext(profile, true));
+}
+
+// static
+AuthTokenValidatorFactory* AuthTokenValidatorFactory::GetInstance() {
+  return base::Singleton<AuthTokenValidatorFactory>::get();
+}
+
+AuthTokenValidatorFactory::AuthTokenValidatorFactory()
+    : BrowserContextKeyedServiceFactory(
+          "AuthTokenValidatorFactory",
+          BrowserContextDependencyManager::GetInstance()) {}
+
+AuthTokenValidatorFactory::~AuthTokenValidatorFactory() {}
+
+KeyedService* AuthTokenValidatorFactory::BuildServiceInstanceFor(
+    content::BrowserContext* context) const {
+  return new AuthTokenValidatorImpl(
+      chromeos::quick_unlock::QuickUnlockFactory::GetForProfile(
+          Profile::FromBrowserContext(context)));
+}
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos

chrome/browser/chromeos/multidevice_setup/auth_token_validator_factory.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 CHROME_BROWSER_CHROMEOS_MULTIDEVICE_SETUP_AUTH_TOKEN_VALIDATOR_FACTORY_H_
+#define CHROME_BROWSER_CHROMEOS_MULTIDEVICE_SETUP_AUTH_TOKEN_VALIDATOR_FACTORY_H_
+
+#include "base/memory/singleton.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+class KeyedService;
+class Profile;
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+class AuthTokenValidator;
+
+// Owns AuthTokenValidator instances and associates them with Profiles.
+class AuthTokenValidatorFactory : public BrowserContextKeyedServiceFactory {
+ public:
+  static AuthTokenValidator* GetForProfile(Profile* profile);
+
+  static AuthTokenValidatorFactory* GetInstance();
+
+ private:
+  friend struct base::DefaultSingletonTraits<AuthTokenValidatorFactory>;
+
+  AuthTokenValidatorFactory();
+  ~AuthTokenValidatorFactory() override;
+
+  // BrowserContextKeyedServiceFactory:
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const override;
+
+  DISALLOW_COPY_AND_ASSIGN(AuthTokenValidatorFactory);
+};
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_MULTIDEVICE_SETUP_AUTH_TOKEN_VALIDATOR_FACTORY_H_

chrome/browser/chromeos/multidevice_setup/auth_token_validator_impl.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 "chrome/browser/chromeos/multidevice_setup/auth_token_validator_impl.h"
+
+#include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_factory.h"
+#include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_storage.h"
+
+namespace chromeos {
+
+namespace multidevice_setup {
+
+AuthTokenValidatorImpl::AuthTokenValidatorImpl(
+    quick_unlock::QuickUnlockStorage* quick_unlock_storage)
+    : quick_unlock_storage_(quick_unlock_storage) {}
+
+AuthTokenValidatorImpl::~AuthTokenValidatorImpl() = default;
+
+bool AuthTokenValidatorImpl::IsAuthTokenValid(const std::string& auth_token) {
+  return quick_unlock_storage_ &&
+         !quick_unlock_storage_->GetAuthTokenExpired() &&
+         auth_token == quick_unlock_storage_->GetAuthToken();
+}
+
+void AuthTokenValidatorImpl::Shutdown() {
+  quick_unlock_storage_ = nullptr;
+}
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos

chrome/browser/chromeos/multidevice_setup/auth_token_validator_impl.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 CHROME_BROWSER_CHROMEOS_MULTIDEVICE_SETUP_AUTH_TOKEN_VALIDATOR_IMPL_H_
+#define CHROME_BROWSER_CHROMEOS_MULTIDEVICE_SETUP_AUTH_TOKEN_VALIDATOR_IMPL_H_
+
+#include "chromeos/services/multidevice_setup/public/cpp/auth_token_validator.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+namespace chromeos {
+
+namespace quick_unlock {
+class QuickUnlockStorage;
+}  // namespace quick_unlock
+
+namespace multidevice_setup {
+
+// Concrete AuthTokenValidator implementation.
+//
+// The functionality of this class is very simple, to the point that it does not
+// merit a test. If this class becomes any more complex, simple unit tests
+// should be added.
+class AuthTokenValidatorImpl : public AuthTokenValidator, public KeyedService {
+ public:
+  AuthTokenValidatorImpl(
+      quick_unlock::QuickUnlockStorage* quick_unlock_storage);
+  ~AuthTokenValidatorImpl() override;
+
+  bool IsAuthTokenValid(const std::string& auth_token) override;
+
+ private:
+  // KeyedService:
+  void Shutdown() override;
+
+  quick_unlock::QuickUnlockStorage* quick_unlock_storage_;
+
+  DISALLOW_COPY_AND_ASSIGN(AuthTokenValidatorImpl);
+};
+
+}  // namespace multidevice_setup
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_MULTIDEVICE_SETUP_AUTH_TOKEN_VALIDATOR_IMPL_H_

chrome/browser/profiles/profile_impl.cc

@@ -149,6 +149,8 @@
 #include "chrome/browser/chromeos/device_sync/device_sync_client_factory.h"
 #include "chrome/browser/chromeos/locale_change_guard.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
+#include "chrome/browser/chromeos/multidevice_setup/auth_token_validator_factory.h"
+#include "chrome/browser/chromeos/multidevice_setup/auth_token_validator_impl.h"
 #include "chrome/browser/chromeos/net/delay_network_call.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/user_policy_manager_factory_chromeos.h"
@@ -1524,7 +1526,9 @@ ProfileImpl::CreateMultiDeviceSetupService() {
       GetPrefs(),
       chromeos::device_sync::DeviceSyncClientFactory::GetForProfile(this),
       chromeos::secure_channel::SecureChannelClientProvider::GetInstance()
-          ->GetClient());
+          ->GetClient(),
+      chromeos::multidevice_setup::AuthTokenValidatorFactory::GetForProfile(
+          this));
 }
 
 #endif  // defined(OS_CHROMEOS)

chromeos/services/multidevice_setup/multidevice_setup_impl.cc

@@ -45,15 +45,18 @@ std::unique_ptr<mojom::MultiDeviceSetup>
 MultiDeviceSetupImpl::Factory::BuildInstance(
     PrefService* pref_service,
     device_sync::DeviceSyncClient* device_sync_client,
-    secure_channel::SecureChannelClient* secure_channel_client) {
-  return base::WrapUnique(new MultiDeviceSetupImpl(
-      pref_service, device_sync_client, secure_channel_client));
+    secure_channel::SecureChannelClient* secure_channel_client,
+    AuthTokenValidator* auth_token_validator) {
+  return base::WrapUnique(
+      new MultiDeviceSetupImpl(pref_service, device_sync_client,
+                               secure_channel_client, auth_token_validator));
 }
 
 MultiDeviceSetupImpl::MultiDeviceSetupImpl(
     PrefService* pref_service,
     device_sync::DeviceSyncClient* device_sync_client,
-    secure_channel::SecureChannelClient* secure_channel_client)
+    secure_channel::SecureChannelClient* secure_channel_client,
+    AuthTokenValidator* auth_token_validator)
     : eligible_host_devices_provider_(
           EligibleHostDevicesProviderImpl::Factory::Get()->BuildInstance(
               device_sync_client)),
@@ -124,6 +127,9 @@ void MultiDeviceSetupImpl::GetEligibleHostDevices(
 
 void MultiDeviceSetupImpl::SetHostDevice(const std::string& host_device_id,
                                          SetHostDeviceCallback callback) {
+  // TODO(crbug.com/870122): Use AuthTokenValidator to verify that the
+  // user is authenticated.
+
   cryptauth::RemoteDeviceRefList eligible_devices =
       eligible_host_devices_provider_->GetEligibleHostDevices();
   auto it =

chromeos/services/multidevice_setup/multidevice_setup_impl.h

@@ -29,6 +29,7 @@ class SecureChannelClient;
 namespace multidevice_setup {
 
 class AccountStatusChangeDelegateNotifier;
+class AuthTokenValidator;
 class HostBackendDelegate;
 class HostStatusProvider;
 class HostVerifier;
@@ -48,7 +49,8 @@ class MultiDeviceSetupImpl : public mojom::MultiDeviceSetup,
     virtual std::unique_ptr<mojom::MultiDeviceSetup> BuildInstance(
         PrefService* pref_service,
         device_sync::DeviceSyncClient* device_sync_client,
-        secure_channel::SecureChannelClient* secure_channel_client);
+        secure_channel::SecureChannelClient* secure_channel_client,
+        AuthTokenValidator* auth_token_validator);
 
    private:
     static Factory* test_factory_;
@@ -62,7 +64,8 @@ class MultiDeviceSetupImpl : public mojom::MultiDeviceSetup,
   MultiDeviceSetupImpl(
       PrefService* pref_service,
       device_sync::DeviceSyncClient* device_sync_client,
-      secure_channel::SecureChannelClient* secure_channel_client);
+      secure_channel::SecureChannelClient* secure_channel_client,
+      AuthTokenValidator* auth_token_validator);
 
   // mojom::MultiDeviceSetup:
   void SetAccountStatusChangeDelegate(

chromeos/services/multidevice_setup/multidevice_setup_impl_unittest.cc

@@ -26,6 +26,7 @@
 #include "chromeos/services/multidevice_setup/host_status_provider_impl.h"
 #include "chromeos/services/multidevice_setup/host_verifier_impl.h"
 #include "chromeos/services/multidevice_setup/multidevice_setup_impl.h"
+#include "chromeos/services/multidevice_setup/public/cpp/fake_auth_token_validator.h"
 #include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
 #include "chromeos/services/multidevice_setup/setup_flow_completion_recorder_impl.h"
 #include "chromeos/services/secure_channel/public/cpp/client/fake_secure_channel_client.h"
@@ -361,6 +362,7 @@ class MultiDeviceSetupImplTest : public testing::Test {
         std::make_unique<device_sync::FakeDeviceSyncClient>();
     fake_secure_channel_client_ =
         std::make_unique<secure_channel::FakeSecureChannelClient>();
+    fake_auth_token_validator_ = std::make_unique<FakeAuthTokenValidator>();
 
     fake_eligible_host_devices_provider_factory_ =
         std::make_unique<FakeEligibleHostDevicesProviderFactory>(
@@ -411,7 +413,7 @@ class MultiDeviceSetupImplTest : public testing::Test {
 
     multidevice_setup_ = MultiDeviceSetupImpl::Factory::Get()->BuildInstance(
         test_pref_service_.get(), fake_device_sync_client_.get(),
-        fake_secure_channel_client_.get());
+        fake_secure_channel_client_.get(), fake_auth_token_validator_.get());
   }
 
   void TearDown() override {
@@ -662,6 +664,7 @@ class MultiDeviceSetupImplTest : public testing::Test {
   std::unique_ptr<device_sync::FakeDeviceSyncClient> fake_device_sync_client_;
   std::unique_ptr<secure_channel::FakeSecureChannelClient>
       fake_secure_channel_client_;
+  std::unique_ptr<FakeAuthTokenValidator> fake_auth_token_validator_;
 
   std::unique_ptr<FakeEligibleHostDevicesProviderFactory>
       fake_eligible_host_devices_provider_factory_;

chromeos/services/multidevice_setup/multidevice_setup_initializer.cc

@@ -40,18 +40,22 @@ std::unique_ptr<MultiDeviceSetupBase>
 MultiDeviceSetupInitializer::Factory::BuildInstance(
     PrefService* pref_service,
     device_sync::DeviceSyncClient* device_sync_client,
-    secure_channel::SecureChannelClient* secure_channel_client) {
+    secure_channel::SecureChannelClient* secure_channel_client,
+    AuthTokenValidator* auth_token_validator) {
   return base::WrapUnique(new MultiDeviceSetupInitializer(
-      pref_service, device_sync_client, secure_channel_client));
+      pref_service, device_sync_client, secure_channel_client,
+      auth_token_validator));
 }
 
 MultiDeviceSetupInitializer::MultiDeviceSetupInitializer(
     PrefService* pref_service,
     device_sync::DeviceSyncClient* device_sync_client,
-    secure_channel::SecureChannelClient* secure_channel_client)
+    secure_channel::SecureChannelClient* secure_channel_client,
+    AuthTokenValidator* auth_token_validator)
     : pref_service_(pref_service),
       device_sync_client_(device_sync_client),
-      secure_channel_client_(secure_channel_client) {
+      secure_channel_client_(secure_channel_client),
+      auth_token_validator_(auth_token_validator) {
   if (device_sync_client_->is_ready()) {
     InitializeImplementation();
     return;
@@ -205,7 +209,8 @@ void MultiDeviceSetupInitializer::InitializeImplementation() {
   DCHECK(!multidevice_setup_impl_);
 
   multidevice_setup_impl_ = MultiDeviceSetupImpl::Factory::Get()->BuildInstance(
-      pref_service_, device_sync_client_, secure_channel_client_);
+      pref_service_, device_sync_client_, secure_channel_client_,
+      auth_token_validator_);
 
   if (pending_delegate_) {
     multidevice_setup_impl_->SetAccountStatusChangeDelegate(

chromeos/services/multidevice_setup/multidevice_setup_initializer.h

@@ -24,6 +24,8 @@ class SecureChannelClient;
 
 namespace multidevice_setup {
 
+class AuthTokenValidator;
+
 // Initializes the MultiDeviceSetup service. This class is responsible for
 // waiting for asynchronous initialization steps to complete before creating
 // the concrete implementation of the mojom::MultiDeviceSetup interface.
@@ -39,7 +41,8 @@ class MultiDeviceSetupInitializer
     virtual std::unique_ptr<MultiDeviceSetupBase> BuildInstance(
         PrefService* pref_service,
         device_sync::DeviceSyncClient* device_sync_client,
-        secure_channel::SecureChannelClient* secure_channel_client);
+        secure_channel::SecureChannelClient* secure_channel_client,
+        AuthTokenValidator* auth_token_validator);
 
    private:
     static Factory* test_factory_;
@@ -51,7 +54,8 @@ class MultiDeviceSetupInitializer
   MultiDeviceSetupInitializer(
       PrefService* pref_service,
       device_sync::DeviceSyncClient* device_sync_client,
-      secure_channel::SecureChannelClient* secure_channel_client);
+      secure_channel::SecureChannelClient* secure_channel_client,
+      AuthTokenValidator* auth_token_validator);
 
   // mojom::MultiDeviceSetup:
   void SetAccountStatusChangeDelegate(
@@ -81,6 +85,7 @@ class MultiDeviceSetupInitializer
   PrefService* pref_service_;
   device_sync::DeviceSyncClient* device_sync_client_;
   secure_channel::SecureChannelClient* secure_channel_client_;
+  AuthTokenValidator* auth_token_validator_;
 
   std::unique_ptr<mojom::MultiDeviceSetup> multidevice_setup_impl_;
 

chromeos/services/multidevice_setup/multidevice_setup_service.cc

@@ -28,12 +28,14 @@ void MultiDeviceSetupService::RegisterProfilePrefs(
 MultiDeviceSetupService::MultiDeviceSetupService(
     PrefService* pref_service,
     device_sync::DeviceSyncClient* device_sync_client,
-    secure_channel::SecureChannelClient* secure_channel_client)
+    secure_channel::SecureChannelClient* secure_channel_client,
+    AuthTokenValidator* auth_token_validator)
     : multidevice_setup_(
           MultiDeviceSetupInitializer::Factory::Get()->BuildInstance(
               pref_service,
               device_sync_client,
-              secure_channel_client)) {}
+              secure_channel_client,
+              auth_token_validator)) {}
 
 MultiDeviceSetupService::~MultiDeviceSetupService() = default;
 

chromeos/services/multidevice_setup/multidevice_setup_service.h

@@ -26,6 +26,7 @@ class SecureChannelClient;
 
 namespace multidevice_setup {
 
+class AuthTokenValidator;
 class MultiDeviceSetupBase;
 
 // Service which provides an implementation for mojom::MultiDeviceSetup. This
@@ -36,7 +37,8 @@ class MultiDeviceSetupService : public service_manager::Service {
   MultiDeviceSetupService(
       PrefService* pref_service,
       device_sync::DeviceSyncClient* device_sync_client,
-      secure_channel::SecureChannelClient* secure_channel_client);
+      secure_channel::SecureChannelClient* secure_channel_client,
+      AuthTokenValidator* auth_token_validator);
   ~MultiDeviceSetupService() override;
 
   static void RegisterProfilePrefs(PrefRegistrySimple* registry);

chromeos/services/multidevice_setup/multidevice_setup_service_unittest.cc

@@ -11,6 +11,7 @@
 #include "chromeos/services/multidevice_setup/fake_host_status_observer.h"
 #include "chromeos/services/multidevice_setup/multidevice_setup_impl.h"
 #include "chromeos/services/multidevice_setup/multidevice_setup_service.h"
+#include "chromeos/services/multidevice_setup/public/cpp/fake_auth_token_validator.h"
 #include "chromeos/services/multidevice_setup/public/cpp/fake_multidevice_setup.h"
 #include "chromeos/services/multidevice_setup/public/mojom/constants.mojom.h"
 #include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
@@ -34,10 +35,12 @@ class FakeMultiDeviceSetupFactory : public MultiDeviceSetupImpl::Factory {
       sync_preferences::TestingPrefServiceSyncable*
           expected_testing_pref_service,
       device_sync::FakeDeviceSyncClient* expected_device_sync_client,
-      secure_channel::FakeSecureChannelClient* expected_secure_channel_client)
+      secure_channel::FakeSecureChannelClient* expected_secure_channel_client,
+      FakeAuthTokenValidator* expected_auth_token_validator)
       : expected_testing_pref_service_(expected_testing_pref_service),
         expected_device_sync_client_(expected_device_sync_client),
-        expected_secure_channel_client_(expected_secure_channel_client) {}
+        expected_secure_channel_client_(expected_secure_channel_client),
+        expected_auth_token_validator_(expected_auth_token_validator) {}
 
   ~FakeMultiDeviceSetupFactory() override = default;
 
@@ -47,11 +50,13 @@ class FakeMultiDeviceSetupFactory : public MultiDeviceSetupImpl::Factory {
   std::unique_ptr<mojom::MultiDeviceSetup> BuildInstance(
       PrefService* pref_service,
       device_sync::DeviceSyncClient* device_sync_client,
-      secure_channel::SecureChannelClient* secure_channel_client) override {
+      secure_channel::SecureChannelClient* secure_channel_client,
+      AuthTokenValidator* auth_token_validator) override {
     EXPECT_FALSE(instance_);
     EXPECT_EQ(expected_testing_pref_service_, pref_service);
     EXPECT_EQ(expected_device_sync_client_, device_sync_client);
     EXPECT_EQ(expected_secure_channel_client_, secure_channel_client);
+    EXPECT_EQ(expected_auth_token_validator_, auth_token_validator);
 
     auto instance = std::make_unique<FakeMultiDeviceSetup>();
     instance_ = instance.get();
@@ -61,6 +66,7 @@ class FakeMultiDeviceSetupFactory : public MultiDeviceSetupImpl::Factory {
   sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
   device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
   secure_channel::FakeSecureChannelClient* expected_secure_channel_client_;
+  FakeAuthTokenValidator* expected_auth_token_validator_;
 
   FakeMultiDeviceSetup* instance_ = nullptr;
 
@@ -84,11 +90,13 @@ class MultiDeviceSetupServiceTest : public testing::Test {
         std::make_unique<device_sync::FakeDeviceSyncClient>();
     fake_secure_channel_client_ =
         std::make_unique<secure_channel::FakeSecureChannelClient>();
+    fake_auth_token_validator_ = std::make_unique<FakeAuthTokenValidator>();
 
     fake_multidevice_setup_factory_ =
         std::make_unique<FakeMultiDeviceSetupFactory>(
             test_pref_service_.get(), fake_device_sync_client_.get(),
-            fake_secure_channel_client_.get());
+            fake_secure_channel_client_.get(),
+            fake_auth_token_validator_.get());
     MultiDeviceSetupImpl::Factory::SetFactoryForTesting(
         fake_multidevice_setup_factory_.get());
 
@@ -96,7 +104,8 @@ class MultiDeviceSetupServiceTest : public testing::Test {
         service_manager::TestConnectorFactory::CreateForUniqueService(
             std::make_unique<MultiDeviceSetupService>(
                 test_pref_service_.get(), fake_device_sync_client_.get(),
-                fake_secure_channel_client_.get()));
+                fake_secure_channel_client_.get(),
+                fake_auth_token_validator_.get()));
 
     auto connector = connector_factory_->CreateConnector();
     connector->BindInterface(mojom::kServiceName, &multidevice_setup_ptr_);
@@ -152,6 +161,7 @@ class MultiDeviceSetupServiceTest : public testing::Test {
   std::unique_ptr<device_sync::FakeDeviceSyncClient> fake_device_sync_client_;
   std::unique_ptr<secure_channel::FakeSecureChannelClient>
       fake_secure_channel_client_;
+  std::unique_ptr<FakeAuthTokenValidator> fake_auth_token_validator_;
 
   std::unique_ptr<FakeMultiDeviceSetupFactory> fake_multidevice_setup_factory_;
 

chromeos/services/multidevice_setup/public/cpp/multidevice_setup_client_impl_unittest.cc

@@ -42,7 +42,8 @@ class FakeMultiDeviceSetupInitializerFactory
   std::unique_ptr<MultiDeviceSetupBase> BuildInstance(
       PrefService* pref_service,
       device_sync::DeviceSyncClient* device_sync_client,
-      secure_channel::SecureChannelClient* secure_channel_client) override {
+      secure_channel::SecureChannelClient* secure_channel_client,
+      AuthTokenValidator* auth_token_validator) override {
     EXPECT_TRUE(fake_multidevice_setup_);
     return std::move(fake_multidevice_setup_);
   }
@@ -97,7 +98,8 @@ class MultiDeviceSetupClientImplTest : public testing::Test {
 
     auto multidevice_setup_service = std::make_unique<MultiDeviceSetupService>(
         nullptr /* pref_service */, nullptr /* device_sync_client */,
-        nullptr /* secure_channel_client */);
+        nullptr /* secure_channel_client */,
+        nullptr /* auth_token_validator */);
 
     connector_factory_ =
         service_manager::TestConnectorFactory::CreateForUniqueService(