Revert of [Autofill] Enable Autofill for dynamically created forms.

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/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 "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/form_field_data_predictions.h"
 #include "grit/component_strings.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/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::WebDocument;
 using blink::WebFormControlElement;
 using blink::WebFormElement;
 using blink::WebFrame;
 using blink::WebInputElement;
 using blink::WebSelectElement;
@@ skipping 28 matching lines @@
     states->erase(*it);
   }
 }
 
 FormCache::FormCache() {
 }
 
 FormCache::~FormCache() {
 }
 
-void FormCache::ExtractNewForms(const WebFrame& frame,
-                                std::vector<FormData>* forms) {
+void FormCache::ExtractForms(const WebFrame& frame,
+                             std::vector<FormData>* forms) {
+  ExtractFormsAndFormElements(frame, kRequiredAutofillFields, forms, NULL);
+}
+
+bool FormCache::ExtractFormsAndFormElements(
+    const WebFrame& frame,
+    size_t minimum_required_fields,
+    std::vector<FormData>* forms,
+    std::vector<WebFormElement>* web_form_elements) {
+  // Reset the cache for this frame.
+  ResetFrame(frame);
+
   WebDocument document = frame.document();
   if (document.isNull())
-    return;
+    return false;
 
   web_documents_.insert(document);
 
   WebVector<WebFormElement> web_forms;
   document.forms(web_forms);
 
   size_t num_fields_seen = 0;
+  bool has_skipped_forms = false;
   for (size_t i = 0; i < web_forms.size(); ++i) {
     WebFormElement form_element = web_forms[i];
 
     std::vector<WebFormControlElement> control_elements;
     ExtractAutofillableElements(form_element, autofill::REQUIRE_NONE,
                                 &control_elements);
 
     size_t num_editable_elements = 0;
     for (size_t j = 0; j < control_elements.size(); ++j) {
       WebFormControlElement element = control_elements[j];
@@ skipping 16 matching lines @@
               std::make_pair(input_element, input_element.isChecked()));
         } else {
           ++num_editable_elements;
         }
       }
     }
 
     // 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 (num_editable_elements < kRequiredAutofillFields &&
+    if (num_editable_elements < minimum_required_fields &&
         control_elements.size() > 0) {
+      has_skipped_forms = true;
       continue;
     }
 
     FormData form;
     ExtractMask extract_mask =
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
 
     if (!WebFormElementToFormData(form_element, WebFormControlElement(),
                                   REQUIRE_NONE, extract_mask, &form, NULL)) {
       continue;
     }
 
     num_fields_seen += form.fields.size();
     if (num_fields_seen > kMaxParseableFields)
       break;
 
-    if (form.fields.size() >= kRequiredAutofillFields &&
-        !parsed_forms_[&frame].count(form)) {
+    if (form.fields.size() >= minimum_required_fields) {
       forms->push_back(form);
-      parsed_forms_[&frame].insert(form);
+      if (web_form_elements)
+        web_form_elements->push_back(form_element);
+    } else {
+      has_skipped_forms = true;
     }
   }
+
+  // Return true if there are any WebFormElements skipped, else false.
+  return has_skipped_forms;
 }
 
 void FormCache::ResetFrame(const WebFrame& frame) {
   std::vector<WebDocument> documents_to_delete;
   for (std::set<WebDocument>::const_iterator it = web_documents_.begin();
        it != web_documents_.end(); ++it) {
     const WebFrame* document_frame = it->frame();
     if (!document_frame || document_frame == &frame)
       documents_to_delete.push_back(*it);
   }
 
   for (std::vector<WebDocument>::const_iterator it =
            documents_to_delete.begin();
        it != documents_to_delete.end(); ++it) {
     web_documents_.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;
@@ skipping 108 matching lines @@
       element->setAttribute("placeholder",
                             WebString(base::UTF8ToUTF16(placeholder)));
     }
     element->setAttribute("title", WebString(title));
   }
 
   return true;
 }
 
 }  // namespace autofill