[Password Generation] Use canonical version of action in for form matching in PasswordGenerationAgen

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"
@@ skipping 13 matching lines @@
 #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"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/gfx/geometry/rect.h"
 
+using autofill::form_util::StripAuthAndParams;

[vabr (Chromium), 2016/09/07 13:10:08]

nit: Move this below "namespace autofill" and drop the "autofill::".

[kolos1, 2016/09/07 13:19:00]

Done.

+
 namespace autofill {
 
 namespace {
 
 // Returns true if we think that this form is for account creation. |passwords|
 // is filled with the password field(s) in the form.
 bool GetAccountCreationPasswordFields(
     const std::vector<blink::WebFormControlElement>& control_elements,
     std::vector<blink::WebInputElement>* passwords) {
   for (size_t i = 0; i < control_elements.size(); i++) {
     const blink::WebInputElement* input_element =
         toWebInputElement(&control_elements[i]);
     if (input_element && input_element->isTextField()) {
       if (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();
 }
 
+// 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.
 const PasswordFormGenerationData* FindFormGenerationData(
     const std::vector<PasswordFormGenerationData>& forms,
-    const PasswordForm& form) {
+    const PasswordForm& form,
+    const GURL& base_url) {
   for (const auto& form_it : forms) {
-    if (form_it.name == form.form_data.name && form_it.action == form.action)
+    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)
       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
 // than 2 elements.
 std::vector<blink::WebInputElement> FindPasswordElementsForGeneration(
@@ skipping 300 matching lines @@
     const PasswordFormGenerationData* generation_data = nullptr;
     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);
+      generation_data = FindFormGenerationData(
+          generation_enabled_forms_, *possible_password_form,
+          render_frame()->GetWebFrame()->document().baseURL());
       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";
@@ skipping 175 matching lines @@
   ShowGenerationPopup();
 }
 
 const mojom::PasswordManagerDriverPtr&
 PasswordGenerationAgent::GetPasswordManagerDriver() {
   DCHECK(password_agent_);
   return password_agent_->GetPasswordManagerDriver();
 }
 
 }  // namespace autofill