Eliminate the use of autofill::REQUIRE_AUTOCOMPLETE [step 3 of 3].

components/autofill/ios/browser/resources/autofill_controller.js

 // 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.
 
 // Installs Autofill management functions on the |__gCrWeb| object.
 //
 // It scans the DOM, extracting and storing forms and returns a JSON string
 // representing an array of objects, each of which represents an Autofill form
 // with information about a form to be filled and/or submitted and it can be
 // translated to struct FormData
@@ skipping 53 matching lines @@
  * Google code project settings.
  *
  * This variable is from
  * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  *
  * @const {number}
  */
 __gCrWeb.autofill.MAX_PARSEABLE_FIELDS = 100;
 
 /**
- * A bit field mask for form or form element requirements for requirement
- * none.
- *
- * This variable is from enum RequirementsMask in
- * chromium/src/components/autofill/content/renderer/form_autofill_util.h
- *
- * @const {number}
- */
-__gCrWeb.autofill.REQUIREMENTS_MASK_NONE = 0;
-
-/**
- * A bit field mask for form or form element requirements for requirement
- * autocomplete != off.
- *
- * This variable is from enum RequirementsMask in
- * chromium/src/components/autofill/content/renderer/form_autofill_util.h
- *
- * @const {number}
- */
-__gCrWeb.autofill.REQUIREMENTS_MASK_REQUIRE_AUTOCOMPLETE = 1;
-
-/**
  * A bit field mask to extract data from WebFormControlElement for
  * extracting none value.
  *
  * This variable is from enum ExtractMask in
  * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  *
  * @const {number}
  */
 __gCrWeb.autofill.EXTRACT_MASK_NONE = 0;
 
@@ skipping 47 matching lines @@
 __gCrWeb.autofill.lastActiveElement = null;
 
 /**
  * Whether CSS for autofilled elements has been injected into the page.
  *
  * @type {boolean}
  */
 __gCrWeb.autofill.styleInjected = false;
 
 /**
- * Extracts fields from |controlElements| with |requirements| and |extractMask|
- * to |formFields|. The extracted fields are also placed in |elementArray|.
+ * Extracts fields from |controlElements| with |extractMask| to |formFields|.
+ * The extracted fields are also placed in |elementArray|.
  *
  * It is based on the logic in
  *     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)
  * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc
  *
- * TODO(thestig): Get rid of |requirements| to match the C++ version.
  * TODO(thestig): Make |element_map| a Map when Chrome makes iOS 8 and Safari 8
  *                part of the minimal requirements.
  *
  * @param {Array<FormControlElement>} controlElements The control elements that
  *     will be processed.
- * @param {number} requirements The requirement on control element
- *     autocompletion.
  * @param {number} extractMask Mask controls what data is extracted from
  *     controlElements.
  * @param {Array<AutofillFormFieldData>} formFields The extracted form fields.
  * @param {Array<boolean>} fieldsExtracted Indicates whether the fields were
  *     extracted.
  * @param {Array<?AutofillFormFieldData>} elementArray The extracted form
  *     fields or null if a particular control has no corresponding field.
  * @return {boolean} Whether there are fields and not too many fields in the
  *     form.
  */
-function extractFieldsFromControlElements_(controlElements, requirements,
-    extractMask, formFields, fieldsExtracted, elementArray) {
+function extractFieldsFromControlElements_(controlElements, extractMask,
+    formFields, fieldsExtracted, elementArray) {
   for (var i = 0; i < controlElements.length; ++i) {
     fieldsExtracted[i] = false;
     elementArray[i] = null;
 
     /** @type {FormControlElement} */
     var controlElement = controlElements[i];
     if (!__gCrWeb.autofill.isAutofillableElement(controlElement)) {
       continue;
     }
 
-    if ((requirements &
-            __gCrWeb.autofill.REQUIREMENTS_MASK_REQUIRE_AUTOCOMPLETE) &&
-        __gCrWeb.autofill.isAutofillableInputElement(controlElement) &&
-        !__gCrWeb.autofill.satisfiesRequireAutocomplete(
-            controlElement, false)) {
-      continue;
-    }
-
     // Create a new AutofillFormFieldData, fill it out and map it to the
     // field's name.
     var formField = new __gCrWeb['common'].JSONSafeObject;
     __gCrWeb.autofill.webFormControlElementToFormField(
         controlElement, extractMask, formField);
     formFields.push(formField);
     elementArray[i] = formField;
     fieldsExtracted[i] = true;
 
     // To avoid overly expensive computation, we impose a maximum number of
@@ skipping 114 matching lines @@
  * 1) |formElement|, |formControlElement| and an empty |fieldsets|.
  * or
  * 2) a non-empty |fieldsets|.
  *
  * It is based on the logic in
  *     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)
  * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc
  *
  * @param {HTMLFormElement} formElement The form element that will be processed.
  * @param {FormControlElement} formControlElement A control element in
  *     formElment, the FormField of which will be returned in field.
  * @param {Array<Element>} fieldsets The fieldsets to look through if
  *     formElement and formControlElement are not specified.
  * @param {Array<FormControlElement>} controlElements The control elements that
  *     will be processed.
- * @param {number} requirements The requirement on formElement autocompletion.
  * @param {number} extractMask Mask controls what data is extracted from
  *     formElement.
  * @param {AutofillFormData} form Form to fill in the AutofillFormData
  *     information of formElement.
  * @param {AutofillFormFieldData|null} field Field to fill in the form field
  *     information of formControlElement.
  * @return {boolean} Whether there are fields and not too many fields in the
  *     form.
  */
 function formOrFieldsetsToFormData_(formElement, formControlElement,
-    fieldsets, controlElements, requirements, extractMask, form, field) {
+    fieldsets, controlElements, extractMask, form, field) {
   // This should be a map from a control element to the AutofillFormFieldData.
   // However, without Map support, it's just an Array of AutofillFormFieldData.
   var elementArray = [];
 
   // The extracted FormFields.
   var formFields = [];
 
   // A vector of bools that indicate whether each element in |controlElements|
   // meets the requirements and thus will be in the resulting |form|.
   var fieldsExtracted = [];
 
-  if (!extractFieldsFromControlElements_(controlElements, requirements,
-                                         extractMask, formFields,
-                                         fieldsExtracted, elementArray)) {
+  if (!extractFieldsFromControlElements_(controlElements, extractMask,
+                                         formFields, fieldsExtracted,
+                                         elementArray)) {
     return false;
   }
 
   if (formElement) {
     // Loop through the label elements inside the form element. For each label
     // element, get the corresponding form control element, use the form control
     // element along with |controlElements| and |elementArray| to find the
     // previously created AutofillFormFieldData and set the
     // AutofillFormFieldData's label.
     var labels = formElement.getElementsByTagName('label');
@@ skipping 35 matching lines @@
 }
 
 /**
  * Scans DOM and returns a JSON string representation of forms and form
  * extraction results.
  *
  * TODO(thestig): Merge with extractNewForms()?
  *
  * @param {number} requiredFields The minimum number of fields forms must have
  *     to be extracted.
- * @param {number} requirements The requirements mask for forms, e.g.
- *      autocomplete attribute state.
  * @return {string} A JSON encoded object with object['forms'] containing the
  *     forms data.
  */
-__gCrWeb.autofill['extractForms'] = function(requiredFields, requirements) {
+__gCrWeb.autofill['extractForms'] = function(requiredFields) {
   var forms = [];
   // Protect against custom implementation of Array.toJSON in host pages.
   /** @suppress {checkTypes} */(function() { forms.toJSON = null; })();
 
   // TODO(chenyu): check if any preparation is needed for information such as
   // user_submitted or the one added in core.js is sufficient.
   __gCrWeb.autofill.extractNewForms(
       window,
       requiredFields,
-      requirements,
       forms);
   var results = new __gCrWeb.common.JSONSafeObject;
   results['forms'] = forms;
   return __gCrWeb.stringify(results);
 };
 
 /**
  * Stores the current active element. This is used to make the element active
  * again in case the web view loses focus when a dialog is presented over it.
  */
@@ skipping 112 matching lines @@
   formElement.dispatchEvent(event);
 };
 
 /**
  * See extractFormsAndFormElements below.
  *
  * @param {HTMLFrameElement|Window} frame A window or a frame containing forms
  *     from which the data will be extracted.
  * @param {number} minimumRequiredFields The minimum number of fields a form
  *     should contain for autofill.
- * @param {number} requirements The requirements mask for forms, e.g.
- *     autocomplete attribute state.
  * @param {Array<AutofillFormData>} forms Forms that will be filled in data of
  *     forms in frame.
  */
 __gCrWeb.autofill.extractNewForms = function(
-    frame, minimumRequiredFields, requirements, forms) {
+    frame, minimumRequiredFields, forms) {
   __gCrWeb.autofill.extractFormsAndFormElements(
-      frame, minimumRequiredFields, requirements, forms);
+      frame, minimumRequiredFields, forms);
 }
 
 /**
  * Scans the DOM in |frame| extracting and storing forms. Fills |forms| with
  * extracted forms.
  *
  * This method is based on the logic in method
  *
  *     bool FormCache::ExtractNewForms(
  *         const WebFrame& frame,
  *         std::vector<FormData>* forms)
  *
  * in chromium/src/components/autofill/content/renderer/form_cache.cc.
  *
  * The difference is in this implementation, the cache is not considered.
  * Initial values of select and checkable elements are not recorded at the
  * moment.
  *
- * This version still takes the minimumRequiredFields and requirements
- * parameters. Whereas the C++ version does not.
+ * This version still takes the minimumRequiredFields parameters. Whereas the
+ * C++ version does not.
  *
  * TODO(thestig): Update iOS internal callers to use extractNewForms(). Once
  * that happens, this can be removed.
  *
  * @param {HTMLFrameElement|Window} frame A window or a frame containing forms
  *     from which the data will be extracted.
  * @param {number} minimumRequiredFields The minimum number of fields a form
  *     should contain for autofill.
- * @param {number} requirements The requirements mask for forms, e.g.
- *     autocomplete attribute state.
  * @param {Array<AutofillFormData>} forms Forms that will be filled in data of
  *     forms in frame.
  * @return {boolean} Whether there are unextracted forms due to
  *     |minimumRequiredFields| limit.
  */
 __gCrWeb.autofill.extractFormsAndFormElements = function(
-    frame, minimumRequiredFields, requirements, forms) {
+    frame, minimumRequiredFields, forms) {
   if (!frame) {
     return false;
   }
   var doc = frame.document;
   if (!doc) {
     return false;
   }
 
   /** @type {HTMLCollection} */
   var webForms = doc.forms;
 
   var numFieldsSeen = 0;
   var hasSkippedForms = false;
   for (var formIndex = 0; formIndex < webForms.length; ++formIndex) {
     /** @type {HTMLFormElement} */
     var formElement = webForms[formIndex];
-    var controlElements = __gCrWeb.autofill.extractAutofillableElementsInForm(
-        formElement, requirements);
+    var controlElements =
+        __gCrWeb.autofill.extractAutofillableElementsInForm(formElement);
     var numEditableElements = 0;
     for (var elementIndex = 0; elementIndex < controlElements.length;
          ++elementIndex) {
       var element = controlElements[elementIndex];
       if (!__gCrWeb.autofill.isCheckableElement(element)) {
         ++numEditableElements;
       }
     }
 
     // To avoid overly expensive computation, we impose a minimum number of
     // allowable fields.  The corresponding maximum number of allowable
     // fields is imposed by webFormElementToFormData().
     if (numEditableElements < minimumRequiredFields &&
         controlElements.length > 0) {
       hasSkippedForms = true;
       continue;
     }
 
     var extractMask = __gCrWeb.autofill.EXTRACT_MASK_VALUE |
         __gCrWeb.autofill.EXTRACT_MASK_OPTIONS;
     var form = new __gCrWeb['common'].JSONSafeObject;
     if (!__gCrWeb.autofill.webFormElementToFormData(
-        frame, formElement, null, requirements, extractMask, form,
-        null /* field */)) {
+        frame, formElement, null, extractMask, form, null /* field */)) {
       continue;
     }
     numFieldsSeen += form['fields'].length;
     if (numFieldsSeen > __gCrWeb.autofill.MAX_PARSEABLE_FIELDS) {
       break;
     }
 
     if (form.fields.length >= minimumRequiredFields) {
       forms.push(form);
     } else {
       hasSkippedForms = true;
     }
   }
 
   // Recursively invoke for all frames/iframes.
   var frames = frame.frames;
   for (var i = 0; i < frames.length; i++) {
     var hasSkippedInframe = __gCrWeb.autofill.extractFormsAndFormElements(
-        frames[i], minimumRequiredFields, requirements, forms);
+        frames[i], minimumRequiredFields, forms);
     hasSkippedForms = hasSkippedForms || hasSkippedInframe;
   }
   return hasSkippedForms;
 };
 
 /**
  * Fills |form| with the form data object corresponding to the |formElement|.
  * If |field| is non-NULL, also fills |field| with the FormField object
  * corresponding to the |formControlElement|.
  * |extract_mask| controls what data is extracted.
- * Returns true if |form| is filled out; it's possible that the |formElement|
- * won't meet the |requirements|.  Also returns false if there are no fields or
+ * Returns true if |form| is filled out. Returns false if there are no fields or
  * too many fields in the |form|.
  *
  * It is based on the logic in
  *     bool WebFormElementToFormData(
  *         const blink::WebFormElement& form_element,
  *         const blink::WebFormControlElement& form_control_element,
- *         RequirementsMask requirements,
  *         ExtractMask extract_mask,
  *         FormData* form,
  *         FormFieldData* field)
  * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc
  *
  * @param {HTMLFrameElement|Window} frame The window or frame where the
  *     formElement is in.
  * @param {HTMLFormElement} formElement The form element that will be processed.
  * @param {FormControlElement} formControlElement A control element in
  *     formElment, the FormField of which will be returned in field.
- * @param {number} requirements The requirement on formElement autocompletion.
  * @param {number} extractMask Mask controls what data is extracted from
  *     formElement.
  * @param {AutofillFormData} form Form to fill in the AutofillFormData
  *     information of formElement.
  * @param {AutofillFormFieldData|null} field Field to fill in the form field
  *     information of formControlElement.
  * @return {boolean} Whether there are fields and not too many fields in the
  *     form.
  */
 __gCrWeb.autofill.webFormElementToFormData = function(
-    frame, formElement, formControlElement, requirements, extractMask, form,
-    field) {
+    frame, formElement, formControlElement, extractMask, form, field) {
   if (!frame) {
     return false;
   }
 
-  if ((requirements &
-           __gCrWeb.autofill.REQUIREMENTS_MASK_REQUIRE_AUTOCOMPLETE) &&
-         !__gCrWeb['common'].autoComplete(formElement)) {
-    return false;
-  }
-
   form['name'] = __gCrWeb.common.getFormIdentifier(formElement);
   var method = formElement.getAttribute('method');
   if (method) {
     form['method'] = method;
   }
   form['origin'] = __gCrWeb.common.removeQueryAndReferenceFromURL(
       frame.location.href);
   form['action'] = __gCrWeb.common.absoluteURL(
       frame.document,
       formElement.getAttribute('action'));
   // form['userSubmitted'] is filled by native code. See http://crbug.com/231264
 
   // Note different from form_autofill_util.cc version of this method, which
   // computes |form.action| using document.completeURL(form_element.action())
   // and falls back to formElement.action() if the computed action is invalid,
   // here the action returned by |__gCrWeb.common.absoluteURL| is always
   // valid, which is computed by creating a <a> element, and we don't check if
   // the action is valid.
 
   var controlElements = __gCrWeb['common'].getFormControlElements(formElement);
 
   return formOrFieldsetsToFormData_(formElement, formControlElement,
-      [] /* fieldsets */, controlElements, requirements, extractMask, form,
-      field);
+      [] /* fieldsets */, controlElements, extractMask, form, field);
 };
 
 /**
  * Returns is the tag of an |element| is tag.
  *
  * It is based on the logic in
  *     bool HasTagName(const WebNode& node, const blink::WebString& tag)
  * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Node} node Node to examine.
@@ skipping 16 matching lines @@
  * @return {boolean} Whether element is one of the element types that can be
  *     autofilled.
  */
 __gCrWeb.autofill.isAutofillableElement = function(element) {
   return __gCrWeb.autofill.isAutofillableInputElement(element) ||
          __gCrWeb.autofill.isSelectElement(element) ||
          __gCrWeb.autofill.isTextAreaElement(element);
 };
 
 /**
- * Check whether the given field satisfies the
- * __gCrWeb.autofill.REQUIREMENTS_MASK_REQUIRE_AUTOCOMPLETE requirement. When
- * Autocheckout is enabled, all fields are considered to satisfy this
- * requirement.
- *
- * It is based on the logic in
- *     bool SatisfiesRequireAutocomplete(const WebInputElement& input_element)
- * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
- *
- * @param {Element} element The element to be examined.
- * @param {boolean} isExperimentalFormFillingEnabled Boolean from
- *     switches::kEnableExperimentalFormFilling.
- * @return {boolean} Whether the inputElement satisfies the requirement.
- */
-__gCrWeb.autofill.satisfiesRequireAutocomplete = function(
-    element, isExperimentalFormFillingEnabled) {
-  return __gCrWeb.common.autoComplete(element) ||
-         isExperimentalFormFillingEnabled;
-};
-
-/**
  * Trims whitespace from the start of the input string.
  * Simplified version of string_util::TrimWhitespace.
  * @param {string} input String to trim.
  * @return {string} The |input| string without leading whitespace.
  */
 __gCrWeb.autofill.trimWhitespaceLeading = function(input) {
   return input.replace(/^\s+/gm, '');
 };
 
 /**
@@ skipping 730 matching lines @@
 __gCrWeb.autofill.value = function(element) {
   return (element.value || '').replace(/[\n\t]/gm, '');
 };
 
 /**
  * Returns the auto-fillable form control elements in |formElement|.
  *
  * It is based on the logic in:
  *     std::vector<blink::WebFormControlElement>
  *     ExtractAutofillableElementsFromSet(
- *         const WebVector<WebFormControlElement>& control_elements,
- *         RequirementsMask requirements);
+ *         const WebVector<WebFormControlElement>& control_elements);
  * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {Array<FormControlElement>} controlElements Set of control elements.
- * @param {number} requirementsMask A mask on the requirement.
  * @return {Array<FormControlElement>} The array of autofillable elements.
  */
-__gCrWeb.autofill.extractAutofillableElementsFromSet = function(
-    controlElements, requirementsMask) {
+__gCrWeb.autofill.extractAutofillableElementsFromSet =
+    function(controlElements) {
   var autofillableElements = [];
   for (var i = 0; i < controlElements.length; ++i) {
     var element = controlElements[i];
     if (!__gCrWeb.autofill.isAutofillableElement(element)) {
       continue;
     }
-    if (requirementsMask &
-        __gCrWeb.autofill.REQUIREMENTS_MASK_REQUIRE_AUTOCOMPLETE) {
-      // Different from method void ExtractAutofillableElements() in
-      // chromium/src/components/autofill/content/renderer/form_autofill_util.h,
-      // where satisfiesRequireAutocomplete() check is only applied on input
-      // controls, here satisfiesRequireAutocomplete() check is also applied on
-      // select control element. This is based on the TODO in that file saying
-      // "WebKit currently doesn't handle the autocomplete attribute for select
-      // control elements, but it probably should."
-      if (!__gCrWeb.autofill.satisfiesRequireAutocomplete(element, false)) {
-        continue;
-      }
-    }
     autofillableElements.push(element);
   }
   return autofillableElements;
 };
 
 /**
  * Returns all the auto-fillable form control elements in |formElement|.
  *
  * It is based on the logic in
  *     void ExtractAutofillableElementsInForm(
- *         const blink::WebFormElement& form_element,
- *         RequirementsMask requirements);
+ *         const blink::WebFormElement& form_element);
  * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {HTMLFormElement} formElement A form element to be processed.
- * @param {number} requirementsMask A mask on the requirement.
  * @return {Array<FormControlElement>} The array of autofillable elements.
  */
-__gCrWeb.autofill.extractAutofillableElementsInForm = function(
-    formElement, requirementsMask) {
+__gCrWeb.autofill.extractAutofillableElementsInForm = function(formElement) {
   var controlElements = __gCrWeb.common.getFormControlElements(formElement);
-  return __gCrWeb.autofill.extractAutofillableElementsFromSet(
-      controlElements, requirementsMask);
+  return __gCrWeb.autofill.extractAutofillableElementsFromSet(controlElements);
 };
 
 /**
  * Fills out a FormField object from a given form control element.
  *
  * It is based on the logic in
  *     void WebFormControlElementToFormField(
  *         const blink::WebFormControlElement& element,
  *         ExtractMask extract_mask,
  *         FormFieldData* field);
@@ skipping 104 matching lines @@
         continue;
       }
       var elementName = __gCrWeb['common'].nameForAutofill(element);
       var value = formData[elementName];
       if (value) {
         element.placeholder = value;
       }
     }
   }
 };