Revert of [Password Manager] Convert |pending_login_managers_| to an array of scoped_refptr

components/password_manager/core/browser/password_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_manager.h"
 
 #include <stddef.h>
 #include <map>
 #include <utility>
 
@@ skipping 220 matching lines @@
   if (form_manager) {
     form_manager->set_generation_element(generation_element);
     form_manager->set_is_manual_generation(is_manually_triggered);
     form_manager->set_generation_popup_was_shown(true);
     return;
   }
 
   // If there is no corresponding PasswordFormManager, we create one. This is
   // not the common case, and should only happen when there is a bug in our
   // ability to detect forms.
-  auto manager = base::MakeRefCounted<PasswordFormManager>(
+  auto manager = base::MakeUnique<PasswordFormManager>(
       this, client_, driver->AsWeakPtr(), form,
       base::WrapUnique(new FormSaverImpl(client_->GetPasswordStore())),
       nullptr);
   pending_login_managers_.push_back(std::move(manager));
 }
 
 void PasswordManager::SaveGenerationFieldDetectedByClassifier(
     const autofill::PasswordForm& form,
     const base::string16& generation_field) {
   if (!client_->IsSavingAndFillingEnabledForCurrentPage())
@@ skipping 90 matching lines @@
     }
   }
   // If we didn't find a manager, this means a form was submitted without
   // first loading the page containing the form. Don't offer to save
   // passwords in this case.
   if (matched_manager_it == pending_login_managers_.end()) {
     RecordFailure(NO_MATCHING_FORM, form.origin, logger.get());
     return;
   }
 
-  // Copy ownership of the manager from |pending_login_managers_| to
+  std::unique_ptr<PasswordFormManager> manager;
+  // Transfer ownership of the manager from |pending_login_managers_| to
   // |manager|.
-  scoped_refptr<PasswordFormManager> manager(*matched_manager_it);
+  manager.swap(*matched_manager_it);
+  pending_login_managers_.erase(matched_manager_it);
 
   PasswordForm submitted_form(form);
   submitted_form.preferred = true;
   if (logger) {
     logger->LogPasswordForm(Logger::STRING_PROVISIONALLY_SAVED_FORM,
                             submitted_form);
   }
   PasswordFormManager::OtherPossibleUsernamesAction action =
       PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES;
   if (OtherPossibleUsernamesEnabled())
@@ skipping 36 matching lines @@
 }
 
 void PasswordManager::UpdateFormManagers() {
   for (const auto& form_manager : pending_login_managers_) {
     form_manager->form_fetcher()->Fetch();
   }
 }
 
 void PasswordManager::DropFormManagers() {
   pending_login_managers_.clear();
-  provisional_save_manager_ = nullptr;
+  provisional_save_manager_.reset();
   all_visible_forms_.clear();
 }
 
 bool PasswordManager::IsPasswordFieldDetectedOnPage() {
   return !pending_login_managers_.empty();
 }
 
 void PasswordManager::RecordFailure(ProvisionalSaveFailure failure,
                                     const GURL& form_origin,
                                     BrowserSavePasswordProgressLogger* logger) {
@@ skipping 136 matching lines @@
     // are password change forms.
     if (iter->username_element.empty()) {
       UMA_HISTOGRAM_BOOLEAN(
           "PasswordManager.EmptyUsernames."
           "FormWithoutUsernameFieldIsPasswordChangeForm",
           !iter->new_password_element.empty());
     }
 
     if (logger)
       logger->LogFormSignatures(Logger::STRING_ADDING_SIGNATURE, *iter);
-    auto manager = base::MakeRefCounted<PasswordFormManager>(
+    auto manager = base::MakeUnique<PasswordFormManager>(
         this, client_,
         (driver ? driver->AsWeakPtr() : base::WeakPtr<PasswordManagerDriver>()),
         *iter, base::WrapUnique(new FormSaverImpl(client_->GetPasswordStore())),
         nullptr);
     pending_login_managers_.push_back(std::move(manager));
   }
 
   if (logger) {
     logger->LogNumber(Logger::STRING_NEW_NUMBER_LOGIN_MANAGERS,
                       pending_login_managers_.size());
@@ skipping 15 matching lines @@
     return false;
   }
 
   if (provisional_save_manager_->form_fetcher()->GetState() ==
       FormFetcher::State::WAITING) {
     // We have a provisional save manager, but it didn't finish matching yet.
     // We just give up.
     RecordFailure(MATCHING_NOT_COMPLETE,
                   provisional_save_manager_->observed_form().origin,
                   logger.get());
-    provisional_save_manager_ = nullptr;
+    provisional_save_manager_.reset();
     return false;
   }
   return true;
 }
 
 bool PasswordManager::ShouldBlockPasswordForSameOriginButDifferentScheme(
     const PasswordForm& form) const {
   const GURL& old_origin = main_frame_url_.GetOrigin();
   const GURL& new_origin = form.origin.GetOrigin();
   return old_origin.host_piece() == new_origin.host_piece() &&
@@ skipping 26 matching lines @@
 
   if (!CanProvisionalManagerSave())
     return;
 
   // If the server throws an internal error, access denied page, page not
   // found etc. after a login attempt, we do not save the credentials.
   if (client_->WasLastNavigationHTTPError()) {
     if (logger)
       logger->LogMessage(Logger::STRING_DECISION_DROP);
     provisional_save_manager_->LogSubmitFailed();
-    provisional_save_manager_ = nullptr;
+    provisional_save_manager_.reset();
     return;
   }
 
   if (logger) {
     logger->LogNumber(Logger::STRING_NUMBER_OF_VISIBLE_FORMS,
                       visible_forms.size());
   }
 
   // Record all visible forms from the frame.
   all_visible_forms_.insert(all_visible_forms_.end(),
@@ skipping 16 matching lines @@
           if (provisional_save_manager_
                   ->is_possible_change_password_form_without_username() &&
               AreAllFieldsEmpty(all_visible_forms_[i]))
             continue;
           provisional_save_manager_->LogSubmitFailed();
           if (logger) {
             logger->LogPasswordForm(Logger::STRING_PASSWORD_FORM_REAPPEARED,
                                     all_visible_forms_[i]);
             logger->LogMessage(Logger::STRING_DECISION_DROP);
           }
-          provisional_save_manager_ = nullptr;
+          provisional_save_manager_.reset();
           // Clear all_visible_forms_ once we found the match.
           all_visible_forms_.clear();
           return;
         }
       }
     } else {
       if (logger)
         logger->LogMessage(Logger::STRING_PROVISIONALLY_SAVED_FORM_IS_NOT_HTML);
     }
 
@@ skipping 46 matching lines @@
   }
 
   if (base::FeatureList::IsEnabled(features::kDropSyncCredential)) {
     DCHECK(provisional_save_manager_->submitted_form());
     if (!client_->GetStoreResultFilter()->ShouldSave(
             *provisional_save_manager_->submitted_form())) {
       provisional_save_manager_->WipeStoreCopyIfOutdated();
       RecordFailure(SYNC_CREDENTIAL,
                     provisional_save_manager_->observed_form().origin,
                     logger.get());
-      provisional_save_manager_ = nullptr;
+      provisional_save_manager_.reset();
       return;
     }
   }
 
   provisional_save_manager_->LogSubmitPassed();
 
   RecordWhetherTargetDomainDiffers(main_frame_url_, client_->GetMainFrameURL());
 
   if (ShouldPromptUserToSavePassword()) {
     bool empty_password =
@@ skipping 19 matching lines @@
     provisional_save_manager_->Save();
 
     if (!provisional_save_manager_->IsNewLogin()) {
       client_->NotifySuccessfulLoginWithExistingPassword(
           provisional_save_manager_->pending_credentials());
     }
 
     if (provisional_save_manager_->has_generated_password()) {
       client_->AutomaticPasswordSave(std::move(provisional_save_manager_));
     } else {
-      provisional_save_manager_ = nullptr;
+      provisional_save_manager_.reset();
     }
   }
 }
 
 bool PasswordManager::OtherPossibleUsernamesEnabled() const {
   return false;
 }
 
 void PasswordManager::Autofill(
     password_manager::PasswordManagerDriver* driver,
@@ skipping 137 matching lines @@
       current_match_result = result;
     } else if (result > current_match_result) {
       matched_manager = login_manager.get();
       current_match_result = result;
     }
   }
   return matched_manager;
 }
 
 }  // namespace password_manager