Prepare the infrastructure for password overrides.

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 <vector>
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
-#include "components/autofill/core/common/form_data_predictions.h"
 #include "components/autofill/core/common/password_form.h"
+#include "components/autofill/core/common/password_form_field_prediction_map.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/icu/source/i18n/unicode/regex.h"
 
 using blink::WebDocument;
 using blink::WebFormControlElement;
 using blink::WebFormElement;
 using blink::WebInputElement;
@@ skipping 148 matching lines @@
         *new_password = passwords[0];
       } else {
         // Three different passwords, or first and last match with middle
         // different. No idea which is which, so no luck.
         return false;
       }
   }
   return true;
 }
 
-void FindPredictedUsernameElement(
+void FindPredictedElements(
     const WebFormElement& form,
-    const std::map<autofill::FormData, autofill::FormFieldData>&
-        form_predictions,
+    const std::map<autofill::FormData,
+                   autofill::PasswordFormFieldPredictionMap>& form_predictions,
     WebVector<WebFormControlElement>* control_elements,
-    WebInputElement* predicted_username_element) {
+    std::map<autofill::PasswordFormFieldPredictionType, WebInputElement>*
+        predicted_elements) {
   FormData form_data;
   if (!WebFormElementToFormData(form, WebFormControlElement(), EXTRACT_NONE,
                                 &form_data, nullptr)) {
     return;
   }
 
   // Matching only requires that action and name of the form match to allow
   // the username to be updated even if the form is changed after page load.
   // See https://crbug.com/476092 for more details.
   auto predictions_iterator = form_predictions.begin();
   for (;predictions_iterator != form_predictions.end();
        ++predictions_iterator) {
     if (predictions_iterator->first.action == form_data.action &&
         predictions_iterator->first.name == form_data.name) {
       break;
     }
   }
 
   if (predictions_iterator == form_predictions.end())
     return;
 
   std::vector<blink::WebFormControlElement> autofillable_elements =
       ExtractAutofillableElementsFromSet(*control_elements);
 
-  const autofill::FormFieldData& username_field = predictions_iterator->second;
-  for (size_t i = 0; i < autofillable_elements.size(); ++i) {
-    if (autofillable_elements[i].nameForAutofill() == username_field.name) {
-      WebInputElement* input_element =
-          toWebInputElement(&autofillable_elements[i]);
-      if (input_element) {
-        *predicted_username_element = *input_element;
+  const autofill::PasswordFormFieldPredictionMap& field_predictions =
+      predictions_iterator->second;
+  for (autofill::PasswordFormFieldPredictionMap::const_iterator prediction =
+           field_predictions.begin();
+       prediction != field_predictions.end(); ++prediction) {
+    const autofill::PasswordFormFieldPredictionType& type = prediction->first;
+    const autofill::FormFieldData& target_field = prediction->second;
+
+    for (size_t i = 0; i < autofillable_elements.size(); ++i) {
+      if (autofillable_elements[i].nameForAutofill() == target_field.name) {
+        WebInputElement* input_element =
+            toWebInputElement(&autofillable_elements[i]);
+        if (input_element) {
+          (*predicted_elements)[type] = *input_element;
+        }
+        break;
       }
-      break;
     }
   }
 }
 
 // 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.
 void GetPasswordForm(
     const WebFormElement& form,
     PasswordForm* password_form,
     const std::map<const blink::WebInputElement, blink::WebString>*
         nonscript_modified_values,
-    const std::map<autofill::FormData, autofill::FormFieldData>*
+    const std::map<autofill::FormData,
+                   autofill::PasswordFormFieldPredictionMap>*
         form_predictions) {
   WebInputElement latest_input_element;
   WebInputElement username_element;
   password_form->username_marked_by_site = false;
   std::vector<WebInputElement> passwords;
   std::vector<base::string16> other_possible_usernames;
 
   WebVector<WebFormControlElement> control_elements;
   form.getFormControlElements(control_elements);
 
@@ skipping 82 matching lines @@
           if (username_element.isNull())
             latest_input_element = *input_element;
           if (!input_element->value().isEmpty())
             other_possible_usernames.push_back(input_element->value());
         }
       }
     }
   }
   password_form->layout = SequenceToLayout(layout_sequence);
 
-  WebInputElement predicted_username_element;
+  std::map<autofill::PasswordFormFieldPredictionType, WebInputElement>
+      predicted_elements;
   if (form_predictions) {
-    FindPredictedUsernameElement(form, *form_predictions, &control_elements,
-                                 &predicted_username_element);
+    FindPredictedElements(form, *form_predictions, &control_elements,
+                          &predicted_elements);
   }
   // Let server predictions override the selection of the username field. This
   // allows instant adjusting without changing Chromium code.
-  if (!predicted_username_element.isNull() &&
-      username_element != predicted_username_element) {
+  if (!predicted_elements[autofill::PREDICTION_USERNAME].isNull() &&
+      username_element != predicted_elements[autofill::PREDICTION_USERNAME]) {
     auto it =
         find(other_possible_usernames.begin(), other_possible_usernames.end(),
-             predicted_username_element.value());
+             predicted_elements[autofill::PREDICTION_USERNAME].value());
     if (it != other_possible_usernames.end())
       other_possible_usernames.erase(it);
     if (!username_element.isNull()) {
       other_possible_usernames.push_back(username_element.value());
     }
-    username_element = predicted_username_element;
+    username_element = predicted_elements[autofill::PREDICTION_USERNAME];
     password_form->was_parsed_using_autofill_predictions = true;
   }
 
   if (!username_element.isNull()) {
     password_form->username_element = username_element.nameForAutofill();
     base::string16 username_value = username_element.value();
     if (nonscript_modified_values != nullptr) {
       auto username_iterator =
         nonscript_modified_values->find(username_element);
       if (username_iterator != nonscript_modified_values->end()) {
@@ skipping 81 matching lines @@
 
 GURL GetCanonicalOriginForDocument(const WebDocument& document) {
   GURL full_origin(document.url());
   return StripAuthAndParams(full_origin);
 }
 
 scoped_ptr<PasswordForm> CreatePasswordForm(
     const WebFormElement& web_form,
     const std::map<const blink::WebInputElement, blink::WebString>*
         nonscript_modified_values,
-    const std::map<autofill::FormData, autofill::FormFieldData>*
+    const std::map<autofill::FormData,
+                   autofill::PasswordFormFieldPredictionMap>*
         form_predictions) {
   if (web_form.isNull())
     return scoped_ptr<PasswordForm>();
 
   scoped_ptr<PasswordForm> password_form(new PasswordForm());
   GetPasswordForm(web_form, password_form.get(), nonscript_modified_values,
                   form_predictions);
 
   if (!password_form->action.is_valid())
     return scoped_ptr<PasswordForm>();
 
   WebFormElementToFormData(web_form,
                            blink::WebFormControlElement(),
                            EXTRACT_NONE,
                            &password_form->form_data,
                            NULL /* FormFieldData */);
 
   return password_form.Pass();
 }
 
 }  // namespace autofill