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

components/password_manager/core/browser/password_form_manager.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 <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 246 matching lines @@
 
   scoped_ptr<autofill::PasswordForm> mutable_provisionally_saved_form(
       new PasswordForm(credentials));
   if (credentials.IsPossibleChangePasswordForm() &&
       !credentials.username_value.empty() &&
       IsProbablyNotUsername(credentials.username_value)) {
     mutable_provisionally_saved_form->username_value.clear();
     mutable_provisionally_saved_form->username_element.clear();
     is_possible_change_password_form_without_username_ = true;
   }
-  provisionally_saved_form_ = mutable_provisionally_saved_form.Pass();
+  provisionally_saved_form_ = std::move(mutable_provisionally_saved_form);
   other_possible_username_action_ = action;
 
   if (HasCompletedMatching())
     CreatePendingCredentials();
 }
 
 void PasswordFormManager::Save() {
   DCHECK_EQ(state_, POST_MATCHING_PHASE);
   DCHECK(!client_->IsOffTheRecord());
 
@@ skipping 120 matching lines @@
   }
 
   // Remove credentials which need to be ignored from |logins_result|.
   if (!observed_form_.ssl_valid) {
     logins_result.erase(
         std::partition(logins_result.begin(), logins_result.end(),
                        [](PasswordForm* form) { return !form->ssl_valid; }),
         logins_result.end());
   }
   logins_result =
-      client_->GetStoreResultFilter()->FilterResults(logins_result.Pass());
+      client_->GetStoreResultFilter()->FilterResults(std::move(logins_result));
 
   // Deal with blacklisted forms.
   auto begin_blacklisted = std::partition(
       logins_result.begin(), logins_result.end(),
       [](PasswordForm* form) { return !form->blacklisted_by_user; });
   for (auto it = begin_blacklisted; it != logins_result.end(); ++it) {
     if (IsBlacklistMatch(**it)) {
       blacklisted_matches_.push_back(*it);
       *it = nullptr;
     }
@@ skipping 50 matching lines @@
 
       // Websites that participate in affiliation-based matching will normally
       // have a single authentication system per domain, therefore affiliation
       // based matches are desired to be offered on any login form on the site.
       // However, for Android credentials, most meta-data attributes are empty,
       // so they will have a very low score, hence need to be protected against
       // the high-scoring logins saved from the website.
       is_credential_protected |= IsValidAndroidFacetURI(login->signon_realm);
 
       if (is_credential_protected)
-        protected_credentials.push_back(login.Pass());
+        protected_credentials.push_back(std::move(login));
       else
-        not_best_matches_.push_back(login.Pass());
+        not_best_matches_.push_back(std::move(login));
       continue;
     }
 
     // If there is another best-score match for the same username then leave it
     // and add the current form to |not_best_matches_|.
     const base::string16& username = login->username_value;
     auto best_match_username = best_matches_.find(username);
     if (best_match_username == best_matches_.end()) {
       if (login->preferred)
         preferred_match_ = login.get();
       best_matches_.insert(std::make_pair(username, std::move(login)));
     } else {
       not_best_matches_.push_back(std::move(login));
     }
   }
 
   // Add the protected results if we don't already have a result with the same
   // username.
   for (ScopedVector<PasswordForm>::iterator it = protected_credentials.begin();
        it != protected_credentials.end(); ++it) {
     // Take ownership of the PasswordForm from the ScopedVector.
     scoped_ptr<PasswordForm> protege(*it);
     *it = nullptr;
     const base::string16& username = protege->username_value;
     if (best_matches_.find(username) == best_matches_.end())
       best_matches_.insert(std::make_pair(username, std::move(protege)));
     else
-      not_best_matches_.push_back(protege.Pass());
+      not_best_matches_.push_back(std::move(protege));
   }
 
   UMA_HISTOGRAM_COUNTS("PasswordManager.NumPasswordsNotShown",
                        logins_result_size - best_matches_.size());
 
   if (!best_matches_.empty()) {
     // It is possible we have at least one match but have no preferred_match_,
     // because a user may have chosen to 'Forget' the preferred match. So we
     // just pick the first one and whichever the user selects for submit will
     // be saved as preferred.
@@ skipping 76 matching lines @@
 
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (password_manager_util::IsLoggingActive(client_)) {
     logger.reset(
         new BrowserSavePasswordProgressLogger(client_->GetLogManager()));
     logger->LogMessage(Logger::STRING_ON_GET_STORE_RESULTS_METHOD);
     logger->LogNumber(Logger::STRING_NUMBER_RESULTS, results.size());
   }
 
   if (!results.empty())
-    OnRequestDone(results.Pass());
+    OnRequestDone(std::move(results));
   state_ = POST_MATCHING_PHASE;
 
   // If password store was slow and provisionally saved form is already here
   // then create pending credentials (see http://crbug.com/470322).
   if (provisionally_saved_form_)
     CreatePendingCredentials();
 
   if (manager_action_ != kManagerActionBlacklisted) {
     for (auto const& driver : drivers_)
       ProcessFrameInternal(driver);
@@ skipping 721 matching lines @@
       continue;
     }
     password_store->RemoveLogin(*credential_to_delete->second);
     if (credential_to_delete->second.get() == preferred_match_)
       preferred_match_ = nullptr;
     best_matches_.erase(credential_to_delete);
   }
 }
 
 }  // namespace password_manager