Autofill: Modify various utility function to deal with unowned form fields.

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"
 #include "base/memory/scoped_vector.h"
-#include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/autofill_data_validation.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
@@ skipping 70 matching lines @@
   return node.isElementNode() && node.toConst<WebElement>().hasHTMLTagName(tag);
 }
 
 bool IsAutofillableElement(const WebFormControlElement& element) {
   const WebInputElement* input_element = toWebInputElement(&element);
   return IsAutofillableInputElement(input_element) ||
          IsSelectElement(element) ||
          IsTextAreaElement(element);
 }
 
+bool IsElementInControlElementSet(
+    const WebElement& element,
+    const std::vector<WebFormControlElement>& control_elements) {
+  if (!element.isFormControlElement())
+    return false;
+  const WebFormControlElement form_control_element =
+      element.toConst<WebFormControlElement>();
+  return std::find(control_elements.begin(),
+                   control_elements.end(),
+                   form_control_element) != control_elements.end();
+}
+
+bool IsElementInsideFormOrFieldSet(const WebElement& element) {
+  for (WebNode parent_node = element.parentNode();
+       !parent_node.isNull();
+       parent_node = parent_node.parentNode()) {
+    if (!parent_node.isElementNode())
+      continue;
+
+    WebElement cur_element = parent_node.to<WebElement>();
+    if (cur_element.hasHTMLTagName("form") ||
+        cur_element.hasHTMLTagName("fieldset")) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // Check whether the given field satisfies the REQUIRE_AUTOCOMPLETE requirement.
 bool SatisfiesRequireAutocomplete(const WebInputElement& input_element) {
   return input_element.autoComplete();
 }
 
 // Appends |suffix| to |prefix| so that any intermediary whitespace is collapsed
 // to a single space.  If |force_whitespace| is true, then the resulting string
 // is guaranteed to have a space between |prefix| and |suffix|.  Otherwise, the
 // result includes a space only if |prefix| has trailing whitespace or |suffix|
 // has leading whitespace.
@@ skipping 375 matching lines @@
       option_contents->push_back(option.text());
     }
   }
 }
 
 // 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,
-                              FieldFilterMask filters,
-                              bool force_override,
-                              Callback callback) {
-  std::vector<WebFormControlElement> control_elements =
-      ExtractAutofillableElementsInForm(form_element, ExtractionRequirements());
-
-  if (control_elements.size() != data.fields.size()) {
+// Common code shared by ForEachMatchingFormField() and
+// ForEachMatchingUnownedFormField().

[Evan Stade, 2014/12/12 23:05:53]

this documentation isn't necessary imo

[Lei Zhang, 2014/12/12 23:11:17]

Done.

+void ForEachMatchingFormFieldCommon(
+    std::vector<WebFormControlElement>* control_elements,
+    const WebElement& initiating_element,
+    const FormData& data,
+    FieldFilterMask filters,
+    bool force_override,
+    Callback callback) {
+  DCHECK(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
   // elements is equal to the size of the fields in |form|.  Fortunately, the
   // one case in the wild where this happens, paypal.com signup form, the fields
   // are appended to the end of the form and are not visible.
-  for (size_t i = 0; i < control_elements.size(); ++i) {
-    WebFormControlElement* element = &control_elements[i];
+  for (size_t i = 0; i < control_elements->size(); ++i) {
+    WebFormControlElement* element = &(*control_elements)[i];
 
     if (base::string16(element->nameForAutofill()) != data.fields[i].name) {
       // This case should be reachable only for pathological websites, which
       // rename form fields while the user is interacting with the Autofill
       // popup.  I (isherman) am not aware of any such websites, and so am
       // optimistically including a NOTREACHED().  If you ever trip this check,
       // please file a bug against me.
       NOTREACHED();
       continue;
     }
@@ skipping 11 matching lines @@
 
     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);
   }
 }
 
+// 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 =
+      ExtractAutofillableElementsInForm(form_element, ExtractionRequirements());
+  ForEachMatchingFormFieldCommon(&control_elements, initiating_element, data,
+                                 filters, force_override, callback);
+}
+
+// For each autofillable field in |data| that matches a field in the set of
+// unowned autofillable form fields, the |callback| is invoked with the
+// corresponding |data| field.
+void ForEachMatchingUnownedFormField(const WebElement& initiating_element,
+                                     const FormData& data,
+                                     FieldFilterMask filters,
+                                     bool force_override,
+                                     Callback callback) {
+  if (initiating_element.isNull())
+    return;
+
+  std::vector<WebFormControlElement> control_elements =
+      GetUnownedAutofillableFormFieldElements(
+          initiating_element.document().all(), nullptr);
+  if (!IsElementInControlElementSet(initiating_element, control_elements))
+    return;
+
+  ForEachMatchingFormFieldCommon(&control_elements, initiating_element, data,
+                                 filters, force_override, callback);
+}
+
 // 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,
                    blink::WebFormControlElement* field) {
   // Nothing to fill.
   if (data.value.empty())
     return;
 
   if (!data.is_autofilled)
@@ skipping 154 matching lines @@
     // Concatenate labels because some sites might have multiple label
     // candidates.
     if (!iter->second->label.empty() && !label_text.empty())
       iter->second->label += base::ASCIIToUTF16(" ");
     iter->second->label += label_text;
   }
 }
 
 // Common function shared by WebFormElementToFormData() and
 // UnownedFormElementsAndFieldSetsToFormData(). Either pass in:
-// 1) |form_element|, |form_control_element| and an empty |fieldsets|.
+// 1) |form_element| and an empty |fieldsets|.
 // or
-// 2) a non-empty |fieldsets|.
+// 2) a NULL |form_element|.
+//
+// If |field| is not NULL, then |form_control_element| should be not NULL.
 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) {
   CR_DEFINE_STATIC_LOCAL(WebString, kLabel, ("label"));
 
-  if (form_element) {
+  if (form_element)
+    DCHECK(fieldsets.empty());
+  if (field)
     DCHECK(form_control_element);
-    DCHECK(fieldsets.empty());
-  } else {
-    DCHECK(!form_control_element);
-    DCHECK(!field);
-  }
 
   // A map from a FormFieldData's name to the FormFieldData itself.
   std::map<base::string16, FormFieldData*> name_map;
 
   // The extracted FormFields.  We use pointers so we can store them in
   // |name_map|.
   ScopedVector<FormFieldData> form_fields;
 
   // A vector of bools that indicate whether each field in the form meets the
   // requirements and thus will be in the resulting |form|.
@@ skipping 253 matching lines @@
 
   WebVector<WebFormControlElement> control_elements;
   form_element.getFormControlElements(control_elements);
 
   std::vector<blink::WebElement> dummy_fieldset;
   return FormOrFieldsetsToFormData(&form_element, &form_control_element,
                                    dummy_fieldset, control_elements,
                                    requirements, extract_mask, form, field);
 }
 
+std::vector<WebFormControlElement>
+GetUnownedAutofillableFormFieldElements(
+    const WebElementCollection& elements,
+    std::vector<WebElement>* fieldsets) {
+  std::vector<WebFormControlElement> unowned_fieldset_children;
+  for (WebElement element = elements.firstItem();
+       !element.isNull();
+       element = elements.nextItem()) {
+    if (element.isFormControlElement()) {
+      WebFormControlElement control = element.to<WebFormControlElement>();
+      if (control.form().isNull())
+        unowned_fieldset_children.push_back(control);
+    }
+
+    if (fieldsets && element.hasHTMLTagName("fieldset") &&
+        !IsElementInsideFormOrFieldSet(element)) {
+      fieldsets->push_back(element);
+    }
+  }
+  return ExtractAutofillableElementsFromSet(unowned_fieldset_children,
+                                            REQUIRE_NONE);
+}
+
 bool UnownedFormElementsAndFieldSetsToFormData(
     const std::vector<blink::WebElement>& fieldsets,
     const std::vector<blink::WebFormControlElement>& control_elements,
+    const blink::WebFormControlElement* element,
     const GURL& origin,
+    RequirementsMask requirements,
     ExtractMask extract_mask,
-    FormData* form) {
+    FormData* form,
+    FormFieldData* field) {
   form->origin = origin;
   form->user_submitted = false;
 
-  return FormOrFieldsetsToFormData(nullptr, nullptr, fieldsets,
-                                   control_elements, REQUIRE_NONE, extract_mask,
-                                   form, nullptr);
+  return FormOrFieldsetsToFormData(nullptr, element, fieldsets,
+                                   control_elements, requirements, extract_mask,
+                                   form, field);
 }
 
 bool FindFormAndFieldForFormControlElement(const WebFormControlElement& element,
                                            FormData* form,
                                            FormFieldData* field,
                                            RequirementsMask requirements) {
   if (!IsAutofillableElement(element))
     return false;
 
-  const WebFormElement form_element = element.form();
-  if (form_element.isNull())
-    return false;
-
   ExtractMask extract_mask =
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
+  const WebFormElement form_element = element.form();
+  if (form_element.isNull()) {
+    // No associated form, try the synthetic form for unowned form elements.
+    WebDocument document = element.document();
+    std::vector<WebElement> fieldsets;
+    std::vector<WebFormControlElement> control_elements =
+        GetUnownedAutofillableFormFieldElements(document.all(), &fieldsets);
+    return UnownedFormElementsAndFieldSetsToFormData(
+        fieldsets, control_elements, &element, document.url(), requirements,
+        extract_mask, form, field);
+  }
+
   return WebFormElementToFormData(form_element,
                                   element,
                                   requirements,
                                   extract_mask,
                                   form,
                                   field);
 }
 
 void FillForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
-  if (form_element.isNull())
+  if (form_element.isNull()) {
+    ForEachMatchingUnownedFormField(element,
+                                    form,
+                                    FILTER_ALL_NON_EDITABLE_ELEMENTS,
+                                    false, /* dont force override */
+                                    &FillFormField);
     return;
+  }
 
   ForEachMatchingFormField(form_element,
                            element,
                            form,
                            FILTER_ALL_NON_EDITABLE_ELEMENTS,
                            false, /* dont force override */
                            &FillFormField);
 }
 
 void FillFormIncludingNonFocusableElements(const FormData& form_data,
                                            const WebFormElement& form_element) {
-  if (form_element.isNull())
+  if (form_element.isNull()) {
+    NOTREACHED();
     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 PreviewForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
-  if (form_element.isNull())
+  if (form_element.isNull()) {
+    ForEachMatchingUnownedFormField(element,
+                                    form,
+                                    FILTER_ALL_NON_EDITABLE_ELEMENTS,
+                                    false, /* dont force override */
+                                    &PreviewFormField);
     return;
+  }
 
   ForEachMatchingFormField(form_element,
                            element,
                            form,
                            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;
+  if (form_element.isNull()) {
+    control_elements = GetUnownedAutofillableFormFieldElements(
+        element.document().all(), nullptr);
+    if (!IsElementInControlElementSet(element, control_elements))
+      return false;
+  } else {
+    control_elements = ExtractAutofillableElementsInForm(
+        form_element, ExtractionRequirements());
+  }
 
-  std::vector<WebFormControlElement> control_elements =
-      ExtractAutofillableElementsInForm(form_element, ExtractionRequirements());
   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 92 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