[Password Manager] Send username correction votes

components/autofill/content/renderer/password_form_conversion_utils.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_form_conversion_utils.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 123 matching lines @@
   // test frame origin to match GAIA login page. Once this code gets moved to
   // browser, we need to add tests for this as well.
   blink::WebVector<blink::WebFormControlElement> web_control_elements;
   web_form.getFormControlElements(web_control_elements);
   synthetic_form->control_elements.assign(web_control_elements.begin(),
                                           web_control_elements.end());
   synthetic_form->action = web_form.action();
   synthetic_form->document = web_form.document();
 }
 
-// Helper function that removes |username_element.value()| from the vector
+// Helper function that removes |possible_username_pair| from the vector
 // |other_possible_usernames|, if the value presents in the vector.
 void ExcludeUsernameFromOtherUsernamesList(
-    const WebInputElement& username_element,
-    std::vector<base::string16>* other_possible_usernames) {
-  other_possible_usernames->erase(std::remove(other_possible_usernames->begin(),
-                                              other_possible_usernames->end(),
-                                              username_element.value().utf16()),
-                                  other_possible_usernames->end());
+    const PossibleUsernamePair& possible_username_pair,
+    PossibleUsernamesVector* other_possible_usernames) {
+  other_possible_usernames->erase(
+      std::remove(other_possible_usernames->begin(),
+                  other_possible_usernames->end(), possible_username_pair),
+      other_possible_usernames->end());
 }
 
 // Helper to determine which password is the main (current) one, and which is
 // the new password (e.g., on a sign-up or change password form), if any. If the
 // new password is found and there is another password field with the same user
 // input, the function also sets |confirmation_password| to this field.
 bool LocateSpecificPasswords(std::vector<WebInputElement> passwords,
                              WebInputElement* current_password,
                              WebInputElement* new_password,
                              WebInputElement* confirmation_password) {
@@ skipping 197 matching lines @@
     if (input_element->isPasswordField()) {
       *found_visible_password = true;
       *found_visible_username_before_visible_password = found_visible_username;
       break;
     } else {
       found_visible_username = true;
     }
   }
 }
 
+autofill::PossibleUsernamePair MakePossibleUsernamePair(
+    const blink::WebInputElement& input) {
+  return autofill::PossibleUsernamePair(input.value().utf16(),
+                                        input.nameForAutofill().utf16());
+}
+
 // Get information about a login form encapsulated in a PasswordForm struct.
 // If an element of |form| has an entry in |nonscript_modified_values|, the
 // associated string is used instead of the element's value to create
 // the PasswordForm.
 bool GetPasswordForm(
     const SyntheticForm& form,
     PasswordForm* password_form,
     const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     const FormsPredictionsMap* form_predictions) {
   WebInputElement latest_input_element;
   WebInputElement username_element;
   password_form->username_marked_by_site = false;
   std::vector<WebInputElement> passwords;
   std::map<blink::WebInputElement, blink::WebInputElement>
       last_text_input_before_password;
-  std::vector<base::string16> other_possible_usernames;
+  autofill::PossibleUsernamesVector other_possible_usernames;
 
   // Bail if this is a GAIA passwords site reauthentication form, so that
   // the form will be ignored.
   // TODO(msramek): Move this logic to the browser, and disable filling only
   // for the sync credential and if passwords are being synced.
   if (IsGaiaReauthenticationForm(GURL(form.document.url()).GetOrigin(),
                                  form.control_elements)) {
     return false;
   }
 
@@ skipping 79 matching lines @@
         if (password_form->username_marked_by_site) {
           // A second or subsequent element marked with autocomplete='username'.
           // This makes us less confident that we have understood the form. We
           // will stick to our choice that the first such element was the real
           // username, but will start collecting other_possible_usernames from
           // the extra elements marked with autocomplete='username'. Note that
           // unlike username_element, other_possible_usernames is used only for
           // autofill, not for form identification, and blank autofill entries
           // are not useful, so we do not collect empty strings.
           if (!input_element->value().isEmpty())
-            other_possible_usernames.push_back(input_element->value().utf16());
+            other_possible_usernames.push_back(
+                MakePossibleUsernamePair(*input_element));
         } else {
           // The first element marked with autocomplete='username'. Take the
           // hint and treat it as the username (overruling the tentative choice
           // we might have made before). Furthermore, drop all other possible
           // usernames we have accrued so far: they come from fields not marked
           // with the autocomplete attribute, making them unlikely alternatives.
           username_element = *input_element;
           password_form->username_marked_by_site = true;
           other_possible_usernames.clear();
         }
       } else {
         if (password_form->username_marked_by_site) {
           // Having seen elements with autocomplete='username', elements without
           // this attribute are no longer interesting. No-op.
         } else {
           // No elements marked with autocomplete='username' so far whatsoever.
           // If we have not yet selected a username element even provisionally,
           // then remember this element for the case when the next field turns
           // out to be a password. Save a non-empty username as a possible
           // alternative, at least for now.
           if (username_element.isNull())
             latest_input_element = *input_element;
           if (!input_element->value().isEmpty())
-            other_possible_usernames.push_back(input_element->value().utf16());
+            other_possible_usernames.push_back(
+                MakePossibleUsernamePair(*input_element));
         }
       }
     }
   }
 
   WebInputElement password;
   WebInputElement new_password;
   WebInputElement confirmation_password;
   if (!LocateSpecificPasswords(passwords, &password, &new_password,
                                &confirmation_password))
     return false;
 
   DCHECK_EQ(passwords.size(), last_text_input_before_password.size());
   if (username_element.isNull()) {
     if (!password.isNull())
       username_element = last_text_input_before_password[password];
     if (username_element.isNull() && !new_password.isNull())
       username_element = last_text_input_before_password[new_password];
     if (!username_element.isNull())
-      ExcludeUsernameFromOtherUsernamesList(username_element,
-                                            &other_possible_usernames);
+      ExcludeUsernameFromOtherUsernamesList(
+          MakePossibleUsernamePair(username_element),
+          &other_possible_usernames);
   }
 
   password_form->layout = SequenceToLayout(layout_sequence);
 
   WebInputElement predicted_username_element;
   bool map_has_username_prediction = MapContainsPrediction(
       predicted_elements, PREDICTION_USERNAME, &predicted_username_element);
 
   // Let server predictions override the selection of the username field. This
   // allows instant adjusting without changing Chromium code.
   auto username_element_iterator = predicted_elements.find(username_element);
   if (map_has_username_prediction &&
       (username_element_iterator == predicted_elements.end() ||
        username_element_iterator->second != PREDICTION_USERNAME)) {
-    ExcludeUsernameFromOtherUsernamesList(predicted_username_element,
-                                          &other_possible_usernames);
+    ExcludeUsernameFromOtherUsernamesList(
+        MakePossibleUsernamePair(predicted_username_element),
+        &other_possible_usernames);
     if (!username_element.isNull()) {
-      other_possible_usernames.push_back(username_element.value().utf16());
+      other_possible_usernames.push_back(
+          MakePossibleUsernamePair(username_element));
     }
     username_element = predicted_username_element;
     password_form->was_parsed_using_autofill_predictions = true;
   }
 
   if (!username_element.isNull()) {
     password_form->username_element =
         FieldName(username_element, "anonymous_username");
     base::string16 username_value = username_element.value().utf16();
     if (FieldHasNonscriptModifiedValue(field_value_and_properties_map,
@@ skipping 167 matching lines @@
                                    const char* value_in_lowercase) {
   base::string16 autocomplete_attribute(
       element.getAttribute("autocomplete").utf16());
   std::vector<std::string> tokens = LowercaseAndTokenizeAttributeString(
       base::UTF16ToUTF8(autocomplete_attribute));
 
   return base::ContainsValue(tokens, value_in_lowercase);
 }
 
 }  // namespace autofill