Remove PasswordStore::AuthorizationPromptPolicy

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 105 matching lines @@
       password_manager_(password_manager),
       preferred_match_(nullptr),
       is_ignorable_change_password_form_(false),
       is_possible_change_password_form_without_username_(
           observed_form.IsPossibleChangePasswordFormWithoutUsername()),
       state_(PRE_MATCHING_PHASE),
       client_(client),
       manager_action_(kManagerActionNone),
       user_action_(kUserActionNone),
       submit_result_(kSubmitResultNotSubmitted),
-      form_type_(kFormTypeUnspecified) {
+      form_type_(kFormTypeUnspecified),
+      need_to_refetch_(false) {
   DCHECK_EQ(observed_form.scheme == PasswordForm::SCHEME_HTML,
             driver != nullptr);
   if (driver)
     drivers_.push_back(driver);
 }
 
 PasswordFormManager::~PasswordFormManager() {
   UMA_HISTOGRAM_ENUMERATION(
       "PasswordManager.ActionsTakenV3", GetActionsTaken(), kMaxNumActionsTaken);
   if (submit_result_ == kSubmitResultNotSubmitted) {
@@ skipping 165 matching lines @@
                              form_structure.FormSignature());
   }
   base::string16 password_to_save = pending_credentials_.password_value;
   pending_credentials_ = credentials_to_update;
   pending_credentials_.password_value = password_to_save;
   pending_credentials_.preferred = true;
   is_new_login_ = false;
   UpdateLogin();
 }
 
-void PasswordFormManager::FetchDataFromPasswordStore(
-    PasswordStore::AuthorizationPromptPolicy prompt_policy) {
+void PasswordFormManager::FetchDataFromPasswordStore() {
   if (state_ == MATCHING_PHASE) {
-    // There is currently a password store query in progress. Remember the
-    // prompt policy for when the store results are back and another store query
-    // might be issued.
-    next_prompt_policy_.reset(
-        new PasswordStore::AuthorizationPromptPolicy(prompt_policy));
+    // There is currently a password store query in progress, need to re-fetch
+    // store results later.
+    need_to_refetch_ = true;
     return;
   }
 
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (password_manager_util::IsLoggingActive(client_)) {
     logger.reset(
         new BrowserSavePasswordProgressLogger(client_->GetLogManager()));
     logger->LogMessage(Logger::STRING_FETCH_LOGINS_METHOD);
     logger->LogNumber(Logger::STRING_FORM_MANAGER_STATE, state_);
   }
 
   provisionally_saved_form_.reset();
   state_ = MATCHING_PHASE;
 
   PasswordStore* password_store = client_->GetPasswordStore();
   if (!password_store) {
     if (logger)
       logger->LogMessage(Logger::STRING_NO_STORE);
     NOTREACHED();
     return;
   }
-  password_store->GetLogins(observed_form_, prompt_policy, this);
+  password_store->GetLogins(observed_form_, this);
 
 // The statistics isn't needed on mobile, only on desktop. Let's save some
 // processor cycles.
 #if !defined(OS_IOS) && !defined(OS_ANDROID)
   // The statistics is needed for the "Save password?" bubble.
   password_store->GetSiteStats(observed_form_.origin.GetOrigin(), this);
 #endif
 }
 
 bool PasswordFormManager::HasCompletedMatching() const {
@@ skipping 171 matching lines @@
     return;
 
   manager_action_ = kManagerActionAutofilled;
   password_manager_->AutofillHttpAuth(best_matches_, *preferred_match_);
 }
 
 void PasswordFormManager::OnGetPasswordStoreResults(
     ScopedVector<PasswordForm> results) {
   DCHECK_EQ(state_, MATCHING_PHASE);
 
-  if (next_prompt_policy_) {
+  if (need_to_refetch_) {
     // The received results are no longer up-to-date, need to re-request.
     state_ = PRE_MATCHING_PHASE;
-    FetchDataFromPasswordStore(*next_prompt_policy_);
-    next_prompt_policy_.reset();
+    FetchDataFromPasswordStore();
+    need_to_refetch_ = false;
     return;
   }
 
   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());
   }
@@ skipping 112 matching lines @@
 
   UpdateMetadataForUsage(pending_credentials_);
 
   client_->GetStoreResultFilter()->ReportFormUsed(pending_credentials_);
 
   // Check to see if this form is a candidate for password generation.
   // Do not send votes on change password forms, since they were already sent in
   // Update() method.
   if (has_generated_password_) {
     UploadGeneratedVote();
-  } else if (!observed_form_.IsPossibleChangePasswordForm())
+  } else if (!observed_form_.IsPossibleChangePasswordForm()) {
     SendAutofillVotes(observed_form_, &pending_credentials_);
+  }
 
   UpdatePreferredLoginState(password_store);
 
   bool password_was_updated = false;
   // Update the new preferred login.
   if (!selected_username_.empty()) {
     // Username has changed. We set this selected username as the real
     // username. Given that |username_value| is part of the Sync and
     // PasswordStore primary key, the old primary key must be supplied.
     PasswordForm old_primary_key(pending_credentials_);
@@ skipping 390 matching lines @@
                   ->IsPossibleChangePasswordFormWithoutUsername() ||
               provisionally_saved_form_->username_element.empty())) {
     PasswordForm* best_update_match = FindBestMatchForUpdatePassword(
         provisionally_saved_form_->password_value);
 
     retry_password_form_password_update_ =
         provisionally_saved_form_->username_element.empty() &&
         provisionally_saved_form_->new_password_element.empty();
 
     is_new_login_ = false;
-    if (best_update_match)
+    if (best_update_match) {
       pending_credentials_ = *best_update_match;
-    else if (has_generated_password_) {
+    } else if (has_generated_password_) {
       // If a password was generated and we didn't find match we have to save it
       // in separate entry since we have to store it but we don't know where.
       CreatePendingCredentialsForNewCredentials();
       is_new_login_ = true;
     } else {
       // We don't care about |pending_credentials_| if we didn't find the best
       // match, since the user will select the correct one.
       pending_credentials_.origin = provisionally_saved_form_->origin;
     }
   } else {
@@ skipping 256 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