Add a flag to ignore autocomplete="off" for Autofill.

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 "base/command_line.h"
 #include "base/logging.h"
@@ skipping 38 matching lines @@
 using blink::WebSelectElement;
 using blink::WebTextAreaElement;
 using blink::WebString;
 using blink::WebVector;
 
 namespace autofill {
 namespace {
 
 // A bit field mask for FillForm functions to not fill some fields.
 enum FieldFilterMask {
-  FILTER_NONE                       = 0,
-  FILTER_DISABLED_ELEMENTS          = 1 << 0,
-  FILTER_READONLY_ELEMENTS          = 1 << 1,
-  FILTER_NON_FOCUSABLE_ELEMENTS     = 1 << 2,
-  FILTER_ALL_NON_EDITIABLE_ELEMENTS = FILTER_DISABLED_ELEMENTS |
-                                      FILTER_READONLY_ELEMENTS |
-                                      FILTER_NON_FOCUSABLE_ELEMENTS,
+  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::kIgnoreAutocompleteOffForAutofill)
+             ? REQUIRE_NONE
+             : REQUIRE_AUTOCOMPLETE;
+}
+
 bool IsOptionElement(const WebElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kOption, ("option"));
   return element.hasHTMLTagName(kOption);
 }
 
 bool IsScriptElement(const WebElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kScript, ("script"));
   return element.hasHTMLTagName(kScript);
 }
 
@@ skipping 395 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,
                               Callback callback) {
   std::vector<WebFormControlElement> control_elements;
-  ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
-                              &control_elements);
+  ExtractAutofillableElements(
+      form_element, ExtractionRequirements(), &control_elements);
 
   if (control_elements.size() != data.fields.size()) {
     // This case should be reachable only for pathological websites and tests,
     // which add or remove form fields while the user is interacting with the
     // Autofill popup.
     return;
   }
 
   // It's possible that the site has injected fields into the form after the
   // page has loaded, so we can't assert that the size of the cached control
@@ skipping 499 matching lines @@
 }
 
 void FillForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return;
 
   ForEachMatchingFormField(form_element,
                            element,
                            form,
-                           FILTER_ALL_NON_EDITIABLE_ELEMENTS,
+                           FILTER_ALL_NON_EDITABLE_ELEMENTS,
                            false, /* dont force override */
                            &FillFormField);
 }
 
 void FillFormIncludingNonFocusableElements(const FormData& form_data,
                                            const WebFormElement& form_element) {
   if (form_element.isNull())
     return;
 
   FieldFilterMask filter_mask = static_cast<FieldFilterMask>(
@@ skipping 20 matching lines @@
 }
 
 void PreviewForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return;
 
   ForEachMatchingFormField(form_element,
                            element,
                            form,
-                           FILTER_ALL_NON_EDITIABLE_ELEMENTS,
+                           FILTER_ALL_NON_EDITABLE_ELEMENTS,
                            false, /* dont force override */
                            &PreviewFormField);
 }
 
 bool ClearPreviewedFormWithElement(const WebFormControlElement& element,
                                    bool was_autofilled) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
-  ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
-                              &control_elements);
+  ExtractAutofillableElements(
+      form_element, ExtractionRequirements(), &control_elements);
   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.
     WebInputElement* input_element = toWebInputElement(&control_element);
     if (!IsTextInput(input_element) &&
@@ skipping 38 matching lines @@
 
   return true;
 }
 
 bool FormWithElementIsAutofilled(const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
-  ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
-                              &control_elements);
+  ExtractAutofillableElements(
+      form_element, ExtractionRequirements(), &control_elements);
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebInputElement* input_element = toWebInputElement(&control_elements[i]);
     if (!IsAutofillableInputElement(input_element))
       continue;
 
     if (input_element->isAutofilled())
       return true;
   }
 
   return false;
@@ skipping 52 matching lines @@
 
 gfx::RectF GetScaledBoundingBox(float scale, WebFormControlElement* 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