[Autofill] Migrate ContentAutofillDriver<-->AutofillAgent IPCs to mojo.

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 <stddef.h>
 
 #include <tuple>
 
@@ skipping 24 matching lines @@
 #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/password_form_fill_data.h"
 #include "components/autofill/core/common/save_password_progress_logger.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 "mojo/common/common_type_converters.h"
 #include "net/cert/cert_status_flags.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.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 117 matching lines @@
     : content::RenderFrameObserver(render_frame),
       form_cache_(*render_frame->GetWebFrame()),
       password_autofill_agent_(password_autofill_agent),
       password_generation_agent_(password_generation_agent),
       legacy_(render_frame->GetRenderView(), this),
       autofill_query_id_(0),
       was_query_node_autofilled_(false),
       ignore_text_changes_(false),
       is_popup_possibly_visible_(false),
       is_generation_popup_possibly_visible_(false),
+      binding_(this),
       weak_ptr_factory_(this) {
   render_frame->GetWebFrame()->setAutofillClient(this);
+  password_autofill_agent->SetAutofillAgent(this);
 
   // AutofillAgent is guaranteed to outlive |render_frame|.
   render_frame->GetInterfaceRegistry()->AddInterface(
       base::Bind(&AutofillAgent::BindRequest, base::Unretained(this)));
 
   // This owns itself, and will delete itself when |render_frame| is destructed
   // (same as AutofillAgent). This object must be constructed after
   // AutofillAgent so that password generation UI is shown before password
   // manager UI (see https://crbug.com/498545).
   new PageClickTracker(render_frame, this);
 }
 
 AutofillAgent::~AutofillAgent() {}
 
 void AutofillAgent::BindRequest(mojom::AutofillAgentRequest request) {
-  bindings_.AddBinding(this, std::move(request));
+  binding_.Bind(std::move(request));
 }
 
 bool AutofillAgent::FormDataCompare::operator()(const FormData& lhs,
                                                 const FormData& rhs) const {
   return std::tie(lhs.name, lhs.origin, lhs.action, lhs.is_form_tag) <
          std::tie(rhs.name, rhs.origin, rhs.action, rhs.is_form_tag);
 }
 
-bool AutofillAgent::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(AutofillAgent, message)
-    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_ShowInitialPasswordAccountSuggestions,
-                        OnShowInitialPasswordAccountSuggestions);
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
 void AutofillAgent::DidCommitProvisionalLoad(bool is_new_navigation,
                                              bool is_same_page_navigation) {
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   // TODO(dvadym): check if we need to check if it is main frame navigation
   // http://crbug.com/443155
   if (frame->parent())
     return;  // Not a top-level navigation.
 
   if (is_same_page_navigation) {
     OnSamePageNavigationCompleted();
@@ skipping 24 matching lines @@
   HidePopup();
 }
 
 void AutofillAgent::FocusedNodeChanged(const WebNode& node) {
   HidePopup();
 
   if (node.isNull() || !node.isElementNode()) {
     if (!last_interacted_form_.isNull()) {
       // Focus moved away from the last interacted form to somewhere else on
       // the page.
-      Send(new AutofillHostMsg_FocusNoLongerOnForm(routing_id()));
+      GetMojoAutofillDriver()->FocusNoLongerOnForm();
     }
     return;
   }
 
   WebElement web_element = node.toConst<WebElement>();
   const WebInputElement* element = toWebInputElement(&web_element);
 
   if (!last_interacted_form_.isNull() &&
       (!element || last_interacted_form_ != element->form())) {
     // The focused element is not part of the last interacted form (could be
     // in a different form).
-    Send(new AutofillHostMsg_FocusNoLongerOnForm(routing_id()));
+    GetMojoAutofillDriver()->FocusNoLongerOnForm();
     return;
   }
 
   if (!element || !element->isEnabled() || element->isReadOnly() ||
       !element->isTextField())
     return;
 
   element_ = *element;
 }
 
@@ skipping 10 matching lines @@
 
   FireHostSubmitEvents(form_data, form_submitted);
 }
 
 void AutofillAgent::FireHostSubmitEvents(const FormData& form_data,
                                          bool form_submitted) {
   // We remember when we have fired this IPC for this form in this frame load,
   // because forms with a submit handler may fire both WillSendSubmitEvent
   // and WillSubmitForm, and we don't want duplicate messages.
   if (!submitted_forms_.count(form_data)) {
-    Send(new AutofillHostMsg_WillSubmitForm(routing_id(), form_data,
-                                            base::TimeTicks::Now()));
+    GetMojoAutofillDriver()->WillSubmitForm(form_data, base::TimeTicks::Now());
     submitted_forms_.insert(form_data);
   }
 
-  if (form_submitted)
-    Send(new AutofillHostMsg_FormSubmitted(routing_id(), form_data));
+  if (form_submitted) {
+    GetMojoAutofillDriver()->FormSubmitted(form_data);
+  }
 }
 
 void AutofillAgent::Shutdown() {
   legacy_.Shutdown();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void AutofillAgent::FocusChangeComplete() {
   WebDocument doc = render_frame()->GetWebFrame()->document();
   WebElement focused_element;
@@ skipping 31 matching lines @@
     // the initial click (not focused yet), only show password suggestions.
     options.show_full_suggestion_list =
         options.show_full_suggestion_list || was_focused;
     options.show_password_suggestions_only = !was_focused;
   }
   ShowSuggestions(element, options);
 }
 
 void AutofillAgent::textFieldDidEndEditing(const WebInputElement& element) {
   password_autofill_agent_->TextFieldDidEndEditing(element);
-  Send(new AutofillHostMsg_DidEndTextFieldEditing(routing_id()));
+  GetMojoAutofillDriver()->DidEndTextFieldEditing();
 }
 
 void AutofillAgent::textFieldDidChange(const WebFormControlElement& element) {
   DCHECK(toWebInputElement(&element) || form_util::IsTextAreaElement(element));
 
   if (ignore_text_changes_)
     return;
 
   // Disregard text changes that aren't caused by user gestures or pastes. Note
   // that pastes aren't necessarily user gestures because Blink's conception of
@@ skipping 41 matching lines @@
   }
 
   ShowSuggestionsOptions options;
   options.requires_caret_at_end = true;
   ShowSuggestions(element, options);
 
   FormData form;
   FormFieldData field;
   if (form_util::FindFormAndFieldForFormControlElement(element, &form,
                                                        &field)) {
-    Send(new AutofillHostMsg_TextFieldDidChange(routing_id(), form, field,
-                                                base::TimeTicks::Now()));
+    GetMojoAutofillDriver()->TextFieldDidChange(form, field,
+                                                base::TimeTicks::Now());
   }
 }
 
 void AutofillAgent::textFieldDidReceiveKeyDown(const WebInputElement& element,
                                                const WebKeyboardEvent& event) {
   if (event.windowsKeyCode == ui::VKEY_DOWN ||
       event.windowsKeyCode == ui::VKEY_UP) {
     ShowSuggestionsOptions options;
     options.autofill_on_empty_values = true;
     options.requires_caret_at_end = true;
@@ skipping 10 matching lines @@
 void AutofillAgent::dataListOptionsChanged(const WebInputElement& element) {
   if (!is_popup_possibly_visible_ || !element.focused())
     return;
 
   TextFieldDidChangeImpl(element);
 }
 
 void AutofillAgent::firstUserGestureObserved() {
   password_autofill_agent_->FirstUserGestureObserved();
 
-  ConnectToMojoAutofillDriverIfNeeded();
-  mojo_autofill_driver_->FirstUserGestureObserved();
+  GetMojoAutofillDriver()->FirstUserGestureObserved();
 }
 
-void AutofillAgent::AcceptDataListSuggestion(
+void AutofillAgent::DoAcceptDataListSuggestion(
     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()) {
     std::vector<base::string16> parts = base::SplitString(
         base::StringPiece16(input_element->editingValue()),
         base::ASCIIToUTF16(","), base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
     if (parts.size() == 0)
       parts.push_back(base::string16());
 
     base::string16 last_part = parts.back();
     // We want to keep just the leading whitespace.
     for (size_t i = 0; i < last_part.size(); ++i) {
       if (!base::IsUnicodeWhitespace(last_part[i])) {
         last_part = last_part.substr(0, i);
         break;
       }
     }
     last_part.append(suggested_value);
     parts[parts.size() - 1] = last_part;
 
     new_value = base::JoinString(parts, base::ASCIIToUTF16(","));
   }
-  FillFieldWithValue(new_value, input_element);
+  DoFillFieldWithValue(new_value, input_element);
 }
 
-void AutofillAgent::OnFieldTypePredictionsAvailable(
-    const std::vector<FormDataPredictions>& forms) {
-  for (size_t i = 0; i < forms.size(); ++i) {
-    form_cache_.ShowPredictions(forms[i]);
-  }
+// mojom::AutofillAgent:
+void AutofillAgent::FirstUserGestureObservedInTab() {
+  password_autofill_agent_->FirstUserGestureObserved();
 }
 
-void AutofillAgent::OnFillForm(int query_id, const FormData& form) {
-  if (query_id != autofill_query_id_)
+void AutofillAgent::FillForm(int32_t id, const FormData& form) {
+  if (id != autofill_query_id_)
     return;
 
   was_query_node_autofilled_ = element_.isAutofilled();
   form_util::FillForm(form, element_);
   if (!element_.form().isNull())
     last_interacted_form_ = element_.form();
 
-  Send(new AutofillHostMsg_DidFillAutofillFormData(routing_id(), form,
-                                                   base::TimeTicks::Now()));
+  GetMojoAutofillDriver()->DidFillAutofillFormData(form,
+                                                   base::TimeTicks::Now());
 }
 
-// mojom::AutofillAgent:
-void AutofillAgent::FirstUserGestureObservedInTab() {
-  password_autofill_agent_->FirstUserGestureObserved();
-}
-
-void AutofillAgent::OnPing() {
-  Send(new AutofillHostMsg_PingAck(routing_id()));
-}
-
-void AutofillAgent::OnPreviewForm(int query_id, const FormData& form) {
-  if (query_id != autofill_query_id_)
+void AutofillAgent::PreviewForm(int32_t id, const FormData& form) {
+  if (id != autofill_query_id_)
     return;
 
   was_query_node_autofilled_ = element_.isAutofilled();
   form_util::PreviewForm(form, element_);
-  Send(new AutofillHostMsg_DidPreviewAutofillFormData(routing_id()));
+
+  GetMojoAutofillDriver()->DidPreviewAutofillFormData();
 }
 
-void AutofillAgent::OnClearForm() {
+void AutofillAgent::OnPing() {
+  GetMojoAutofillDriver()->PingAck();
+}
+
+void AutofillAgent::FieldTypePredictionsAvailable(
+    mojo::Array<FormDataPredictions> forms) {
+  for (size_t i = 0; i < forms.size(); ++i) {
+    form_cache_.ShowPredictions(forms[i]);
+  }
+}
+
+void AutofillAgent::ClearForm() {
   form_cache_.ClearFormWithElement(element_);
 }
 
-void AutofillAgent::OnClearPreviewedForm() {
+void AutofillAgent::ClearPreviewedForm() {
   if (!element_.isNull()) {
     if (password_autofill_agent_->DidClearAutofillSelection(element_))
       return;
 
     form_util::ClearPreviewedFormWithElement(element_,
                                              was_query_node_autofilled_);
   } else {
     // TODO(isherman): There seem to be rare cases where this code *is*
     // reachable: see [ http://crbug.com/96321#c6 ].  Ideally we would
     // understand those cases and fix the code to avoid them.  However, so far I
     // have been unable to reproduce such a case locally.  If you hit this
     // NOTREACHED(), please file a bug against me.
     NOTREACHED();
   }
 }
 
-void AutofillAgent::OnFillFieldWithValue(const base::string16& value) {
+void AutofillAgent::FillFieldWithValue(const mojo::String& value) {
   WebInputElement* input_element = toWebInputElement(&element_);
   if (input_element) {
-    FillFieldWithValue(value, input_element);
+    DoFillFieldWithValue(value.To<base::string16>(), input_element);
     input_element->setAutofilled(true);
   }
 }
 
-void AutofillAgent::OnPreviewFieldWithValue(const base::string16& value) {
+void AutofillAgent::PreviewFieldWithValue(const mojo::String& value) {
   WebInputElement* input_element = toWebInputElement(&element_);
   if (input_element)
-    PreviewFieldWithValue(value, input_element);
+    DoPreviewFieldWithValue(value.To<base::string16>(), input_element);
 }
 
-void AutofillAgent::OnAcceptDataListSuggestion(const base::string16& value) {
-  AcceptDataListSuggestion(value);
+void AutofillAgent::AcceptDataListSuggestion(const mojo::String& value) {
+  DoAcceptDataListSuggestion(value.To<base::string16>());
 }
 
-void AutofillAgent::OnFillPasswordSuggestion(const base::string16& username,
-                                             const base::string16& password) {
+void AutofillAgent::FillPasswordSuggestion(const mojo::String& username,
+                                           const mojo::String& password) {
   bool handled = password_autofill_agent_->FillSuggestion(
-      element_,
-      username,
-      password);
+      element_, username.To<base::string16>(), password.To<base::string16>());
   DCHECK(handled);
 }
 
-void AutofillAgent::OnPreviewPasswordSuggestion(
-    const base::string16& username,
-    const base::string16& password) {
+void AutofillAgent::PreviewPasswordSuggestion(const mojo::String& username,
+                                              const mojo::String& password) {
   bool handled = password_autofill_agent_->PreviewSuggestion(
-      element_,
-      username,
-      password);
+      element_, username.To<base::string16>(), password.To<base::string16>());
   DCHECK(handled);
 }
 
-void AutofillAgent::OnShowInitialPasswordAccountSuggestions(
-    int key,
+void AutofillAgent::ShowInitialPasswordAccountSuggestions(
+    int32_t key,
     const PasswordFormFillData& form_data) {
   std::vector<blink::WebInputElement> elements;
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (password_autofill_agent_->logging_state_active()) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
     logger->LogMessage(SavePasswordProgressLogger::
                            STRING_ON_SHOW_INITIAL_PASSWORD_ACCOUNT_SUGGESTIONS);
   }
   password_autofill_agent_->GetFillableElementFromFormData(
       key, form_data, logger.get(), &elements);
@@ skipping 103 matching lines @@
   if (input_element) {
     // Find the datalist values and send them to the browser process.
     GetDataListSuggestions(*input_element,
                            &data_list_values,
                            &data_list_labels);
     TrimStringVectorForIPC(&data_list_values);
     TrimStringVectorForIPC(&data_list_labels);
   }
 
   is_popup_possibly_visible_ = true;
-  Send(new AutofillHostMsg_SetDataList(routing_id(),
-                                       data_list_values,
-                                       data_list_labels));
 
-  Send(new AutofillHostMsg_QueryFormFieldAutofill(
-           routing_id(),
-           autofill_query_id_,
-           form,
-           field,
-           render_frame()->GetRenderView()->ElementBoundsInWindow(element_)));
+  GetMojoAutofillDriver()->SetDataList(
+      mojo::Array<mojo::String>::From(data_list_values),
+      mojo::Array<mojo::String>::From(data_list_labels));
+  GetMojoAutofillDriver()->QueryFormFieldAutofill(
+      autofill_query_id_, form, field,
+      render_frame()->GetRenderView()->ElementBoundsInWindow(element_));
 }
 
-void AutofillAgent::FillFieldWithValue(const base::string16& value,
-                                       WebInputElement* node) {
+void AutofillAgent::DoFillFieldWithValue(const base::string16& value,
+                                         WebInputElement* node) {
   base::AutoReset<bool> auto_reset(&ignore_text_changes_, true);
   node->setEditingValue(value.substr(0, node->maxLength()));
 }
 
-void AutofillAgent::PreviewFieldWithValue(const base::string16& value,
-                                          WebInputElement* node) {
+void AutofillAgent::DoPreviewFieldWithValue(const base::string16& value,
+                                            WebInputElement* node) {
   was_query_node_autofilled_ = element_.isAutofilled();
   node->setSuggestedValue(value.substr(0, node->maxLength()));
   node->setAutofilled(true);
   form_util::PreviewSuggestion(node->suggestedValue(), node->value(), node);
 }
 
 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();
 
   WebLocalFrame* frame = render_frame()->GetWebFrame();
   std::vector<FormData> forms = form_cache_.ExtractNewForms();
 
   // Always communicate to browser process for topmost frame.
   if (!forms.empty() || !frame->parent()) {
-    Send(new AutofillHostMsg_FormsSeen(routing_id(), forms,
-                                       forms_seen_timestamp));
+    GetMojoAutofillDriver()->FormsSeen(std::move(forms), forms_seen_timestamp);
   }
 }
 
 void AutofillAgent::HidePopup() {
   if (!is_popup_possibly_visible_)
     return;
   is_popup_possibly_visible_ = false;
   is_generation_popup_possibly_visible_ = false;
-  Send(new AutofillHostMsg_HidePopup(routing_id()));
+
+  GetMojoAutofillDriver()->HidePopup();
 }
 
 bool AutofillAgent::IsUserGesture() const {
   return WebUserGestureIndicator::isProcessingUserGesture();
 }
 
 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->isLoading()) {
       ProcessForms();
       password_autofill_agent_->OnDynamicFormsSeen();
       if (password_generation_agent_)
         password_generation_agent_->OnDynamicFormsSeen();
       return;
     }
   }
 }
 
 void AutofillAgent::ajaxSucceeded() {
   OnSamePageNavigationCompleted();
   password_autofill_agent_->AJAXSucceeded();
 }
 
-void AutofillAgent::ConnectToMojoAutofillDriverIfNeeded() {
-  if (mojo_autofill_driver_.is_bound() &&
-      !mojo_autofill_driver_.encountered_error())
-    return;
+const mojom::AutofillDriverPtr& AutofillAgent::GetMojoAutofillDriver() {
+  if (!mojo_autofill_driver_.is_bound() ||
+      mojo_autofill_driver_.encountered_error()) {
+    render_frame()->GetRemoteInterfaces()->GetInterface(
+        mojo::GetProxy(&mojo_autofill_driver_));
+  }
 
-  render_frame()->GetRemoteInterfaces()->GetInterface(&mojo_autofill_driver_);
+  return mojo_autofill_driver_;
 }
 
 // LegacyAutofillAgent ---------------------------------------------------------
 
 AutofillAgent::LegacyAutofillAgent::LegacyAutofillAgent(
     content::RenderView* render_view,
     AutofillAgent* agent)
     : content::RenderViewObserver(render_view), agent_(agent) {
 }
 
 AutofillAgent::LegacyAutofillAgent::~LegacyAutofillAgent() {
 }
 
 void AutofillAgent::LegacyAutofillAgent::Shutdown() {
   agent_ = nullptr;
 }
 
 void AutofillAgent::LegacyAutofillAgent::OnDestruct() {
   // No-op. Don't delete |this|.
 }
 
 void AutofillAgent::LegacyAutofillAgent::FocusChangeComplete() {
   if (agent_)
     agent_->FocusChangeComplete();
 }
 
 }  // namespace autofill