Refactor Autofill for out of process iframes (OOPIF).

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"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/page_click_tracker.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/password_generation_agent.h"
 #include "components/autofill/core/common/autofill_constants.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_data_predictions.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/web_element_descriptor.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/ssl_status.h"
 #include "content/public/common/url_constants.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "net/cert/cert_status_flags.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDataSource.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"
@@ skipping 81 matching lines @@
 
 AutofillAgent::ShowSuggestionsOptions::ShowSuggestionsOptions()
     : autofill_on_empty_values(false),
       requires_caret_at_end(false),
       display_warning_if_disabled(false),
       datalist_only(false),
       show_full_suggestion_list(false),
       show_password_suggestions_only(false) {
 }
 
-AutofillAgent::AutofillAgent(content::RenderView* render_view,
+AutofillAgent::AutofillAgent(content::RenderFrame* render_frame,
                              PasswordAutofillAgent* password_autofill_agent,
                              PasswordGenerationAgent* password_generation_agent)
-    : content::RenderViewObserver(render_view),
+    : content::RenderFrameObserver(render_frame),
       password_autofill_agent_(password_autofill_agent),
       password_generation_agent_(password_generation_agent),
+      legacy_(render_frame->GetRenderView(), this),
+      page_click_tracker_(render_frame->GetRenderView(), this),
       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),
       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);
+  render_frame->GetWebFrame()->setAutofillClient(this);
 }
 
 AutofillAgent::~AutofillAgent() {}
 
 bool AutofillAgent::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AutofillAgent, message)
+  IPC_MESSAGE_HANDLER(AutofillMsg_FirstUserGestureObservedInTab,
+                      OnFirstUserGestureObservedInTab)
     IPC_MESSAGE_HANDLER(AutofillMsg_Ping, OnPing)
     IPC_MESSAGE_HANDLER(AutofillMsg_FillForm, OnFillForm)
     IPC_MESSAGE_HANDLER(AutofillMsg_PreviewForm, OnPreviewForm)
     IPC_MESSAGE_HANDLER(AutofillMsg_FieldTypePredictionsAvailable,
                         OnFieldTypePredictionsAvailable)
     IPC_MESSAGE_HANDLER(AutofillMsg_ClearForm, OnClearForm)
     IPC_MESSAGE_HANDLER(AutofillMsg_ClearPreviewedForm, OnClearPreviewedForm)
     IPC_MESSAGE_HANDLER(AutofillMsg_FillFieldWithValue, OnFillFieldWithValue)
     IPC_MESSAGE_HANDLER(AutofillMsg_PreviewFieldWithValue,
                         OnPreviewFieldWithValue)
     IPC_MESSAGE_HANDLER(AutofillMsg_AcceptDataListSuggestion,
                         OnAcceptDataListSuggestion)
     IPC_MESSAGE_HANDLER(AutofillMsg_FillPasswordSuggestion,
                         OnFillPasswordSuggestion)
     IPC_MESSAGE_HANDLER(AutofillMsg_PreviewPasswordSuggestion,
                         OnPreviewPasswordSuggestion)
     IPC_MESSAGE_HANDLER(AutofillMsg_RequestAutocompleteResult,
                         OnRequestAutocompleteResult)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void AutofillAgent::DidFinishDocumentLoad(WebLocalFrame* frame) {
-  // If the main frame just finished loading, we should process it.
-  if (!frame->parent())
-    main_frame_processed_ = false;
-
-  ProcessForms(*frame);
+void AutofillAgent::DidCommitProvisionalLoad(bool is_new_navigation) {
+  // TODO(estade): |form_cache_| shouldn't track multiple frames.
+  form_cache_.ResetFrame(*render_frame()->GetWebFrame());
 }
 
-void AutofillAgent::DidCommitProvisionalLoad(WebLocalFrame* frame,
-                                             bool is_new_navigation) {
-  form_cache_.ResetFrame(*frame);
+void AutofillAgent::DidFinishDocumentLoad() {
+  ProcessForms();
 }
 
 void AutofillAgent::FrameDetached(WebFrame* frame) {
-  form_cache_.ResetFrame(*frame);
-}
-
-void AutofillAgent::FrameWillClose(WebFrame* frame) {
-  if (in_flight_request_form_.isNull())
+  if (frame != render_frame()->GetWebFrame())
     return;
 
-  for (WebFrame* temp = in_flight_request_form_.document().frame();
-       temp; temp = temp->parent()) {
-    if (temp == frame) {
-      Send(new AutofillHostMsg_CancelRequestAutocomplete(routing_id()));
-      break;
-    }
-  }
+  form_cache_.ResetFrame(*frame);
 }
 
 void AutofillAgent::WillSubmitForm(WebLocalFrame* frame,
                                    const WebFormElement& form) {
+  if (frame != render_frame()->GetWebFrame())
+    return;
+
   FormData form_data;
   if (WebFormElementToFormData(form,
                                WebFormControlElement(),
                                REQUIRE_NONE,
                                static_cast<ExtractMask>(
                                    EXTRACT_VALUE | EXTRACT_OPTION_TEXT),
                                &form_data,
                                NULL)) {
     Send(new AutofillHostMsg_FormSubmitted(routing_id(), form_data,
                                            base::TimeTicks::Now()));
   }
 }
 
+void AutofillAgent::DidChangeScrollOffset(WebLocalFrame* frame) {
+  if (frame != render_frame()->GetWebFrame())
+    return;
+
+  HidePopup();
+}
+
 void AutofillAgent::FocusedNodeChanged(const WebNode& node) {
   HidePopup();
 
+  if (node.isNull() || !node.isElementNode())
+    return;
+
+  if (node.document().frame() != render_frame()->GetWebFrame())
+    return;
+
   if (password_generation_agent_ &&
       password_generation_agent_->FocusedNodeHasChanged(node)) {
     is_popup_possibly_visible_ = true;
     return;
   }
 
-  if (node.isNull() || !node.isElementNode())
-    return;
-
   WebElement web_element = node.toConst<WebElement>();
 
   if (!web_element.document().frame())
-      return;
+    return;
 
   const WebInputElement* element = toWebInputElement(&web_element);
 
   if (!element || !element->isEnabled() || element->isReadOnly() ||
       !element->isTextField() || element->isPasswordField())
     return;
 
   element_ = *element;
 }
 
 void AutofillAgent::OrientationChangeEvent() {
   HidePopup();
 }
 
 void AutofillAgent::Resized() {
   HidePopup();
 }
 
-void AutofillAgent::DidChangeScrollOffset(WebLocalFrame*) {
-  HidePopup();
+void AutofillAgent::LegacyFrameWillClose(blink::WebFrame* frame) {
+  if (in_flight_request_form_.isNull())
+    return;
+
+  for (blink::WebFrame* temp = render_frame()->GetWebFrame(); temp;
+       temp = temp->parent()) {
+    if (temp == frame) {
+      Send(new AutofillHostMsg_CancelRequestAutocomplete(routing_id()));
+      break;
+    }
+  }
 }
 
 void AutofillAgent::didRequestAutocomplete(
     const WebFormElement& form) {
+  DCHECK_EQ(form.document().frame(), render_frame()->GetWebFrame());
+
   // Disallow the dialog over non-https or broken https, except when the
   // ignore SSL flag is passed. See http://crbug.com/272512.
   // TODO(palmer): this should be moved to the browser process after frames
   // get their own processes.
   GURL url(form.document().url());
   content::SSLStatus ssl_status =
-      render_view()->GetSSLStatusOfFrame(form.document().frame());
+      render_frame()->GetRenderView()->GetSSLStatusOfFrame(
+          form.document().frame());
   bool is_safe = url.SchemeIs(url::kHttpsScheme) &&
       !net::IsCertStatusError(ssl_status.cert_status);
   bool allow_unsafe = base::CommandLine::ForCurrentProcess()->HasSwitch(
       ::switches::kReduceSecurityForTesting);
 
   FormData form_data;
   std::string error_message;
   if (!in_flight_request_form_.isNull()) {
     error_message = "already active.";
   } else if (!is_safe && !allow_unsafe) {
@@ skipping 30 matching lines @@
   Send(new AutofillHostMsg_RequestAutocomplete(routing_id(), form_data, url));
 }
 
 void AutofillAgent::setIgnoreTextChanges(bool ignore) {
   ignore_text_changes_ = ignore;
 }
 
 void AutofillAgent::FormControlElementClicked(
     const WebFormControlElement& element,
     bool was_focused) {
+  // TODO(estade): Remove this check when PageClickTracker is per-frame.
+  if (element.document().frame() != render_frame()->GetWebFrame())
+    return;
+
   const WebInputElement* input_element = toWebInputElement(&element);
   if (!input_element && !IsTextAreaElement(element))
     return;
 
   ShowSuggestionsOptions options;
   options.autofill_on_empty_values = true;
   options.display_warning_if_disabled = true;
   options.show_full_suggestion_list = element.isAutofilled();
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 96 matching lines @@
 
 void AutofillAgent::openTextDataListChooser(const WebInputElement& element) {
   ShowSuggestionsOptions options;
   options.autofill_on_empty_values = true;
   options.datalist_only = true;
   ShowSuggestions(element, options);
 }
 
 void AutofillAgent::firstUserGestureObserved() {
   password_autofill_agent_->FirstUserGestureObserved();
+  Send(new AutofillHostMsg_FirstUserGestureObserved(routing_id()));
 }
 
 void AutofillAgent::AcceptDataListSuggestion(
     const base::string16& suggested_value) {
   WebInputElement* input_element = toWebInputElement(&element_);
   DCHECK(input_element);
   base::string16 new_value = suggested_value;
   // If this element takes multiple values then replace the last part with
   // the suggestion.
   if (input_element->isMultiple() && input_element->isEmailField()) {
@@ skipping 20 matching lines @@
 }
 
 void AutofillAgent::OnFieldTypePredictionsAvailable(
     const std::vector<FormDataPredictions>& forms) {
   for (size_t i = 0; i < forms.size(); ++i) {
     form_cache_.ShowPredictions(forms[i]);
   }
 }
 
 void AutofillAgent::OnFillForm(int query_id, const FormData& form) {
-  if (!render_view()->GetWebView() || query_id != autofill_query_id_)
+  if (query_id != autofill_query_id_)
     return;
 
   was_query_node_autofilled_ = element_.isAutofilled();
   FillForm(form, element_);
   Send(new AutofillHostMsg_DidFillAutofillFormData(routing_id(),
                                                    base::TimeTicks::Now()));
 }
 
+void AutofillAgent::OnFirstUserGestureObservedInTab() {
+  password_autofill_agent_->FirstUserGestureObserved();
+}
+
 void AutofillAgent::OnPing() {
   Send(new AutofillHostMsg_PingAck(routing_id()));
 }
 
 void AutofillAgent::OnPreviewForm(int query_id, const FormData& form) {
-  if (!render_view()->GetWebView() || query_id != autofill_query_id_)
+  if (query_id != autofill_query_id_)
     return;
 
   was_query_node_autofilled_ = element_.isAutofilled();
   PreviewForm(form, element_);
   Send(new AutofillHostMsg_DidPreviewAutofillFormData(routing_id()));
 }
 
 void AutofillAgent::OnClearForm() {
   form_cache_.ClearFormWithElement(element_);
 }
@@ skipping 166 matching lines @@
   FormFieldData field;
   if (!FindFormAndFieldForFormControlElement(element, &form, &field,
                                              requirements)) {
     // If we didn't find the cached form, at least let autocomplete have a shot
     // at providing suggestions.
     WebFormControlElementToFormField(element, EXTRACT_VALUE, &field);
   }
   if (datalist_only)
     field.should_autocomplete = false;
 
-  gfx::RectF bounding_box_scaled =
-      GetScaledBoundingBox(web_view_->pageScaleFactor(), &element_);
+  gfx::RectF bounding_box_scaled = GetScaledBoundingBox(
+      render_frame()->GetRenderView()->GetWebView()->pageScaleFactor(),
+      &element_);
 
   std::vector<base::string16> data_list_values;
   std::vector<base::string16> data_list_labels;
   const WebInputElement* input_element = toWebInputElement(&element);
   if (input_element) {
     // Find the datalist values and send them to the browser process.
     GetDataListSuggestions(*input_element,
                            datalist_only,
                            &data_list_values,
                            &data_list_labels);
@@ skipping 22 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) {
+void AutofillAgent::ProcessForms() {
   // 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);
+  WebLocalFrame* frame = render_frame()->GetWebFrame();
+  std::vector<FormData> forms = form_cache_.ExtractNewForms(*frame);
 
   // Always communicate to browser process for topmost frame.
-  if (!forms.empty() ||
-      (!frame.parent() && !main_frame_processed_)) {
+  if (!forms.empty() || !frame->parent()) {
     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()));
 }
 
 void AutofillAgent::didAssociateFormControls(const WebVector<WebNode>& nodes) {
   for (size_t i = 0; i < nodes.size(); ++i) {
     WebLocalFrame* frame = nodes[i].document().frame();
     // Only monitors dynamic forms created in the top frame. Dynamic forms
     // 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.
-    if (frame && !frame->parent() && !frame->isLoading()) {
-      ProcessForms(*frame);
-      password_autofill_agent_->OnDynamicFormsSeen(frame);
+    if (frame && !frame->isLoading()) {
+      ProcessForms();
+      password_autofill_agent_->OnDynamicFormsSeen();
       if (password_generation_agent_)
-        password_generation_agent_->OnDynamicFormsSeen(frame);
+        password_generation_agent_->OnDynamicFormsSeen();
       return;
     }
   }
 }
 
+// LegacyAutofillAgent ---------------------------------------------------------
+
+AutofillAgent::LegacyAutofillAgent::LegacyAutofillAgent(
+    content::RenderView* render_view,
+    AutofillAgent* agent)
+    : content::RenderViewObserver(render_view), agent_(agent) {
+}
+
+AutofillAgent::LegacyAutofillAgent::~LegacyAutofillAgent() {
+}
+
+void AutofillAgent::LegacyAutofillAgent::OnDestruct() {
+  // No-op. Don't delete |this|.
+}
+
+void AutofillAgent::LegacyAutofillAgent::FrameDetached(WebFrame* frame) {
+  agent_->FrameDetached(frame);
+}
+
+void AutofillAgent::LegacyAutofillAgent::WillSubmitForm(
+    WebLocalFrame* frame,
+    const WebFormElement& form) {
+  agent_->WillSubmitForm(frame, form);
+}
+
+void AutofillAgent::LegacyAutofillAgent::DidChangeScrollOffset(
+    WebLocalFrame* frame) {
+  agent_->DidChangeScrollOffset(frame);
+}
+
+void AutofillAgent::LegacyAutofillAgent::FocusedNodeChanged(
+    const WebNode& node) {
+  agent_->FocusedNodeChanged(node);
+}
+
+void AutofillAgent::LegacyAutofillAgent::OrientationChangeEvent() {
+  agent_->OrientationChangeEvent();
+}
+
+void AutofillAgent::LegacyAutofillAgent::Resized() {
+  agent_->Resized();
+}
+
+void AutofillAgent::LegacyAutofillAgent::FrameWillClose(
+    blink::WebFrame* frame) {
+  agent_->LegacyFrameWillClose(frame);
+}
+
 }  // namespace autofill