[Password manager] Relplace the FormFieldData vector from autofill::FormData with named fields…

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/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 43 matching lines @@
 // necessary form elements. To avoid having to look these up again when we want
 // to fill the form, the FindFormElements function stores the pointers
 // in a FormElements* result, referenced to ensure they are safe to use.
 struct FormElements {
   blink::WebFormElement form_element;
   FormInputElementMap input_elements;
 };
 
 typedef std::vector<FormElements*> FormElementsList;
 
+bool FillDataContainsUsername(const PasswordFormFillData& fill_data) {
+  return !fill_data.username_field.name.empty();
+}
+
 // Utility function to find the unique entry of the |form_element| 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(blink::WebFormElement* form_element,
                           const FormFieldData& field,
                           FormElements* result) {
   blink::WebVector<blink::WebNode> temp_elements;
   form_element->getNamedElements(field.name, temp_elements);
 
@@ skipping 37 matching lines @@
     result->input_elements.clear();
     return false;
   }
 
   return true;
 }
 
 // Helper to search the given form element for the specified input elements in
 // |data|, and add results to |result|.
 bool FindFormInputElements(blink::WebFormElement* form_element,
-                           const FormData& data,
+                           const PasswordFormFillData& data,
                            FormElements* result) {
-  const bool username_is_present = !data.fields[0].name.empty();
-
-  // Loop through the list of elements we need to find on the form in order to
-  // autofill it. If we don't find any one of them, abort processing this
-  // form; it can't be the right one.
-  // First field is the username, skip it if not present.
-  for (size_t j = (username_is_present ? 0 : 1); j < data.fields.size(); ++j) {
-    if (!FindFormInputElement(form_element, data.fields[j], result))
-      return false;
-  }
-
-  return true;
+  return FindFormInputElement(form_element, data.password_field, result) &&
+         (!FillDataContainsUsername(data) ||
+          FindFormInputElement(form_element, data.username_field, result));
 }
 
 // Helper to locate form elements identified by |data|.
 void FindFormElements(blink::WebView* view,
-                      const FormData& data,
+                      const PasswordFormFillData& data,
                       FormElementsList* results) {
   DCHECK(view);
   DCHECK(results);
   blink::WebFrame* main_frame = view->mainFrame();
   if (!main_frame)
     return;
 
   GURL::Replacements rep;
   rep.ClearQuery();
   rep.ClearRef();
@@ skipping 87 matching lines @@
 
 // Log a message including the name, method and action of |form|.
 void LogHTMLForm(SavePasswordProgressLogger* logger,
                  SavePasswordProgressLogger::StringID message_id,
                  const blink::WebFormElement& form) {
   logger->LogHTMLForm(message_id,
                       form.name().utf8(),
                       GURL(form.action().utf8()));
 }
 
-bool FillDataContainsUsername(const PasswordFormFillData& fill_data) {
-  return !fill_data.basic_data.fields[0].name.empty();
-}
-
 // Sets |suggestions_present| to true if there are any suggestions to be derived
 // from |fill_data|. Unless |show_all| is true, only considers suggestions with
 // usernames having |current_username| as a prefix. Returns true if a username
 // from the |fill_data.other_possible_usernames| would be included in the
 // suggestions.
 bool GetSuggestionsStats(const PasswordFormFillData& fill_data,
                          const base::string16& current_username,
                          bool show_all,
                          bool* suggestions_present) {
   *suggestions_present = false;
 
   for (const auto& usernames : fill_data.other_possible_usernames) {
     for (size_t i = 0; i < usernames.second.size(); ++i) {
       if (show_all ||
           StartsWith(usernames.second[i], current_username, false)) {
         *suggestions_present = true;
         return true;
       }
     }
   }
 
-  if (show_all || StartsWith(fill_data.basic_data.fields[0].value,
-                             current_username, false)) {
+  if (show_all ||
+      StartsWith(fill_data.username_field.value, current_username, false)) {
     *suggestions_present = true;
     return false;
   }
 
   for (const auto& login : fill_data.additional_logins) {
     if (show_all || StartsWith(login.first, current_username, false)) {
       *suggestions_present = true;
       return false;
     }
   }
@@ skipping 21 matching lines @@
   base::string16 current_username;
   if (!username_element->isNull()) {
     current_username = username_element->value();
   }
 
   // username and password will contain the match found if any.
   base::string16 username;
   base::string16 password;
 
   // Look for any suitable matches to current field text.
-  if (DoUsernamesMatch(fill_data.basic_data.fields[0].value,
-                       current_username,
+  if (DoUsernamesMatch(fill_data.username_field.value, current_username,
                        exact_username_match)) {
-    username = fill_data.basic_data.fields[0].value;
-    password = fill_data.basic_data.fields[1].value;
+    username = fill_data.username_field.value;
+    password = fill_data.password_field.value;
   } else {
     // Scan additional logins for a match.
     PasswordFormFillData::LoginCollection::const_iterator iter;
     for (iter = fill_data.additional_logins.begin();
          iter != fill_data.additional_logins.end();
          ++iter) {
       if (DoUsernamesMatch(
               iter->first, current_username, exact_username_match)) {
         username = iter->first;
         password = iter->second.password;
@@ skipping 75 matching lines @@
   if (!IsElementAutocompletable(password_element))
     return false;
 
   bool form_contains_username_field = FillDataContainsUsername(fill_data);
   // Try to set the username to the preferred name, but only if the field
   // can be set and isn't prefilled.
   if (form_contains_username_field &&
       IsElementAutocompletable(username_element) &&
       username_element.value().isEmpty()) {
     // TODO(tkent): Check maxlength and pattern.
-    username_element.setValue(fill_data.basic_data.fields[0].value, true);
+    username_element.setValue(fill_data.username_field.value, true);
   }
 
   // Fill if we have an exact match for the username. Note that this sets
   // username to autofilled.
   return FillUserNameAndPassword(&username_element,
                                  &password_element,
                                  fill_data,
                                  true /* exact_username_match */,
                                  false /* set_selection */,
                                  registration_callback);
@@ skipping 594 matching lines @@
     const PasswordFormFillData& form_data) {
   if (usernames_usage_ == NOTHING_TO_AUTOFILL) {
     if (form_data.other_possible_usernames.size())
       usernames_usage_ = OTHER_POSSIBLE_USERNAMES_PRESENT;
     else if (usernames_usage_ == NOTHING_TO_AUTOFILL)
       usernames_usage_ = OTHER_POSSIBLE_USERNAMES_ABSENT;
   }
 
   FormElementsList forms;
   // We own the FormElements* in forms.
-  FindFormElements(render_view()->GetWebView(), form_data.basic_data, &forms);
+  FindFormElements(render_view()->GetWebView(), form_data, &forms);
   FormElementsList::iterator iter;
   for (iter = forms.begin(); iter != forms.end(); ++iter) {
     scoped_ptr<FormElements> form_elements(*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.
     bool form_contains_username_field = FillDataContainsUsername(form_data);
     if (form_contains_username_field) {
       username_element =
-          form_elements->input_elements[form_data.basic_data.fields[0].name];
+          form_elements->input_elements[form_data.username_field.name];
     }
 
     // No password field, bail out.
-    if (form_data.basic_data.fields[1].name.empty())
+    if (form_data.password_field.name.empty())
       break;
 
     // Get pointer to password element. (We currently only support single
     // password forms).
     password_element =
-        form_elements->input_elements[form_data.basic_data.fields[1].name];
+        form_elements->input_elements[form_data.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 &&
         FillFormOnPasswordRecieved(
             form_data,
             username_element,
             password_element,
             base::Bind(&PasswordValueGatekeeper::RegisterElement,
                        base::Unretained(&gatekeeper_)))) {
@@ skipping 175 matching lines @@
   scoped_ptr<PasswordForm> password_form(CreatePasswordForm(form));
   if (!password_form || (restriction == RESTRICTION_NON_EMPTY_PASSWORD &&
                          password_form->password_value.empty() &&
                          password_form->new_password_value.empty())) {
     return;
   }
   provisionally_saved_forms_[frame].reset(password_form.release());
 }
 
 }  // namespace autofill