Revert "Revert of [Autofill] Enable Autofill for dynamically created forms. (https://codereview.chr…

components/autofill/content/renderer/autofill_agent.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/autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
@@ skipping 118 matching lines @@
       password_generation_agent_(password_generation_agent),
       autofill_query_id_(0),
       web_view_(render_view->GetWebView()),
       display_warning_if_disabled_(false),
       was_query_node_autofilled_(false),
       has_shown_autofill_popup_for_current_edit_(false),
       did_set_node_text_(false),
       has_new_forms_for_browser_(false),
       ignore_text_changes_(false),
       is_popup_possibly_visible_(false),
+      main_frame_processed_(false),
       weak_ptr_factory_(this) {
   render_view->GetWebView()->setAutofillClient(this);
 
   // The PageClickTracker is a RenderViewObserver, and hence will be freed when
   // the RenderView is destroyed.
   new PageClickTracker(render_view, this);
 }
 
 AutofillAgent::~AutofillAgent() {}
 
@@ skipping 14 matching lines @@
     IPC_MESSAGE_HANDLER(AutofillMsg_AcceptPasswordAutofillSuggestion,
                         OnAcceptPasswordAutofillSuggestion)
     IPC_MESSAGE_HANDLER(AutofillMsg_RequestAutocompleteResult,
                         OnRequestAutocompleteResult)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void AutofillAgent::DidFinishDocumentLoad(WebLocalFrame* frame) {
-  // Record timestamp on document load. This is used to record overhead of
-  // Autofill feature.
-  forms_seen_timestamp_ = base::TimeTicks::Now();
+  // If the main frame just finished loading, we should process it.
+  if (!frame->parent())
+    main_frame_processed_ = false;
 
-  // The document has now been fully loaded.  Scan for forms to be sent up to
-  // the browser.
-  std::vector<FormData> forms;
-  bool has_more_forms = false;
-  if (!frame->parent()) {
-    form_elements_.clear();
-    has_more_forms = form_cache_.ExtractFormsAndFormElements(
-        *frame, kRequiredAutofillFields, &forms, &form_elements_);
-  } else {
-    form_cache_.ExtractForms(*frame, &forms);
-  }
-
-  autofill::FormsSeenState state = has_more_forms ?
-      autofill::PARTIAL_FORMS_SEEN : autofill::NO_SPECIAL_FORMS_SEEN;
-
-  // Always communicate to browser process for topmost frame.
-  if (!forms.empty() || !frame->parent()) {
-    Send(new AutofillHostMsg_FormsSeen(routing_id(), forms,
-                                       forms_seen_timestamp_,
-                                       state));
-  }
+  ProcessForms(*frame);
 }
 
 void AutofillAgent::FrameDetached(WebFrame* frame) {
   form_cache_.ResetFrame(*frame);
 }
 
 void AutofillAgent::FrameWillClose(WebFrame* frame) {
   if (in_flight_request_form_.isNull())
     return;
 
@@ skipping 467 matching lines @@
 
 void AutofillAgent::PreviewFieldWithValue(const base::string16& value,
                                           WebInputElement* node) {
   was_query_node_autofilled_ = element_.isAutofilled();
   node->setSuggestedValue(value.substr(0, node->maxLength()));
   node->setAutofilled(true);
   node->setSelectionRange(node->value().length(),
                           node->suggestedValue().length());
 }
 
+void AutofillAgent::ProcessForms(const WebLocalFrame& frame) {
+  // Record timestamp of when the forms are first seen. This is used to
+  // measure the overhead of the Autofill feature.
+  base::TimeTicks forms_seen_timestamp = base::TimeTicks::Now();
+
+  std::vector<FormData> forms;
+  form_cache_.ExtractNewForms(frame, &forms);
+
+  // Always communicate to browser process for topmost frame.
+  if (!forms.empty() ||
+      (!frame.parent() && !main_frame_processed_)) {
+    Send(new AutofillHostMsg_FormsSeen(routing_id(), forms,
+                                       forms_seen_timestamp));
+  }
+
+  if (!frame.parent())
+    main_frame_processed_ = true;
+}
+
 void AutofillAgent::HidePopup() {
   if (!is_popup_possibly_visible_)
     return;
 
   if (!element_.isNull())
     OnClearPreviewedForm();
 
   is_popup_possibly_visible_ = false;
   Send(new AutofillHostMsg_HidePopup(routing_id()));
 }
 
-// TODO(isherman): Decide if we want to support non-password autofill with AJAX.
 void AutofillAgent::didAssociateFormControls(const WebVector<WebNode>& nodes) {
   for (size_t i = 0; i < nodes.size(); ++i) {
-    WebFrame* frame = nodes[i].document().frame();
+    WebLocalFrame* frame = nodes[i].document().frame();
     // Only monitors dynamic forms created in the top frame. Dynamic forms
-    // inserted in iframes are not captured yet.
-    if (frame && !frame->parent()) {
+    // inserted in iframes are not captured yet. Frame is only processed
+    // if it has finished loading, otherwise you can end up with a partially
+    // parsed form.

[Ilya Sherman, 2014/05/12 19:57:54]

Is this method guaranteed to be called again once the frame has finished
loading?

[Garrett Casto, 2014/05/12 23:52:51]

I don't think so, but if elements are inserted before the frame has finished
loading we will still see them when DidFinishDocumentLoad() is called.

+    if (frame && !frame->parent() && !frame->isLoading()) {
+      ProcessForms(*frame);
       password_autofill_agent_->OnDynamicFormsSeen(frame);
       return;
     }
   }
 }
 
 }  // namespace autofill