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

components/password_manager/core/browser/password_store.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 "components/password_manager/core/browser/password_store.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/debug/dump_without_crashing.h"
@@ skipping 39 matching lines @@
     ScopedVector<autofill::PasswordForm> results) {
   if (!ignore_logins_cutoff_.is_null()) {
     ScopedVector<autofill::PasswordForm> remaining_logins;
     remaining_logins.reserve(results.size());
     for (auto& login : results) {
       if (login->date_created >= ignore_logins_cutoff_) {
         remaining_logins.push_back(login);
         login = nullptr;
       }
     }
-    results = remaining_logins.Pass();
+    results = std::move(remaining_logins);
   }
 
   origin_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PasswordStoreConsumer::OnGetPasswordStoreResults,
                             consumer_weak_, base::Passed(&results)));
 }
 
 void PasswordStore::GetLoginsRequest::NotifyWithSiteStatistics(
     std::vector<scoped_ptr<InteractionsStats>> stats) {
   auto passed_stats(make_scoped_ptr(
@@ skipping 13 matching lines @@
       shutdown_called_(false) {
 }
 
 bool PasswordStore::Init(const syncer::SyncableService::StartSyncFlare& flare) {
   ScheduleTask(base::Bind(&PasswordStore::InitSyncableService, this, flare));
   return true;
 }
 
 void PasswordStore::SetAffiliatedMatchHelper(
     scoped_ptr<AffiliatedMatchHelper> helper) {
-  affiliated_match_helper_ = helper.Pass();
+  affiliated_match_helper_ = std::move(helper);
 }
 
 void PasswordStore::AddLogin(const PasswordForm& form) {
   CheckForEmptyUsernameAndPassword(form);
   ScheduleTask(base::Bind(&PasswordStore::AddLoginInternal, this, form));
 }
 
 void PasswordStore::UpdateLogin(const PasswordForm& form) {
   CheckForEmptyUsernameAndPassword(form);
   ScheduleTask(base::Bind(&PasswordStore::UpdateLoginInternal, this, form));
@@ skipping 290 matching lines @@
   RemoveStatisticsCreatedBetweenImpl(delete_begin, delete_end);
   if (!completion.is_null())
     main_thread_runner_->PostTask(FROM_HERE, completion);
 }
 
 void PasswordStore::GetAutofillableLoginsImpl(
     scoped_ptr<GetLoginsRequest> request) {
   ScopedVector<PasswordForm> obtained_forms;
   if (!FillAutofillableLogins(&obtained_forms))
     obtained_forms.clear();
-  request->NotifyConsumerWithResults(obtained_forms.Pass());
+  request->NotifyConsumerWithResults(std::move(obtained_forms));
 }
 
 void PasswordStore::GetBlacklistLoginsImpl(
     scoped_ptr<GetLoginsRequest> request) {
   ScopedVector<PasswordForm> obtained_forms;
   if (!FillBlacklistLogins(&obtained_forms))
     obtained_forms.clear();
-  request->NotifyConsumerWithResults(obtained_forms.Pass());
+  request->NotifyConsumerWithResults(std::move(obtained_forms));
 }
 
 void PasswordStore::NotifySiteStats(const GURL& origin_domain,
                                     scoped_ptr<GetLoginsRequest> request) {
   request->NotifyWithSiteStatistics(GetSiteStatsImpl(origin_domain));
 }
 
 void PasswordStore::GetLoginsWithAffiliationsImpl(
     const PasswordForm& form,
     AuthorizationPromptPolicy prompt_policy,
@@ skipping 10 matching lines @@
     for (PasswordForm* form : more_results)
       form->is_affiliation_based_match = true;
     ScopedVector<PasswordForm>::iterator it_first_federated = std::partition(
         more_results.begin(), more_results.end(),
         [](PasswordForm* form) { return form->federation_url.is_empty(); });
     more_results.erase(it_first_federated, more_results.end());
     password_manager_util::TrimUsernameOnlyCredentials(&more_results);
     results.insert(results.end(), more_results.begin(), more_results.end());
     more_results.weak_clear();
   }
-  request->NotifyConsumerWithResults(results.Pass());
+  request->NotifyConsumerWithResults(std::move(results));
 }
 
 void PasswordStore::ScheduleGetLoginsWithAffiliations(
     const PasswordForm& form,
     AuthorizationPromptPolicy prompt_policy,
     scoped_ptr<GetLoginsRequest> request,
     const std::vector<std::string>& additional_android_realms) {
   ScheduleTask(base::Bind(&PasswordStore::GetLoginsWithAffiliationsImpl, this,
                           form, prompt_policy, base::Passed(&request),
                           additional_android_realms));
 }
 
 scoped_ptr<PasswordForm> PasswordStore::GetLoginImpl(
     const PasswordForm& primary_key) {
   DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   ScopedVector<PasswordForm> candidates(
       FillMatchingLogins(primary_key, DISALLOW_PROMPT));
   for (PasswordForm*& candidate : candidates) {
     if (ArePasswordFormUniqueKeyEqual(*candidate, primary_key) &&
         !candidate->is_public_suffix_match) {
       scoped_ptr<PasswordForm> result(candidate);
       candidate = nullptr;
-      return result.Pass();
+      return result;
     }
   }
   return make_scoped_ptr<PasswordForm>(nullptr);
 }
 
 void PasswordStore::FindAndUpdateAffiliatedWebLogins(
     const PasswordForm& added_or_updated_android_form) {
   if (!affiliated_match_helper_ ||
       !is_propagating_password_changes_to_web_credentials_enabled_) {
     return;
@@ skipping 119 matching lines @@
 // TODO(ttr314@googlemail.com): Once crbug.com/113973 is done, remove default
 // implementation and mark method as pure virtual.
 PasswordStoreChangeList PasswordStore::RemoveLoginsByOriginAndTimeImpl(
     const url::Origin& origin,
     base::Time delete_begin,
     base::Time delete_end) {
   return PasswordStoreChangeList();
 }
 
 }  // namespace password_manager