Rename GoogleServiceAuthError::None() to AuthErrorNone() and LoginFailure::None() to LoginFailureNo…

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 259 matching lines @@
   // When there is no online attempt and online results, POSSIBLE_PW_CHANGE
   EXPECT_EQ(ParallelAuthenticator::FAILED_MOUNT,
             SetAndResolveState(auth_, state_.release()));
 }
 
 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, cryptohome::MOUNT_ERROR_KEY_FAILURE);
-  state_->PresetOnlineLoginStatus(LoginFailure::None());
+  state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
 
   EXPECT_EQ(ParallelAuthenticator::NEED_OLD_PW,
             SetAndResolveState(auth_, state_.release()));
 }
 
 TEST_F(ParallelAuthenticatorTest, ResolveOwnerNeededDirectFailedMount) {
   // 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 is a high level test to verify the proper transitioning in this mode
   // only. It is not testing that we properly verify that the user is an owner
@@ skipping 156 matching lines @@
   // |CREATE_IF_MISSING| flag to AsyncMount).
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncRemove(username_, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_caller_, AsyncMount(username_, hash_ascii_,
                                         cryptohome::CREATE_IF_MISSING, _))
       .Times(1)
       .RetiresOnSaturation();
 
-  state_->PresetOnlineLoginStatus(LoginFailure::None());
+  state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
   SetAttemptState(auth_, state_.release());
 
   auth_->ResyncEncryptedData();
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveResyncFail) {
   FailOnLoginSuccess();
   ExpectLoginFailure(LoginFailure(LoginFailure::DATA_REMOVAL_FAILED));
 
   // Set up mock cryptohome library to fail a cryptohome remove attempt.
   mock_caller_->SetUp(false, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncRemove(username_, _))
       .Times(1)
       .RetiresOnSaturation();
 
   SetAttemptState(auth_, state_.release());
 
   auth_->ResyncEncryptedData();
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveRequestOldPassword) {
   FailOnLoginSuccess();
   ExpectPasswordChange();
 
   state_->PresetCryptohomeStatus(false, cryptohome::MOUNT_ERROR_KEY_FAILURE);
-  state_->PresetOnlineLoginStatus(LoginFailure::None());
+  state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
   SetAttemptState(auth_, state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveDataRecover) {
   ExpectLoginSuccess(username_, password_, false);
   FailOnLoginFailure();
 
   // Set up mock cryptohome library to respond successfully to a key migration.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncMigrateKey(username_, _, hash_ascii_, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_caller_, AsyncMount(username_, hash_ascii_,
                                         cryptohome::MOUNT_FLAGS_NONE, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_cryptohome_library_, GetSystemSalt())
       .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
-  state_->PresetOnlineLoginStatus(LoginFailure::None());
+  state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
   SetAttemptState(auth_, state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveDataRecoverButFail) {
   FailOnLoginSuccess();
   ExpectPasswordChange();
 
@@ skipping 37 matching lines @@
   EXPECT_EQ(ParallelAuthenticator::FAILED_MOUNT,
             SetAndResolveState(auth_, state_.release()));
 }
 
 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,
                                  cryptohome::MOUNT_ERROR_USER_DOES_NOT_EXIST);
-  state_->PresetOnlineLoginStatus(LoginFailure::None());
+  state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
 
   EXPECT_EQ(ParallelAuthenticator::CREATE_NEW,
             SetAndResolveState(auth_, state_.release()));
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveCreateForNewUser) {
   ExpectLoginSuccess(username_, password_, false);
   FailOnLoginFailure();
 
   // Set up mock cryptohome library to respond successfully to a cryptohome
   // create attempt (indicated by the |CREATE_IF_MISSING| flag to AsyncMount).
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncMount(username_, hash_ascii_,
                                         cryptohome::CREATE_IF_MISSING, _))
       .Times(1)
       .RetiresOnSaturation();
 
   // 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,
                                  cryptohome::MOUNT_ERROR_USER_DOES_NOT_EXIST);
-  state_->PresetOnlineLoginStatus(LoginFailure::None());
+  state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
   SetAttemptState(auth_, state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveOfflineLogin) {
   ExpectLoginSuccess(username_, password_, false);
   FailOnLoginFailure();
 
   // Set up state as though a cryptohome mount attempt has occurred and
@@ skipping 118 matching lines @@
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveOnlineLogin) {
   ExpectLoginSuccess(username_, password_, false);
   FailOnLoginFailure();
 
   // Set up state as though a cryptohome mount attempt has occurred and
   // succeeded.
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
-  state_->PresetOnlineLoginStatus(LoginFailure::None());
+  state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
   SetAttemptState(auth_, state_.release());
 
   RunResolve(auth_.get());
 }
 
 // http://crbug.com/106538
 TEST_F(ParallelAuthenticatorTest, DISABLED_DriveNeedNewPassword) {
   FailOnLoginSuccess();  // Set failing on success as the default...
   // ...but expect ONE successful login first.
   ExpectLoginSuccess(username_, password_, true);
@@ skipping 23 matching lines @@
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_cryptohome_library_, GetSystemSalt())
       .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
   auth_->AuthenticateToUnlock(username_, "");
   message_loop_.Run();
 }
 
 }  // namespace chromeos