Autofill: Fix some nits in autofill_controller.js.

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
 // (chromium/src/components/autofill/common/form_data.h) for further processing.
 
 /**
  * Namespace for this file. It depends on |__gCrWeb| having already been
  * injected.
  */
 __gCrWeb['autofill'] = {};
 
 /**
  * The maximum length allowed for form data.
  *
  * This variable is from
- * chromium/src/components/autofill/renderer/form_autofill_util.cc
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.cc
  */
 __gCrWeb.autofill.MAX_DATA_LENGTH = 1024;
 
 /**
  * The maximum number of form fields we are willing to parse, due to
  * computational costs. Several examples of forms with lots of fields that are
  * not relevant to Autofill: (1) the Netflix queue; (2) the Amazon wishlist;
  * (3) router configuration pages; and (4) other configuration pages, e.g. for
  * Google code project settings.
  *
  * This variable is from
- * chromium/src/components/autofill/renderer/form_autofill_util.h
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  */
-__gCrWeb.autofill.MAX_PARSEABE_FIELDS = 100;
+__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/renderer/form_autofill_util.h
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  */
 __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/renderer/form_autofill_util.h
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  */
 __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/renderer/form_autofill_util.h
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  */
 __gCrWeb.autofill.EXTRACT_MASK_NONE = 0;
 
 /**
  * A bit field mask to extract data from WebFormControlElement for
  * extracting value from WebFormControlElement.
  *
  * This variable is from enum ExtractMask in
- * chromium/src/components/autofill/renderer/form_autofill_util.h
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  */
 __gCrWeb.autofill.EXTRACT_MASK_VALUE = 1 << 0;
 
 /**
  * A bit field mask to extract data from WebFormControlElement for
  * extracting option text from WebFormSelectElement. Only valid when
  * EXTRACT_MASK_VALUE is set. This is used for form submission where human
  * readable value is captured.
  *
  * This variable is from enum ExtractMask in
- * chromium/src/components/autofill/renderer/form_autofill_util.h
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  */
 __gCrWeb.autofill.EXTRACT_MASK_OPTION_TEXT = 1 << 1;
 
 /**
  * A bit field mask to extract data from WebFormControlElement for
  * extracting options from WebFormControlElement.
  *
  * This variable is from enum ExtractMask in
- * chromium/src/components/autofill/renderer/form_autofill_util.h
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.h
  */
 __gCrWeb.autofill.EXTRACT_MASK_OPTIONS = 1 << 2;
 
 /**
  * The last element that was autofilled.
  */
 __gCrWeb.autofill.lastAutoFilledElement = null;
 
 /**
  * Scans DOM and returns a JSON string representation of forms and form
@@ skipping 102 matching lines @@
  * |minimumRequiredFields| limit, else false.
  *
  * This method is based on the logic in method
  *
  *     bool FormCache::ExtractFormsAndFormElements(
  *         const WebFrame& frame,
  *         size_t minimum_required_fields,
  *         std::vector<FormData>* forms,
  *         std::vector<WebFormElement>* web_form_elements)
  *
- * in chromium/src/components/autofill/renderer/form_cache.cc.
+ * in chromium/src/components/autofill/content/renderer/form_cache.cc.
  *
  * The difference is in this implementation, no form elements are returned in
  * |web_form_elements|, and cache is not considered. Initial values of select
  * and checkable elements are not recorded at the momemt.
  *
  * @param {Object} frame A window or a frame containing forms from which the
  *     data will be extracted.
  * @param {int} minimumRequiredFields The minimum number of fields a form should
  *     contain for autofill.
  * @param {int} requirements The requirements mask for forms, e.g. autocomplete
@@ skipping 39 matching lines @@
     }
 
     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)) {
       continue;
     }
     numFieldsSeen += form['fields'].length;
-    if (numFieldsSeen > __gCrWeb.autofill.MAX_PARSEABE_FIELDS) {
+    if (numFieldsSeen > __gCrWeb.autofill.MAX_PARSEABLE_FIELDS) {
       break;
     }
 
     if (form.fields.length >= minimumRequiredFields) {
       forms.push(form);
     } else {
       hasSkippedForms = true;
     }
   }
 
@@ skipping 17 matching lines @@
  * 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/renderer/form_autofill_util.cc
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc
  *
  * @param {Element} frame The frame where the formElement is in.
  * @param {Element} formElement The form element that will be processed.
  * @param {Element} formControlElement A control element in formElment, the
  *     FormField of which will be returned in field.
  * @param {int} requirements The requirement on formElement autocompletion.
  * @param {int} extractMask Mask controls what data is extracted from
  *     formElement.
  * @param {Object} form Form to fill in the FormData information of formElement.
  * @param {Object} field Field to fill in the form field information of
@@ skipping 17 matching lines @@
   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'));
-  // TODO(chenyu): fill form['userSubmitted'] (Issue 231264).
+  // form['userSubmitted'] is filled by native code. See http://crbug.com/231264
 
-  // Note different from form_autofill_utill.cc version of this method, which
+  // 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.
 
   // A map from a FormFieldData's name to the FormFieldData itself.
   var nameMap = {};
 
   // The extracted FormFields.
@@ skipping 24 matching lines @@
     // Create a new FormFieldData, 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);
     nameMap[formField['name']] = formField;
     fieldsExtracted[i] = true;
 
     // To avoid overly expensive computation, we impose a maximum number of
     // allowable fields.
-    if (formFields.length > __gCrWeb.autofill.MAX_PARSEABE_FIELDS) {
+    if (formFields.length > __gCrWeb.autofill.MAX_PARSEABLE_FIELDS) {
       return false;
     }
   }
 
   // If we failed to extract any fields, give up.
   if (formFields.length === 0) {
     return false;
   }
 
   // Loop through the label elements inside the form element. For each label
@@ skipping 61 matching lines @@
   // Protect against custom implementation of Array.toJSON in host pages.
   form['fields'].toJSON = null;
   return true;
 };
 
 /**
  * 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/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} node Node to examine.
  * @param {string} tag Tag name.
  * @return {boolean} Whether the tag of node is tag.
  */
 __gCrWeb.autofill.hasTagName = function(node, tag) {
   return node.nodeType === document.ELEMENT_NODE &&
          node.tagName === tag.toUpperCase();
 };
 
 /**
  * Checks if an element is autofillable.
  *
  * It is based on the logic in
  *     bool IsAutofillableElement(const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @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/renderer/form_autofill_util.cc.
+ * 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;
@@ skipping 123 matching lines @@
 
   return nodeText;
 };
 
 /**
  * Returns the aggregated values of the descendants of |element| that are
  * non-empty text nodes.
  *
  * It is based on the logic in
  *    string16 FindChildText(const WebNode& node)
- * chromium/src/components/autofill/renderer/form_autofill_util.cc, which is a
- * faster alternative to |innerText()| for performance critical operations.
+ * chromium/src/components/autofill/content/renderer/form_autofill_util.cc,
+ * which is a faster alternative to |innerText()| for performance critical
+ * operations.
  *
  * @param {Element} node A node of which the child text will be return.
  * @return {string} The child text.
  */
 __gCrWeb.autofill.findChildText = function(node) {
   if (node.nodeType === document.TEXT_NODE)
     return __gCrWeb.autofill.nodeValue(node);
   var child = node.firstChild;
 
   var kChildSearchDepth = 10;
   var nodeText = __gCrWeb.autofill.findChildTextInner(child, kChildSearchDepth);
   nodeText = nodeText.trim();
   return nodeText;
 };
 
 /**
  * Helper for |InferLabelForElement()| that infers a label, if possible, from
  * a previous sibling of |element|,
  * e.g. Some Text <input ...>
  * or   Some <span>Text</span> <input ...>
  * or   <p>Some Text</p><input ...>
  * or   <label>Some Text</label> <input ...>
  * or   Some Text <img><input ...>
  * or   <b>Some Text</b><br/> <input ...>.
  *
  * It is based on the logic in
  *     string16 InferLabelFromPrevious(const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @return {string} The label of element.
  */
 __gCrWeb.autofill.inferLabelFromPrevious = function(element) {
   var inferredLabel = '';
   var previous = element;
   if (!previous) {
     return '';
   }
@@ skipping 58 matching lines @@
   }
   return inferredLabel.trim();
 };
 
 /**
  * Helper for |InferLabelForElement()| that infers a label, if possible, from
  * the placeholder attribute.
  *
  * It is based on the logic in
  *     string16 InferLabelFromPlaceholder(const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @return {string} The label of element.
  */
 __gCrWeb.autofill.inferLabelFromPlaceholder = function(element) {
   if (!element || !element.placeholder) {
     return '';
   }
 
   return element.placeholder;
 };
 
 /**
  * Helper for |InferLabelForElement()| that infers a label, if possible, from
  * enclosing list item, e.g.
  *     <li>Some Text<input ...><input ...><input ...></li>
  *
  * It is based on the logic in
  *     string16 InferLabelFromListItem(const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @return {string} The label of element.
  */
 __gCrWeb.autofill.inferLabelFromListItem = function(element) {
   if (!element) {
     return '';
   }
 
-  var parent = element.parentNode;
-  while (parent &&
-         parent.nodeType === document.ELEMENT_NODE &&
-         !__gCrWeb.autofill.hasTagName(parent, 'li')) {
-    parent = parent.parentNode;
+  var parentNode = element.parentNode;
+  while (parentNode &&
+         parentNode.nodeType === document.ELEMENT_NODE &&
+         !__gCrWeb.autofill.hasTagName(parentNode, 'li')) {
+    parentNode = parentNode.parentNode;
   }
 
-  if (parent && __gCrWeb.autofill.hasTagName(parent, 'li'))
-    return __gCrWeb.autofill.findChildText(parent);
+  if (parentNode && __gCrWeb.autofill.hasTagName(parentNode, 'li'))
+    return __gCrWeb.autofill.findChildText(parentNode);
 
   return '';
 };
 
 /**
  * Helper for |InferLabelForElement()| that infers a label, if possible, from
  * surrounding table structure,
  * e.g. <tr><td>Some Text</td><td><input ...></td></tr>
  * or   <tr><th>Some Text</th><td><input ...></td></tr>
  * or   <tr><td><b>Some Text</b></td><td><b><input ...></b></td></tr>
  * or   <tr><th><b>Some Text</b></th><td><b><input ...></b></td></tr>
  *
  * It is based on the logic in
  *    string16 InferLabelFromTableColumn(const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @return {string} The label of element.
  */
 __gCrWeb.autofill.inferLabelFromTableColumn = function(element) {
   if (!element) {
     return '';
   }
 
-  var parent = element.parentNode;
-  while (parent &&
-         parent.nodeType === document.ELEMENT_NODE &&
-         !__gCrWeb.autofill.hasTagName(parent, 'td')) {
-    parent = parent.parentNode;
+  var parentNode = element.parentNode;
+  while (parentNode &&
+         parentNode.nodeType === document.ELEMENT_NODE &&
+         !__gCrWeb.autofill.hasTagName(parentNode, 'td')) {
+    parentNode = parentNode.parentNode;
   }
 
-  if (!parent) {
+  if (!parentNode) {
     return '';
   }
 
   // Check all previous siblings, skipping non-element nodes, until we find a
   // non-empty text block.
   var inferredLabel = '';
-  var previous = parent.previousSibling;
+  var previous = parentNode.previousSibling;
   while (inferredLabel.length === 0 && previous) {
     if (__gCrWeb.autofill.hasTagName(previous, 'td') ||
         __gCrWeb.autofill.hasTagName(previous, 'th')) {
       inferredLabel = __gCrWeb.autofill.findChildText(previous);
     }
     previous = previous.previousSibling;
   }
 
   return inferredLabel;
 };
 
 /**
  * Helper for |InferLabelForElement()| that infers a label, if possible, from
  * surrounding table structure,
  * e.g. <tr><td>Some Text</td></tr><tr><td><input ...></td></tr>
  *
  * It is based on the logic in
  *     string16 InferLabelFromTableRow(const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @return {string} The label of element.
  */
 __gCrWeb.autofill.inferLabelFromTableRow = function(element) {
   if (!element) {
     return '';
   }
 
-  var parent = element.parentNode;
-  while (parent &&
-         parent.nodeType === document.ELEMENT_NODE &&
-         !__gCrWeb.autofill.hasTagName(parent, 'tr')) {
-    parent = parent.parentNode;
+  var parentNode = element.parentNode;
+  while (parentNode &&
+         parentNode.nodeType === document.ELEMENT_NODE &&
+         !__gCrWeb.autofill.hasTagName(parentNode, 'tr')) {
+    parentNode = parentNode.parentNode;
   }
 
-  if (!parent) {
+  if (!parentNode) {
     return '';
   }
 
   var inferredLabel = '';
   // Check all previous siblings, skipping non-element nodes, until we find a
   // non-empty text block.
-  var previous = parent.previousSibling;
+  var previous = parentNode.previousSibling;
   while (inferredLabel.length === 0 && previous) {
     if (__gCrWeb.autofill.hasTagName(previous, 'tr')) {
       inferredLabel = __gCrWeb.autofill.findChildText(previous);
     }
     previous = previous.previousSibling;
   }
   return inferredLabel;
 };
 
 /**
  * Helper for |InferLabelForElement()| that infers a label, if possible, from
  * a surrounding div table,
  * e.g. <div>Some Text<span><input ...></span></div>
  * e.g. <div>Some Text</div><div><input ...></div>
  *
  * It is based on the logic in
  *    string16 InferLabelFromDivTable(const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @return {string} The label of element.
  */
 __gCrWeb.autofill.inferLabelFromDivTable = function(element) {
   if (!element) {
     return '';
   }
 
   var node = element.parentNode;
@@ skipping 29 matching lines @@
 
 /**
  * Helper for |InferLabelForElement()| that infers a label, if possible, from
  * a surrounding definition list,
  * e.g. <dl><dt>Some Text</dt><dd><input ...></dd></dl>
  * e.g. <dl><dt><b>Some Text</b></dt><dd><b><input ...></b></dd></dl>
  *
  * It is based on the logic in
  *    string16 InferLabelFromDefinitionList(
  *        const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @return {string} The label of element.
  */
 __gCrWeb.autofill.inferLabelFromDefinitionList = function(element) {
   if (!element) {
     return '';
   }
 
-  var parent = element.parentNode;
-  while (parent &&
-         parent.nodeType === document.ELEMENT_NODE &&
-         !__gCrWeb.autofill.hasTagName(parent, 'dd')) {
-    parent = parent.parentNode;
+  var parentNode = element.parentNode;
+  while (parentNode &&
+         parentNode.nodeType === document.ELEMENT_NODE &&
+         !__gCrWeb.autofill.hasTagName(parentNode, 'dd')) {
+    parentNode = parentNode.parentNode;
   }
 
-  if (!parent || !__gCrWeb.autofill.hasTagName(parent, 'dd')) {
+  if (!parentNode || !__gCrWeb.autofill.hasTagName(parentNode, 'dd')) {
     return '';
   }
 
   // Skip by any intervening text nodes.
-  var previous = parent.previousSibling;
+  var previous = parentNode.previousSibling;
   while (previous &&
          previous.nodeType === document.TEXT_NODE) {
     previous = previous.previousSibling;
   }
 
   if (!previous || !__gCrWeb.autofill.hasTagName(previous, 'dt'))
     return '';
 
   return __gCrWeb.autofill.findChildText(previous);
 };
 
 /**
  * Infers corresponding label for |element| from surrounding context in the DOM,
  * e.g. the contents of the preceding <p> tag or text element.
  *
  * It is based on the logic in
  *    string16 InferLabelForElement(const WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} element An element to examine.
  * @return {string} The label of element.
  */
 __gCrWeb.autofill.inferLabelForElement = function(element) {
   var inferredLabel = __gCrWeb.autofill.inferLabelFromPrevious(element);
   if (inferredLabel.length > 0) {
     return inferredLabel;
   }
 
@@ skipping 32 matching lines @@
 };
 
 /**
  * Fills |field| data with the values of the <option> elements present in
  * |selectElement|.
  *
  * It is based on the logic in
  *     void GetOptionStringsFromElement(const WebSelectElement& select_element,
  *                                      std::vector<string16>* option_values,
  *                                      std::vector<string16>* option_contents)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * @param {Element} selectElement A select element from which option data are
  *     extracted.
  * @param {Object} field A field that will contain the extracted option
  *     information.
  */
 __gCrWeb.autofill.getOptionStringsFromElement = function(
     selectElement, field) {
   field['option_values'] = [];
   // Protect against custom implementation of Array.toJSON in host pages.
   field['option_values'].toJSON = null;
   field['option_contents'] = [];
   field['option_contents'].toJSON = null;
   var options = selectElement.options;
   for (var i = 0; i < options.length; ++i) {
     var option = options[i];
     field['option_values'].push(option['value']);
     field['option_contents'].push(option['text']);
   }
 };
 
 /**
  * Sets the |field|'s value to the value in |data|.
  * Also sets the "autofilled" attribute.
  *
  * It is based on the logic in
  *     void FillFormField(const FormFieldData& data,
  *                        bool is_initiating_node,
  *                        blink::WebFormControlElement* field)
- * in chromium/src/components/autofill/renderer/form_autofill_util.cc.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.cc.
  *
  * Different from FillFormField(), is_initiating_node is not considered in
  * this implementation.
  *
  * @param {Object} data Data that will be filled into field.
  * @param {Element} field The element to which data will be filled.
  */
 __gCrWeb.autofill.fillFormField = function(data, field) {
   // Nothing to fill.
   if (!data['value'] || data['value'].length === 0) {
@@ skipping 26 matching lines @@
       __gCrWeb.common.setInputElementChecked(data['is_checked'], field, true);
     }
   }
 };
 
 /**
  * Returns true if |element| is a text input element.
  *
  * It is based on the logic in
  *     bool IsTextInput(const blink::WebInputElement* element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.h.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {Element} element An element to examine.
  * @return {boolean} Whether element is a text input field.
  */
 __gCrWeb.autofill.isTextInput = function(element) {
   if (!element) {
     return false;
   }
   return __gCrWeb.common.isTextField(element);
 };
 
 /**
  * Returns true if |element| is a 'select' element.
  *
  * It is based on the logic in
  *     bool IsSelectElement(const blink::WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.h.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {Element} element An element to examine.
  * @return {boolean} Whether element is a 'select' element.
  */
 __gCrWeb.autofill.isSelectElement = function(element) {
   if (!element) {
     return false;
   }
   return element.type === 'select-one';
 };
 
 /**
  * Returns true if |element| is a 'textarea' element.
  *
  * It is based on the logic in
  *     bool IsTextAreaElement(const blink::WebFormControlElement& element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.h.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {Element} element An element to examine.
  * @return {boolean} Whether element is a 'textarea' element.
  */
 __gCrWeb.autofill.isTextAreaElement = function(element) {
   if (!element) {
     return false;
   }
   return element.type === 'textarea';
 };
 
 /**
  * Returns true if |element| is a checkbox or a radio button element.
  *
  * It is based on the logic in
  *     bool IsCheckableElement(const blink::WebInputElement* element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.h.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {Element} element An element to examine.
  * @return {boolean} Whether element is a checkbox or a radio button.
  */
 __gCrWeb.autofill.isCheckableElement = function(element) {
   if (!element) {
     return false;
   }
   return element.type === 'checkbox' || element.type === 'radio';
 };
 
 /**
  * Returns true if |element| is one of the input element types that can be
  * autofilled. {Text, Radiobutton, Checkbox}.
  *
  * It is based on the logic in
  *    bool IsAutofillableInputElement(const blink::WebInputElement* element)
- * in chromium/src/components/autofill/renderer/form_autofill_util.h.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {Element} element An element to examine.
  * @return {boolean} Whether element is one of the input element types that
  *     can be autofilled.
  */
 __gCrWeb.autofill.isAutofillableInputElement = function(element) {
   return __gCrWeb.autofill.isTextInput(element) ||
          __gCrWeb.autofill.isCheckableElement(element);
 };
 
 /**
  * Returns the nodeValue in a way similar to the C++ version of node.nodeValue,
- * used in src/components/autofill/renderer/form_autofill_util.h. Newlines and
- * tabs are stripped.
+ * used in src/components/autofill/content/renderer/form_autofill_util.h.
+ * Newlines and tabs are stripped.
  *
  * @param {Element} element An element to examine.
  * @return {string} The text contained in |element|.
  */
 __gCrWeb.autofill.nodeValue = function(element) {
   return (element.nodeValue || '').replace(/[\n\t]/gm, '');
 };
 
 /**
  * Returns the value in a way similar to the C++ version of node.value,
- * used in src/components/autofill/renderer/form_autofill_util.h. Newlines and
- * tabs are stripped.
+ * used in src/components/autofill/content/renderer/form_autofill_util.h.
+ * Newlines and tabs are stripped.
  *
  * @param {Element} element An element to examine.
  * @return {string} The value for |element|.
  */
 __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
  *     void ExtractAutofillableElements(
  *         const blink::WebFormElement& form_element,
  *         RequirementsMask requirements,
  *         std::vector<blink::WebFormControlElement>* autofillable_elements);
- * in chromium/src/components/autofill/renderer/form_autofill_util.h.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {Element} formElement A form element to be processed.
  * @param {int} requirementsMask A mask on the requirement.
  * @param {Array.<Element>} autofillableElements The array of autofillable
  *     elements.
  */
 __gCrWeb.autofill.extractAutofillableElements = function(
     formElement, requirementsMask, autofillableElements) {
   var controlElements = __gCrWeb.common.getFormControlElements(formElement);
 
   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/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."
+      // 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);
   }
 };
 
 /**
  * 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);
- * in chromium/src/components/autofill/renderer/form_autofill_util.h.
+ * in chromium/src/components/autofill/content/renderer/form_autofill_util.h.
  *
  * @param {Element} element The element to be processed.
  * @param {int} extractMask A bit field mask to extract data from |element|.
  *     See the document on variable __gCrWeb.autofill.EXTRACT_MASK_NONE,
  *     __gCrWeb.autofill.EXTRACT_MASK_VALUE,
  *     __gCrWeb.autofill.EXTRACT_MASK_OPTION_TEXT and
  *     __gCrWeb.autofill.EXTRACT_MASK_OPTIONS.
  * @param {Object} field Field to fill in the element information.
  */
 __gCrWeb.autofill.webFormControlElementToFormField = function(
@@ skipping 92 matching lines @@
         continue;
       }
       var elementName = __gCrWeb['common'].nameForAutofill(element);
       var value = formData[elementName];
       if (value) {
         element.placeholder = value;
       }
     }
   }
 };