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

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"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_data_predictions.h"
 #include "grit/components_strings.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
-#include "third_party/WebKit/public/web/WebElementCollection.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNodeList.h"
 #include "third_party/WebKit/public/web/WebSelectElement.h"
 #include "third_party/WebKit/public/web/WebTextAreaElement.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using blink::WebConsoleMessage;
 using blink::WebDocument;
 using blink::WebElement;
-using blink::WebElementCollection;
 using blink::WebFormControlElement;
 using blink::WebFormElement;
 using blink::WebFrame;
 using blink::WebInputElement;
 using blink::WebNode;
 using blink::WebSelectElement;
 using blink::WebString;
 using blink::WebTextAreaElement;
 using blink::WebVector;
 
@@ skipping 37 matching lines @@
       continue;
     std::string msg = std::string("autocomplete='") + deprecated[i] +
         "' is deprecated and will soon be ignored. See http://goo.gl/YjeSsW";
     WebConsoleMessage console_message = WebConsoleMessage(
         WebConsoleMessage::LevelWarning,
         WebString(base::ASCIIToUTF16(msg)));
     element.document().frame()->addMessageToConsole(console_message);
   }
 }
 
-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;
-}
-
 // To avoid overly expensive computation, we impose a minimum number of
 // allowable fields.  The corresponding maximum number of allowable fields
 // is imposed by WebFormElementToFormData().
 bool ShouldIgnoreForm(size_t num_editable_elements,
                       size_t num_control_elements) {
   return (num_editable_elements < kRequiredAutofillFields &&
           num_control_elements > 0);
 }
 
 }  // namespace
 
 FormCache::FormCache() {
 }
 
 FormCache::~FormCache() {
 }
 
-// static
-std::vector<WebFormControlElement>
-FormCache::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);
-}
-
 std::vector<FormData> FormCache::ExtractNewForms(const WebFrame& frame) {
   std::vector<FormData> forms;
   WebDocument document = frame.document();
   if (document.isNull())
     return forms;
 
   if (!ContainsKey(documents_to_synthetic_form_map_, document))
     documents_to_synthetic_form_map_[document] = FormData();
 
   WebVector<WebFormElement> web_forms;
@@ skipping 13 matching lines @@
     std::vector<WebFormControlElement> control_elements =
         ExtractAutofillableElementsInForm(form_element, REQUIRE_NONE);
     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, NULL)) {
+                                  REQUIRE_NONE, 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_[&frame], form)) {
       forms.push_back(form);
       parsed_forms_[&frame].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 form;
   if (!UnownedFormElementsAndFieldSetsToFormData(fieldsets, control_elements,
-                                                 document.url(), extract_mask,
-                                                 &form)) {
+                                                 nullptr, document.url(),
+                                                 REQUIRE_NONE, extract_mask,
+                                                 &form, nullptr)) {
     return forms;
   }
 
   num_fields_seen += form.fields.size();
   if (num_fields_seen > kMaxParseableFields)
     return forms;
 
   if (form.fields.size() >= kRequiredAutofillFields &&
       !parsed_forms_[&frame].count(form)) {
     forms.push_back(form);
@@ skipping 14 matching lines @@
   for (const auto& it : documents_to_delete)
     documents_to_synthetic_form_map_.erase(it);
 
   parsed_forms_[&frame].clear();
   RemoveOldElements(frame, &initial_select_values_);
   RemoveOldElements(frame, &initial_checked_state_);
 }
 
 bool FormCache::ClearFormWithElement(const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
-  if (form_element.isNull())
-    return false;
-
-  std::vector<WebFormControlElement> control_elements =
-      ExtractAutofillableElementsInForm(form_element, REQUIRE_NONE);
+  std::vector<WebFormControlElement> control_elements;
+  if (form_element.isNull()) {
+    control_elements = GetUnownedAutofillableFormFieldElements(
+        element.document().all(), nullptr);
+  } else {
+    control_elements = ExtractAutofillableElementsInForm(
+        form_element, REQUIRE_NONE);
+  }
   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 149 matching lines @@
             std::make_pair(input_element, input_element.isChecked()));
       } else {
         ++num_editable_elements;
       }
     }
   }
   return num_editable_elements;
 }
 
 }  // namespace autofill