Convert Pass()→std::move() in //components/[n-z]*

components/password_manager/core/browser/password_form_manager_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 "components/password_manager/core/browser/password_form_manager.h"
+
 #include <map>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "build/build_config.h"
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/autofill/core/browser/test_autofill_client.h"
 #include "components/autofill/core/browser/test_autofill_driver.h"
 #include "components/autofill/core/browser/test_personal_data_manager.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/browser/credentials_filter.h"
 #include "components/password_manager/core/browser/mock_password_store.h"
-#include "components/password_manager/core/browser/password_form_manager.h"
 #include "components/password_manager/core/browser/password_manager.h"
 #include "components/password_manager/core/browser/password_manager_driver.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_test_utils.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/browser/statistics_table.h"
 #include "components/password_manager/core/browser/stub_password_manager_client.h"
 #include "components/password_manager/core/browser/stub_password_manager_driver.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 14 matching lines @@
 
 namespace {
 
 // Invokes the password store consumer with a copy of all forms.
 ACTION_P4(InvokeConsumer, form1, form2, form3, form4) {
   ScopedVector<PasswordForm> result;
   result.push_back(make_scoped_ptr(new PasswordForm(form1)));
   result.push_back(make_scoped_ptr(new PasswordForm(form2)));
   result.push_back(make_scoped_ptr(new PasswordForm(form3)));
   result.push_back(make_scoped_ptr(new PasswordForm(form4)));
-  arg0->OnGetPasswordStoreResults(result.Pass());
+  arg0->OnGetPasswordStoreResults(std::move(result));
 }
 
 MATCHER_P(CheckUsername, username_value, "Username incorrect") {
   return arg.username_value == username_value;
 }
 
 MATCHER_P2(CheckUploadFormStructure,
            form_signature,
            expected_types,
            "Upload form structure is incorrect") {
@@ skipping 61 matching lines @@
 
 class MockPasswordManagerDriver : public StubPasswordManagerDriver {
  public:
   MockPasswordManagerDriver()
       : mock_autofill_manager_(&test_autofill_driver_,
                                &test_autofill_client_,
                                &test_personal_data_manager_) {
     scoped_ptr<TestingPrefServiceSimple> prefs(new TestingPrefServiceSimple());
     prefs->registry()->RegisterBooleanPref(autofill::prefs::kAutofillEnabled,
                                            true);
-    test_autofill_client_.SetPrefs(prefs.Pass());
+    test_autofill_client_.SetPrefs(std::move(prefs));
     mock_autofill_download_manager_ = new MockAutofillDownloadManager(
         &test_autofill_driver_, &mock_autofill_manager_);
     // AutofillManager takes ownership of |mock_autofill_download_manager_|.
     mock_autofill_manager_.SetDownloadManager(mock_autofill_download_manager_);
   }
 
   ~MockPasswordManagerDriver() {}
 
   MOCK_METHOD1(FillPasswordForm, void(const autofill::PasswordFormFillData&));
   MOCK_METHOD1(AllowPasswordGenerationForForm,
@@ skipping 21 matching lines @@
   MOCK_CONST_METHOD1(FilterResultsPtr,
                      void(ScopedVector<autofill::PasswordForm>* results));
 
   // This method is not relevant here.
   MOCK_CONST_METHOD1(ShouldSave, bool(const autofill::PasswordForm& form));
 
   // GMock cannot handle move-only arguments.
   ScopedVector<autofill::PasswordForm> FilterResults(
       ScopedVector<autofill::PasswordForm> results) const override {
     FilterResultsPtr(&results);
-    return results.Pass();
+    return results;
   }
 };
 
 class TestPasswordManagerClient : public StubPasswordManagerClient {
  public:
   explicit TestPasswordManagerClient(PasswordStore* password_store)
       : password_store_(password_store),
         driver_(new NiceMock<MockPasswordManagerDriver>),
         is_update_password_ui_enabled_(false),
         filter_all_results_(false) {
@@ skipping 132 matching lines @@
       return;
     }
 
     ScopedVector<PasswordForm> result_form;
     if (result & RESULT_SAVED_MATCH) {
       result_form.push_back(new PasswordForm(saved_match_));
     }
     if (result & RESULT_PSL_MATCH) {
       result_form.push_back(new PasswordForm(psl_saved_match_));
     }
-    p->OnGetPasswordStoreResults(result_form.Pass());
+    p->OnGetPasswordStoreResults(std::move(result_form));
   }
 
   // Save saved_match() for observed_form() where |observed_form_data|,
   // |times_used|, and |status| are used to overwrite the default values for
   // observed_form(). |field_type| is the upload that we expect from saving,
   // with nullptr meaning no upload expected.
   void AccountCreationUploadTest(const autofill::FormData& observed_form_data,
                                  int times_used,
                                  PasswordForm::GenerationUploadStatus status,
                                  const autofill::ServerFieldType* field_type) {
@@ skipping 15 matching lines @@
     form_to_save.password_value = result[0]->password_value;
 
     // When we're voting for an account creation form, we should also vote
     // for its username field.
     base::string16 username_vote =
         (field_type && *field_type == autofill::ACCOUNT_CREATION_PASSWORD)
             ? result[0]->username_element
             : base::string16();
 
     form_manager.SimulateFetchMatchingLoginsFromPasswordStore();
-    form_manager.OnGetPasswordStoreResults(result.Pass());
+    form_manager.OnGetPasswordStoreResults(std::move(result));
     std::string expected_login_signature;
     autofill::FormStructure observed_structure(observed_form_data);
     autofill::FormStructure pending_structure(saved_match()->form_data);
     if (observed_structure.FormSignature() !=
             pending_structure.FormSignature() &&
         times_used == 0) {
       expected_login_signature = observed_structure.FormSignature();
     }
     autofill::ServerFieldTypeSet expected_available_field_types;
     expected_available_field_types.insert(autofill::USERNAME);
@@ skipping 262 matching lines @@
   PasswordForm blacklisted_match = *observed_form();
   blacklisted_match.origin = GURL("http://accounts.google.com/a/LoginAuth1234");
   blacklisted_match.blacklisted_by_user = true;
 
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(blacklisted_psl));
   result.push_back(new PasswordForm(blacklisted_not_match));
   result.push_back(new PasswordForm(blacklisted_not_match2));
   result.push_back(new PasswordForm(blacklisted_match));
   result.push_back(new PasswordForm(*saved_match()));
-  form_manager.OnGetPasswordStoreResults(result.Pass());
+  form_manager.OnGetPasswordStoreResults(std::move(result));
   EXPECT_TRUE(form_manager.IsBlacklisted());
   EXPECT_THAT(form_manager.blacklisted_matches(),
               ElementsAre(Pointee(blacklisted_match)));
   EXPECT_EQ(1u, form_manager.best_matches().size());
   EXPECT_EQ(*saved_match(), *form_manager.preferred_match());
 }
 
 TEST_F(PasswordFormManagerTest, AutofillBlacklisted) {
   // Blacklisted best matches credentials should not be autofilled, but the
   // non-blacklisted should.
   PasswordForm saved_form = *observed_form();
   saved_form.username_value = ASCIIToUTF16("user");
   saved_form.password_value = ASCIIToUTF16("pass");
 
   PasswordForm blacklisted = *observed_form();
   blacklisted.blacklisted_by_user = true;
   blacklisted.username_value.clear();
 
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   result.push_back(new PasswordForm(blacklisted));
 
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
 
   autofill::PasswordFormFillData fill_data;
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_))
       .WillOnce(SaveArg<0>(&fill_data));
 
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
   EXPECT_EQ(1u, form_manager()->blacklisted_matches().size());
   EXPECT_TRUE(form_manager()->IsBlacklisted());
   EXPECT_EQ(1u, form_manager()->best_matches().size());
   EXPECT_TRUE(fill_data.additional_logins.empty());
 }
 
 // If PSL-matched credentials had been suggested, but the user has overwritten
 // the password, the provisionally saved credentials should no longer be
 // considered as PSL-matched, so that the exception for not prompting before
 // saving PSL-matched credentials should no longer apply.
@@ skipping 187 matching lines @@
   saved_form.ssl_valid = !kObservedFormSSLValid;
   saved_form.username_value = ASCIIToUTF16("test1@gmail.com");
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   saved_form.username_value = ASCIIToUTF16("test2@gmail.com");
   result.push_back(new PasswordForm(saved_form));
   saved_form.username_value = ASCIIToUTF16("test3@gmail.com");
   saved_form.ssl_valid = kObservedFormSSLValid;
   result.push_back(new PasswordForm(saved_form));
   form_manager.SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager.OnGetPasswordStoreResults(result.Pass());
+  form_manager.OnGetPasswordStoreResults(std::move(result));
 
   // Make sure we don't match a PasswordForm if it was originally saved on
   // an SSL-valid page and we are now on a page with invalid certificate.
   EXPECT_EQ(1u, form_manager.best_matches().count(saved_form.username_value));
   EXPECT_EQ(1u, form_manager.best_matches().size());
 }
 
 TEST_F(PasswordFormManagerTest, TestIgnoreResult_Paths) {
   PasswordForm observed(*observed_form());
   observed.origin = GURL("https://accounts.google.com/a/LoginAuth");
   observed.action = GURL("https://accounts.google.com/a/Login");
   observed.signon_realm = "https://accounts.google.com";
 
   PasswordFormManager form_manager(password_manager(), client(),
                                    client()->driver(), observed, false);
 
   PasswordForm saved_form = observed;
   saved_form.origin = GURL("https://accounts.google.com/a/OtherLoginAuth");
   saved_form.action = GURL("https://accounts.google.com/a/OtherLogin");
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   form_manager.SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager.OnGetPasswordStoreResults(result.Pass());
+  form_manager.OnGetPasswordStoreResults(std::move(result));
 
   // Different paths for action / origin are okay.
   EXPECT_FALSE(form_manager.best_matches().empty());
 }
 
 TEST_F(PasswordFormManagerTest, TestIgnoreResult_IgnoredCredentials) {
   PasswordForm observed(*observed_form());
   observed.origin = GURL("https://accounts.google.com/a/LoginAuth");
   observed.action = GURL("https://accounts.google.com/a/Login");
   observed.signon_realm = "https://accounts.google.com";
 
   PasswordFormManager form_manager(password_manager(), client(),
                                    client()->driver(), observed, false);
   client()->FilterAllResults();
 
   PasswordForm saved_form = observed;
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   form_manager.SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager.OnGetPasswordStoreResults(result.Pass());
+  form_manager.OnGetPasswordStoreResults(std::move(result));
 
   // Results should be ignored if the client requests it.
   EXPECT_TRUE(form_manager.best_matches().empty());
 }
 
 TEST_F(PasswordFormManagerTest, TestEmptyAction) {
   saved_match()->action = GURL();
   SimulateMatchingPhase(form_manager(), RESULT_SAVED_MATCH);
   // User logs in with the autofilled username / password from saved_match.
   PasswordForm login = *observed_form();
@@ skipping 42 matching lines @@
 
 TEST_F(PasswordFormManagerTest, TestAlternateUsername_NoChange) {
   EXPECT_CALL(*client()->mock_driver(), AllowPasswordGenerationForForm(_));
 
   PasswordForm saved_form = *saved_match();
   ASSERT_FALSE(saved_form.other_possible_usernames.empty());
 
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   // The saved match has the right username already.
   PasswordForm login(*observed_form());
   login.preferred = true;
   login.username_value = saved_match()->username_value;
   login.password_value = saved_match()->password_value;
 
   form_manager()->ProvisionallySave(
       login, PasswordFormManager::ALLOW_OTHER_POSSIBLE_USERNAMES);
 
@@ skipping 16 matching lines @@
   // This time use an alternate username.
 
   EXPECT_CALL(*client()->mock_driver(), AllowPasswordGenerationForForm(_));
 
   PasswordForm saved_form = *saved_match();
   ASSERT_FALSE(saved_form.other_possible_usernames.empty());
 
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   // The saved match has the right username already.
   PasswordForm login(*observed_form());
   login.preferred = true;
   login.username_value = saved_match()->other_possible_usernames[0];
   login.password_value = saved_match()->password_value;
 
   form_manager()->ProvisionallySave(
       login, PasswordFormManager::ALLOW_OTHER_POSSIBLE_USERNAMES);
 
@@ skipping 28 matching lines @@
 
 TEST_F(PasswordFormManagerTest, TestSendNotBlacklistedMessage_Credentials) {
   // Signing up on a previously visited site. Credentials are found in the
   // password store, and are not blacklisted. AllowPasswordGenerationForForm
   // should be called to send the "not blacklisted" message.
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_))
       .Times(1);
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(CreateSavedMatch(false));
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
 }
 
 TEST_F(PasswordFormManagerTest,
        TestSendNotBlacklistedMessage_DroppedCredentials) {
   // There are cases, such as when a form is explicitly for creating a new
   // password, where we may ignore saved credentials. Make sure that we still
   // allow generation in that case.
   PasswordForm signup_form(*observed_form());
   signup_form.new_password_element = base::ASCIIToUTF16("new_password_field");
 
   PasswordFormManager form_manager(password_manager(), client(),
                                    client()->driver(), signup_form, false);
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_))
       .Times(1);
   form_manager.SimulateFetchMatchingLoginsFromPasswordStore();
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(CreateSavedMatch(false));
-  form_manager.OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager.OnGetPasswordStoreResults(std::move(simulated_results));
 }
 
 TEST_F(PasswordFormManagerTest,
        TestSendNotBlacklistedMessage_BlacklistedCredentials) {
   // Signing up on a previously visited site. Credentials are found in the
   // password store, but they are blacklisted. AllowPasswordGenerationForForm
   // is still called.
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(CreateSavedMatch(true));
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
 }
 
 TEST_F(PasswordFormManagerTest, TestForceInclusionOfGeneratedPasswords_Match) {
   // Simulate having two matches for this origin, one of which was from a form
   // with different HTML tags for elements. Because of scoring differences,
   // only the first form will be sent to Autofill().
   EXPECT_CALL(*client()->mock_driver(), AllowPasswordGenerationForForm(_));
 
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(CreateSavedMatch(false));
   simulated_results.push_back(CreateSavedMatch(false));
   simulated_results[1]->username_value = ASCIIToUTF16("other@gmail.com");
   simulated_results[1]->password_element = ASCIIToUTF16("signup_password");
   simulated_results[1]->username_element = ASCIIToUTF16("signup_username");
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
 
   autofill::PasswordFormFillData fill_data;
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_))
       .WillOnce(SaveArg<0>(&fill_data));
 
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
   EXPECT_EQ(1u, form_manager()->best_matches().size());
   EXPECT_TRUE(fill_data.additional_logins.empty());
 }
 
 TEST_F(PasswordFormManagerTest,
        TestForceInclusionOfGeneratedPasswords_NoMatch) {
   // Same thing, except this time the credentials that don't match quite as
   // well are generated. They should now be sent to Autofill().
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_));
 
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(CreateSavedMatch(false));
   simulated_results.push_back(CreateSavedMatch(false));
   simulated_results[0]->username_value = ASCIIToUTF16("other@gmail.com");
   simulated_results[0]->password_element = ASCIIToUTF16("signup_password");
   simulated_results[0]->username_element = ASCIIToUTF16("signup_username");
   simulated_results[0]->type = PasswordForm::TYPE_GENERATED;
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
 
   autofill::PasswordFormFillData fill_data;
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_))
       .WillOnce(SaveArg<0>(&fill_data));
 
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
   EXPECT_EQ(2u, form_manager()->best_matches().size());
   EXPECT_EQ(1u, fill_data.additional_logins.size());
 }
 
 TEST_F(PasswordFormManagerTest, TestSanitizePossibleUsernames) {
   const base::string16 kUsernameOther = ASCIIToUTF16("other username");
 
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
   form_manager()->OnGetPasswordStoreResults(ScopedVector<PasswordForm>());
 
@@ skipping 94 matching lines @@
   complete_form.action = encountered_form.action;
   complete_form.password_element = encountered_form.password_element;
   complete_form.username_element = encountered_form.username_element;
   complete_form.submit_element = encountered_form.submit_element;
 
   PasswordForm obsolete_form(*incomplete_form);
   obsolete_form.action = encountered_form.action;
 
   // Feed the incomplete credentials to the manager.
   ScopedVector<PasswordForm> simulated_results;
-  simulated_results.push_back(incomplete_form.Pass());
-  form_manager.OnGetPasswordStoreResults(simulated_results.Pass());
+  simulated_results.push_back(std::move(incomplete_form));
+  form_manager.OnGetPasswordStoreResults(std::move(simulated_results));
 
   form_manager.ProvisionallySave(
       complete_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   // By now that form has been used once.
   complete_form.times_used = 1;
   obsolete_form.times_used = 1;
 
   // Check that PasswordStore receives an update request with the complete form.
   EXPECT_CALL(*mock_store(),
               UpdateLoginWithPrimaryKey(complete_form, obsolete_form));
@@ skipping 15 matching lines @@
   simulated_results[1]->origin =
       GURL("http://accounts.google.com/a/ServiceLoginAuth2");
   simulated_results[1]->action =
       GURL("http://accounts.google.com/a/ServiceLogin2");
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
 
   autofill::PasswordFormFillData fill_data;
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_))
       .WillOnce(SaveArg<0>(&fill_data));
 
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
   EXPECT_TRUE(fill_data.additional_logins.empty());
   EXPECT_EQ(1u, form_manager()->best_matches().size());
   EXPECT_TRUE(
       !form_manager()->best_matches().begin()->second->is_public_suffix_match);
 }
 
 TEST_F(PasswordFormManagerTest, AndroidCredentialsAreAutofilled) {
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_));
 
   // Although Android-based credentials are treated similarly to PSL-matched
   // credentials in most respects, they should be autofilled as opposed to be
   // filled on username-select.
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(new PasswordForm());
   simulated_results[0]->signon_realm = "android://hash@com.google.android";
   simulated_results[0]->origin = observed_form()->origin;
   simulated_results[0]->username_value = saved_match()->username_value;
   simulated_results[0]->password_value = saved_match()->password_value;
 
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
 
   autofill::PasswordFormFillData fill_data;
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_))
       .WillOnce(SaveArg<0>(&fill_data));
 
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
   EXPECT_TRUE(fill_data.additional_logins.empty());
   EXPECT_FALSE(fill_data.wait_for_username);
   EXPECT_EQ(1u, form_manager()->best_matches().size());
 }
 
 // Credentials saved through Android apps should always be shown in the drop-
 // down menu, unless there is a better-scoring match with the same username.
 TEST_F(PasswordFormManagerTest, AndroidCredentialsAreProtected) {
   const char kTestUsername1[] = "test-user@gmail.com";
   const char kTestUsername2[] = "test-other-user@gmail.com";
@@ skipping 21 matching lines @@
   simulated_results[2]->password_value = ASCIIToUTF16(kTestAndroidPassword2);
 
   ScopedVector<PasswordForm> expected_matches;
   expected_matches.push_back(new PasswordForm(*simulated_results[0]));
   expected_matches.push_back(new PasswordForm(*simulated_results[2]));
 
   autofill::PasswordFormFillData fill_data;
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_))
       .WillOnce(SaveArg<0>(&fill_data));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
 
   EXPECT_FALSE(fill_data.wait_for_username);
   EXPECT_EQ(1u, fill_data.additional_logins.size());
 
   std::vector<PasswordForm*> actual_matches;
   for (const auto& username_match_pair : form_manager()->best_matches())
     actual_matches.push_back(username_match_pair.second.get());
   EXPECT_THAT(actual_matches,
               UnorderedPasswordFormElementsAre(expected_matches.get()));
 }
@@ skipping 119 matching lines @@
   first.preferred = true;
 
   PasswordForm second(first);
   second.password_value = ASCIIToUTF16("second");
   second.preferred = false;
 
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(first));
   result.push_back(new PasswordForm(second));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   // We always take the first credential with a particular username, regardless
   // of which ones are labeled preferred.
   EXPECT_EQ(ASCIIToUTF16("first"),
             form_manager()->preferred_match()->password_value);
 
   PasswordForm login(*observed_form());
   login.username_value = saved_match()->username_value;
   login.password_value = ASCIIToUTF16("third");
   login.preferred = true;
@@ skipping 139 matching lines @@
 
   const PasswordStore::AuthorizationPromptPolicy auth_policy =
       PasswordStore::DISALLOW_PROMPT;
   EXPECT_CALL(*mock_store(), GetLogins(*form, auth_policy, &form_manager));
   form_manager.FetchDataFromPasswordStore(auth_policy);
 
   // Suddenly, the frame and its driver disappear.
   client()->KillDriver();
 
   ScopedVector<PasswordForm> simulated_results;
-  simulated_results.push_back(form.Pass());
-  form_manager.OnGetPasswordStoreResults(simulated_results.Pass());
+  simulated_results.push_back(std::move(form));
+  form_manager.OnGetPasswordStoreResults(std::move(simulated_results));
 }
 
 TEST_F(PasswordFormManagerTest, PreferredMatchIsUpToDate) {
   // Check that preferred_match() is always a member of best_matches().
   const PasswordStore::AuthorizationPromptPolicy auth_policy =
       PasswordStore::DISALLOW_PROMPT;
   EXPECT_CALL(*mock_store(),
               GetLogins(*observed_form(), auth_policy, form_manager()));
   form_manager()->FetchDataFromPasswordStore(auth_policy);
 
   ScopedVector<PasswordForm> simulated_results;
   scoped_ptr<PasswordForm> form(new PasswordForm(*observed_form()));
   form->username_value = ASCIIToUTF16("username");
   form->password_value = ASCIIToUTF16("password1");
   form->preferred = false;
 
   scoped_ptr<PasswordForm> generated_form(new PasswordForm(*form));
   generated_form->type = PasswordForm::TYPE_GENERATED;
   generated_form->password_value = ASCIIToUTF16("password2");
   generated_form->preferred = true;
 
-  simulated_results.push_back(generated_form.Pass());
-  simulated_results.push_back(form.Pass());
+  simulated_results.push_back(std::move(generated_form));
+  simulated_results.push_back(std::move(form));
 
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
   EXPECT_EQ(1u, form_manager()->best_matches().size());
   EXPECT_EQ(form_manager()->preferred_match(),
             form_manager()->best_matches().begin()->second.get());
   // Make sure to access all fields of preferred_match; this way if it was
   // deleted, ASAN might notice it.
   PasswordForm dummy(*form_manager()->preferred_match());
 }
 
 TEST_F(PasswordFormManagerTest,
        IsIngnorableChangePasswordForm_MatchingUsernameAndPassword) {
@@ skipping 101 matching lines @@
                                     client()->driver(),
                                     observed_change_password_form, false);
   manager_creds.SimulateFetchMatchingLoginsFromPasswordStore();
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(CreateSavedMatch(false));
 
   autofill::PasswordFormFillData fill_data;
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_))
       .WillOnce(SaveArg<0>(&fill_data));
 
-  manager_creds.OnGetPasswordStoreResults(simulated_results.Pass());
+  manager_creds.OnGetPasswordStoreResults(std::move(simulated_results));
   EXPECT_EQ(1u, manager_creds.best_matches().size());
   EXPECT_EQ(0u, fill_data.additional_logins.size());
   EXPECT_TRUE(fill_data.wait_for_username);
 }
 
 TEST_F(PasswordFormManagerTest, TestUpdateMethod) {
   // Add a new password field to the test form. The PasswordFormManager should
   // save the password from this field, instead of the current password field.
   observed_form()->new_password_element = ASCIIToUTF16("NewPasswd");
   autofill::FormFieldData field;
@@ skipping 207 matching lines @@
   histogram_tester.ExpectUniqueSample("PasswordManager.StoreReadyWhenWiping", 1,
                                       1);
 }
 
 TEST_F(PasswordFormManagerTest, RemoveNoUsernameAccounts) {
   PasswordForm saved_form = *saved_match();
   saved_form.username_value.clear();
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   PasswordForm submitted_form(*observed_form());
   submitted_form.preferred = true;
   submitted_form.username_value = saved_match()->username_value;
   submitted_form.password_value = saved_match()->password_value;
 
   saved_form.preferred = false;
   EXPECT_CALL(*mock_store(),
               AddLogin(CheckUsername(saved_match()->username_value)));
   EXPECT_CALL(*mock_store(), RemoveLogin(saved_form));
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager()->Save();
 }
 
 TEST_F(PasswordFormManagerTest, NotRemovePSLNoUsernameAccounts) {
   PasswordForm saved_form = *saved_match();
   saved_form.username_value.clear();
   saved_form.is_public_suffix_match = true;
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   PasswordForm submitted_form(*observed_form());
   submitted_form.preferred = true;
   submitted_form.username_value = saved_match()->username_value;
   submitted_form.password_value = saved_match()->password_value;
 
   EXPECT_CALL(*mock_store(),
               AddLogin(CheckUsername(saved_match()->username_value)));
   EXPECT_CALL(*mock_store(), RemoveLogin(_)).Times(0);
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager()->Save();
 }
 
 TEST_F(PasswordFormManagerTest, NotRemoveCredentialsWithUsername) {
   PasswordForm saved_form = *saved_match();
   ASSERT_FALSE(saved_form.username_value.empty());
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   PasswordForm submitted_form(*observed_form());
   submitted_form.preferred = true;
   base::string16 username = saved_form.username_value + ASCIIToUTF16("1");
   submitted_form.username_value = username;
   submitted_form.password_value = saved_match()->password_value;
 
   EXPECT_CALL(*mock_store(), AddLogin(CheckUsername(username)));
   EXPECT_CALL(*mock_store(), RemoveLogin(_)).Times(0);
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager()->Save();
 }
 
 TEST_F(PasswordFormManagerTest, NotRemoveCredentialsWithDiferrentPassword) {
   PasswordForm saved_form = *saved_match();
   saved_form.username_value.clear();
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(saved_form));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   PasswordForm submitted_form(*observed_form());
   submitted_form.preferred = true;
   submitted_form.username_value = saved_match()->username_value;
   submitted_form.password_value = saved_form.password_value + ASCIIToUTF16("1");
 
   EXPECT_CALL(*mock_store(),
               AddLogin(CheckUsername(saved_match()->username_value)));
   EXPECT_CALL(*mock_store(), RemoveLogin(_)).Times(0);
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager()->Save();
 }
 
 TEST_F(PasswordFormManagerTest, SaveNoUsernameEvenIfWithUsernamePresent) {
   PasswordForm* saved_form = saved_match();
   ASSERT_FALSE(saved_match()->username_value.empty());
   ScopedVector<PasswordForm> result;
   result.push_back(new PasswordForm(*saved_form));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   PasswordForm submitted_form(*observed_form());
   submitted_form.preferred = true;
   submitted_form.username_value.clear();
 
   EXPECT_CALL(*mock_store(), AddLogin(CheckUsername(base::string16())));
   EXPECT_CALL(*mock_store(), RemoveLogin(_)).Times(0);
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager()->Save();
 }
 
 TEST_F(PasswordFormManagerTest, NotRemoveOnUpdate) {
   ScopedVector<PasswordForm> result;
   PasswordForm saved_form = *saved_match();
   ASSERT_FALSE(saved_form.username_value.empty());
   result.push_back(new PasswordForm(saved_form));
   saved_form.username_value.clear();
   saved_form.preferred = false;
   result.push_back(new PasswordForm(saved_form));
   form_manager()->SimulateFetchMatchingLoginsFromPasswordStore();
-  form_manager()->OnGetPasswordStoreResults(result.Pass());
+  form_manager()->OnGetPasswordStoreResults(std::move(result));
 
   PasswordForm submitted_form(*observed_form());
   submitted_form.preferred = true;
   submitted_form.username_value = saved_match()->username_value;
   submitted_form.password_value = saved_form.password_value + ASCIIToUTF16("1");
 
   EXPECT_CALL(*mock_store(),
               UpdateLogin(CheckUsername(saved_match()->username_value)));
   EXPECT_CALL(*mock_store(), RemoveLogin(_)).Times(0);
 
@@ skipping 12 matching lines @@
   scoped_ptr<PasswordForm> generated_form(new PasswordForm(*observed_form()));
   generated_form->type = PasswordForm::TYPE_GENERATED;
   generated_form->username_value = ASCIIToUTF16("username");
   generated_form->password_value = ASCIIToUTF16("password2");
   generated_form->preferred = true;
 
   PasswordForm submitted_form(*generated_form);
   submitted_form.password_value = ASCIIToUTF16("password3");
 
   ScopedVector<PasswordForm> simulated_results;
-  simulated_results.push_back(generated_form.Pass());
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  simulated_results.push_back(std::move(generated_form));
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   PasswordForm new_credentials;
   EXPECT_CALL(*mock_store(), UpdateLogin(_))
       .WillOnce(testing::SaveArg<0>(&new_credentials));
   form_manager()->Save();
 
   EXPECT_EQ(PasswordForm::TYPE_MANUAL, new_credentials.type);
@@ skipping 10 matching lines @@
 
   scoped_ptr<PasswordForm> generated_form(new PasswordForm(*observed_form()));
   generated_form->type = PasswordForm::TYPE_GENERATED;
   generated_form->username_value = ASCIIToUTF16("username");
   generated_form->password_value = ASCIIToUTF16("password2");
   generated_form->preferred = true;
 
   PasswordForm submitted_form(*generated_form);
 
   ScopedVector<PasswordForm> simulated_results;
-  simulated_results.push_back(generated_form.Pass());
-  form_manager()->OnGetPasswordStoreResults(simulated_results.Pass());
+  simulated_results.push_back(std::move(generated_form));
+  form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   PasswordForm new_credentials;
   EXPECT_CALL(*mock_store(), UpdateLogin(_))
       .WillOnce(testing::SaveArg<0>(&new_credentials));
   form_manager()->Save();
 
   EXPECT_EQ(PasswordForm::TYPE_GENERATED, new_credentials.type);
   histogram_tester.ExpectBucketCount("PasswordGeneration.SubmissionEvent",
                                      metrics_util::PASSWORD_USED, 1);
 }
 
 TEST_F(PasswordFormManagerTest,
        FetchMatchingLoginsFromPasswordStore_Reentrance) {
   const PasswordStore::AuthorizationPromptPolicy auth_policy =
       PasswordStore::DISALLOW_PROMPT;
   EXPECT_CALL(*mock_store(), GetLogins(form_manager()->observed_form(),
                                        auth_policy, form_manager()))
       .Times(2);
   form_manager()->FetchDataFromPasswordStore(auth_policy);
   form_manager()->FetchDataFromPasswordStore(auth_policy);
 
   // First response from the store, should be ignored.
   scoped_ptr<PasswordForm> saved_form(new PasswordForm(*saved_match()));
   saved_form->username_value = ASCIIToUTF16("a@gmail.com");
   ScopedVector<PasswordForm> results;
-  results.push_back(saved_form.Pass());
-  form_manager()->OnGetPasswordStoreResults(results.Pass());
+  results.push_back(std::move(saved_form));
+  form_manager()->OnGetPasswordStoreResults(std::move(results));
   EXPECT_TRUE(form_manager()->best_matches().empty());
 
   // Second response from the store should not be ignored.
   saved_form.reset(new PasswordForm(*saved_match()));
   saved_form->username_value = ASCIIToUTF16("b@gmail.com");
-  results.push_back(saved_form.Pass());
+  results.push_back(std::move(saved_form));
   saved_form.reset(new PasswordForm(*saved_match()));
   saved_form->username_value = ASCIIToUTF16("c@gmail.com");
-  results.push_back(saved_form.Pass());
-  form_manager()->OnGetPasswordStoreResults(results.Pass());
+  results.push_back(std::move(saved_form));
+  form_manager()->OnGetPasswordStoreResults(std::move(results));
   EXPECT_EQ(2U, form_manager()->best_matches().size());
 }
 
 TEST_F(PasswordFormManagerTest, ProcessFrame) {
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_));
   SimulateMatchingPhase(form_manager(), RESULT_SAVED_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, ProcessFrame_MoreProcessFrameMoreFill) {
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_)).Times(2);
@@ skipping 19 matching lines @@
   EXPECT_CALL(*mock_store(),
               GetLogins(form_manager()->observed_form(), _, form_manager()));
   form_manager()->FetchDataFromPasswordStore(PasswordStore::DISALLOW_PROMPT);
 
   // Now add the extra driver.
   form_manager()->ProcessFrame(extra_driver.AsWeakPtr());
 
   // Password store responds.
   scoped_ptr<PasswordForm> match(new PasswordForm(*saved_match()));
   ScopedVector<PasswordForm> result_form;
-  result_form.push_back(match.Pass());
-  form_manager()->OnGetPasswordStoreResults(result_form.Pass());
+  result_form.push_back(std::move(match));
+  form_manager()->OnGetPasswordStoreResults(std::move(result_form));
 }
 
 TEST_F(PasswordFormManagerTest, ProcessFrame_StoreUpdatesCausesAutofill) {
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_)).Times(2);
   SimulateMatchingPhase(form_manager(), RESULT_SAVED_MATCH);
   SimulateMatchingPhase(form_manager(), RESULT_SAVED_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, UpdateFormManagers_IsCalled) {
   // Let |password_manager()| create one additional PasswordFormManager.
@@ skipping 321 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("new_password"),
             form_manager()->pending_credentials().password_value);
   EXPECT_EQ(base::string16(),
             form_manager()->pending_credentials().username_value);
   EXPECT_TRUE(
       form_manager()->pending_credentials().new_password_element.empty());
   EXPECT_TRUE(form_manager()->pending_credentials().new_password_value.empty());
 }
 
 }  // namespace password_manager