Convert Pass()→std::move() for Mac build.

chrome/browser/password_manager/password_store_mac.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/password_manager/password_store_mac.h"
 
 #include <CoreServices/CoreServices.h>
 #include <stddef.h>
 #include <set>
 #include <string>
@@ skipping 482 matching lines @@
 // Moves entries from |forms| that represent either blacklisted or federated
 // logins into |extracted|. These two types are stored only in the LoginDatabase
 // and do not have corresponding Keychain entries.
 void ExtractNonKeychainForms(ScopedVector<autofill::PasswordForm>* forms,
                              ScopedVector<autofill::PasswordForm>* extracted) {
   extracted->reserve(extracted->size() + forms->size());
   ScopedVector<autofill::PasswordForm> remaining;
   MoveAllFormsOut(
       forms, [&remaining, extracted](scoped_ptr<autofill::PasswordForm> form) {
         if (IsLoginDatabaseOnlyForm(*form))
-          extracted->push_back(form.Pass());
+          extracted->push_back(std::move(form));
         else
-          remaining.push_back(form.Pass());
+          remaining.push_back(std::move(form));
       });
   forms->swap(remaining);
 }
 
 // Takes |keychain_forms| and |database_forms| and moves the following 2 types
 // of forms to |merged_forms|:
 //   (1) |database_forms| that by principle never have a corresponding Keychain
 //       entry (viz., blacklisted and federated logins),
 //   (2) |database_forms| which should have and do have a corresponding entry in
 //       |keychain_forms|.
@@ skipping 16 matching lines @@
   // forms or not. If there is a match, add its password to the DB form and
   // mark the keychain form as used.
   MoveAllFormsOut(database_forms, [keychain_forms, &used_keychain_forms,
                                    merged_forms, &unused_database_forms](
                                       scoped_ptr<autofill::PasswordForm> form) {
     const PasswordForm* best_match =
         BestKeychainFormForForm(*form, keychain_forms->get());
     if (best_match) {
       used_keychain_forms.insert(best_match);
       form->password_value = best_match->password_value;
-      merged_forms->push_back(form.Pass());
+      merged_forms->push_back(std::move(form));
     } else {
-      unused_database_forms.push_back(form.Pass());
+      unused_database_forms.push_back(std::move(form));
     }
   });
   database_forms->swap(unused_database_forms);
 
   // Clear out all the Keychain entries we used.
   ScopedVector<autofill::PasswordForm> unused_keychain_forms;
   unused_keychain_forms.reserve(keychain_forms->size());
   for (auto& keychain_form : *keychain_forms) {
     if (!ContainsKey(used_keychain_forms, keychain_form)) {
       unused_keychain_forms.push_back(keychain_form);
@@ skipping 45 matching lines @@
   unused_db_forms.reserve(database_forms->size());
   // Move database forms with a password stored in |keychain| to |passwords|,
   // including the password. The rest is moved to |unused_db_forms|.
   MoveAllFormsOut(database_forms,
                   [&keychain, &item_form_pairs, passwords, &unused_db_forms](
                       scoped_ptr<autofill::PasswordForm> form) {
     ScopedVector<autofill::PasswordForm> keychain_matches =
         ExtractPasswordsMergeableWithForm(keychain, item_form_pairs, *form);
 
     ScopedVector<autofill::PasswordForm> db_form_container;
-    db_form_container.push_back(form.Pass());
+    db_form_container.push_back(std::move(form));
     MergePasswordForms(&keychain_matches, &db_form_container, passwords);
     AppendSecondToFirst(&unused_db_forms, &db_form_container);
   });
   database_forms->swap(unused_db_forms);
 
   STLDeleteContainerPairSecondPointers(item_form_pairs.begin(),
                                        item_form_pairs.end());
   for (SecKeychainItemRef item : keychain_items) {
     keychain.Free(item);
   }
@@ skipping 63 matching lines @@
        i != item_form_pairs.end(); ++i) {
     if (FormIsValidAndMatchesOtherForm(query_form, *(i->second))) {
       // Create a new object, since the caller is responsible for deleting the
       // returned forms.
       scoped_ptr<PasswordForm> form_with_password(new PasswordForm());
       FillPasswordFormFromKeychainItem(
           keychain, *(i->first), form_with_password.get(),
           true);  // Load password attributes and data.
       // Do not include blacklisted items found in the keychain.
       if (!form_with_password->blacklisted_by_user)
-        matches.push_back(form_with_password.Pass());
+        matches.push_back(std::move(form_with_password));
     }
   }
-  return matches.Pass();
+  return matches;
 }
 
 }  // namespace internal_keychain_helpers
 
 #pragma mark -
 
 MacKeychainPasswordFormAdapter::MacKeychainPasswordFormAdapter(
     const AppleKeychain* keychain)
     : keychain_(keychain), finds_only_owned_(false) {
 }
@@ skipping 126 matching lines @@
 }
 
 ScopedVector<autofill::PasswordForm>
 MacKeychainPasswordFormAdapter::ConvertKeychainItemsToForms(
     std::vector<SecKeychainItemRef>* items) {
   ScopedVector<autofill::PasswordForm> forms;
   for (SecKeychainItemRef item : *items) {
     scoped_ptr<PasswordForm> form(new PasswordForm());
     if (internal_keychain_helpers::FillPasswordFormFromKeychainItem(
             *keychain_, item, form.get(), true)) {
-      forms.push_back(form.Pass());
+      forms.push_back(std::move(form));
     }
     keychain_->Free(item);
   }
   items->clear();
-  return forms.Pass();
+  return forms;
 }
 
 SecKeychainItemRef MacKeychainPasswordFormAdapter::KeychainItemForForm(
     const PasswordForm& form) {
   // We don't store blacklist entries in the keychain, so the answer to "what
   // Keychain item goes with this form" is always "nothing" for blacklists.
   // Same goes for federated logins.
   if (IsLoginDatabaseOnlyForm(form))
     return NULL;
 
@@ skipping 91 matching lines @@
   return finds_only_owned_ ? base::mac::CreatorCodeForApplication() : 0;
 }
 
 #pragma mark -
 
 PasswordStoreMac::PasswordStoreMac(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner,
     scoped_ptr<AppleKeychain> keychain)
     : password_manager::PasswordStore(main_thread_runner, db_thread_runner),
-      keychain_(keychain.Pass()),
+      keychain_(std::move(keychain)),
       login_metadata_db_(nullptr) {
   DCHECK(keychain_);
 }
 
 PasswordStoreMac::~PasswordStoreMac() {}
 
 void PasswordStoreMac::InitWithTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> background_task_runner) {
   db_thread_runner_ = background_task_runner;
   DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
@@ skipping 172 matching lines @@
   ScopedVector<PasswordForm> forms_to_remove;
   if (login_metadata_db_ &&
       login_metadata_db_->GetLoginsCreatedBetween(delete_begin, delete_end,
                                                   &forms_to_consider)) {
     MoveAllFormsOut(
         &forms_to_consider,
         [this, &origin, &forms_to_remove](
             scoped_ptr<autofill::PasswordForm> form_to_consider) {
           if (origin.IsSameOriginWith(url::Origin(form_to_consider->origin)) &&
               login_metadata_db_->RemoveLogin(*form_to_consider))
-            forms_to_remove.push_back(form_to_consider.Pass());
+            forms_to_remove.push_back(std::move(form_to_consider));
         });
     if (!forms_to_remove.empty()) {
       RemoveKeychainForms(forms_to_remove.get());
       CleanOrphanedForms(&forms_to_remove);  // Add the orphaned forms.
       changes = FormsToRemoveChangeList(forms_to_remove.get());
       LogStatsForBulkDeletion(changes.size());
     }
   }
   return changes;
 }
@@ skipping 82 matching lines @@
   ScopedVector<PasswordForm> keychain_blacklist_forms;
   internal_keychain_helpers::ExtractNonKeychainForms(&keychain_forms,
                                                      &keychain_blacklist_forms);
   AppendSecondToFirst(&matched_forms, &keychain_forms);
 
   if (!database_forms.empty()) {
     RemoveDatabaseForms(&database_forms);
     NotifyLoginsChanged(FormsToRemoveChangeList(database_forms.get()));
   }
 
-  return matched_forms.Pass();
+  return matched_forms;
 }
 
 bool PasswordStoreMac::FillAutofillableLogins(
     ScopedVector<PasswordForm>* forms) {
   DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   forms->clear();
 
   ScopedVector<PasswordForm> database_forms;
   if (!login_metadata_db_ ||
       !login_metadata_db_->GetAutofillableLogins(&database_forms))
@@ skipping 64 matching lines @@
   return has_match;
 }
 
 void PasswordStoreMac::RemoveDatabaseForms(
   ScopedVector<autofill::PasswordForm>* forms) {
   DCHECK(login_metadata_db_);
   ScopedVector<autofill::PasswordForm> removed_forms;
   MoveAllFormsOut(forms, [this, &removed_forms](
                              scoped_ptr<autofill::PasswordForm> form) {
     if (login_metadata_db_->RemoveLogin(*form))
-      removed_forms.push_back(form.Pass());
+      removed_forms.push_back(std::move(form));
   });
   removed_forms.swap(*forms);
 }
 
 void PasswordStoreMac::RemoveKeychainForms(
     const std::vector<PasswordForm*>& forms) {
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_.get());
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   for (std::vector<PasswordForm*>::const_iterator i = forms.begin();
        i != forms.end(); ++i) {
@@ skipping 14 matching lines @@
   ScopedVector<PasswordForm> forms_with_keychain_entry;
   internal_keychain_helpers::GetPasswordsForForms(*keychain_, &database_forms,
                                                   &forms_with_keychain_entry);
 
   // Clean up any orphaned database entries.
   RemoveDatabaseForms(&database_forms);
 
   // Move the orphaned DB forms to the output parameter.
   AppendSecondToFirst(orphaned_forms, &database_forms);
 }