Update CrOS to use scoped_refptr<T>::get() rather than implicit "operator T*"

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 216 matching lines @@
 
 TEST_F(ParallelAuthenticatorTest, OnLoginSuccess) {
   EXPECT_CALL(consumer_, OnLoginSuccess(UserContext(username_,
                                                     password_,
                                                     std::string(),
                                                     username_hash_),
                                         false, false))
       .Times(1)
       .RetiresOnSaturation();
 
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
   auth_->OnLoginSuccess(false);
 }
 
 TEST_F(ParallelAuthenticatorTest, OnPasswordChangeDetected) {
   EXPECT_CALL(consumer_, OnPasswordChangeDetected())
       .Times(1)
       .RetiresOnSaturation();
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
   auth_->OnPasswordChangeDetected();
 }
 
 TEST_F(ParallelAuthenticatorTest, ResolveNothingDone) {
   EXPECT_EQ(ParallelAuthenticator::CONTINUE,
-            SetAndResolveState(auth_, state_.release()));
+            SetAndResolveState(auth_.get(), state_.release()));
 }
 
 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, cryptohome::MOUNT_ERROR_KEY_FAILURE);
 
   EXPECT_EQ(ParallelAuthenticator::POSSIBLE_PW_CHANGE,
-            SetAndResolveState(auth_, state_.release()));
+            SetAndResolveState(auth_.get(), state_.release()));
 }
 
 TEST_F(ParallelAuthenticatorTest, ResolvePossiblePwChangeToFailedMount) {
   // Set up state as though a cryptohome mount attempt has occurred
   // and been rejected.
   state_->PresetCryptohomeStatus(false, cryptohome::MOUNT_ERROR_KEY_FAILURE);
 
   // When there is no online attempt and online results, POSSIBLE_PW_CHANGE
   EXPECT_EQ(ParallelAuthenticator::FAILED_MOUNT,
-            SetAndResolveState(auth_, state_.release()));
+            SetAndResolveState(auth_.get(), 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::LoginFailureNone());
 
   EXPECT_EQ(ParallelAuthenticator::NEED_OLD_PW,
-            SetAndResolveState(auth_, state_.release()));
+            SetAndResolveState(auth_.get(), 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
   // or that we really are in "safe-mode".
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   SetOwnerState(true, false);
 
   EXPECT_EQ(ParallelAuthenticator::OWNER_REQUIRED,
-            SetAndResolveState(auth_, state_.release()));
+            SetAndResolveState(auth_.get(), state_.release()));
 }
 
 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()),
                                     hash_ascii_,
                                     "",
                                     "",
                                     User::USER_TYPE_REGULAR,
                                     false));
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_EQ(ParallelAuthenticator::OFFLINE_LOGIN,
-            SetAndResolveState(auth_, state_.release()));
+            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);
 
   MockDBusThreadManagerWithoutGMock* mock_dbus_thread_manager =
       new MockDBusThreadManagerWithoutGMock;
   DBusThreadManager::InitializeForTesting(mock_dbus_thread_manager);
@@ skipping 10 matching lines @@
   // Remove the real DeviceSettingsProvider and replace it with a stub.
   device_settings_provider =
       CrosSettings::Get()->GetProvider(chromeos::kReportDeviceVersionInfo);
   EXPECT_TRUE(device_settings_provider != NULL);
   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()));
+            SetAndResolveState(auth_.get(), state_.release()));
   // Let the owner verification run.
   device_settings_test_helper_.Flush();
   // and test that the mount has succeeded.
   state_.reset(new TestAttemptState(UserContext(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()));
+            SetAndResolveState(auth_.get(), state_.release()));
 
   EXPECT_TRUE(
       CrosSettings::Get()->RemoveSettingsProvider(&stub_settings_provider));
   CrosSettings::Get()->AddSettingsProvider(device_settings_provider);
   DBusThreadManager::Get()->Shutdown();
 }
 
 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, cryptohome::MOUNT_ERROR_NONE);
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveGuestLogin) {
   ExpectGuestLoginSuccess();
   FailOnLoginFailure();
 
   // Set up mock cryptohome library to respond as though a tmpfs mount
   // attempt has occurred and succeeded.
@@ skipping 67 matching lines @@
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_caller_, AsyncMount(username_, hash_ascii_,
                                         cryptohome::CREATE_IF_MISSING, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_caller_, AsyncGetSanitizedUsername(username_, _))
       .Times(1)
       .RetiresOnSaturation();
 
   state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), 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());
+  SetAttemptState(auth_.get(), state_.release());
 
   auth_->ResyncEncryptedData();
   message_loop_.Run();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveRequestOldPassword) {
   FailOnLoginSuccess();
   ExpectPasswordChange();
 
   state_->PresetCryptohomeStatus(false, cryptohome::MOUNT_ERROR_KEY_FAILURE);
   state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveDataRecover) {
   ExpectLoginSuccess(username_,
                      password_,
                      cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername,
                      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_caller_, AsyncGetSanitizedUsername(username_, _))
         .Times(1)
         .RetiresOnSaturation();
   EXPECT_CALL(*mock_cryptohome_library_, GetSystemSalt())
       .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
   state_->PresetOnlineLoginStatus(LoginFailure::LoginFailureNone());
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   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_caller_->SetUp(false, cryptohome::MOUNT_ERROR_KEY_FAILURE);
   EXPECT_CALL(*mock_caller_, AsyncMigrateKey(username_, _, hash_ascii_, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_cryptohome_library_, GetSystemSalt())
       .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   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,
                                  cryptohome::MOUNT_ERROR_USER_DOES_NOT_EXIST);
 
   EXPECT_EQ(ParallelAuthenticator::NO_MOUNT,
-            SetAndResolveState(auth_, state_.release()));
+            SetAndResolveState(auth_.get(), state_.release()));
 }
 
 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,
                                  cryptohome::MOUNT_ERROR_USER_DOES_NOT_EXIST);
 
   // When there is no online attempt and online results, NO_MOUNT will be
   // resolved to FAILED_MOUNT.
   EXPECT_EQ(ParallelAuthenticator::FAILED_MOUNT,
-            SetAndResolveState(auth_, state_.release()));
+            SetAndResolveState(auth_.get(), 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::LoginFailureNone());
 
   EXPECT_EQ(ParallelAuthenticator::CREATE_NEW,
-            SetAndResolveState(auth_, state_.release()));
+            SetAndResolveState(auth_.get(), state_.release()));
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveCreateForNewUser) {
   ExpectLoginSuccess(username_,
                      password_,
                      cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername,
                      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();
   EXPECT_CALL(*mock_caller_, AsyncGetSanitizedUsername(username_, _))
       .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::LoginFailureNone());
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveOfflineLogin) {
   ExpectLoginSuccess(username_, password_, username_hash_, false);
   FailOnLoginFailure();
 
   // Set up state as though a cryptohome mount attempt has occurred and
   // succeeded.
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   GoogleServiceAuthError error =
       GoogleServiceAuthError::FromConnectionError(net::ERR_CONNECTION_RESET);
   state_->PresetOnlineLoginStatus(LoginFailure::FromNetworkAuthFailure(error));
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveOfflineLoginDelayedOnline) {
   ExpectLoginSuccess(username_, password_, username_hash_, true);
   FailOnLoginFailure();
 
   // Set up state as though a cryptohome mount attempt has occurred and
   // succeeded.
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   // state_ is released further down.
-  SetAttemptState(auth_, state_.get());
+  SetAttemptState(auth_.get(), state_.get());
   RunResolve(auth_.get());
 
   // Offline login has completed, so now we "complete" the online request.
   GoogleServiceAuthError error(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   LoginFailure failure = LoginFailure::FromNetworkAuthFailure(error);
   state_.release()->PresetOnlineLoginStatus(failure);
   ExpectLoginFailure(failure);
 
   RunResolve(auth_.get());
@@ skipping 12 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_cryptohome_library_, GetSystemSalt())
       .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, cryptohome::MOUNT_ERROR_NONE);
   // state_ is released further down.
-  SetAttemptState(auth_, state_.get());
+  SetAttemptState(auth_.get(), state_.get());
   RunResolve(auth_.get());
 
   // Offline login has completed, so now we "complete" the online request.
   GoogleServiceAuthError error(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   LoginFailure failure = LoginFailure::FromNetworkAuthFailure(error);
   state_.release()->PresetOnlineLoginStatus(failure);
   ExpectLoginFailure(failure);
 
   RunResolve(auth_.get());
@@ skipping 18 matching lines @@
   ExpectLoginSuccess(username_, password_, username_hash_, true);
   FailOnLoginFailure();
   EXPECT_CALL(*mock_cryptohome_library_, GetSystemSalt())
       .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, cryptohome::MOUNT_ERROR_NONE);
   // state_ is released further down.
-  SetAttemptState(auth_, state_.get());
+  SetAttemptState(auth_.get(), state_.get());
   RunResolve(auth_.get());
 
   // Offline login has completed, so now we "complete" the online request.
   GoogleServiceAuthError error(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   LoginFailure failure = LoginFailure::FromNetworkAuthFailure(error);
   state_.release()->PresetOnlineLoginStatus(failure);
   ExpectLoginFailure(failure);
 
   RunResolve(auth_.get());
@@ skipping 20 matching lines @@
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveOnlineLogin) {
   ExpectLoginSuccess(username_, password_, username_hash_, 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::LoginFailureNone());
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), 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_, username_hash_, true);
   GoogleServiceAuthError error(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   LoginFailure failure = LoginFailure::FromNetworkAuthFailure(error);
   ExpectLoginFailure(failure);
 
   // Set up state as though a cryptohome mount attempt has occurred and
   // succeeded.
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   state_->PresetOnlineLoginStatus(failure);
-  SetAttemptState(auth_, state_.release());
+  SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveUnlock) {
   ExpectLoginSuccess(username_, std::string(), std::string(), false);
   FailOnLoginFailure();
 
   // 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(UserContext(username_,
                                           std::string(),
                                           std::string()));
   message_loop_.Run();
 }
 
 }  // namespace chromeos