Convert Pass()→std::move() in //chrome/browser/ui

chrome/browser/ui/passwords/manage_passwords_state_unittest.cc

 // Copyright 2015 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/ui/passwords/manage_passwords_state.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/strings/utf_string_conversions.h"
@@ skipping 68 matching lines @@
 
 scoped_ptr<password_manager::PasswordFormManager>
 ManagePasswordsStateTest::CreateFormManager() {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       new password_manager::PasswordFormManager(
           &password_manager_, &stub_client_, driver_.AsWeakPtr(),
           test_local_form(), false));
   test_form_manager->SimulateFetchMatchingLoginsFromPasswordStore();
   ScopedVector<autofill::PasswordForm> stored_forms;
   stored_forms.push_back(new autofill::PasswordForm(test_local_form()));
-  test_form_manager->OnGetPasswordStoreResults(stored_forms.Pass());
+  test_form_manager->OnGetPasswordStoreResults(std::move(stored_forms));
   EXPECT_EQ(1u, test_form_manager->best_matches().size());
   EXPECT_EQ(test_local_form(),
             *test_form_manager->best_matches().begin()->second);
-  return test_form_manager.Pass();
+  return test_form_manager;
 }
 
 void ManagePasswordsStateTest::TestNoisyUpdates() {
   const std::vector<const autofill::PasswordForm*> forms =
       passwords_data_.GetCurrentForms();
   const std::vector<const autofill::PasswordForm*> federated_forms =
       passwords_data_.federated_credentials_forms();
   const password_manager::ui::State state = passwords_data_.state();
   const GURL origin = passwords_data_.origin();
 
@@ skipping 117 matching lines @@
 
   TestNoisyUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PasswordSubmitted) {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  passwords_data().OnPendingPassword(test_form_manager.Pass());
+  passwords_data().OnPendingPassword(std::move(test_form_manager));
 
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             passwords_data().state());
   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
   ASSERT_TRUE(passwords_data().form_manager());
   EXPECT_EQ(test_submitted_form(),
             passwords_data().form_manager()->pending_credentials());
   TestAllUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PasswordSaved) {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  passwords_data().OnPendingPassword(test_form_manager.Pass());
+  passwords_data().OnPendingPassword(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             passwords_data().state());
 
   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
   EXPECT_EQ(password_manager::ui::MANAGE_STATE,
             passwords_data().state());
   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
   TestAllUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, OnRequestCredentials) {
   ScopedVector<autofill::PasswordForm> local_credentials;
   local_credentials.push_back(new autofill::PasswordForm(test_local_form()));
   ScopedVector<autofill::PasswordForm> federated_credentials;
   federated_credentials.push_back(
       new autofill::PasswordForm(test_federated_form()));
   const GURL origin = test_local_form().origin;
-  passwords_data().OnRequestCredentials(local_credentials.Pass(),
-                                        federated_credentials.Pass(), origin);
+  passwords_data().OnRequestCredentials(
+      std::move(local_credentials), std::move(federated_credentials), origin);
   passwords_data().set_credentials_callback(base::Bind(
       &ManagePasswordsStateTest::CredentialCallback, base::Unretained(this)));
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_THAT(passwords_data().federated_credentials_forms(),
               ElementsAre(Pointee(test_federated_form())));
   EXPECT_EQ(password_manager::ui::CREDENTIAL_REQUEST_STATE,
             passwords_data().state());
   EXPECT_EQ(origin, passwords_data().origin());
   TestAllUpdates();
@@ skipping 11 matching lines @@
               ElementsAre(Pointee(test_local_form())));
   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
   EXPECT_EQ(origin, passwords_data().origin());
   TestAllUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, AutoSignin) {
   ScopedVector<autofill::PasswordForm> local_credentials;
   local_credentials.push_back(new autofill::PasswordForm(test_local_form()));
-  passwords_data().OnAutoSignin(local_credentials.Pass());
+  passwords_data().OnAutoSignin(std::move(local_credentials));
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
   EXPECT_EQ(password_manager::ui::AUTO_SIGNIN_STATE, passwords_data().state());
   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
   TestAllUpdates();
 
   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
   TestAllUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSave) {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
-  passwords_data().OnAutomaticPasswordSave(test_form_manager.Pass());
+  passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state());
   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
   ASSERT_TRUE(passwords_data().form_manager());
   EXPECT_EQ(test_submitted_form(),
             passwords_data().form_manager()->pending_credentials());
   TestAllUpdates();
 
   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               UnorderedElementsAre(Pointee(test_local_form()),
@@ skipping 40 matching lines @@
   EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin());
   EXPECT_FALSE(passwords_data().form_manager());
 }
 
 TEST_F(ManagePasswordsStateTest, OnInactive) {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  passwords_data().OnPendingPassword(test_form_manager.Pass());
+  passwords_data().OnPendingPassword(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             passwords_data().state());
   passwords_data().OnInactive();
   EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty());
   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
   EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state());
   EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin());
   EXPECT_FALSE(passwords_data().form_manager());
   TestNoisyUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PendingPasswordAddBlacklisted) {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  passwords_data().OnPendingPassword(test_form_manager.Pass());
+  passwords_data().OnPendingPassword(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             passwords_data().state());
 
   TestBlacklistedUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, RequestCredentialsAddBlacklisted) {
   ScopedVector<autofill::PasswordForm> local_credentials;
   local_credentials.push_back(new autofill::PasswordForm(test_local_form()));
   ScopedVector<autofill::PasswordForm> federated_credentials;
   federated_credentials.push_back(
       new autofill::PasswordForm(test_federated_form()));
   const GURL origin = test_local_form().origin;
-  passwords_data().OnRequestCredentials(local_credentials.Pass(),
-                                        federated_credentials.Pass(), origin);
+  passwords_data().OnRequestCredentials(
+      std::move(local_credentials), std::move(federated_credentials), origin);
   passwords_data().set_credentials_callback(base::Bind(
       &ManagePasswordsStateTest::CredentialCallback, base::Unretained(this)));
   EXPECT_EQ(password_manager::ui::CREDENTIAL_REQUEST_STATE,
             passwords_data().state());
 
   TestBlacklistedUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, AutoSigninAddBlacklisted) {
   ScopedVector<autofill::PasswordForm> local_credentials;
   local_credentials.push_back(new autofill::PasswordForm(test_local_form()));
-  passwords_data().OnAutoSignin(local_credentials.Pass());
+  passwords_data().OnAutoSignin(std::move(local_credentials));
   EXPECT_EQ(password_manager::ui::AUTO_SIGNIN_STATE, passwords_data().state());
 
   TestBlacklistedUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSaveAddBlacklisted) {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  passwords_data().OnAutomaticPasswordSave(test_form_manager.Pass());
+  passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state());
 
   TestBlacklistedUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, BackgroundAutofilledAddBlacklisted) {
   autofill::PasswordFormMap password_form_map;
   password_form_map.insert(std::make_pair(
       test_local_form().username_value,
       make_scoped_ptr(new autofill::PasswordForm(test_local_form()))));
   passwords_data().OnPasswordAutofilled(
       password_form_map, password_form_map.begin()->second->origin);
   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 
   TestBlacklistedUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PasswordUpdateAddBlacklisted) {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  passwords_data().OnUpdatePassword(test_form_manager.Pass());
+  passwords_data().OnUpdatePassword(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE,
             passwords_data().state());
 
   TestBlacklistedUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PasswordUpdateSubmitted) {
   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  passwords_data().OnUpdatePassword(test_form_manager.Pass());
+  passwords_data().OnUpdatePassword(std::move(test_form_manager));
 
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE,
             passwords_data().state());
   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
   ASSERT_TRUE(passwords_data().form_manager());
   EXPECT_EQ(test_submitted_form(),
             passwords_data().form_manager()->pending_credentials());
@@ skipping 55 matching lines @@
   passwords_data().set_credentials_callback(base::Bind(
       &ManagePasswordsStateTest::CredentialCallback, base::Unretained(this)));
   password_manager::CredentialInfo credential_info(
       form, password_manager::CredentialType::CREDENTIAL_TYPE_FEDERATED);
   EXPECT_CALL(*this, CredentialCallback(credential_info));
   passwords_data().ChooseCredential(
       form, password_manager::CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 }  // namespace