Revert of [Autofill Clean up] Revert changes introduced by Autocheckout to 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 36 matching lines @@
 using blink::WebNodeList;
 using blink::WebOptionElement;
 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,
+};
+
 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 391 matching lines @@
 // The callback type used by |ForEachMatchingFormField()|.
 typedef void (*Callback)(const FormFieldData&,
                          bool, /* is_initiating_element */
                          blink::WebFormControlElement*);
 
 // 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,
-                              bool only_focusable_elements,
+                              FieldFilterMask filters,
                               bool force_override,
                               Callback callback) {
   std::vector<WebFormControlElement> control_elements;
   ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
                               &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.
@@ skipping 22 matching lines @@
 
     // Only autofill empty fields and the field that initiated the filling,
     // i.e. the field the user is currently editing and interacting with.
     const WebInputElement* input_element = toWebInputElement(element);
     if (!force_override && !is_initiating_element &&
         ((IsAutofillableInputElement(input_element) ||
           IsTextAreaElement(*element)) &&
          !element->value().isEmpty()))
       continue;
 
-    if (!element->isEnabled() || element->isReadOnly() ||
-        (only_focusable_elements && !element->isFocusable()))
+    if (((filters & FILTER_DISABLED_ELEMENTS) && !element->isEnabled()) ||
+        ((filters & FILTER_READONLY_ELEMENTS) && element->isReadOnly()) ||
+        ((filters & FILTER_NON_FOCUSABLE_ELEMENTS) && !element->isFocusable()))
       continue;
 
     callback(data.fields[i], is_initiating_element, element);
   }
 }
 
 // Sets the |field|'s value to the value in |data|.
 // Also sets the "autofilled" attribute, causing the background to be yellow.
 void FillFormField(const FormFieldData& data,
                    bool is_initiating_node,
@@ skipping 459 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,
-                           true, /* only_focusable_elements */
-                           false, /* don't force override */
+                           FILTER_ALL_NON_EDITIABLE_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>(
+      FILTER_DISABLED_ELEMENTS | FILTER_READONLY_ELEMENTS);
+  ForEachMatchingFormField(form_element,
+                           WebInputElement(),
+                           form_data,
+                           filter_mask,
+                           true, /* force override */
+                           &FillFormField);
+}
+
+void FillFormForAllElements(const FormData& form_data,
+                            const WebFormElement& form_element) {
+  if (form_element.isNull())
+    return;
+
   ForEachMatchingFormField(form_element,
                            WebInputElement(),
                            form_data,
-                           false, /* only_focusable_elements */
+                           FILTER_NONE,
                            true, /* force override */
                            &FillFormField);
 }
 
 void PreviewForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return;
 
   ForEachMatchingFormField(form_element,
                            element,
                            form,
-                           true, /* only_focusable_elements */
+                           FILTER_ALL_NON_EDITIABLE_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;
 
@@ skipping 125 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