[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 115 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 25 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()));
+      GetAutofillDriver()->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()));
+    GetAutofillDriver()->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()));
+    GetAutofillDriver()->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) {
+    GetAutofillDriver()->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()));
+  GetAutofillDriver()->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 44 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()));
+    GetAutofillDriver()->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();
+  GetAutofillDriver()->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.back() = 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()));
+  GetAutofillDriver()->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()));
+
+  GetAutofillDriver()->DidPreviewAutofillFormData();
 }
 
-void AutofillAgent::OnClearForm() {
+void AutofillAgent::OnPing() {
+  GetAutofillDriver()->PingAck();
+}
+
+void AutofillAgent::FieldTypePredictionsAvailable(
+    mojo::Array<FormDataPredictions> forms) {
+  for (size_t i = 0; i < forms.size(); ++i) {

[dcheng, 2016/07/12 14:22:12]

Nit: I think ranged-based for loops work with mojo::Array (and will require less
changes in the future if mojo starts passing vectors as STL vectors directly).

[leonhsl(Using Gerrit), 2016/07/13 03:48:30]

Done.

+    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 139 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_)));
+  GetAutofillDriver()->SetDataList(
+      mojo::Array<mojo::String>::From(data_list_values),
+      mojo::Array<mojo::String>::From(data_list_labels));
+  GetAutofillDriver()->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));
+    GetAutofillDriver()->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()));
+
+  GetAutofillDriver()->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::GetAutofillDriver() {
+  if (!mojo_autofill_driver_.is_bound() ||
+      mojo_autofill_driver_.encountered_error()) {

[dcheng, 2016/07/12 14:22:12]

How comes this check isn't simply !mojo_autofill_driver_? What's the difference?

ALso, a similar question to earlier applies: why do we want to late bind, and
why do we want to reconnect on connection error? On a connection error, I'd
imagine we'd have consistency problems.

[leonhsl(Using Gerrit), 2016/07/13 03:48:30]

En,, seems reconnecting after a connection error is a problem. Let me consider
more about this..

[dcheng, 2016/07/14 04:31:44]

Shall we remove the reconnecting part?

[leonhsl(Using Gerrit), 2016/07/14 09:57:31]

Yeah,, I think I've finally figured out that we do not need reconnect here. The
normal scenario of binding remote AutofillDriver would not close the pipe
unexpectedly except when AutofillDriver destroyed, otherwise if connection error
happened it just means something really went wrong and even reconnecting would
not make anything better. Thanks for raising the discussion thread in
chromium-mojo@ and getting things clearer! 
Done.

+    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