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

components/autofill/content/renderer/form_cache.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_cache.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
@@ skipping 78 matching lines @@
   bool log_deprecation_messages = parsed_forms_.empty();
 
   const ExtractMask extract_mask =
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
 
   size_t num_fields_seen = 0;
   for (size_t i = 0; i < web_forms.size(); ++i) {
     const WebFormElement& form_element = web_forms[i];
 
     std::vector<WebFormControlElement> control_elements =
-        ExtractAutofillableElementsInForm(form_element, REQUIRE_NONE);
+        ExtractAutofillableElementsInForm(form_element);
     size_t num_editable_elements =
         ScanFormControlElements(control_elements, log_deprecation_messages);
 
     if (ShouldIgnoreForm(num_editable_elements, control_elements.size()))
       continue;
 
     FormData form;
     if (!WebFormElementToFormData(form_element, WebFormControlElement(),
-                                  REQUIRE_NONE, extract_mask, &form, nullptr)) {
+                                  extract_mask, &form, nullptr)) {
       continue;
     }
 
     num_fields_seen += form.fields.size();
     if (num_fields_seen > kMaxParseableFields)
       return forms;
 
     if (form.fields.size() >= kRequiredAutofillFields &&
         !ContainsKey(parsed_forms_, form)) {
       forms.push_back(form);
       parsed_forms_.insert(form);
     }
   }
 
   // Look for more parseable fields outside of forms.
   std::vector<WebElement> fieldsets;
   std::vector<WebFormControlElement> control_elements =
       GetUnownedAutofillableFormFieldElements(document.all(), &fieldsets);
 
   size_t num_editable_elements =
       ScanFormControlElements(control_elements, log_deprecation_messages);
 
   if (ShouldIgnoreForm(num_editable_elements, control_elements.size()))
     return forms;
 
   FormData synthetic_form;
-  if (!UnownedFormElementsAndFieldSetsToFormData(fieldsets, control_elements,
-                                                 nullptr, document.url(),
-                                                 REQUIRE_NONE, extract_mask,
-                                                 &synthetic_form, nullptr)) {
+  if (!UnownedFormElementsAndFieldSetsToFormData(
+          fieldsets, control_elements, nullptr, document.url(), extract_mask,
+          &synthetic_form, nullptr)) {
     return forms;
   }
 
   num_fields_seen += synthetic_form.fields.size();
   if (num_fields_seen > kMaxParseableFields)
     return forms;
 
   if (synthetic_form.fields.size() >= kRequiredAutofillFields &&
       !parsed_forms_.count(synthetic_form)) {
     forms.push_back(synthetic_form);
@@ skipping 10 matching lines @@
   initial_checked_state_.clear();
 }
 
 bool FormCache::ClearFormWithElement(const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   std::vector<WebFormControlElement> control_elements;
   if (form_element.isNull()) {
     control_elements = GetUnownedAutofillableFormFieldElements(
         element.document().all(), nullptr);
   } else {
-    control_elements = ExtractAutofillableElementsInForm(
-        form_element, REQUIRE_NONE);
+    control_elements = ExtractAutofillableElementsInForm(form_element);
   }
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebFormControlElement control_element = control_elements[i];
     // Don't modify the value of disabled fields.
     if (!control_element.isEnabled())
       continue;
 
     // Don't clear field that was not autofilled
     if (!control_element.isAutofilled())
       continue;
@@ skipping 64 matching lines @@
       // we would have a way to uniquely identify the form cross-process. For
       // now, we'll check form name and form action for identity.
       // Also note that WebString() == WebString(string16()) does not evaluate
       // to |true| -- WebKit distinguishes between a "null" string (lhs) and
       // an "empty" string (rhs). We don't want that distinction, so forcing
       // to string16.
       base::string16 element_name = GetFormIdentifier(form_element);
       GURL action(form_element.document().completeURL(form_element.action()));
       if (element_name == form.data.name && action == form.data.action) {
         found_form = true;
-        control_elements =
-            ExtractAutofillableElementsInForm(form_element, REQUIRE_NONE);
+        control_elements = ExtractAutofillableElementsInForm(form_element);
         break;
       }
     }
 
     if (!found_form)
       return false;
   }
 
   if (control_elements.size() != form.fields.size()) {
     // Keep things simple.  Don't show predictions for forms that were modified
@@ skipping 51 matching lines @@
             std::make_pair(input_element, input_element.isChecked()));
       } else {
         ++num_editable_elements;
       }
     }
   }
   return num_editable_elements;
 }
 
 }  // namespace autofill