[PasswordGeneration] Improve change/confirm password field detection.

components/autofill/content/renderer/password_generation_agent.cc

 // Copyright 2013 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/autofill/content/renderer/password_generation_agent.h"
 
+#include <algorithm>
 #include <memory>
+#include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/form_classifier.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
@@ skipping 14 matching lines @@
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace autofill {
 
 namespace {
 
 using Logger = autofill::SavePasswordProgressLogger;
 
-// Returns true if we think that this form is for account creation. |passwords|
-// is filled with the password field(s) in the form.
+// Returns true if we think that this form is for account creation. Password
+// field(s) of the form are pushed back to |passwords|.
 bool GetAccountCreationPasswordFields(
     const std::vector<blink::WebFormControlElement>& control_elements,
     std::vector<blink::WebInputElement>* passwords) {
-  for (size_t i = 0; i < control_elements.size(); i++) {
+  for (const auto& control_element : control_elements) {
     const blink::WebInputElement* input_element =
-        ToWebInputElement(&control_elements[i]);
-    if (input_element && input_element->IsTextField()) {
-      if (input_element->IsPasswordField())
-        passwords->push_back(*input_element);
+        ToWebInputElement(&control_element);
+    if (input_element && input_element->IsTextField() &&
+        input_element->IsPasswordField()) {
+      passwords->push_back(*input_element);
     }
   }
   return !passwords->empty();
 }
 
 bool ContainsURL(const std::vector<GURL>& urls, const GURL& url) {
   return std::find(urls.begin(), urls.end(), url) != urls.end();
 }
 
 // Calculates the signature of |form| and searches it in |forms|.
 const PasswordFormGenerationData* FindFormGenerationData(
     const std::vector<PasswordFormGenerationData>& forms,
     const PasswordForm& form) {
   FormSignature form_signature = CalculateFormSignature(form.form_data);
   for (const auto& form_it : forms) {
     if (form_it.form_signature == form_signature)
       return &form_it;
   }
   return nullptr;
 }
 
-// This function returns a vector of password fields into which Chrome should
-// fill the generated password. It assumes that |field_signature| describes the
-// field where Chrome shows the password generation prompt. It returns no more
-// than 2 elements.
+// Returns a vector of up to 2 password fields with autocomplete attribute set
+// to "new-password". These will be filled with the generated password.
+std::vector<blink::WebInputElement> FindNewPasswordElementsMarkedBySite(
+    const std::vector<blink::WebInputElement>& all_password_elements) {
+  std::vector<blink::WebInputElement> passwords;
+
+  auto is_new_password_field = [](const blink::WebInputElement& element) {
+    return HasAutocompleteAttributeValue(element, "new-password");
+  };
+
+  auto field_iter =
+      std::find_if(all_password_elements.begin(), all_password_elements.end(),
+                   is_new_password_field);
+  if (field_iter != all_password_elements.end()) {
+    passwords.push_back(*field_iter++);
+    field_iter = std::find_if(field_iter, all_password_elements.end(),
+                              is_new_password_field);
+    if (field_iter != all_password_elements.end())
+      passwords.push_back(*field_iter);
+  }
+
+  return passwords;
+}
+
+// Returns a vector of up to 2 password fields into which Chrome should fill the
+// generated password. It assumes that |field_signature| describes the field
+// where Chrome shows the password generation prompt.
 std::vector<blink::WebInputElement> FindPasswordElementsForGeneration(
     const std::vector<blink::WebInputElement>& all_password_elements,
     const PasswordFormGenerationData& generation_data) {
   auto generation_field_iter = all_password_elements.end();
   auto confirmation_field_iter = all_password_elements.end();
   for (auto iter = all_password_elements.begin();
        iter != all_password_elements.end(); ++iter) {
     const blink::WebInputElement& input = *iter;
     FieldSignature signature = CalculateFieldSignatureByNameAndType(
         input.NameForAutofill().Utf16(), input.FormControlType().Utf8());
-    if (signature == generation_data.field_signature)
+    if (signature == generation_data.field_signature) {
       generation_field_iter = iter;
-    else if (generation_data.confirmation_field_signature &&
-             signature == *generation_data.confirmation_field_signature)
+    } else if (generation_data.confirmation_field_signature &&
+               signature == *generation_data.confirmation_field_signature) {
       confirmation_field_iter = iter;
+    }
   }
 
   std::vector<blink::WebInputElement> passwords;
   if (generation_field_iter != all_password_elements.end()) {
     passwords.push_back(*generation_field_iter);
 
     if (confirmation_field_iter == all_password_elements.end())
       confirmation_field_iter = generation_field_iter + 1;
     if (confirmation_field_iter != all_password_elements.end())
       passwords.push_back(*confirmation_field_iter);
   }
   return passwords;
 }
 
 void CopyElementValueToOtherInputElements(
     const blink::WebInputElement* element,
     std::vector<blink::WebInputElement>* elements) {
   for (blink::WebInputElement& it : *elements) {
     if (*element != it) {
       it.SetAutofillValue(element->Value());
     }
   }
 }
 
-bool AutocompleteAttributesSetForGeneration(const PasswordForm& form) {
-  return form.username_marked_by_site && form.new_password_marked_by_site;
-}
-
 }  // namespace
 
 PasswordGenerationAgent::AccountCreationFormData::AccountCreationFormData(
     linked_ptr<PasswordForm> password_form,
     std::vector<blink::WebInputElement> passwords)
-    : form(password_form),
-      password_elements(passwords) {}
+    : form(password_form), password_elements(std::move(passwords)) {}
 
 PasswordGenerationAgent::AccountCreationFormData::AccountCreationFormData(
     const AccountCreationFormData& other) = default;
 
 PasswordGenerationAgent::AccountCreationFormData::~AccountCreationFormData() {}
 
 PasswordGenerationAgent::PasswordGenerationAgent(
     content::RenderFrame* render_frame,
     PasswordAutofillAgent* password_agent)
     : content::RenderFrameObserver(render_frame),
@@ skipping 132 matching lines @@
     GURL realm(password_form->signon_realm);
     if (realm == GaiaUrls::GetInstance()->gaia_login_form_realm())
       continue;
 
     std::vector<blink::WebInputElement> passwords;
     if (GetAccountCreationPasswordFields(
             form_util::ExtractAutofillableElementsInForm(forms[i]),
             &passwords)) {
       if (form_classifier_enabled_)
         RunFormClassifierAndSaveVote(forms[i], *password_form);
-      AccountCreationFormData ac_form_data(
-          make_linked_ptr(password_form.release()), passwords);
-      possible_account_creation_forms_.push_back(ac_form_data);
+      possible_account_creation_forms_.emplace_back(
+          make_linked_ptr(password_form.release()), std::move(passwords));
     }
   }
 
   if (!possible_account_creation_forms_.empty()) {
     LogNumber(
         Logger::STRING_GENERATION_RENDERER_POSSIBLE_ACCOUNT_CREATION_FORMS,
         possible_account_creation_forms_.size());
     DetermineGenerationElement();
   }
 }
@@ skipping 89 matching lines @@
   if (possible_account_creation_forms_.empty()) {
     LogMessage(Logger::STRING_GENERATION_RENDERER_NO_POSSIBLE_CREATION_FORMS);
     return;
   }
 
   // Note that no messages will be sent if this feature is disabled
   // (e.g. password saving is disabled).
   for (auto& possible_form_data : possible_account_creation_forms_) {
     PasswordForm* possible_password_form = possible_form_data.form.get();
     const PasswordFormGenerationData* generation_data = nullptr;
+
+    std::vector<blink::WebInputElement> password_elements;
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kLocalHeuristicsOnlyForPasswordGeneration)) {
+      password_elements = possible_form_data.password_elements;
       VLOG(2) << "Bypassing additional checks.";
     } else if (!ContainsURL(not_blacklisted_password_form_origins_,
                             possible_password_form->origin)) {
       LogMessage(Logger::STRING_GENERATION_RENDERER_NOT_BLACKLISTED);
       continue;
     } else {
       generation_data = FindFormGenerationData(generation_enabled_forms_,
                                                *possible_password_form);
-      if (!generation_data) {
-        if (AutocompleteAttributesSetForGeneration(*possible_password_form)) {
-          LogMessage(Logger::STRING_GENERATION_RENDERER_AUTOCOMPLETE_ATTRIBUTE);
-          password_generation::LogPasswordGenerationEvent(
-              password_generation::AUTOCOMPLETE_ATTRIBUTES_ENABLED_GENERATION);
-        } else {
+      if (generation_data) {
+        password_elements = FindPasswordElementsForGeneration(
+            possible_form_data.password_elements, *generation_data);
+      } else {
+        if (!possible_password_form->new_password_marked_by_site) {
           LogMessage(Logger::STRING_GENERATION_RENDERER_NO_SERVER_SIGNAL);
           continue;
         }
+
+        LogMessage(Logger::STRING_GENERATION_RENDERER_AUTOCOMPLETE_ATTRIBUTE);
+        password_generation::LogPasswordGenerationEvent(
+            password_generation::AUTOCOMPLETE_ATTRIBUTES_ENABLED_GENERATION);
+
+        password_elements = FindNewPasswordElementsMarkedBySite(
+            possible_form_data.password_elements);
       }
     }
+
     LogMessage(Logger::STRING_GENERATION_RENDERER_ELIGIBLE_FORM_FOUND);
-    std::vector<blink::WebInputElement> password_elements =
-        generation_data
-            ? FindPasswordElementsForGeneration(
-                  possible_form_data.password_elements, *generation_data)
-            : possible_form_data.password_elements;
     if (password_elements.empty()) {
       // It might be if JavaScript changes field names.
       LogMessage(Logger::STRING_GENERATION_RENDERER_NO_FIELD_FOUND);
       return;
     }
+
     generation_form_data_.reset(new AccountCreationFormData(
         possible_form_data.form, std::move(password_elements)));
     generation_element_ = generation_form_data_->password_elements[0];
     generation_element_.SetAttribute("aria-autocomplete", "list");
     password_generation::LogPasswordGenerationEvent(
         password_generation::GENERATION_AVAILABLE);
     possible_account_creation_forms_.clear();
     GetPasswordManagerClient()->GenerationAvailableForForm(
         *generation_form_data_->form);
     return;
@@ skipping 191 matching lines @@
 
 void PasswordGenerationAgent::LogNumber(Logger::StringID message_id,
                                         int number) {
   if (!password_agent_->logging_state_active())
     return;
   RendererSavePasswordProgressLogger logger(GetPasswordManagerDriver().get());
   logger.LogNumber(message_id, number);
 }
 
 }  // namespace autofill