[Password Generation] Use signatures for form matching

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 <memory>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "components/autofill/content/common/autofill_messages.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"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_form_generation_data.h"
 #include "components/autofill/core/common/password_generation_util.h"
+#include "components/autofill/core/common/signatures_util.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
@@ skipping 19 matching lines @@
         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();
 }
 
-// Finds a form in |forms| that has the same action and name as |form|.
-// If the action of a form in |forms| is empty, it uses |base_url| as action. It
-// also strips parameters of the action.
+// Calculates the signature of |form| and searches it in |forms|.
 const PasswordFormGenerationData* FindFormGenerationData(
     const std::vector<PasswordFormGenerationData>& forms,
-    const PasswordForm& form,
-    const GURL& base_url) {
+    const PasswordForm& form) {
+  FormSignature form_signature = CalculateFormSignature(form.form_data);
   for (const auto& form_it : forms) {
-    GURL action = form_it.action;
-    if (action.is_empty())
-      action = base_url;
-    action = form_util::StripAuthAndParams(action);
-    if (form_it.name == form.form_data.name && action == form.action)
+    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_data| describes the field
-// where Chrome shows the password generation prompt. It returns no more
+// 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.
 std::vector<blink::WebInputElement> FindPasswordElementsForGeneration(
     const std::vector<blink::WebInputElement>& all_password_elements,
-    const base::string16& field_name) {
-  auto iter =
-      std::find_if(all_password_elements.begin(), all_password_elements.end(),
-                   [&field_name](const blink::WebInputElement& input) {
-                     // Make explicit conversion before comparing with string16.
-                     base::string16 input_name = input.nameForAutofill();
-                     return input_name == field_name;
-                   });
+    const FieldSignature field_signature) {
+  auto iter = std::find_if(
+      all_password_elements.begin(), all_password_elements.end(),
+      [&field_signature](const blink::WebInputElement& input) {
+        FieldSignature signature = CalculateFieldSignatureByNameAndType(
+            input.nameForAutofill(), input.formControlType().utf8());
+        return signature == field_signature;
+      });
   std::vector<blink::WebInputElement> passwords;
 
   // We copy not more than 2 fields because occasionally there are forms where
   // the security question answers are put in password fields and we don't want
   // to fill those.
-  for (; iter != all_password_elements.end() && passwords.size() < 2; ++iter) {
+  for (; iter != all_password_elements.end() && passwords.size() < 2; ++iter)
     passwords.push_back(*iter);
-  }
   return passwords;
 }
 
 void CopyElementValueToOtherInputElements(
     const blink::WebInputElement* element,
     std::vector<blink::WebInputElement>* elements) {
   for (blink::WebInputElement& it : *elements) {
     if (*element != it) {
       it.setValue(element->value(), true /* sendEvents */);
     }
@@ skipping 274 matching lines @@
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kLocalHeuristicsOnlyForPasswordGeneration)) {
       VLOG(2) << "Bypassing additional checks.";
     } else if (!ContainsURL(not_blacklisted_password_form_origins_,
                             possible_password_form->origin)) {
       VLOG(2) << "Have not received confirmation that password form isn't "
                << "blacklisted";
       continue;
     } else {
       generation_data = FindFormGenerationData(
-          generation_enabled_forms_, *possible_password_form,
-          render_frame()->GetWebFrame()->document().baseURL());
+          generation_enabled_forms_, *possible_password_form);
       if (!generation_data) {
         if (AutocompleteAttributesSetForGeneration(*possible_password_form)) {
           VLOG(2) << "Ignoring lack of Autofill signal due to Autocomplete "
                   << "attributes";
           password_generation::LogPasswordGenerationEvent(
               password_generation::AUTOCOMPLETE_ATTRIBUTES_ENABLED_GENERATION);
         } else {
           VLOG(2)
               << "Have not received confirmation from Autofill that form is "
               << "used for account creation";
           continue;
         }
       }
     }
 
     VLOG(2) << "Password generation eligible form found";
     std::vector<blink::WebInputElement> password_elements =
         generation_data ? FindPasswordElementsForGeneration(
                               possible_form_data.password_elements,
-                              generation_data->generation_field.name)
+                              generation_data->field_signature)
                         : possible_form_data.password_elements;
     if (password_elements.empty()) {
       // It might be if JavaScript changes field names.
       VLOG(2) << "Fields for generation are not 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");
@@ skipping 141 matching lines @@
         form_util::GetUnownedFormFieldElements(doc.all(), nullptr);
   }
 
   if (!password_form)
     return;
 
   generation_element_ = last_focused_password_element_;
   std::vector<blink::WebInputElement> password_elements;
   GetAccountCreationPasswordFields(control_elements, &password_elements);
   password_elements = FindPasswordElementsForGeneration(
-      password_elements, last_focused_password_element_.nameForAutofill());
+      password_elements,
+      CalculateFieldSignatureByNameAndType(
+          last_focused_password_element_.nameForAutofill(),
+          last_focused_password_element_.formControlType().utf8()));
   generation_form_data_.reset(new AccountCreationFormData(
       make_linked_ptr(password_form.release()), password_elements));
   is_manually_triggered_ = true;
   ShowGenerationPopup();
 }
 
 const mojom::PasswordManagerDriverPtr&
 PasswordGenerationAgent::GetPasswordManagerDriver() {
   DCHECK(password_agent_);
   return password_agent_->GetPasswordManagerDriver();
 }
 
 }  // namespace autofill