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

components/autofill/content/renderer/form_autofill_util.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/form_autofill_util.h"
 
 #include <map>
 #include <set>
 
 #include "base/command_line.h"
@@ skipping 940 matching lines @@
 
 // Extracts the fields from |control_elements| with |extract_mask| to
 // |form_fields|. The extracted fields are also placed in |element_map|.
 // |form_fields| and |element_map| should start out empty.
 // |fields_extracted| should have as many elements as |control_elements|,
 // initialized to false.
 // Returns true if the number of fields extracted is within
 // [1, kMaxParseableFields].
 bool ExtractFieldsFromControlElements(
     const WebVector<WebFormControlElement>& control_elements,
+    const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     ExtractMask extract_mask,
     ScopedVector<FormFieldData>* form_fields,
     std::vector<bool>* fields_extracted,
     std::map<WebFormControlElement, FormFieldData*>* element_map) {
   DCHECK(form_fields->empty());
   DCHECK(element_map->empty());
   DCHECK_EQ(control_elements.size(), fields_extracted->size());
 
   for (size_t i = 0; i < control_elements.size(); ++i) {
     const WebFormControlElement& control_element = control_elements[i];
 
     if (!IsAutofillableElement(control_element))
       continue;
 
     // Create a new FormFieldData, fill it out and map it to the field's name.
     FormFieldData* form_field = new FormFieldData;
-    WebFormControlElementToFormField(control_element, extract_mask, form_field);
+    WebFormControlElementToFormField(control_element,
+                                     field_value_and_properties_map,
+                                     extract_mask, form_field);
     form_fields->push_back(form_field);
     (*element_map)[control_element] = form_field;
     (*fields_extracted)[i] = true;
 
     // To avoid overly expensive computation, we impose a maximum number of
     // allowable fields.
     if (form_fields->size() > kMaxParseableFields)
       return false;
   }
 
@@ skipping 66 matching lines @@
 // 1) |form_element| and an empty |fieldsets|.
 // or
 // 2) a NULL |form_element|.
 //
 // If |field| is not NULL, then |form_control_element| should be not NULL.
 bool FormOrFieldsetsToFormData(
     const blink::WebFormElement* form_element,
     const blink::WebFormControlElement* form_control_element,
     const std::vector<blink::WebElement>& fieldsets,
     const WebVector<WebFormControlElement>& control_elements,
+    const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     ExtractMask extract_mask,
     FormData* form,
     FormFieldData* field) {
   CR_DEFINE_STATIC_LOCAL(WebString, kLabel, ("label"));
 
   if (form_element)
     DCHECK(fieldsets.empty());
   if (field)
     DCHECK(form_control_element);
 
   // A map from a FormFieldData's name to the FormFieldData itself.
   std::map<WebFormControlElement, FormFieldData*> element_map;
 
   // The extracted FormFields. We use pointers so we can store them in
   // |element_map|.
   ScopedVector<FormFieldData> form_fields;
 
   // A vector of bools that indicate whether each field in the form meets the
   // requirements and thus will be in the resulting |form|.
   std::vector<bool> fields_extracted(control_elements.size(), false);
 
-  if (!ExtractFieldsFromControlElements(control_elements, extract_mask,
-                                        &form_fields, &fields_extracted,
-                                        &element_map)) {
+  if (!ExtractFieldsFromControlElements(
+          control_elements, field_value_and_properties_map, extract_mask,
+          &form_fields, &fields_extracted, &element_map)) {
     return false;
   }
 
   if (form_element) {
     // Loop through the label elements inside the form element.  For each label
     // element, get the corresponding form control element, use the form control
     // element's name as a key into the <name, FormFieldData> map to find the
     // previously created FormFieldData and set the FormFieldData's label to the
     // label.firstChild().nodeValue() of the label element.
     WebElementCollection labels =
@@ skipping 50 matching lines @@
   for (const auto* iter : form_fields)
     form->fields.push_back(*iter);
   return true;
 }
 
 bool UnownedFormElementsAndFieldSetsToFormData(
     const std::vector<blink::WebElement>& fieldsets,
     const std::vector<blink::WebFormControlElement>& control_elements,
     const blink::WebFormControlElement* element,
     const blink::WebDocument& document,
+    const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     ExtractMask extract_mask,
     FormData* form,
     FormFieldData* field) {
   form->origin = GetCanonicalOriginForDocument(document);
   form->is_form_tag = false;
 
-  return FormOrFieldsetsToFormData(nullptr, element, fieldsets,
-                                   control_elements, extract_mask, form, field);
+  return FormOrFieldsetsToFormData(
+      nullptr, element, fieldsets, control_elements,
+      field_value_and_properties_map, extract_mask, form, field);
 }
 
 GURL StripAuthAndParams(const GURL& gurl) {
   // We want to keep the path but strip any authentication data, as well as
   // query and ref portions of URL, for the form action and form origin.
   GURL::Replacements rep;
   rep.ClearUsername();
   rep.ClearPassword();
   rep.ClearQuery();
   rep.ClearRef();
   return gurl.ReplaceComponents(rep);
 }
 
 }  // namespace
 
 ScopedLayoutPreventer::ScopedLayoutPreventer() {
   DCHECK(!g_prevent_layout) << "Is any other instance of ScopedLayoutPreventer "
                                "alive in the same process?";
   g_prevent_layout = true;
 }
 
 ScopedLayoutPreventer::~ScopedLayoutPreventer() {
   DCHECK(g_prevent_layout) << "Is any other instance of ScopedLayoutPreventer "
                               "alive in the same process?";
   g_prevent_layout = false;
 }
 
 bool ExtractFormData(const WebFormElement& form_element, FormData* data) {
   return WebFormElementToFormData(
-      form_element, WebFormControlElement(),
+      form_element, WebFormControlElement(), nullptr,
       static_cast<form_util::ExtractMask>(form_util::EXTRACT_VALUE |
                                           form_util::EXTRACT_OPTION_TEXT |
                                           form_util::EXTRACT_OPTIONS),
       data, NULL);
 }
 
 bool IsFormVisible(blink::WebFrame* frame,
                    const GURL& canonical_action,
                    const GURL& canonical_origin,
                    const FormData& form_data) {
@@ skipping 21 matching lines @@
 
     GURL iter_canonical_action = GetCanonicalActionForForm(form);
 #if !defined(OS_ANDROID)
     bool form_action_is_empty = iter_canonical_action.is_empty() ||
                                 iter_canonical_action == frame_origin;
     if (action_is_empty != form_action_is_empty)
       continue;
 
     if (action_is_empty) {  // Both actions are empty, compare all fields.
       FormData extracted_form_data;
-      WebFormElementToFormData(form, WebFormControlElement(), EXTRACT_NONE,
-                               &extracted_form_data, nullptr);
+      WebFormElementToFormData(form, WebFormControlElement(), nullptr,
+                               EXTRACT_NONE, &extracted_form_data, nullptr);
       if (form_data.SameFormAs(extracted_form_data)) {
         return true;  // Form still exists.
       }
     } else {  // Both actions are non-empty, compare actions only.
       if (canonical_action == iter_canonical_action) {
         return true;  // Form still exists.
       }
     }
 #else  // OS_ANDROID
     if (canonical_action == iter_canonical_action) {
@@ skipping 101 matching lines @@
 }
 
 std::vector<WebFormControlElement> ExtractAutofillableElementsInForm(
     const WebFormElement& form_element) {
   WebVector<WebFormControlElement> control_elements;
   form_element.getFormControlElements(control_elements);
 
   return ExtractAutofillableElementsFromSet(control_elements);
 }
 
-void WebFormControlElementToFormField(const WebFormControlElement& element,
-                                      ExtractMask extract_mask,
-                                      FormFieldData* field) {
+void WebFormControlElementToFormField(
+    const WebFormControlElement& element,
+    const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
+    ExtractMask extract_mask,
+    FormFieldData* field) {
   DCHECK(field);
   DCHECK(!element.isNull());
   CR_DEFINE_STATIC_LOCAL(WebString, kAutocomplete, ("autocomplete"));
   CR_DEFINE_STATIC_LOCAL(WebString, kRole, ("role"));
   CR_DEFINE_STATIC_LOCAL(WebString, kPlaceholder, ("placeholder"));
   CR_DEFINE_STATIC_LOCAL(WebString, kClass, ("class"));
 
   // The label is not officially part of a WebFormControlElement; however, the
   // labels for all form control elements are scraped from the DOM and set in
   // WebFormElementToFormData.
   field->name = element.nameForAutofill();
   field->form_control_type = element.formControlType().utf8();
   field->autocomplete_attribute = element.getAttribute(kAutocomplete).utf8();
   if (field->autocomplete_attribute.size() > kMaxDataLength) {
     // Discard overly long attribute values to avoid DOS-ing the browser
     // process.  However, send over a default string to indicate that the
     // attribute was present.
     field->autocomplete_attribute = "x-max-data-length-exceeded";
   }
   if (base::LowerCaseEqualsASCII(
           base::StringPiece16(element.getAttribute(kRole)), "presentation"))
     field->role = FormFieldData::ROLE_ATTRIBUTE_PRESENTATION;
 
   field->placeholder = element.getAttribute(kPlaceholder);
   if (element.hasAttribute(kClass))
     field->css_classes = element.getAttribute(kClass);
 
+  if (field_value_and_properties_map) {
+    FieldValueAndPropertiesMaskMap::const_iterator it =
+        field_value_and_properties_map->find(element);
+    if (it != field_value_and_properties_map->end())
+      field->properties_mask = it->second.second;
+  }
+
   if (!IsAutofillableElement(element))
     return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
   if (IsAutofillableInputElement(input_element) ||
       IsTextAreaElement(element) ||
       IsSelectElement(element)) {
     field->is_autofilled = element.isAutofilled();
     if (!g_prevent_layout)
       field->is_focusable = element.isFocusable();
@@ skipping 50 matching lines @@
   // Constrain the maximum data length to prevent a malicious site from DOS'ing
   // the browser: http://crbug.com/49332
   TruncateString(&value, kMaxDataLength);
 
   field->value = value;
 }
 
 bool WebFormElementToFormData(
     const blink::WebFormElement& form_element,
     const blink::WebFormControlElement& form_control_element,
+    const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     ExtractMask extract_mask,
     FormData* form,
     FormFieldData* field) {
   const WebFrame* frame = form_element.document().frame();
   if (!frame)
     return false;
 
   form->name = GetFormIdentifier(form_element);
   form->origin = GetCanonicalOriginForDocument(frame->document());
   form->action = frame->document().completeURL(form_element.action());
 
   // If the completed URL is not valid, just use the action we get from
   // WebKit.
   if (!form->action.is_valid())
     form->action = GURL(blink::WebStringToGURL(form_element.action()));
 
   WebVector<WebFormControlElement> control_elements;
   form_element.getFormControlElements(control_elements);
 
   std::vector<blink::WebElement> dummy_fieldset;
-  return FormOrFieldsetsToFormData(&form_element, &form_control_element,
-                                   dummy_fieldset, control_elements,
-                                   extract_mask, form, field);
+  return FormOrFieldsetsToFormData(
+      &form_element, &form_control_element, dummy_fieldset, control_elements,
+      field_value_and_properties_map, extract_mask, form, field);
 }
 
 std::vector<WebFormControlElement> GetUnownedFormFieldElements(
     const WebElementCollection& elements,
     std::vector<WebElement>* fieldsets) {
   std::vector<WebFormControlElement> unowned_fieldset_children;
   for (WebElement element = elements.firstItem();
        !element.isNull();
        element = elements.nextItem()) {
     if (element.isFormControlElement()) {
@@ skipping 32 matching lines @@
 
   // For now this restriction only applies to English-language pages, because
   // the keywords are not translated. Note that an empty "lang" attribute
   // counts as English.
   std::string lang;
   if (!html_element.isNull())
     lang = html_element.getAttribute("lang").utf8();
   if (!lang.empty() &&
       !base::StartsWith(lang, "en", base::CompareCase::INSENSITIVE_ASCII)) {
     return UnownedFormElementsAndFieldSetsToFormData(
-        fieldsets, control_elements, element, document, extract_mask, form,
-        field);
+        fieldsets, control_elements, element, document, nullptr, extract_mask,
+        form, field);
   }
 
   // A potential problem is that this only checks document.title(), but should
   // actually check the main frame's title. Thus it may make bad decisions for
   // iframes.
   base::string16 title(base::ToLowerASCII(base::string16(document.title())));
 
   // Don't check the path for url's without a standard format path component,
   // such as data:.
   std::string path;
@@ skipping 13 matching lines @@
   for (const auto* keyword : kKeywords) {
     // Compare char16 elements of |title| with char elements of |keyword| using
     // operator==.
     auto title_pos = std::search(title.begin(), title.end(),
                                  keyword, keyword + strlen(keyword));
     if (title_pos != title.end() ||
         path.find(keyword) != std::string::npos) {
       form->is_formless_checkout = true;
       // Found a keyword: treat this as an unowned form.
       return UnownedFormElementsAndFieldSetsToFormData(
-          fieldsets, control_elements, element, document, extract_mask, form,
-          field);
+          fieldsets, control_elements, element, document, nullptr, extract_mask,
+          form, field);
     }
   }
 
   // Since it's not a checkout flow, only add fields that have a non-"off"
   // autocomplete attribute to the formless autofill.
   CR_DEFINE_STATIC_LOCAL(WebString, kOffAttribute, ("off"));
   std::vector<WebFormControlElement> elements_with_autocomplete;
   for (const WebFormControlElement& element : control_elements) {
     blink::WebString autocomplete = element.getAttribute("autocomplete");
     if (autocomplete.length() && autocomplete != kOffAttribute)
       elements_with_autocomplete.push_back(element);
   }
 
   if (elements_with_autocomplete.empty())
     return false;
 
   return UnownedFormElementsAndFieldSetsToFormData(
-      fieldsets, elements_with_autocomplete, element, document, extract_mask,
-      form, field);
+      fieldsets, elements_with_autocomplete, element, document, nullptr,
+      extract_mask, form, field);
 }
 
 bool UnownedPasswordFormElementsAndFieldSetsToFormData(
     const std::vector<blink::WebElement>& fieldsets,
     const std::vector<blink::WebFormControlElement>& control_elements,
     const blink::WebFormControlElement* element,
     const blink::WebDocument& document,
+    const FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     ExtractMask extract_mask,
     FormData* form,
     FormFieldData* field) {
   return UnownedFormElementsAndFieldSetsToFormData(
-      fieldsets, control_elements, element, document, extract_mask, form,
-      field);
+      fieldsets, control_elements, element, document,
+      field_value_and_properties_map, extract_mask, form, field);
 }
 
 
 bool FindFormAndFieldForFormControlElement(const WebFormControlElement& element,
                                            FormData* form,
                                            FormFieldData* field) {
   if (!IsAutofillableElement(element))
     return false;
 
   ExtractMask extract_mask =
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
   const WebFormElement form_element = element.form();
   if (form_element.isNull()) {
     // No associated form, try the synthetic form for unowned form elements.
     WebDocument document = element.document();
     std::vector<WebElement> fieldsets;
     std::vector<WebFormControlElement> control_elements =
         GetUnownedAutofillableFormFieldElements(document.all(), &fieldsets);
     return UnownedCheckoutFormElementsAndFieldSetsToFormData(
         fieldsets, control_elements, &element, document, extract_mask,
         form, field);
   }
 
-  return WebFormElementToFormData(form_element,
-                                  element,
-                                  extract_mask,
-                                  form,
-                                  field);
+  return WebFormElementToFormData(form_element, element, nullptr, extract_mask,
+                                  form, field);
 }
 
 void FillForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull()) {
     ForEachMatchingUnownedFormField(element,
                                     form,
                                     FILTER_ALL_NON_EDITABLE_ELEMENTS,
                                     false, /* dont force override */
                                     &FillFormField);
@@ skipping 153 matching lines @@
     // Zero selection start is for password manager, which can show usernames
     // that do not begin with the user input value.
     selection_start = (offset == base::string16::npos) ? 0 : offset;
   }
 
   input_element->setSelectionRange(selection_start, suggestion.length());
 }
 
 }  // namespace form_util
 }  // namespace autofill