Reland: [Autofill] Migrate ContentPasswordManagerDriver<-->Password{Autofill,Generation}Agent IPCs …

components/autofill/content/renderer/password_autofill_agent.cc

Index: components/autofill/content/renderer/password_autofill_agent.cc
diff --git a/components/autofill/content/renderer/password_autofill_agent.cc b/components/autofill/content/renderer/password_autofill_agent.cc
index 34e28598f3145eb9c75ac0ff73b0ef58e46d428d..fc8ef276da0d6ce63e8a1af4e8211f52f7dc538c 100644
--- a/components/autofill/content/renderer/password_autofill_agent.cc
+++ b/components/autofill/content/renderer/password_autofill_agent.cc
@@ -14,11 +14,12 @@
 #include "base/i18n/case_conversion.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
-#include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/content/renderer/renderer_save_password_progress_logger.h"
@@ -30,6 +31,8 @@
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
+#include "services/shell/public/cpp/interface_provider.h"
+#include "services/shell/public/cpp/interface_registry.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebAutofillClient.h"
@@ -578,13 +581,22 @@ PasswordAutofillAgent::PasswordAutofillAgent(content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
       logging_state_active_(false),
       was_username_autofilled_(false),
-      was_password_autofilled_(false) {
-  Send(new AutofillHostMsg_PasswordAutofillAgentConstructed(routing_id()));
+      was_password_autofilled_(false),
+      binding_(this) {
+  // PasswordAutofillAgent is guaranteed to outlive |render_frame|.
+  render_frame->GetInterfaceRegistry()->AddInterface(
+      base::Bind(&PasswordAutofillAgent::BindRequest, base::Unretained(this)));
+  GetPasswordManagerDriver()->PasswordAutofillAgentConstructed();
 }
 
 PasswordAutofillAgent::~PasswordAutofillAgent() {
 }
 
+void PasswordAutofillAgent::BindRequest(
+    mojom::PasswordAutofillAgentRequest request) {
+  binding_.Bind(std::move(request));
+}
+
 void PasswordAutofillAgent::SetAutofillAgent(AutofillAgent* autofill_agent) {
   autofill_agent_ = autofill_agent;
 }
@@ -919,8 +931,7 @@ void PasswordAutofillAgent::OnSamePageNavigationCompleted() {
     return;
   }
 
-  Send(new AutofillHostMsg_InPageNavigation(routing_id(),
-                                            *provisionally_saved_form_));
+  GetPasswordManagerDriver()->InPageNavigation(*provisionally_saved_form_);
   provisionally_saved_form_.reset();
 }
 
@@ -931,7 +942,8 @@ void PasswordAutofillAgent::FirstUserGestureObserved() {
 void PasswordAutofillAgent::SendPasswordForms(bool only_visible) {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
-    logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
+    logger.reset(new RendererSavePasswordProgressLogger(
+        GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_SEND_PASSWORD_FORMS_METHOD);
     logger->LogBoolean(Logger::STRING_ONLY_VISIBLE, only_visible);
   }
@@ -1026,27 +1038,13 @@ void PasswordAutofillAgent::SendPasswordForms(bool only_visible) {
   if (only_visible) {
     blink::WebFrame* main_frame = render_frame()->GetWebFrame()->top();
     bool did_stop_loading = !main_frame || !main_frame->isLoading();
-    Send(new AutofillHostMsg_PasswordFormsRendered(routing_id(), password_forms,
-                                                   did_stop_loading));
+    GetPasswordManagerDriver()->PasswordFormsRendered(password_forms,
+                                                      did_stop_loading);
   } else {
-    Send(new AutofillHostMsg_PasswordFormsParsed(routing_id(), password_forms));
+    GetPasswordManagerDriver()->PasswordFormsParsed(password_forms);
   }
 }
 
-bool PasswordAutofillAgent::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PasswordAutofillAgent, message)
-    IPC_MESSAGE_HANDLER(AutofillMsg_FillPasswordForm, OnFillPasswordForm)
-    IPC_MESSAGE_HANDLER(AutofillMsg_SetLoggingState, OnSetLoggingState)
-    IPC_MESSAGE_HANDLER(AutofillMsg_AutofillUsernameAndPasswordDataReceived,
-                        OnAutofillUsernameAndPasswordDataReceived)
-    IPC_MESSAGE_HANDLER(AutofillMsg_FindFocusedPasswordForm,
-                        OnFindFocusedPasswordForm)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
 void PasswordAutofillAgent::DidFinishDocumentLoad() {
   // The |frame| contents have been parsed, but not yet rendered.  Let the
   // PasswordManager know that forms are loaded, even though we can't yet tell
@@ -1080,8 +1078,7 @@ void PasswordAutofillAgent::FrameDetached() {
   // for examples of sites that perform login using this technique.
   if (render_frame()->GetWebFrame()->parent() &&
       ProvisionallySavedPasswordIsValid()) {
-    Send(new AutofillHostMsg_InPageNavigation(routing_id(),
-                                              *provisionally_saved_form_));
+    GetPasswordManagerDriver()->InPageNavigation(*provisionally_saved_form_);
   }
   FrameClosing();
 }
@@ -1110,7 +1107,8 @@ void PasswordAutofillAgent::WillSendSubmitEvent(
 void PasswordAutofillAgent::WillSubmitForm(const blink::WebFormElement& form) {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
-    logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
+    logger.reset(new RendererSavePasswordProgressLogger(
+        GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_WILL_SUBMIT_FORM_METHOD);
     LogHTMLForm(logger.get(), Logger::STRING_HTML_FORM_FOR_SUBMIT, form);
   }
@@ -1144,8 +1142,7 @@ void PasswordAutofillAgent::WillSubmitForm(const blink::WebFormElement& form) {
     // the frame starts loading. If there are redirects that cause a new
     // RenderView to be instantiated (such as redirects to the WebStore)
     // we will never get to finish the load.
-    Send(new AutofillHostMsg_PasswordFormSubmitted(routing_id(),
-                                                   *submitted_form));
+    GetPasswordManagerDriver()->PasswordFormSubmitted(*submitted_form);
     provisionally_saved_form_.reset();
   } else if (logger) {
     logger->LogMessage(Logger::STRING_FORM_IS_NOT_PASSWORD);
@@ -1159,7 +1156,8 @@ void PasswordAutofillAgent::OnDestruct() {
 void PasswordAutofillAgent::DidStartProvisionalLoad() {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
-    logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
+    logger.reset(new RendererSavePasswordProgressLogger(
+        GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_DID_START_PROVISIONAL_LOAD_METHOD);
   }
 
@@ -1189,8 +1187,8 @@ void PasswordAutofillAgent::DidStartProvisionalLoad() {
             Logger::STRING_PROVISIONALLY_SAVED_FORM_FOR_FRAME,
             *provisionally_saved_form_);
       }
-      Send(new AutofillHostMsg_PasswordFormSubmitted(
-          routing_id(), *provisionally_saved_form_));
+      GetPasswordManagerDriver()->PasswordFormSubmitted(
+          *provisionally_saved_form_);
       provisionally_saved_form_.reset();
     } else {
       ScopedVector<PasswordForm> possible_submitted_forms;
@@ -1224,8 +1222,7 @@ void PasswordAutofillAgent::DidStartProvisionalLoad() {
             logger->LogPasswordForm(Logger::STRING_PASSWORD_FORM_FOUND_ON_PAGE,
                                     *password_form);
           }
-          Send(new AutofillHostMsg_PasswordFormSubmitted(routing_id(),
-                                                         *password_form));
+          GetPasswordManagerDriver()->PasswordFormSubmitted(*password_form);
           break;
         }
       }
@@ -1240,13 +1237,15 @@ void PasswordAutofillAgent::DidStartProvisionalLoad() {
   gatekeeper_.Reset();
 }
 
-void PasswordAutofillAgent::OnFillPasswordForm(
+// mojom::PasswordAutofillAgent:
+void PasswordAutofillAgent::FillPasswordForm(
     int key,
     const PasswordFormFillData& form_data) {
   std::vector<blink::WebInputElement> elements;
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
-    logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
+    logger.reset(new RendererSavePasswordProgressLogger(
+        GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_ON_FILL_PASSWORD_FORM_METHOD);
   }
   GetFillableElementFromFormData(key, form_data, logger.get(), &elements);
@@ -1366,16 +1365,18 @@ void PasswordAutofillAgent::FocusedNodeHasChanged(const blink::WebNode& node) {
                                        &field_value_and_properties_map_);
 }
 
-void PasswordAutofillAgent::OnSetLoggingState(bool active) {
+// mojom::PasswordAutofillAgent:
+void PasswordAutofillAgent::SetLoggingState(bool active) {
   logging_state_active_ = active;
 }
 
-void PasswordAutofillAgent::OnAutofillUsernameAndPasswordDataReceived(
+void PasswordAutofillAgent::AutofillUsernameAndPasswordDataReceived(
     const FormsPredictionsMap& predictions) {
   form_predictions_.insert(predictions.begin(), predictions.end());
 }
 
-void PasswordAutofillAgent::OnFindFocusedPasswordForm() {
+void PasswordAutofillAgent::FindFocusedPasswordForm(
+    const FindFocusedPasswordFormCallback& callback) {
   std::unique_ptr<PasswordForm> password_form;
 
   blink::WebElement element =
@@ -1402,8 +1403,7 @@ void PasswordAutofillAgent::OnFindFocusedPasswordForm() {
   if (!password_form)
     password_form.reset(new PasswordForm());
 
-  Send(new AutofillHostMsg_FocusedPasswordFormFound(
-      routing_id(), *password_form));
+  callback.Run(*password_form);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1444,10 +1444,9 @@ bool PasswordAutofillAgent::ShowSuggestionPopup(
           ? base::string16()
           : static_cast<base::string16>(user_input.value()));
 
-  Send(new AutofillHostMsg_ShowPasswordSuggestions(
-      routing_id(), password_info.key, field.text_direction, username_string,
-      options,
-      render_frame()->GetRenderView()->ElementBoundsInWindow(user_input)));
+  GetPasswordManagerDriver()->ShowPasswordSuggestions(
+      password_info.key, field.text_direction, username_string, options,
+      render_frame()->GetRenderView()->ElementBoundsInWindow(user_input));
   username_query_prefix_ = username_string;
   return CanShowSuggestion(password_info.fill_data, username_string, show_all);
 }
@@ -1499,4 +1498,14 @@ const mojom::AutofillDriverPtr& PasswordAutofillAgent::GetAutofillDriver() {
   return autofill_agent_->GetAutofillDriver();
 }
 
+const mojom::PasswordManagerDriverPtr&
+PasswordAutofillAgent::GetPasswordManagerDriver() {
+  if (!password_manager_driver_) {
+    render_frame()->GetRemoteInterfaces()->GetInterface(
+        mojo::GetProxy(&password_manager_driver_));
+  }
+
+  return password_manager_driver_;
+}
+
 }  // namespace autofill