Support for auth code based authentication flow for both app and web UI driven flow.

chrome/browser/chromeos/login/parallel_authenticator_unittest.cc

 // Copyright (c) 2012 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/parallel_authenticator.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 71 matching lines @@
     test_api->SetCryptohomeLibrary(mock_cryptohome_library_, true);
 
     mock_cert_library_ = new MockCertLibrary();
     EXPECT_CALL(*mock_cert_library_, LoadKeyStore()).Times(AnyNumber());
     test_api->SetCertLibrary(mock_cert_library_, true);
 
     io_thread_.Start();
 
     auth_ = new ParallelAuthenticator(&consumer_);
     auth_->set_using_oauth(false);
-    state_.reset(new TestAttemptState(username_,
-                                      password_,
+    state_.reset(new TestAttemptState(UserCredentials(username_,
+                                                      password_,
+                                                      std::string()),
                                       hash_ascii_,
                                       "",
                                       "",
                                       User::USER_TYPE_REGULAR,
                                       false));
   }
 
   // Tears down the test fixture.
   virtual void TearDown() {
     // Prevent bogus gMock leak check from firing.
@@ skipping 24 matching lines @@
   // Allow test to fail and exit gracefully, even if
   // OnRetailModeLoginSuccess() wasn't supposed to happen.
   void FailOnRetailModeLoginSuccess() {
     ON_CALL(consumer_, OnRetailModeLoginSuccess())
         .WillByDefault(Invoke(MockConsumer::OnRetailModeSuccessQuitAndFail));
   }
 
   // Allow test to fail and exit gracefully, even if OnLoginSuccess()
   // wasn't supposed to happen.
   void FailOnLoginSuccess() {
-    ON_CALL(consumer_, OnLoginSuccess(_, _, _, _))
+    ON_CALL(consumer_, OnLoginSuccess(_, _, _))
         .WillByDefault(Invoke(MockConsumer::OnSuccessQuitAndFail));
   }
 
   // Allow test to fail and exit gracefully, even if
   // OnOffTheRecordLoginSuccess() wasn't supposed to happen.
   void FailOnGuestLoginSuccess() {
     ON_CALL(consumer_, OnOffTheRecordLoginSuccess())
         .WillByDefault(Invoke(MockConsumer::OnGuestSuccessQuitAndFail));
   }
 
   void ExpectLoginFailure(const LoginFailure& failure) {
     EXPECT_CALL(consumer_, OnLoginFailure(failure))
         .WillOnce(Invoke(MockConsumer::OnFailQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectRetailModeLoginSuccess() {
     EXPECT_CALL(consumer_, OnRetailModeLoginSuccess())
         .WillOnce(Invoke(MockConsumer::OnRetailModeSuccessQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectLoginSuccess(const std::string& username,
                           const std::string& password,
                           bool pending) {
-    EXPECT_CALL(consumer_, OnLoginSuccess(username, password, pending,
+    EXPECT_CALL(consumer_, OnLoginSuccess(UserCredentials(username,
+                                                          password,
+                                                          std::string()),
+                                          pending,
                                           false))
         .WillOnce(Invoke(MockConsumer::OnSuccessQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectGuestLoginSuccess() {
     EXPECT_CALL(consumer_, OnOffTheRecordLoginSuccess())
         .WillOnce(Invoke(MockConsumer::OnGuestSuccessQuit))
         .RetiresOnSaturation();
   }
@@ skipping 47 matching lines @@
   ScopedMockUserManagerEnabler mock_user_manager_;
 
   cryptohome::MockAsyncMethodCaller* mock_caller_;
 
   MockConsumer consumer_;
   scoped_refptr<ParallelAuthenticator> auth_;
   scoped_ptr<TestAttemptState> state_;
 };
 
 TEST_F(ParallelAuthenticatorTest, OnLoginSuccess) {
-  EXPECT_CALL(consumer_, OnLoginSuccess(username_, password_, false, false))
+  EXPECT_CALL(consumer_, OnLoginSuccess(UserCredentials(username_,
+                                                        password_,
+                                                        std::string()),
+                                        false, false))
       .Times(1)
       .RetiresOnSaturation();
 
   SetAttemptState(auth_, state_.release());
   auth_->OnLoginSuccess(false);
 }
 
 TEST_F(ParallelAuthenticatorTest, OnPasswordChangeDetected) {
   EXPECT_CALL(consumer_, OnPasswordChangeDetected())
       .Times(1)
@@ skipping 54 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(username_,
-                                    password_,
+  state_.reset(new TestAttemptState(UserCredentials(username_,
+                                                    password_,
+                                                    std::string()),
                                     hash_ascii_,
                                     "",
                                     "",
                                     User::USER_TYPE_REGULAR,
                                     false));
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_EQ(ParallelAuthenticator::OFFLINE_LOGIN,
             SetAndResolveState(auth_, state_.release()));
 }
 
@@ skipping 23 matching lines @@
   EXPECT_TRUE(
       CrosSettings::Get()->RemoveSettingsProvider(device_settings_provider));
   CrosSettings::Get()->AddSettingsProvider(&stub_settings_provider);
   CrosSettings::Get()->SetBoolean(kPolicyMissingMitigationMode, true);
 
   EXPECT_EQ(ParallelAuthenticator::CONTINUE,
             SetAndResolveState(auth_, state_.release()));
   // Let the owner verification run.
   device_settings_test_helper_.Flush();
   // and test that the mount has succeeded.
-  state_.reset(new TestAttemptState(username_,
-                                    password_,
+  state_.reset(new TestAttemptState(UserCredentials(username_,
+                                                    password_,
+                                                    std::string()),
                                     hash_ascii_,
                                     "",
                                     "",
                                     User::USER_TYPE_REGULAR,
                                     false));
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_EQ(ParallelAuthenticator::OWNER_REQUIRED,
             SetAndResolveState(auth_, state_.release()));
 
   EXPECT_TRUE(
@@ skipping 296 matching lines @@
 
   RunResolve(auth_.get());
 
   // After the request below completes, OnLoginSuccess gets called again.
   ExpectLoginSuccess(username_, password_, false);
 
   MockURLFetcherFactory<SuccessFetcher> factory;
   TestingProfile profile;
 
   auth_->RetryAuth(&profile,
-                   username_,
-                   std::string(),
+                   UserCredentials(username_,
+                                   std::string(),
+                                   std::string()),
                    std::string(),
                    std::string());
   message_loop_.Run();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveOfflineLoginGetCaptchad) {
   ExpectLoginSuccess(username_, password_, true);
   FailOnLoginFailure();
   EXPECT_CALL(*mock_cryptohome_library_, GetSystemSalt())
@@ skipping 21 matching lines @@
       GoogleServiceAuthError::FromClientLoginCaptchaChallenge(
           CaptchaFetcher::GetCaptchaToken(),
           GURL(CaptchaFetcher::GetCaptchaUrl()),
           GURL(CaptchaFetcher::GetUnlockUrl())));
   ExpectLoginFailure(failure);
 
   MockURLFetcherFactory<CaptchaFetcher> factory;
   TestingProfile profile;
 
   auth_->RetryAuth(&profile,
-                   username_,
-                   std::string(),
+                   UserCredentials(username_,
+                                   std::string(),
+                                   std::string()),
                    std::string(),
                    std::string());
   message_loop_.Run();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveOnlineLogin) {
   ExpectLoginSuccess(username_, password_, false);
   FailOnLoginFailure();
 
@@ skipping 32 matching lines @@
   // Set up mock cryptohome library 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();
   EXPECT_CALL(*mock_cryptohome_library_, GetSystemSalt())
       .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
-  auth_->AuthenticateToUnlock(username_, "");
+  auth_->AuthenticateToUnlock(UserCredentials(username_,
+                                              std::string(),
+                                              std::string()));
   message_loop_.Run();
 }
 
 }  // namespace chromeos