Remove PasswordStore::AuthorizationPromptPolicy

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 136 matching lines @@
       base::Bind(&PasswordStore::RemoveStatisticsCreatedBetweenInternal, this,
                  delete_begin, delete_end, completion));
 }
 
 void PasswordStore::TrimAffiliationCache() {
   if (affiliated_match_helper_)
     affiliated_match_helper_->TrimAffiliationCache();
 }
 
 void PasswordStore::GetLogins(const PasswordForm& form,
-                              AuthorizationPromptPolicy prompt_policy,
                               PasswordStoreConsumer* consumer) {
   // Per http://crbug.com/121738, we deliberately ignore saved logins for
   // http*://www.google.com/ that were stored prior to 2012. (Google now uses
   // https://accounts.google.com/ for all login forms, so these should be
   // unused.) We don't delete them just yet, and they'll still be visible in the
   // password manager, but we won't use them to autofill any forms. This is a
   // security feature to help minimize damage that can be done by XSS attacks.
   // TODO(mdm): actually delete them at some point, say M24 or so.
   base::Time ignore_logins_cutoff;  // the null time
   if (form.scheme == PasswordForm::SCHEME_HTML &&
       (form.signon_realm == "http://www.google.com" ||
        form.signon_realm == "http://www.google.com/" ||
        form.signon_realm == "https://www.google.com" ||
        form.signon_realm == "https://www.google.com/")) {
     static const base::Time::Exploded exploded_cutoff =
         { 2012, 1, 0, 1, 0, 0, 0, 0 };  // 00:00 Jan 1 2012
     ignore_logins_cutoff = base::Time::FromUTCExploded(exploded_cutoff);
   }
   scoped_ptr<GetLoginsRequest> request(new GetLoginsRequest(consumer));
   request->set_ignore_logins_cutoff(ignore_logins_cutoff);
 
   if (affiliated_match_helper_) {
     affiliated_match_helper_->GetAffiliatedAndroidRealms(
         form, base::Bind(&PasswordStore::ScheduleGetLoginsWithAffiliations,
-                         this, form, prompt_policy, base::Passed(&request)));
+                         this, form, base::Passed(&request)));
   } else {
     ScheduleTask(base::Bind(&PasswordStore::GetLoginsImpl, this, form,
-                            prompt_policy, base::Passed(&request)));
+                            base::Passed(&request)));
   }
 }
 
 void PasswordStore::GetAutofillableLogins(PasswordStoreConsumer* consumer) {
   Schedule(&PasswordStore::GetAutofillableLoginsImpl, consumer);
 }
 
 void PasswordStore::GetBlacklistLogins(PasswordStoreConsumer* consumer) {
   Schedule(&PasswordStore::GetBlacklistLoginsImpl, consumer);
 }
@@ skipping 60 matching lines @@
 PasswordStore::~PasswordStore() {
   DCHECK(shutdown_called_);
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 PasswordStore::GetBackgroundTaskRunner() {
   return db_thread_runner_;
 }
 
 void PasswordStore::GetLoginsImpl(const autofill::PasswordForm& form,
-                                  AuthorizationPromptPolicy prompt_policy,
                                   scoped_ptr<GetLoginsRequest> request) {
-  request->NotifyConsumerWithResults(FillMatchingLogins(form, prompt_policy));
+  request->NotifyConsumerWithResults(FillMatchingLogins(form));
 }
 
 
 void PasswordStore::LogStatsForBulkDeletion(int num_deletions) {
   UMA_HISTOGRAM_COUNTS("PasswordManager.NumPasswordsDeletedByBulkDelete",
                        num_deletions);
 }
 
 void PasswordStore::LogStatsForBulkDeletionDuringRollback(int num_deletions) {
   UMA_HISTOGRAM_COUNTS("PasswordManager.NumPasswordsDeletedDuringRollback",
@@ skipping 133 matching lines @@
   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,
     scoped_ptr<GetLoginsRequest> request,
     const std::vector<std::string>& additional_android_realms) {
   DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
-  ScopedVector<PasswordForm> results(FillMatchingLogins(form, prompt_policy));
+  ScopedVector<PasswordForm> results(FillMatchingLogins(form));
   for (const std::string& realm : additional_android_realms) {
     PasswordForm android_form;
     android_form.scheme = PasswordForm::SCHEME_HTML;
     android_form.signon_realm = realm;
-    ScopedVector<PasswordForm> more_results(
-        FillMatchingLogins(android_form, DISALLOW_PROMPT));
+    ScopedVector<PasswordForm> more_results(FillMatchingLogins(android_form));
     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(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),
+                          form, 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));
+  ScopedVector<PasswordForm> candidates(FillMatchingLogins(primary_key));
   for (PasswordForm*& candidate : candidates) {
     if (ArePasswordFormUniqueKeyEqual(*candidate, primary_key) &&
         !candidate->is_public_suffix_match) {
       scoped_ptr<PasswordForm> result(candidate);
       candidate = nullptr;
       return result;
     }
   }
   return make_scoped_ptr<PasswordForm>(nullptr);
 }
@@ skipping 20 matching lines @@
 void PasswordStore::UpdateAffiliatedWebLoginsImpl(
     const PasswordForm& updated_android_form,
     const std::vector<std::string>& affiliated_web_realms) {
   DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   PasswordStoreChangeList all_changes;
   for (const std::string& affiliated_web_realm : affiliated_web_realms) {
     PasswordForm web_form_template;
     web_form_template.scheme = PasswordForm::SCHEME_HTML;
     web_form_template.signon_realm = affiliated_web_realm;
     ScopedVector<PasswordForm> web_logins(
-        FillMatchingLogins(web_form_template, DISALLOW_PROMPT));
+        FillMatchingLogins(web_form_template));
     for (PasswordForm* web_login : web_logins) {
       // Do not update HTTP logins, logins saved under insecure conditions, and
       // non-HTML login forms; PSL matches; logins with a different username;
       // and logins with the same password (to avoid generating no-op updates).
       if (!AffiliatedMatchHelper::IsValidWebCredential(*web_login) ||
           web_login->is_public_suffix_match ||
           web_login->username_value != updated_android_form.username_value ||
           web_login->password_value == updated_android_form.password_value)
         continue;
 
@@ skipping 72 matching lines @@
   syncable_service_.reset(new PasswordSyncableService(this));
   syncable_service_->InjectStartSyncFlare(flare);
 }
 
 void PasswordStore::DestroySyncableService() {
   DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   syncable_service_.reset();
 }
 
 }  // namespace password_manager