Shaving parallel authenticator yak to remove unnecessary dependency on this class from OAuth spec...

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/bind.h"
@@ skipping 229 matching lines @@
 
   // Mocks, destroyed by CrosLibrary class.
   MockCryptohomeLibrary* mock_library_;
   MockLibraryLoader* loader_;
 
   MockConsumer consumer_;
   scoped_refptr<ParallelAuthenticator> auth_;
   scoped_ptr<TestAttemptState> state_;
 };
 
-TEST_F(ParallelAuthenticatorTest, SaltToAscii) {
-  unsigned char fake_salt[8] = { 0 };
-  fake_salt[0] = 10;
-  fake_salt[1] = 1;
-  fake_salt[7] = 10 << 4;
-  std::vector<unsigned char> salt_v(fake_salt, fake_salt + sizeof(fake_salt));
-
-  ON_CALL(*mock_library_, GetSystemSalt())
-      .WillByDefault(Return(salt_v));
-  EXPECT_CALL(*mock_library_, GetSystemSalt())
-      .Times(1)
-      .RetiresOnSaturation();
-
-  EXPECT_EQ("0a010000000000a0", auth_->SaltAsAscii());
-}
-
 TEST_F(ParallelAuthenticatorTest, ReadLocalaccount) {
   FilePath tmp_file_path = FakeLocalaccountFile(username_);
 
   ReadLocalaccountFile(auth_.get(), tmp_file_path.BaseName().value());
   EXPECT_EQ(auth_->localaccount_, username_);
   Delete(tmp_file_path, false);
 }
 
 TEST_F(ParallelAuthenticatorTest, ReadLocalaccountTrailingWS) {
   FilePath tmp_file_path =
@@ skipping 181 matching lines @@
   FailOnLoginFailure();
 
   // Set up mock cryptohome library to respond successfully to a key migration.
   mock_library_->SetUp(true, 0);
   EXPECT_CALL(*mock_library_, AsyncMigrateKey(username_, _, hash_ascii_, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_library_, AsyncMount(username_, hash_ascii_, false, _))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_library_, GetSystemSalt())
-      .WillOnce(Return(CryptohomeBlob(2, 0)))
+  EXPECT_CALL(*mock_library_, HashPassword(_))
+      .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
   state_->PresetOnlineLoginStatus(result_, LoginFailure::None());
   SetAttemptState(auth_, state_.release());
 
   auth_->RecoverEncryptedData(std::string(), result_);
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveDataRecoverButFail) {
   FailOnLoginSuccess();
   ExpectPasswordChange();
 
   // Set up mock cryptohome library to fail a key migration attempt,
   // asserting that the wrong password was used.
   mock_library_->SetUp(false, chromeos::kCryptohomeMountErrorKeyFailure);
   EXPECT_CALL(*mock_library_, AsyncMigrateKey(username_, _, hash_ascii_, _))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_library_, GetSystemSalt())
-      .WillOnce(Return(CryptohomeBlob(2, 0)))
+  EXPECT_CALL(*mock_library_, HashPassword(_))
+      .WillOnce(Return(std::string()))
       .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.
@@ skipping 109 matching lines @@
   FailOnLoginFailure();
 
   // Set up mock cryptohome library to respond successfully to a key migration.
   mock_library_->SetUp(true, 0);
   EXPECT_CALL(*mock_library_, AsyncMigrateKey(username_,
                                               state_->ascii_hash,
                                               _,
                                               _))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_library_, GetSystemSalt())
-      .WillOnce(Return(CryptohomeBlob(2, 0)))
+  EXPECT_CALL(*mock_library_, HashPassword(_))
+      .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
   // Set up state as though a cryptohome mount attempt has occurred and
   // succeeded; also, an online request that never made it.
   state_->PresetCryptohomeStatus(true, 0);
   // state_ is released further down.
   SetAttemptState(auth_, state_.get());
   RunResolve(auth_.get(), &message_loop_);
 
   // Offline login has completed, so now we "complete" the online request.
@@ skipping 15 matching lines @@
                    username_,
                    std::string(),
                    std::string(),
                    std::string());
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveOfflineLoginGetCaptchad) {
   ExpectLoginSuccess(username_, password_, result_, true);
   FailOnLoginFailure();
-  EXPECT_CALL(*mock_library_, GetSystemSalt())
-      .WillOnce(Return(CryptohomeBlob(2, 0)))
+  EXPECT_CALL(*mock_library_, HashPassword(_))
+      .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
   // Set up state as though a cryptohome mount attempt has occurred and
   // succeeded; also, an online request that never made it.
   state_->PresetCryptohomeStatus(true, 0);
   // state_ is released further down.
   SetAttemptState(auth_, state_.get());
   RunResolve(auth_.get(), &message_loop_);
 
   // Offline login has completed, so now we "complete" the online request.
@@ skipping 91 matching lines @@
 TEST_F(ParallelAuthenticatorTest, DriveUnlock) {
   ExpectLoginSuccess(username_, std::string(), result_, false);
   FailOnLoginFailure();
 
   // Set up mock cryptohome library to respond successfully to a cryptohome
   // key-check attempt.
   mock_library_->SetUp(true, 0);
   EXPECT_CALL(*mock_library_, AsyncCheckKey(username_, _, _))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_library_, GetSystemSalt())
-      .WillOnce(Return(CryptohomeBlob(2, 0)))
+  EXPECT_CALL(*mock_library_, HashPassword(_))
+      .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
   auth_->AuthenticateToUnlock(username_, "");
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveLocalUnlock) {
   ExpectLoginSuccess(username_, std::string(), result_, false);
   FailOnLoginFailure();
 
   // Set up mock cryptohome library to fail a cryptohome key-check
   // attempt.
   mock_library_->SetUp(false, 0);
   EXPECT_CALL(*mock_library_, AsyncCheckKey(username_, _, _))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_library_, GetSystemSalt())
-      .WillOnce(Return(CryptohomeBlob(2, 0)))
+  EXPECT_CALL(*mock_library_, HashPassword(_))
+      .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
   // Deal with getting the localaccount file
   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