[PasswordManager] Improve detection of ignorable change password forms.

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 <algorithm>
 #include <set>
 
 #include "base/metrics/histogram.h"
@@ skipping 50 matching lines @@
                             event, SUBMISSION_EVENT_ENUM_COUNT);
 }
 
 PasswordForm CopyAndModifySSLValidity(const PasswordForm& orig,
                                       bool ssl_valid) {
   PasswordForm result(orig);
   result.ssl_valid = ssl_valid;
   return result;
 }
 
+// Returns true if user-typed username and password field values match with one
+// of the password form within |credentials| map; otherwise false.
+bool DoesUsenameAndPasswordMatchCredentials(
+    const base::string16& typed_username,
+    const base::string16& typed_password,
+    const autofill::PasswordFormMap& credentials) {
+  for (auto match : credentials) {
+    if (match.second->username_value == typed_username &&
+        match.second->password_value == typed_password)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 PasswordFormManager::PasswordFormManager(
     PasswordManager* password_manager,
     PasswordManagerClient* client,
     const base::WeakPtr<PasswordManagerDriver>& driver,
     const PasswordForm& observed_form,
     bool ssl_valid)
     : best_matches_deleter_(&best_matches_),
       observed_form_(CopyAndModifySSLValidity(observed_form, ssl_valid)),
@@ skipping 288 matching lines @@
     PasswordStore::AuthorizationPromptPolicy prompt_policy) {
   DCHECK_EQ(state_, PRE_MATCHING_PHASE);
   state_ = MATCHING_PHASE;
 
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (client_->IsLoggingActive()) {
     logger.reset(new BrowserSavePasswordProgressLogger(client_));
     logger->LogMessage(Logger::STRING_FETCH_LOGINS_METHOD);
   }
 
-  // Do not autofill on sign-up or change password forms (until we have some
-  // working change password functionality).
-  if (!observed_form_.new_password_element.empty()) {
-    if (logger)
-      logger->LogMessage(Logger::STRING_FORM_NOT_AUTOFILLED);
-    client_->AutofillResultsComputed();
-    // There is no point in looking for the credentials in the store when they
-    // won't be autofilled, so pretend there were none.
-    OnGetPasswordStoreResults(ScopedVector<autofill::PasswordForm>());
-    return;
-  }
-
   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);
 }
 
 bool PasswordFormManager::HasCompletedMatching() const {
   return state_ == POST_MATCHING_PHASE;
 }
 
-bool PasswordFormManager::IsIgnorableChangePasswordForm() const {
+bool PasswordFormManager::IsIgnorableChangePasswordForm(
+    const base::string16& typed_username,
+    const base::string16& typed_password) const {
   bool is_change_password_form = !observed_form_.new_password_element.empty() &&
                                  !observed_form_.password_element.empty();
-  bool is_username_certainly_correct = observed_form_.username_marked_by_site;
-  return is_change_password_form && !is_username_certainly_correct;
+  return is_change_password_form && !observed_form_.username_marked_by_site &&
+         !DoesUsenameAndPasswordMatchCredentials(typed_username, typed_password,
+                                                 best_matches_);
 }
 
 void PasswordFormManager::OnRequestDone(
     ScopedVector<PasswordForm> logins_result) {
   const size_t logins_result_size = logins_result.size();
 
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (client_->IsLoggingActive()) {
     logger.reset(new BrowserSavePasswordProgressLogger(client_));
     logger->LogMessage(Logger::STRING_ON_REQUEST_DONE_METHOD);
@@ skipping 109 matching lines @@
 
   if (!driver || manager_action_ == kManagerActionBlacklisted)
     return;
 
   // Allow generation for any non-blacklisted form.
   driver->AllowPasswordGenerationForForm(observed_form_);
 
   if (best_matches_.empty())
     return;
 
+  // Do not autofill on sign-up or change password forms (until we have some
+  // working change password functionality).
+  if (!observed_form_.new_password_element.empty()) {
+    if (client_->IsLoggingActive()) {
+      BrowserSavePasswordProgressLogger logger(client_);
+      logger.LogMessage(Logger::PROCESS_FRAME_METHOD);
+      logger.LogMessage(Logger::STRING_FORM_NOT_AUTOFILLED);
+    }
+    return;
+  }
+
   // Proceed to autofill.
   // Note that we provide the choices but don't actually prefill a value if:
   // (1) we are in Incognito mode, (2) the ACTION paths don't match,
   // or (3) if it matched using public suffix domain matching.
   bool wait_for_username = client_->IsOffTheRecord() ||
                            observed_form_.action.GetWithEmptyPath() !=
                                preferred_match_->action.GetWithEmptyPath() ||
                            preferred_match_->IsPublicSuffixMatch();
   if (wait_for_username)
     manager_action_ = kManagerActionNone;
@@ skipping 324 matching lines @@
     LogPasswordGenerationSubmissionEvent(PASSWORD_SUBMITTED);
 }
 
 void PasswordFormManager::SubmitFailed() {
   submit_result_ = kSubmitResultFailed;
   if (has_generated_password_)
     LogPasswordGenerationSubmissionEvent(PASSWORD_SUBMISSION_FAILED);
 }
 
 }  // namespace password_manager