Tame the proliferation of UserContext constructors

chrome/browser/chromeos/login/auth/parallel_authenticator_unittest.cc

 // Copyright 2014 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/login/auth/parallel_authenticator.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 57 matching lines @@
 
     FakeDBusThreadManager* fake_dbus_thread_manager = new FakeDBusThreadManager;
     fake_cryptohome_client_ = new FakeCryptohomeClient;
     fake_dbus_thread_manager->SetCryptohomeClient(
         scoped_ptr<CryptohomeClient>(fake_cryptohome_client_));
     DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager);
 
     SystemSaltGetter::Initialize();
 
     auth_ = new ParallelAuthenticator(&consumer_);
-    state_.reset(new TestAttemptState(UserContext(username_,
-                                                  password_,
-                                                  std::string()),
-                                      "",
-                                      "",
-                                      User::USER_TYPE_REGULAR,
-                                      false));
+    UserContext user_context(username_);
+    user_context.SetPassword(password_);
+    state_.reset(new TestAttemptState(user_context, false));
   }
 
   // Tears down the test fixture.
   virtual void TearDown() {
     SystemSaltGetter::Shutdown();
     DBusThreadManager::Shutdown();
 
     cryptohome::AsyncMethodCaller::Shutdown();
     mock_caller_ = NULL;
   }
@@ skipping 42 matching lines @@
   }
 
   void ExpectRetailModeLoginSuccess() {
     EXPECT_CALL(consumer_, OnRetailModeLoginSuccess(_))
         .WillOnce(Invoke(MockConsumer::OnRetailModeSuccessQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectLoginSuccess(const std::string& username,
                           const std::string& password,
-                          const std::string& username_hash_,
+                          const std::string& username_hash,
                           bool pending) {
-    EXPECT_CALL(consumer_, OnLoginSuccess(UserContext(
-        username,
-        password,
-        std::string(),
-        username_hash_,
-        true,  // using_oauth
-        UserContext::AUTH_FLOW_OFFLINE)))
+    UserContext user_context(username);
+    user_context.SetPassword(password);
+    user_context.SetUserIDHash(username_hash);
+    EXPECT_CALL(consumer_, OnLoginSuccess(user_context))
         .WillOnce(Invoke(MockConsumer::OnSuccessQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectGuestLoginSuccess() {
     EXPECT_CALL(consumer_, OnOffTheRecordLoginSuccess())
         .WillOnce(Invoke(MockConsumer::OnGuestSuccessQuit))
         .RetiresOnSaturation();
   }
 
@@ skipping 36 matching lines @@
 
   cryptohome::MockAsyncMethodCaller* mock_caller_;
 
   MockConsumer consumer_;
   scoped_refptr<ParallelAuthenticator> auth_;
   scoped_ptr<TestAttemptState> state_;
   FakeCryptohomeClient* fake_cryptohome_client_;
 };
 
 TEST_F(ParallelAuthenticatorTest, OnLoginSuccess) {
-  EXPECT_CALL(consumer_, OnLoginSuccess(UserContext(
-      username_,
-      password_,
-      std::string(),
-      username_hash_,
-      true,  // using oauth
-      UserContext::AUTH_FLOW_OFFLINE)))
+  UserContext user_context(username_);
+  user_context.SetPassword(password_);
+  user_context.SetUserIDHash(username_hash_);
+  EXPECT_CALL(consumer_, OnLoginSuccess(user_context))
       .Times(1)
       .RetiresOnSaturation();
 
   SetAttemptState(auth_.get(), state_.release());
   auth_->OnLoginSuccess();
 }
 
 TEST_F(ParallelAuthenticatorTest, OnPasswordChangeDetected) {
   EXPECT_CALL(consumer_, OnPasswordChangeDetected())
       .Times(1)
@@ skipping 43 matching lines @@
 }
 
 TEST_F(ParallelAuthenticatorTest, ResolveOwnerNeededMount) {
   // Set up state as though a cryptohome mount attempt has occurred
   // and succeeded but we are in safe mode and the current user is not owner.
   // This test will check that the "safe-mode" policy is not set and will let
   // the mount finish successfully.
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   SetOwnerState(false, false);
   // and test that the mount has succeeded.
-  state_.reset(new TestAttemptState(UserContext(username_,
-                                                password_,
-                                                std::string()),
-                                    "",
-                                    "",
-                                    User::USER_TYPE_REGULAR,
-                                    false));
+  UserContext user_context(username_);
+  user_context.SetPassword(password_);
+  state_.reset(new TestAttemptState(user_context, false));
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_EQ(ParallelAuthenticator::OFFLINE_LOGIN,
             SetAndResolveState(auth_.get(), state_.release()));
 }
 
 TEST_F(ParallelAuthenticatorTest, ResolveOwnerNeededFailedMount) {
   FailOnLoginSuccess();  // Set failing on success as the default...
   LoginFailure failure = LoginFailure(LoginFailure::OWNER_REQUIRED);
   ExpectLoginFailure(failure);
 
@@ skipping 22 matching lines @@
             SetAndResolveState(auth_.get(), state_.release()));
   EXPECT_TRUE(LoginState::Get()->IsInSafeMode());
 
   // Simulate TPM token ready event.
   DeviceSettingsService::Get()->OnTPMTokenReady();
 
   // Flush all the pending operations. The operations should induce an owner
   // verification.
   device_settings_test_helper_.Flush();
   // and test that the mount has succeeded.
-  state_.reset(new TestAttemptState(UserContext(username_,
-                                                password_,
-                                                std::string()),
-                                    "",
-                                    "",
-                                    User::USER_TYPE_REGULAR,
-                                    false));
+  UserContext user_context(username_);
+  user_context.SetPassword(password_);
+  state_.reset(new TestAttemptState(user_context, false));
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_EQ(ParallelAuthenticator::OWNER_REQUIRED,
             SetAndResolveState(auth_.get(), state_.release()));
 
   // Unset global objects used by this test.
   LoginState::Shutdown();
   EXPECT_TRUE(
       CrosSettings::Get()->RemoveSettingsProvider(&stub_settings_provider));
   CrosSettings::Get()->AddSettingsProvider(device_settings_provider);
 }
@@ skipping 252 matching lines @@
   ExpectLoginSuccess(username_, std::string(), std::string(), false);
   FailOnLoginFailure();
 
   // Set up mock async method caller to respond successfully to a cryptohome
   // key-check attempt.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncCheckKey(username_, _, _))
       .Times(1)
       .RetiresOnSaturation();
 
-  auth_->AuthenticateToUnlock(UserContext(username_,
-                                          std::string(),
-                                          std::string()));
+  auth_->AuthenticateToUnlock(UserContext(username_));
   base::MessageLoop::current()->Run();
 }
 
 }  // namespace chromeos