[Password Generation] Sends the flag whether a field has nonempty user input

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 332 matching lines @@
     } else {
       found_visible_username = true;
     }
   }
 }
 
 // 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 ModifiedValues* nonscript_modified_values,
-                     const FormsPredictionsMap* form_predictions) {
+bool GetPasswordForm(
+    const SyntheticForm& form,
+    PasswordForm* password_form,
+    const FieldValueAndPropertiesMaskMap* nonscript_modified_values,
+    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;
 
   // Bail if this is a GAIA passwords site reauthentication form, so that
   // the form will be ignored.
@@ skipping 164 matching lines @@
   }
 
   if (!username_element.isNull()) {
     password_form->username_element =
         FieldName(username_element, "anonymous_username");
     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()) {
-        base::string16 typed_username_value = username_iterator->second;
+        base::string16 typed_username_value = username_iterator->second.first;
         if (!base::StartsWith(
                 base::i18n::ToLower(username_value),
                 base::i18n::ToLower(typed_username_value),
                 base::CompareCase::SENSITIVE)) {
           // We check that |username_value| was not obtained by autofilling
           // |typed_username_value|. In case when it was, |typed_username_value|
           // is incomplete, so we should leave autofilled value.
           username_value = typed_username_value;
         }
       }
     }
     password_form->username_value = username_value;
   }
 
   password_form->origin =
       form_util::GetCanonicalOriginForDocument(form.document);
   GURL::Replacements rep;
   rep.SetPathStr("");
   password_form->signon_realm =
       password_form->origin.ReplaceComponents(rep).spec();
   password_form->other_possible_usernames.swap(other_possible_usernames);
 
   if (!password.isNull()) {
     password_form->password_element = FieldName(password, "anonymous_password");
     blink::WebString password_value = password.value();
     if (nonscript_modified_values != nullptr) {
       auto password_iterator = nonscript_modified_values->find(password);
       if (password_iterator != nonscript_modified_values->end())
-        password_value = password_iterator->second;
+        password_value = password_iterator->second.first;
     }
     password_form->password_value = password_value;
   }
   if (!new_password.isNull()) {
     password_form->new_password_element =
         FieldName(new_password, "anonymous_new_password");
     password_form->new_password_value = new_password.value();
     password_form->new_password_value_is_default =
         new_password.getAttribute("value") == new_password.value();
     if (HasAutocompleteAttributeValue(new_password, kAutocompleteNewPassword))
@@ skipping 58 matching lines @@
                                g_password_site_matcher.Get())) {
       has_continue_field = true;
     }
   }
 
   return has_rart_field && has_continue_field;
 }
 
 std::unique_ptr<PasswordForm> CreatePasswordFormFromWebForm(
     const WebFormElement& web_form,
-    const ModifiedValues* nonscript_modified_values,
+    const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     const FormsPredictionsMap* form_predictions) {
   if (web_form.isNull())
     return std::unique_ptr<PasswordForm>();
 
   std::unique_ptr<PasswordForm> password_form(new PasswordForm());
   password_form->action = form_util::GetCanonicalActionForForm(web_form);
   if (!password_form->action.is_valid())
     return std::unique_ptr<PasswordForm>();
 
   SyntheticForm synthetic_form;
   PopulateSyntheticFormFromWebForm(web_form, &synthetic_form);
 
   WebFormElementToFormData(web_form, blink::WebFormControlElement(),
+                           field_value_and_properties_map,
                            form_util::EXTRACT_NONE, &password_form->form_data,
                            NULL /* FormFieldData */);
 
   if (!GetPasswordForm(synthetic_form, password_form.get(),
-                       nonscript_modified_values, form_predictions))
+                       field_value_and_properties_map, form_predictions))
     return std::unique_ptr<PasswordForm>();
 
   return password_form;
 }
 
 std::unique_ptr<PasswordForm> CreatePasswordFormFromUnownedInputElements(
     const WebFrame& frame,
-    const ModifiedValues* nonscript_modified_values,
+    const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     const FormsPredictionsMap* form_predictions) {
   SyntheticForm synthetic_form;
   synthetic_form.control_elements = form_util::GetUnownedFormFieldElements(
       frame.document().all(), &synthetic_form.fieldsets);
   synthetic_form.document = frame.document();
 
   if (synthetic_form.control_elements.empty())
     return std::unique_ptr<PasswordForm>();
 
   std::unique_ptr<PasswordForm> password_form(new PasswordForm());
   UnownedPasswordFormElementsAndFieldSetsToFormData(
       synthetic_form.fieldsets, synthetic_form.control_elements, nullptr,
-      frame.document(), form_util::EXTRACT_NONE, &password_form->form_data,
-      nullptr /* FormFieldData */);
+      frame.document(), field_value_and_properties_map, form_util::EXTRACT_NONE,
+      &password_form->form_data, nullptr /* FormFieldData */);
   if (!GetPasswordForm(synthetic_form, password_form.get(),
-                       nonscript_modified_values, form_predictions))
+                       field_value_and_properties_map, form_predictions))
     return std::unique_ptr<PasswordForm>();
 
   // No actual action on the form, so use the the origin as the action.
   password_form->action = password_form->origin;
 
   return password_form;
 }
 
 bool HasAutocompleteAttributeValue(const blink::WebInputElement& element,
                                    const char* value_in_lowercase) {
   return base::LowerCaseEqualsASCII(
       base::StringPiece16(element.getAttribute("autocomplete")),
       value_in_lowercase);
 }
 
 }  // namespace autofill