Integrate ManagePasswordsState into ManagePasswordsUIController.

chrome/browser/ui/passwords/manage_passwords_state.cc

 // Copyright 2015 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/ui/passwords/manage_passwords_state.h"
 
 #include "components/password_manager/content/common/credential_manager_types.h"
 #include "components/password_manager/core/browser/browser_save_password_progress_logger.h"
 #include "components/password_manager/core/browser/password_form_manager.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
@@ skipping 66 matching lines @@
                           Vector* forms) {
   typename Vector::iterator it = std::find_if(
       forms->begin(), forms->end(),
       [&form_to_delete](const autofill::PasswordForm* form) {
     return IsEqualUniqueKey(*form, form_to_delete);
   });
   if (it != forms->end())
     forms->erase(it);
 }
 
+// Inserts |form| to the beginning of |forms| if it's blacklisted or to the end
+// otherwise. UnblacklistSite() expects the first saved password to be the
+// blacklisted credential.
+template <class Vector>
+void InsertFormToVector(const autofill::PasswordForm* form,
+                        Vector* forms) {
+  typename Vector::iterator it = form->blacklisted_by_user ? forms->begin()
+                                                           : forms->end();
+  forms->insert(it, form);
+}
+
 }  // namespace
 
 ManagePasswordsState::ManagePasswordsState()
     : state_(password_manager::ui::INACTIVE_STATE),
       client_(nullptr) {
 }
 
 ManagePasswordsState::~ManagePasswordsState() {}
 
 void ManagePasswordsState::OnPendingPassword(
@@ skipping 54 matching lines @@
     SetState(password_manager::ui::MANAGE_STATE);
   }
 }
 
 void ManagePasswordsState::OnBlacklistBlockedAutofill(
     const autofill::PasswordFormMap& password_form_map) {
   DCHECK(!password_form_map.empty());
   ClearData();
   local_credentials_forms_ = DeepCopyMapToVector(password_form_map);
   origin_ = local_credentials_forms_.front()->origin;
+  DCHECK(local_credentials_forms_.front()->blacklisted_by_user);
   SetState(password_manager::ui::BLACKLIST_STATE);
 }
 
 void ManagePasswordsState::OnInactive() {
   ClearData();
   origin_ = GURL();
   SetState(password_manager::ui::INACTIVE_STATE);
 }
 
 void ManagePasswordsState::TransitionToState(
     password_manager::ui::State state) {
   DCHECK_NE(password_manager::ui::INACTIVE_STATE, state_);
   DCHECK(state == password_manager::ui::BLACKLIST_STATE ||
          state == password_manager::ui::MANAGE_STATE);
-  if (state_ == password_manager::ui::CREDENTIAL_REQUEST_STATE &&
-      !credentials_callback_.is_null()) {
-    credentials_callback_.Run(password_manager::CredentialInfo());
-    credentials_callback_.Reset();
+  if (state_ == password_manager::ui::CREDENTIAL_REQUEST_STATE) {
+    if (!credentials_callback_.is_null()) {
+      credentials_callback_.Run(password_manager::CredentialInfo());
+      credentials_callback_.Reset();
+    }
+    federated_credentials_forms_.clear();
   }
   SetState(state);
 }
 
 void ManagePasswordsState::ProcessLoginsChanged(
     const password_manager::PasswordStoreChangeList& changes) {
   if (state() == password_manager::ui::INACTIVE_STATE)
     return;
 
   for (const password_manager::PasswordStoreChange& change : changes) {
@@ skipping 24 matching lines @@
   local_credentials_forms_.clear();
   federated_credentials_forms_.clear();
   credentials_callback_.Reset();
 }
 
 void ManagePasswordsState::AddForm(const autofill::PasswordForm& form) {
   if (form.origin != origin_)
     return;
   if (UpdateForm(form))
     return;
-  local_credentials_forms_.push_back(new autofill::PasswordForm(form));
-  if (form_manager_)
-    current_forms_weak_.push_back(local_credentials_forms_.back());
+  if (form_manager_) {
+    local_credentials_forms_.push_back(new autofill::PasswordForm(form));
+    InsertFormToVector(local_credentials_forms_.back(), &current_forms_weak_);
+  } else {
+    InsertFormToVector(new autofill::PasswordForm(form),
+                       &local_credentials_forms_);
+  }
 }
 
 bool ManagePasswordsState::UpdateForm(const autofill::PasswordForm& form) {
   if (form_manager_) {
     // |current_forms_weak_| contains the list of current passwords.
     std::vector<const autofill::PasswordForm*>::iterator it = std::find_if(
         current_forms_weak_.begin(), current_forms_weak_.end(),
         [&form](const autofill::PasswordForm* current_form) {
       return IsEqualUniqueKey(form, *current_form);
     });
@@ skipping 12 matching lines @@
   return false;
 }
 
 void ManagePasswordsState::DeleteForm(const autofill::PasswordForm& form) {
   RemoveFormFromVector(form, &current_forms_weak_);
   RemoveFormFromVector(form, &local_credentials_forms_);
   RemoveFormFromVector(form, &federated_credentials_forms_);
 }
 
 void ManagePasswordsState::SetState(password_manager::ui::State state) {
-  if (client_ && client_->IsLoggingActive()) {
+  DCHECK(client_);
+  if (client_->IsLoggingActive()) {
     password_manager::BrowserSavePasswordProgressLogger logger(client_);
     logger.LogNumber(
         autofill::SavePasswordProgressLogger::STRING_NEW_UI_STATE,
         state);
   }
   state_ = state;
 }