Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/login/auth/cryptohome_authenticator_unittest.cc

 // Copyright 2014 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 <stdint.h>
+
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/login/auth/chrome_cryptohome_authenticator.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
@@ skipping 135 matching lines @@
         switches::kLoginManager);
 
     mock_caller_ = new cryptohome::MockAsyncMethodCaller;
     cryptohome::AsyncMethodCaller::InitializeForTesting(mock_caller_);
     mock_homedir_methods_ = new cryptohome::MockHomedirMethods;
     mock_homedir_methods_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
     cryptohome::HomedirMethods::InitializeForTesting(mock_homedir_methods_);
 
     fake_cryptohome_client_ = new FakeCryptohomeClient;
     chromeos::DBusThreadManager::GetSetterForTesting()->SetCryptohomeClient(
-        scoped_ptr<CryptohomeClient>(fake_cryptohome_client_));
+        std::unique_ptr<CryptohomeClient>(fake_cryptohome_client_));
 
     SystemSaltGetter::Initialize();
 
     auth_ = new ChromeCryptohomeAuthenticator(&consumer_);
     state_.reset(new TestAttemptState(user_context_, false));
   }
 
   // Tears down the test fixture.
   void TearDown() override {
     SystemSaltGetter::Shutdown();
@@ skipping 58 matching lines @@
         .WillOnce(Invoke(MockAuthStatusConsumer::OnGuestSuccessQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectPasswordChange() {
     EXPECT_CALL(consumer_, OnPasswordChangeDetected())
         .WillOnce(Invoke(MockAuthStatusConsumer::OnMigrateQuit))
         .RetiresOnSaturation();
   }
 
-  void ExpectGetKeyDataExCall(scoped_ptr<int64_t> key_type,
-                              scoped_ptr<std::string> salt) {
+  void ExpectGetKeyDataExCall(std::unique_ptr<int64_t> key_type,
+                              std::unique_ptr<std::string> salt) {
     key_definitions_.clear();
     key_definitions_.push_back(cryptohome::KeyDefinition(
         std::string() /* secret */,
         kCryptohomeGAIAKeyLabel,
         cryptohome::PRIV_DEFAULT));
     cryptohome::KeyDefinition& key_definition = key_definitions_.back();
     key_definition.revision = 1;
     if (key_type) {
       key_definition.provider_data.push_back(
           cryptohome::KeyDefinition::ProviderData("type"));
@@ skipping 56 matching lines @@
   UserContext user_context_;
   UserContext user_context_with_transformed_key_;
   Key transformed_key_;
 
   std::vector<cryptohome::KeyDefinition> key_definitions_;
 
   ScopedDeviceSettingsTestHelper device_settings_test_helper_;
   ScopedTestCrosSettings test_cros_settings_;
 
   TestingProfile profile_;
-  scoped_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
   user_manager::FakeUserManager* user_manager_;
   ScopedUserManagerEnabler user_manager_enabler_;
 
   cryptohome::MockAsyncMethodCaller* mock_caller_;
   cryptohome::MockHomedirMethods* mock_homedir_methods_;
 
   MockAuthStatusConsumer consumer_;
 
   scoped_refptr<CryptohomeAuthenticator> auth_;
-  scoped_ptr<TestAttemptState> state_;
+  std::unique_ptr<TestAttemptState> state_;
   FakeCryptohomeClient* fake_cryptohome_client_;
 
   scoped_refptr<ownership::MockOwnerKeyUtil> owner_key_util_;
 
  private:
   void InvokeGetDataExCallback(
       const cryptohome::HomedirMethods::GetKeyDataCallback& callback) {
     callback.Run(true /* success */,
                  cryptohome::MOUNT_ERROR_NONE,
                  key_definitions_);
@@ skipping 214 matching lines @@
   // remove attempt.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(
       *mock_caller_,
       AsyncRemove(cryptohome::Identification(user_context_.GetAccountId()), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome create
   // attempt.
-  ExpectGetKeyDataExCall(scoped_ptr<int64_t>(), scoped_ptr<std::string>());
+  ExpectGetKeyDataExCall(std::unique_ptr<int64_t>(),
+                         std::unique_ptr<std::string>());
   ExpectMountExCall(true /* expect_create_attempt */);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->ResyncEncryptedData();
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveResyncFail) {
@@ skipping 36 matching lines @@
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(
       *mock_caller_,
       AsyncMigrateKey(cryptohome::Identification(user_context_.GetAccountId()),
                       _, transformed_key_.GetSecret(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome mount
   // attempt.
-  ExpectGetKeyDataExCall(scoped_ptr<int64_t>(), scoped_ptr<std::string>());
+  ExpectGetKeyDataExCall(std::unique_ptr<int64_t>(),
+                         std::unique_ptr<std::string>());
   ExpectMountExCall(false /* expect_create_attempt */);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataRecoverButFail) {
@@ skipping 42 matching lines @@
 
 TEST_F(CryptohomeAuthenticatorTest, DriveCreateForNewUser) {
   UserContext expected_user_context(user_context_with_transformed_key_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock homedir methods to respond successfully to a cryptohome create
   // attempt.
-  ExpectGetKeyDataExCall(scoped_ptr<int64_t>(), scoped_ptr<std::string>());
+  ExpectGetKeyDataExCall(std::unique_ptr<int64_t>(),
+                         std::unique_ptr<std::string>());
   ExpectMountExCall(true /* expect_create_attempt */);
 
   // 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(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
@@ skipping 50 matching lines @@
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock homedir methods to respond with key metadata indicating that a
   // pre-hashed key was used to create the cryptohome and allow a successful
   // mount when this pre-hashed key is used.
 
   ExpectGetKeyDataExCall(
-      make_scoped_ptr(new int64_t(Key::KEY_TYPE_SALTED_SHA256)),
-      make_scoped_ptr(new std::string(kSalt)));
+      base::WrapUnique(new int64_t(Key::KEY_TYPE_SALTED_SHA256)),
+      base::WrapUnique(new std::string(kSalt)));
   ExpectMountExCall(false /* expect_create_attempt */);
 
   auth_->AuthenticateToLogin(NULL, user_context_);
   base::RunLoop().Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, FailLoginWithMissingSalt) {
   CreateTransformedKey(Key::KEY_TYPE_SALTED_SHA256, kSalt);
 
   FailOnLoginSuccess();
   ExpectLoginFailure(AuthFailure(AuthFailure::COULD_NOT_MOUNT_CRYPTOHOME));
 
   // Set up mock homedir methods to respond with key metadata indicating that a
   // pre-hashed key was used to create the cryptohome but without the required
   // salt.
   ExpectGetKeyDataExCall(
-      make_scoped_ptr(new int64_t(Key::KEY_TYPE_SALTED_SHA256)),
-      scoped_ptr<std::string>());
+      base::WrapUnique(new int64_t(Key::KEY_TYPE_SALTED_SHA256)),
+      std::unique_ptr<std::string>());
 
   auth_->AuthenticateToLogin(NULL, user_context_);
   base::RunLoop().Run();
 }
 
 }  // namespace chromeos