[ChromeOS] Fix login wrong password handling.

chrome/browser/chromeos/login/parallel_authenticator_unittest.cc

 // Copyright (c) 2011 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 <vector>
 
 #include "base/file_path.h"
@@ skipping 27 matching lines @@
 using file_util::Delete;
 using file_util::WriteFile;
 using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::SetArgumentPointee;
 using ::testing::_;
 
 namespace chromeos {
+
 class ResolveChecker : public base::ThreadTestHelper {
  public:
   ResolveChecker(TestAttemptState* state,
                  ParallelAuthenticator* auth,
                  ParallelAuthenticator::AuthState expected)
       : base::ThreadTestHelper(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)),
         state_(state),
         auth_(auth),
         expected_(expected) {
   }
   ~ResolveChecker() {}
 
   virtual void RunTest() {
     auth_->set_attempt_state(state_);
     set_test_result(expected_ == auth_->ResolveState());
   }
 
  private:
   TestAttemptState* state_;
   ParallelAuthenticator* auth_;
   ParallelAuthenticator::AuthState expected_;
 };
 
+class TestOnlineAttempt : public OnlineAttempt {
+ public:
+  TestOnlineAttempt(AuthAttemptState* state,
+                    AuthAttemptStateResolver* resolver)
+      : OnlineAttempt(false, state, resolver) {
+  }
+};
+
 class ParallelAuthenticatorTest : public ::testing::Test {
  public:
   ParallelAuthenticatorTest()
       : message_loop_(MessageLoop::TYPE_UI),
         ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE),
         io_thread_(BrowserThread::IO),
         username_("me@nowhere.org"),
         password_("fakepass") {
     hash_ascii_.assign("0a010000000000a0");
@@ skipping 124 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(auth, &ParallelAuthenticator::Resolve));
     loop->Run();
   }
 
   void SetAttemptState(ParallelAuthenticator* auth, TestAttemptState* state) {
     auth->set_attempt_state(state);
   }
 
+  void FakeOnlineAttempt() {
+    auth_->set_online_attempt(new TestOnlineAttempt(state_.get(), auth_.get()));
+  }
+
   MessageLoop message_loop_;
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
   BrowserThread io_thread_;
 
   std::string username_;
   std::string password_;
   std::string hash_ascii_;
   GaiaAuthConsumer::ClientLoginResult result_;
 
@@ skipping 67 matching lines @@
 
 TEST_F(ParallelAuthenticatorTest, ResolveNothingDone) {
   scoped_refptr<ResolveChecker> checker(
       new ResolveChecker(state_.release(),
                          auth_.get(),
                          ParallelAuthenticator::CONTINUE));
   EXPECT_TRUE(checker->Run());
 }
 
 TEST_F(ParallelAuthenticatorTest, ResolvePossiblePwChange) {
+  // Set a fake online attempt so that we return intermediate cryptohome state.
+  FakeOnlineAttempt();
+
   // Set up state as though a cryptohome mount attempt has occurred
   // and been rejected.
   state_->PresetCryptohomeStatus(false,
                                  chromeos::kCryptohomeMountErrorKeyFailure);
   scoped_refptr<ResolveChecker> checker(
       new ResolveChecker(state_.release(),
                          auth_.get(),
                          ParallelAuthenticator::POSSIBLE_PW_CHANGE));
   EXPECT_TRUE(checker->Run());
 }
 
+TEST_F(ParallelAuthenticatorTest, ResolvePossiblePwChangeToFailedMount) {
+  // Set up state as though a cryptohome mount attempt has occurred
+  // and been rejected.
+  state_->PresetCryptohomeStatus(false,
+                                 chromeos::kCryptohomeMountErrorKeyFailure);
+
+  // When there is no online attempt and online results, POSSIBLE_PW_CHANGE
+  // will be resolved to FAILED_MOUNT.
+  scoped_refptr<ResolveChecker> checker(
+      new ResolveChecker(state_.release(),
+                         auth_.get(),
+                         ParallelAuthenticator::FAILED_MOUNT));
+  EXPECT_TRUE(checker->Run());
+}
+
+TEST_F(ParallelAuthenticatorTest, ResolveNeedOldPw) {
+  // Set up state as though a cryptohome mount attempt has occurred
+  // and been rejected because of unmatched key; additionally,
+  // an online auth attempt has completed successfully.
+  state_->PresetCryptohomeStatus(
+      false,
+      chromeos::kCryptohomeMountErrorKeyFailure);
+  state_->PresetOnlineLoginStatus(GaiaAuthConsumer::ClientLoginResult(),
+                                 LoginFailure::None());
+  scoped_refptr<ResolveChecker> checker(
+      new ResolveChecker(state_.release(),
+                         auth_.get(),
+                         ParallelAuthenticator::NEED_OLD_PW));
+  EXPECT_TRUE(checker->Run());
+}
+
 TEST_F(ParallelAuthenticatorTest, DriveFailedMount) {
   FailOnLoginSuccess();
   ExpectLoginFailure(LoginFailure(LoginFailure::COULD_NOT_MOUNT_CRYPTOHOME));
 
   // Set up state as though a cryptohome mount attempt has occurred
   // and failed.
   state_->PresetCryptohomeStatus(false, 0);
   SetAttemptState(auth_, state_.release());
 
   RunResolve(auth_.get(), &message_loop_);
@@ skipping 65 matching lines @@
 
   auth_->ResyncEncryptedData(result_);
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveRequestOldPassword) {
   FailOnLoginSuccess();
   ExpectPasswordChange();
 
   state_->PresetCryptohomeStatus(false,
-                                chromeos::kCryptohomeMountErrorKeyFailure);
+                                 chromeos::kCryptohomeMountErrorKeyFailure);
   state_->PresetOnlineLoginStatus(result_, LoginFailure::None());
   SetAttemptState(auth_, state_.release());
 
   RunResolve(auth_.get(), &message_loop_);
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveDataRecover) {
   ExpectLoginSuccess(username_, password_, result_, false);
   FailOnLoginFailure();
 
@@ skipping 30 matching lines @@
       .WillOnce(Return(CryptohomeBlob(2, 0)))
       .RetiresOnSaturation();
 
   SetAttemptState(auth_, state_.release());
 
   auth_->RecoverEncryptedData(std::string(), result_);
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, ResolveNoMount) {
+  // Set a fake online attempt so that we return intermediate cryptohome state.
+  FakeOnlineAttempt();
+
   // Set up state as though a cryptohome mount attempt has occurred
   // and been rejected because the user doesn't exist.
   state_->PresetCryptohomeStatus(
       false,
       chromeos::kCryptohomeMountErrorUserDoesNotExist);
   scoped_refptr<ResolveChecker> checker(
       new ResolveChecker(state_.release(),
                          auth_.get(),
                          ParallelAuthenticator::NO_MOUNT));
   EXPECT_TRUE(checker->Run());
 }
 
+TEST_F(ParallelAuthenticatorTest, ResolveNoMountToFailedMount) {
+  // Set up state as though a cryptohome mount attempt has occurred
+  // and been rejected because the user doesn't exist.
+  state_->PresetCryptohomeStatus(
+      false,
+      chromeos::kCryptohomeMountErrorUserDoesNotExist);
+
+  // When there is no online attempt and online results, NO_MOUNT will be
+  // resolved to FAILED_MOUNT.
+  scoped_refptr<ResolveChecker> checker(
+      new ResolveChecker(state_.release(),
+                         auth_.get(),
+                         ParallelAuthenticator::FAILED_MOUNT));
+  EXPECT_TRUE(checker->Run());
+}
+
 TEST_F(ParallelAuthenticatorTest, ResolveCreateNew) {
   // Set up state as though a cryptohome mount attempt has occurred
   // and been rejected because the user doesn't exist; additionally,
   // an online auth attempt has completed successfully.
   state_->PresetCryptohomeStatus(
       false,
       chromeos::kCryptohomeMountErrorUserDoesNotExist);
   state_->PresetOnlineLoginStatus(GaiaAuthConsumer::ClientLoginResult(),
                                  LoginFailure::None());
   scoped_refptr<ResolveChecker> checker(
@@ skipping 252 matching lines @@
   FilePath tmp_file_path = FakeLocalaccountFile(username_);
   ReadLocalaccountFile(auth_.get(), tmp_file_path.BaseName().value());
 
   auth_->AuthenticateToUnlock(username_, "");
   message_loop_.Run();
 
   Delete(tmp_file_path, false);
 }
 
 }  // namespace chromeos