[Password Manager] Autofill forms with field name and id attributes missing.

components/autofill/content/renderer/password_autofill_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_autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 36 matching lines @@
 
 // The size above which we stop triggering autocomplete.
 static const size_t kMaximumTextSizeForAutocomplete = 1000;
 
 // Experiment information
 const char kFillOnAccountSelectFieldTrialName[] = "FillOnAccountSelect";
 const char kFillOnAccountSelectFieldTrialEnabledWithHighlightGroup[] =
     "EnableWithHighlight";
 const char kFillOnAccountSelectFieldTrialEnabledWithNoHighlightGroup[] =
     "EnableWithNoHighlight";
+const char kDummyUsernameField[] = "anonymous_username";
+const char kDummyPasswordField[] = "anonymous_password";
 
 // Maps element names to the actual elements to simplify form filling.
 typedef std::map<base::string16, blink::WebInputElement> FormInputElementMap;
 
 // Use the shorter name when referencing SavePasswordProgressLogger::StringID
 // values to spare line breaks. The code provides enough context for that
 // already.
 typedef SavePasswordProgressLogger Logger;
 
 typedef std::vector<FormInputElementMap> FormElementsList;
 
 bool FillDataContainsFillableUsername(const PasswordFormFillData& fill_data) {
   return !fill_data.username_field.name.empty() &&
          (!fill_data.additional_logins.empty() ||
           !fill_data.username_field.value.empty());
 }
 
 // Returns true if |control_elements| contains an element named |name| and is
 // visible.
 bool IsNamedElementVisible(
     const std::vector<blink::WebFormControlElement>& control_elements,
     const base::string16& name) {
-  for (size_t i = 0; i < control_elements.size(); ++i) {
-    if (control_elements[i].nameForAutofill() == name) {
-      return IsWebNodeVisible(control_elements[i]);
+  for (const blink::WebFormControlElement& control_element : control_elements) {
+    if (control_element.nameForAutofill() == name) {
+      return IsWebNodeVisible(control_element);
     }
   }
   return false;
 }
 
+// Returns true if password form has username and password fields with either
+// same or no name and id attributes supplied.
+bool DoesFormContainAmbiguousOrEmptyNames(
+    const PasswordFormFillData& fill_data) {
+  return (fill_data.username_field.name == fill_data.password_field.name) ||
+         (fill_data.password_field.name ==
+              base::ASCIIToUTF16(kDummyPasswordField) &&
+          (!FillDataContainsFillableUsername(fill_data) ||
+           fill_data.username_field.name ==
+               base::ASCIIToUTF16(kDummyUsernameField)));
+}
+
+bool IsPasswordField(const FormFieldData& field) {
+  return (field.form_control_type == "password");
+}
+
+// Returns true if any password field within |control_elements| is supplied with
+// either |autocomplete='current-password'| or |autocomplete='new-password'|
+// attribute.
+bool HasPasswordWithAutocompleteAttribute(
+    const std::vector<blink::WebFormControlElement>& control_elements) {
+  for (const blink::WebFormControlElement& control_element : control_elements) {
+    if (!control_element.hasHTMLTagName("input"))
+      continue;
+
+    const blink::WebInputElement input_element =
+        control_element.toConst<blink::WebInputElement>();
+    if (input_element.isPasswordField() &&
+        (HasAutocompleteAttributeValue(input_element, "current-password") ||
+         HasAutocompleteAttributeValue(input_element, "new-password")))
+      return true;
+  }
+
+  return false;
+}
+
+// Returns the |field|'s autofillable name. If |ambiguous_or_empty_names| is set
+// to true returns a dummy name instead.
+base::string16 FieldName(const FormFieldData& field,
+                         bool ambiguous_or_empty_names) {
+  return ambiguous_or_empty_names
+             ? IsPasswordField(field) ? base::ASCIIToUTF16(kDummyPasswordField)
+                                      : base::ASCIIToUTF16(kDummyUsernameField)
+             : field.name;
+}
+
 // Utility function to find the unique entry of |control_elements| for the
 // specified input |field|. On successful find, adds it to |result| and returns
 // |true|. Otherwise clears the references from each |HTMLInputElement| from
 // |result| and returns |false|.
 bool FindFormInputElement(
     const std::vector<blink::WebFormControlElement>& control_elements,
     const FormFieldData& field,
+    bool ambiguous_or_empty_names,
     FormInputElementMap* result) {
   // Match the first input element, if any.
-  // If more than one match is made, then we have ambiguity (due to misuse
-  // of "name" attribute) so is it considered not found.
   bool found_input = false;
-  for (size_t i = 0; i < control_elements.size(); ++i) {
-    if (control_elements[i].nameForAutofill() != field.name)
+  bool is_password_field = IsPasswordField(field);
+  bool does_password_field_has_ambigous_or_empty_name =
+      ambiguous_or_empty_names && is_password_field;
+  bool ambiguous_and_multiple_password_fields_with_autocomplete =
+      does_password_field_has_ambigous_or_empty_name &&
+      HasPasswordWithAutocompleteAttribute(control_elements);
+  base::string16 field_name = FieldName(field, ambiguous_or_empty_names);
+  for (const blink::WebFormControlElement& control_element : control_elements) {
+    if (!ambiguous_or_empty_names &&
+        control_element.nameForAutofill() != field_name) {
+      continue;
+    }
+
+    if (!control_element.hasHTMLTagName("input"))
       continue;
 
-    if (!control_elements[i].hasHTMLTagName("input"))
+    // Only fill saved passwords into password fields and usernames into text
+    // fields.
+    const blink::WebInputElement input_element =
+        control_element.toConst<blink::WebInputElement>();
+    if (input_element.isPasswordField() != is_password_field)
       continue;
 
+    // For change password form with ambiguous or empty names keep only the
+    // first password field having |autocomplete='current-password'| attribute
+    // set. Also make sure we avoid keeping password fields having
+    // |autocomplete='new-password'| attribute set.
+    if (ambiguous_and_multiple_password_fields_with_autocomplete &&
+        !HasAutocompleteAttributeValue(input_element, "current-password")) {
+      continue;
+    }
+
     // Check for a non-unique match.
     if (found_input) {
+      // For change password form keep only the first password field entry.
+      if (does_password_field_has_ambigous_or_empty_name)
+        continue;
+
       found_input = false;
       break;
     }
 
-    // Only fill saved passwords into password fields and usernames into
-    // text fields.
-    const blink::WebInputElement input_element =
-        control_elements[i].toConst<blink::WebInputElement>();
-    if (input_element.isPasswordField() !=
-        (field.form_control_type == "password"))
-      continue;
-
-    (*result)[field.name] = input_element;
+    (*result)[field_name] = input_element;
     found_input = true;
   }
 
   // A required element was not found. This is not the right form.
   // Make sure no input elements from a partially matched form in this
   // iteration remain in the result set.
   // Note: clear will remove a reference from each InputElement.
   if (!found_input) {
     result->clear();
     return false;
@@ skipping 41 matching lines @@
 
   return group_name !=
          kFillOnAccountSelectFieldTrialEnabledWithNoHighlightGroup;
 }
 
 // Helper to search through |control_elements| for the specified input elements
 // in |data|, and add results to |result|.
 bool FindFormInputElements(
     const std::vector<blink::WebFormControlElement>& control_elements,
     const PasswordFormFillData& data,
+    bool ambiguous_or_empty_names,
     FormInputElementMap* result) {
-  return FindFormInputElement(control_elements, data.password_field, result) &&
+  return FindFormInputElement(control_elements, data.password_field,
+                              ambiguous_or_empty_names, result) &&
          (!FillDataContainsFillableUsername(data) ||
-          FindFormInputElement(control_elements, data.username_field, result));
+          FindFormInputElement(control_elements, data.username_field,
+                               ambiguous_or_empty_names, result));
 }
 
 // Helper to locate form elements identified by |data|.
 void FindFormElements(content::RenderFrame* render_frame,
                       const PasswordFormFillData& data,
+                      bool ambiguous_or_empty_names,
                       FormElementsList* results) {
   DCHECK(results);
 
   blink::WebDocument doc = render_frame->GetWebFrame()->document();
   if (!doc.isHTMLDocument())
     return;
 
   if (data.origin != GetCanonicalOriginForDocument(doc))
     return;
 
   blink::WebVector<blink::WebFormElement> forms;
   doc.forms(forms);
 
   for (size_t i = 0; i < forms.size(); ++i) {
     blink::WebFormElement fe = forms[i];
 
     // Action URL must match.
     if (data.action != GetCanonicalActionForForm(fe))
       continue;
 
     std::vector<blink::WebFormControlElement> control_elements =
         ExtractAutofillableElementsInForm(fe);
     FormInputElementMap cur_map;
-    if (FindFormInputElements(control_elements, data, &cur_map))
+    if (FindFormInputElements(control_elements, data, ambiguous_or_empty_names,
+                              &cur_map))
       results->push_back(cur_map);
   }
   // If the element to be filled are not in a <form> element, the "action" and
   // origin should be the same.
   if (data.action != data.origin)
     return;
 
   std::vector<blink::WebFormControlElement> control_elements =
       GetUnownedAutofillableFormFieldElements(doc.all(), nullptr);
   FormInputElementMap unowned_elements_map;
-  if (FindFormInputElements(control_elements, data, &unowned_elements_map))
+  if (FindFormInputElements(control_elements, data, ambiguous_or_empty_names,
+                            &unowned_elements_map))
     results->push_back(unowned_elements_map);
 }
 
 bool IsElementEditable(const blink::WebInputElement& element) {
   return element.isEnabled() && !element.isReadOnly();
 }
 
 bool DoUsernamesMatch(const base::string16& username1,
                       const base::string16& username2,
                       bool exact_match) {
   if (exact_match)
     return username1 == username2;
   return FieldIsSuggestionSubstringStartingOnTokenBoundary(username1, username2,
                                                            true);
 }
 
 // Returns |true| if the given element is editable. Otherwise, returns |false|.
 bool IsElementAutocompletable(const blink::WebInputElement& element) {
   return IsElementEditable(element);
 }
 
 // Return true if either password_value or new_password_value is not empty and
-// not default.i
+// not default.
 bool FormContainsNonDefaultPasswordValue(const PasswordForm& password_form) {
   return (!password_form.password_value.empty() &&
           !password_form.password_value_is_default) ||
       (!password_form.new_password_value.empty() &&
        !password_form.new_password_value_is_default);
 }
 
 // Log a message including the name, method and action of |form|.
 void LogHTMLForm(SavePasswordProgressLogger* logger,
                  SavePasswordProgressLogger::StringID message_id,
@@ skipping 187 matching lines @@
     if (!bottom_frame_origin.equals(cur_frame->securityOrigin().toString()))
       return false;
   }
 
   // If we can't modify the password, don't try to set the username
   if (!IsElementAutocompletable(password_element))
     return false;
 
   bool form_contains_fillable_username_field =
       FillDataContainsFillableUsername(fill_data);
+  bool ambiguous_or_empty_names =
+      DoesFormContainAmbiguousOrEmptyNames(fill_data);
+  base::string16 username_field_name;
+  if (form_contains_fillable_username_field)
+    username_field_name =
+        FieldName(fill_data.username_field, ambiguous_or_empty_names);
+
   // If the form contains an autocompletable username field, try to set the
   // username to the preferred name, but only if:
   //   (a) The fill-on-account-select flag is not set, and
   //   (b) The username element isn't prefilled
   //
   // If (a) is false, then just mark the username element as autofilled if the
   // user is not in the "no highlighting" group and return so the fill step is
   // skipped.
   //
   // If there is no autocompletable username field, and (a) is false, then the
   // username element cannot be autofilled, but the user should still be able to
   // select to fill the password element, so the password element must be marked
   // as autofilled and the fill step should also be skipped if the user is not
   // in the "no highlighting" group.
   //
   // In all other cases, do nothing.
-  bool form_has_fillable_username = form_contains_fillable_username_field &&
+  bool form_has_fillable_username = !username_field_name.empty() &&
                                     IsElementAutocompletable(username_element);
 
   if (ShouldFillOnAccountSelect()) {
     if (!ShouldHighlightFields()) {
       return false;
     }
 
     if (form_has_fillable_username) {
       username_element.setAutofilled(true);
     } else if (username_element.isNull() ||
@@ skipping 373 matching lines @@
     return false;
 
   // If autocomplete='off' is set on the form elements, no suggestion dialog
   // should be shown. However, return |true| to indicate that this is a known
   // password form and that the request to show suggestions has been handled (as
   // a no-op).
   if (!element.isTextField() || !IsElementAutocompletable(element) ||
       !IsElementAutocompletable(password_info->password_field))
     return true;
 
-  if (element.nameForAutofill().isEmpty())
+  if (element.nameForAutofill().isEmpty() &&
+      !DoesFormContainAmbiguousOrEmptyNames(password_info->fill_data)) {
     return false;  // If the field has no name, then we won't have values.
+  }
 
   // Don't attempt to autofill with values that are too large.
   if (element.value().length() > kMaximumTextSizeForAutocomplete)
     return false;
 
   bool username_is_available =
       !username_element->isNull() && IsElementEditable(*username_element);
   // If the element is a password field, a popup should only be shown if there
   // is no username or the corresponding username element is not editable since
   // it is only in that case that the username element does not have a
@@ skipping 351 matching lines @@
   }
 
   // This is a new navigation, so require a new user gesture before filling in
   // passwords.
   gatekeeper_.Reset();
 }
 
 void PasswordAutofillAgent::OnFillPasswordForm(
     int key,
     const PasswordFormFillData& form_data) {
-
+  bool ambiguous_or_empty_names =
+      DoesFormContainAmbiguousOrEmptyNames(form_data);
   FormElementsList forms;
-  FindFormElements(render_frame(), form_data, &forms);
+  FindFormElements(render_frame(), form_data, ambiguous_or_empty_names, &forms);
   FormElementsList::iterator iter;
   for (iter = forms.begin(); iter != forms.end(); ++iter) {
     // Attach autocomplete listener to enable selecting alternate logins.
     blink::WebInputElement username_element, password_element;
 
-    // Check whether the password form has a username input field.
+    base::string16 username_field_name, password_field_name;
+    password_field_name =
+        FieldName(form_data.password_field, ambiguous_or_empty_names);
     bool form_contains_fillable_username_field =
         FillDataContainsFillableUsername(form_data);
-    if (form_contains_fillable_username_field) {
-      username_element =
-          (*iter)[form_data.username_field.name];
+    if (form_contains_fillable_username_field)
+      username_field_name =
+          FieldName(form_data.username_field, ambiguous_or_empty_names);
+
+    // Check whether the password form has a username input field.
+    if (!username_field_name.empty()) {
+      username_element = (*iter)[username_field_name];
     }
 
     // No password field, bail out.
-    if (form_data.password_field.name.empty())
+    if (password_field_name.empty())
       break;
 
     // We might have already filled this form if there are two <form> elements
     // with identical markup.
     if (login_to_password_info_.find(username_element) !=
         login_to_password_info_.end())
       continue;
 
     // Get pointer to password element. (We currently only support single
     // password forms).
-    password_element = (*iter)[form_data.password_field.name];
+    password_element = (*iter)[password_field_name];
 
     // If wait_for_username is true, we don't want to initially fill the form
     // until the user types in a valid username.
     if (!form_data.wait_for_username) {
       FillFormOnPasswordReceived(
           form_data,
           username_element,
           password_element,
           &nonscript_modified_values_,
           base::Bind(&PasswordValueGatekeeper::RegisterElement,
@@ skipping 200 matching lines @@
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::DidStopLoading() {
   agent_->DidStopLoading();
 }
 
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::
     DidStartProvisionalLoad(blink::WebLocalFrame* navigated_frame) {
   agent_->LegacyDidStartProvisionalLoad(navigated_frame);
 }
 
 }  // namespace autofill