Remove --respect-autocomplete-off-autofill flag.

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 45 matching lines @@
 enum FieldFilterMask {
   FILTER_NONE                      = 0,
   FILTER_DISABLED_ELEMENTS         = 1 << 0,
   FILTER_READONLY_ELEMENTS         = 1 << 1,
   FILTER_NON_FOCUSABLE_ELEMENTS    = 1 << 2,
   FILTER_ALL_NON_EDITABLE_ELEMENTS = FILTER_DISABLED_ELEMENTS |
                                      FILTER_READONLY_ELEMENTS |
                                      FILTER_NON_FOCUSABLE_ELEMENTS,
 };
 
-RequirementsMask ExtractionRequirements() {
-  return base::CommandLine::ForCurrentProcess()->HasSwitch(
-             switches::kRespectAutocompleteOffForAutofill)
-             ? REQUIRE_AUTOCOMPLETE
-             : REQUIRE_NONE;
-}
-
 void TruncateString(base::string16* str, size_t max_length) {
   if (str->length() > max_length)
     str->resize(max_length);
 }
 
 bool IsOptionElement(const WebElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kOption, ("option"));
   return element.hasHTMLTagName(kOption);
 }
 
@@ skipping 54 matching lines @@
 
   std::string tag_name = node.toConst<WebElement>().tagName().utf8();
   return (tag_name == "DD" ||
           tag_name == "DIV" ||
           tag_name == "FIELDSET" ||
           tag_name == "LI" ||
           tag_name == "TD" ||
           tag_name == "TABLE");
 }
 
-// Check whether the given field satisfies the REQUIRE_AUTOCOMPLETE requirement.
-bool SatisfiesRequireAutocomplete(const WebInputElement& input_element) {
-  return input_element.autoComplete();
-}
-
 // Returns the colspan for a <td> / <th>. Defaults to 1.
 size_t CalculateTableCellColumnSpan(const WebElement& element) {
   DCHECK(element.hasHTMLTagName("td") || element.hasHTMLTagName("th"));
 
   size_t span = 1;
   if (element.hasAttribute("colspan")) {
     base::string16 colspan = element.getAttribute("colspan");
     // Do not check return value to accept imperfect conversions.
     base::StringToSizeT(colspan, &span);
     // Handle overflow.
@@ skipping 620 matching lines @@
 
 // For each autofillable field in |data| that matches a field in the |form|,
 // the |callback| is invoked with the corresponding |form| field data.
 void ForEachMatchingFormField(const WebFormElement& form_element,
                               const WebElement& initiating_element,
                               const FormData& data,
                               FieldFilterMask filters,
                               bool force_override,
                               const Callback& callback) {
   std::vector<WebFormControlElement> control_elements =
-      ExtractAutofillableElementsInForm(form_element, ExtractionRequirements());
+      ExtractAutofillableElementsInForm(form_element);
   ForEachMatchingFormFieldCommon(&control_elements, initiating_element, data,
                                  filters, force_override, callback);
 }
 
 // For each autofillable field in |data| that matches a field in the set of
 // unowned autofillable form fields, the |callback| is invoked with the
 // corresponding |data| field.
 void ForEachMatchingUnownedFormField(const WebElement& initiating_element,
                                      const FormData& data,
                                      FieldFilterMask filters,
@@ skipping 101 matching lines @@
   for (size_t i = 0; i < length; ++i) {
     const blink::WebNode& item = children.item(i);
     if (IsWebNodeVisibleImpl(item, depth - 1))
       return true;
   }
   return false;
 }
 
 bool ExtractFieldsFromControlElements(
     const WebVector<WebFormControlElement>& control_elements,
-    RequirementsMask requirements,
     ExtractMask extract_mask,
     ScopedVector<FormFieldData>* form_fields,
     std::vector<bool>* fields_extracted,
     std::map<WebFormControlElement, FormFieldData*>* element_map) {
   for (size_t i = 0; i < control_elements.size(); ++i) {
     const WebFormControlElement& control_element = control_elements[i];
 
     if (!IsAutofillableElement(control_element))
       continue;
 
-    const WebInputElement* input_element = toWebInputElement(&control_element);
-    if (requirements & REQUIRE_AUTOCOMPLETE &&
-        IsAutofillableInputElement(input_element) &&
-        !SatisfiesRequireAutocomplete(*input_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);
     form_fields->push_back(form_field);
     (*element_map)[control_element] = form_field;
     (*fields_extracted)[i] = true;
   }
 
   // If we failed to extract any fields, give up.  Also, to avoid overly
   // expensive computation, we impose a maximum number of allowable fields.
@@ skipping 68 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,
-    RequirementsMask requirements,
     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, requirements,
-                                        extract_mask, &form_fields,
-                                        &fields_extracted, &element_map)) {
+  if (!ExtractFieldsFromControlElements(control_elements, 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 88 matching lines @@
 
 bool IsWebNodeVisible(const blink::WebNode& node) {
   // In the bug http://crbug.com/237216 the form's bounding box is empty
   // however the form has non empty children. Thus we need to look at the
   // form's children.
   int kNodeSearchDepth = 2;
   return IsWebNodeVisibleImpl(node, kNodeSearchDepth);
 }
 
 std::vector<blink::WebFormControlElement> ExtractAutofillableElementsFromSet(
-    const WebVector<WebFormControlElement>& control_elements,
-    RequirementsMask requirements) {
+    const WebVector<WebFormControlElement>& control_elements) {
   std::vector<blink::WebFormControlElement> autofillable_elements;
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebFormControlElement element = control_elements[i];
     if (!IsAutofillableElement(element))
       continue;
 
-    if (requirements & REQUIRE_AUTOCOMPLETE) {
-      // TODO(isherman): WebKit currently doesn't handle the autocomplete
-      // attribute for select or textarea elements, but it probably should.
-      const WebInputElement* input_element =
-          toWebInputElement(&control_elements[i]);
-      if (IsAutofillableInputElement(input_element) &&
-          !SatisfiesRequireAutocomplete(*input_element))
-        continue;
-    }
-
     autofillable_elements.push_back(element);
   }
   return autofillable_elements;
 }
 
 std::vector<WebFormControlElement> ExtractAutofillableElementsInForm(
-    const WebFormElement& form_element,
-    RequirementsMask requirements) {
+    const WebFormElement& form_element) {
   WebVector<WebFormControlElement> control_elements;
   form_element.getFormControlElements(control_elements);
 
-  return ExtractAutofillableElementsFromSet(control_elements, requirements);
+  return ExtractAutofillableElementsFromSet(control_elements);
 }
 
 void WebFormControlElementToFormField(const WebFormControlElement& element,
                                       ExtractMask extract_mask,
                                       FormFieldData* field) {
   DCHECK(field);
   DCHECK(!element.isNull());
   CR_DEFINE_STATIC_LOCAL(WebString, kAutocomplete, ("autocomplete"));
   CR_DEFINE_STATIC_LOCAL(WebString, kRole, ("role"));
 
@@ skipping 67 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,
-    RequirementsMask requirements,
     ExtractMask extract_mask,
     FormData* form,
     FormFieldData* field) {
   const WebFrame* frame = form_element.document().frame();
   if (!frame)
     return false;
 
-  if (requirements & REQUIRE_AUTOCOMPLETE && !form_element.autoComplete())
-    return false;
-
   form->name = GetFormIdentifier(form_element);
   form->origin = frame->document().url();
   form->action = frame->document().completeURL(form_element.action());
   form->user_submitted = form_element.wasUserSubmitted();
 
   // If the completed URL is not valid, just use the action we get from
   // WebKit.
   if (!form->action.is_valid())
     form->action = GURL(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,
-                                   requirements, extract_mask, form, field);
+                                   extract_mask, form, field);
 }
 
 std::vector<WebFormControlElement>
 GetUnownedAutofillableFormFieldElements(
     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()) {
       WebFormControlElement control = element.to<WebFormControlElement>();
       if (control.form().isNull())
         unowned_fieldset_children.push_back(control);
     }
 
     if (fieldsets && element.hasHTMLTagName("fieldset") &&
         !IsElementInsideFormOrFieldSet(element)) {
       fieldsets->push_back(element);
     }
   }
-  return ExtractAutofillableElementsFromSet(unowned_fieldset_children,
-                                            REQUIRE_NONE);
+  return ExtractAutofillableElementsFromSet(unowned_fieldset_children);
 }
 
 bool UnownedFormElementsAndFieldSetsToFormData(
     const std::vector<blink::WebElement>& fieldsets,
     const std::vector<blink::WebFormControlElement>& control_elements,
     const blink::WebFormControlElement* element,
     const GURL& origin,
-    RequirementsMask requirements,
     ExtractMask extract_mask,
     FormData* form,
     FormFieldData* field) {
   form->origin = origin;
   form->user_submitted = false;
   form->is_form_tag = false;
 
   return FormOrFieldsetsToFormData(nullptr, element, fieldsets,
-                                   control_elements, requirements, extract_mask,
-                                   form, field);
+                                   control_elements, extract_mask, form, field);
 }
 
 bool FindFormAndFieldForFormControlElement(const WebFormControlElement& element,
                                            FormData* form,
-                                           FormFieldData* field,
-                                           RequirementsMask requirements) {
+                                           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 UnownedFormElementsAndFieldSetsToFormData(
-        fieldsets, control_elements, &element, document.url(), requirements,
-        extract_mask, form, field);
+        fieldsets, control_elements, &element, document.url(), extract_mask,
+        form, field);
   }
 
   return WebFormElementToFormData(form_element,
                                   element,
-                                  requirements,
                                   extract_mask,
                                   form,
                                   field);
 }
 
 void FillForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull()) {
     ForEachMatchingUnownedFormField(element,
                                     form,
@@ skipping 50 matching lines @@
 bool ClearPreviewedFormWithElement(const WebFormControlElement& element,
                                    bool was_autofilled) {
   WebFormElement form_element = element.form();
   std::vector<WebFormControlElement> control_elements;
   if (form_element.isNull()) {
     control_elements = GetUnownedAutofillableFormFieldElements(
         element.document().all(), nullptr);
     if (!IsElementInControlElementSet(element, control_elements))
       return false;
   } else {
-    control_elements = ExtractAutofillableElementsInForm(
-        form_element, ExtractionRequirements());
+    control_elements = ExtractAutofillableElementsInForm(form_element);
   }
 
   for (size_t i = 0; i < control_elements.size(); ++i) {
     // There might be unrelated elements in this form which have already been
     // auto-filled.  For example, the user might have already filled the address
     // part of a form and now be dealing with the credit card section.  We only
     // want to reset the auto-filled status for fields that were previewed.
     WebFormControlElement control_element = control_elements[i];
 
     // Only text input, textarea and select elements can be previewed.
@@ skipping 94 matching lines @@
 
 gfx::RectF GetScaledBoundingBox(float scale, WebElement* element) {
   gfx::Rect bounding_box(element->boundsInViewportSpace());
   return gfx::RectF(bounding_box.x() * scale,
                     bounding_box.y() * scale,
                     bounding_box.width() * scale,
                     bounding_box.height() * scale);
 }
 
 }  // namespace autofill