[Autofill] Migrate ContentPasswordManagerDriver<-->Password{Autofill,Generation}Agent IPCs to mojo.

components/autofill/content/renderer/password_generation_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/password_generation_agent.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/form_classifier.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_form_generation_data.h"
 #include "components/autofill/core/common/password_generation_util.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "google_apis/gaia/gaia_urls.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/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace autofill {
@@ skipping 86 matching lines @@
     content::RenderFrame* render_frame,
     PasswordAutofillAgent* password_agent)
     : content::RenderFrameObserver(render_frame),
       password_is_generated_(false),
       is_manually_triggered_(false),
       password_edited_(false),
       generation_popup_shown_(false),
       editing_popup_shown_(false),
       enabled_(password_generation::IsPasswordGenerationEnabled()),
       form_classifier_enabled_(false),
-      password_agent_(password_agent) {
+      password_agent_(password_agent),
+      binding_(this) {
   VLOG(2) << "Password Generation is " << (enabled_ ? "Enabled" : "Disabled");
+  // PasswordGenerationAgent is guaranteed to outlive |render_frame|.
+  render_frame->GetInterfaceRegistry()->AddInterface(base::Bind(
+      &PasswordGenerationAgent::BindRequest, base::Unretained(this)));
 }
 PasswordGenerationAgent::~PasswordGenerationAgent() {}
 
+void PasswordGenerationAgent::BindRequest(
+    mojom::PasswordGenerationAgentRequest request) {
+  binding_.Bind(std::move(request));
+}
+
 void PasswordGenerationAgent::DidFinishDocumentLoad() {
   // Update stats for main frame navigation.
   if (!render_frame()->GetWebFrame()->parent()) {
     // In every navigation, the IPC message sent by the password autofill
     // manager to query whether the current form is blacklisted or not happens
     // when the document load finishes, so we need to clear previous states
     // here before we hear back from the browser. We only clear this state on
     // main frame load as we don't want subframe loads to clear state that we
     // have received from the main frame. Note that we assume there is only one
     // account creation form, but there could be multiple password forms in
@@ skipping 44 matching lines @@
 }
 
 void PasswordGenerationAgent::OnDestruct() {
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
 }
 
 void PasswordGenerationAgent::OnDynamicFormsSeen() {
   FindPossibleGenerationForm();
 }
 
-void PasswordGenerationAgent::OnAllowToRunFormClassifier() {
+void PasswordGenerationAgent::AllowToRunFormClassifier() {
   form_classifier_enabled_ = true;
 }
 
 void PasswordGenerationAgent::RunFormClassifierAndSaveVote(
     const blink::WebFormElement& web_form,
     const PasswordForm& form) {
   DCHECK(form_classifier_enabled_);
 
   base::string16 generation_field;
   ClassifyFormAndFindGenerationField(web_form, &generation_field);
-  Send(new AutofillHostMsg_SaveGenerationFieldDetectedByClassifier(
-      routing_id(), form, generation_field));
+  GetPasswordManagerDriver()->SaveGenerationFieldDetectedByClassifier(
+      form, generation_field);
 }
 
 void PasswordGenerationAgent::FindPossibleGenerationForm() {
   if (!enabled_ || !render_frame())
     return;
 
   // We don't want to generate passwords if the browser won't store or sync
   // them.
   if (!ShouldAnalyzeDocument())
     return;
@@ skipping 51 matching lines @@
            ->document()
            .getSecurityOrigin()
            .canAccessPasswordManager()) {
     VLOG(1) << "No PasswordManager access";
     return false;
   }
 
   return true;
 }
 
-bool PasswordGenerationAgent::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PasswordGenerationAgent, message)
-    IPC_MESSAGE_HANDLER(AutofillMsg_FormNotBlacklisted,
-                        OnFormNotBlacklisted)
-    IPC_MESSAGE_HANDLER(AutofillMsg_GeneratedPasswordAccepted,
-                        OnPasswordAccepted)
-    IPC_MESSAGE_HANDLER(AutofillMsg_FoundFormsEligibleForGeneration,
-                        OnFormsEligibleForGenerationFound);
-    IPC_MESSAGE_HANDLER(AutofillMsg_UserTriggeredGeneratePassword,
-                        OnUserTriggeredGeneratePassword);
-    IPC_MESSAGE_HANDLER(AutofillMsg_AllowToRunFormClassifier,
-                        OnAllowToRunFormClassifier);
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void PasswordGenerationAgent::OnFormNotBlacklisted(const PasswordForm& form) {
+void PasswordGenerationAgent::FormNotBlacklisted(const PasswordForm& form) {
   not_blacklisted_password_form_origins_.push_back(form.origin);
   DetermineGenerationElement();
 }
 
-void PasswordGenerationAgent::OnPasswordAccepted(
+void PasswordGenerationAgent::GeneratedPasswordAccepted(
     const base::string16& password) {
   password_is_generated_ = true;
   password_generation::LogPasswordGenerationEvent(
       password_generation::PASSWORD_ACCEPTED);
   for (auto& password_element : generation_form_data_->password_elements) {
     password_element.setValue(password, true /* sendEvents */);
     // setValue() above may have resulted in JavaScript closing the frame.
     if (!render_frame())
       return;
     password_element.setAutofilled(true);
     // Needed to notify password_autofill_agent that the content of the field
     // has changed. Without this we will overwrite the generated
     // password with an Autofilled password when saving.
     // https://crbug.com/493455
     password_agent_->UpdateStateForTextChange(password_element);
     // Advance focus to the next input field. We assume password fields in
     // an account creation form are always adjacent.
     render_frame()->GetRenderView()->GetWebView()->advanceFocus(false);
   }
   std::unique_ptr<PasswordForm> presaved_form(CreatePasswordFormToPresave());
   if (presaved_form) {
-    Send(new AutofillHostMsg_PresaveGeneratedPassword(routing_id(),
-                                                      *presaved_form));
+    GetPasswordManagerDriver()->PresaveGeneratedPassword(*presaved_form);
   }
 }
 
 std::unique_ptr<PasswordForm>
 PasswordGenerationAgent::CreatePasswordFormToPresave() {
   DCHECK(!generation_element_.isNull());
   // Since the form for presaving should match a form in the browser, create it
   // with the same algorithm (to match html attributes, action, etc.), but
   // change username and password values.
   std::unique_ptr<PasswordForm> password_form;
   if (!generation_element_.form().isNull()) {
     password_form = CreatePasswordFormFromWebForm(generation_element_.form(),
                                                   nullptr, nullptr);
   } else {
     password_form = CreatePasswordFormFromUnownedInputElements(
         *render_frame()->GetWebFrame(), nullptr, nullptr);
   }
   if (password_form) {
     // TODO(kolos): when we are good in username detection, save username
     // as well.
     password_form->username_value = base::string16();
     password_form->password_value = generation_element_.value();
   }
 
   return password_form;
 }
 
-void PasswordGenerationAgent::OnFormsEligibleForGenerationFound(
-    const std::vector<autofill::PasswordFormGenerationData>& forms) {
+void PasswordGenerationAgent::FoundFormsEligibleForGeneration(
+    const std::vector<PasswordFormGenerationData>& forms) {
   generation_enabled_forms_.insert(generation_enabled_forms_.end(),
                                    forms.begin(), forms.end());
   DetermineGenerationElement();
 }
 
 void PasswordGenerationAgent::DetermineGenerationElement() {
   if (generation_form_data_) {
     VLOG(2) << "Account creation form already found";
     return;
   }
@@ skipping 107 matching lines @@
   if (element.value().isEmpty()) {
     if (password_is_generated_) {
       // User generated a password and then deleted it.
       password_generation::LogPasswordGenerationEvent(
           password_generation::PASSWORD_DELETED);
       CopyElementValueToOtherInputElements(&element,
           &generation_form_data_->password_elements);
       std::unique_ptr<PasswordForm> presaved_form(
           CreatePasswordFormToPresave());
       if (presaved_form) {
-        Send(new AutofillHostMsg_PasswordNoLongerGenerated(routing_id(),
-                                                           *presaved_form));
+        GetPasswordManagerDriver()->PasswordNoLongerGenerated(*presaved_form);
       }
     }
 
     // Do not treat the password as generated, either here or in the browser.
     password_is_generated_ = false;
     generation_element_.setShouldRevealPassword(false);
 
     // Offer generation again.
     ShowGenerationPopup();
   } else if (password_is_generated_) {
     password_edited_ = true;
     // Mirror edits to any confirmation password fields.
     CopyElementValueToOtherInputElements(&element,
         &generation_form_data_->password_elements);
     std::unique_ptr<PasswordForm> presaved_form(CreatePasswordFormToPresave());
     if (presaved_form) {
-      Send(new AutofillHostMsg_PresaveGeneratedPassword(routing_id(),
-                                                        *presaved_form));
+      GetPasswordManagerDriver()->PresaveGeneratedPassword(*presaved_form);
     }
   } else if (element.value().length() > kMaximumOfferSize) {
     // User has rejected the feature and has started typing a password.
     HidePopup();
   } else {
     // Password isn't generated and there are fewer than kMaximumOfferSize
     // characters typed, so keep offering the password. Note this function
     // will just keep the previous popup if one is already showing.
     ShowGenerationPopup();
   }
@@ skipping 23 matching lines @@
            render_frame()->GetRenderView()->ElementBoundsInWindow(
                generation_element_),
            *generation_form_data_->form));
   editing_popup_shown_ = true;
 }
 
 void PasswordGenerationAgent::HidePopup() {
   Send(new AutofillHostMsg_HidePasswordGenerationPopup(routing_id()));
 }
 
-void PasswordGenerationAgent::OnUserTriggeredGeneratePassword() {
+void PasswordGenerationAgent::UserTriggeredGeneratePassword() {
   if (last_focused_password_element_.isNull() || !render_frame())
     return;
 
   blink::WebFormElement form = last_focused_password_element_.form();
   std::unique_ptr<PasswordForm> password_form;
   std::vector<blink::WebFormControlElement> control_elements;
   if (!form.isNull()) {
     password_form = CreatePasswordFormFromWebForm(form, nullptr, nullptr);
     control_elements = form_util::ExtractAutofillableElementsInForm(form);
   } else {
@@ skipping 14 matching lines @@
   std::vector<blink::WebInputElement> password_elements;
   GetAccountCreationPasswordFields(control_elements, &password_elements);
   password_elements = FindPasswordElementsForGeneration(
       password_elements, last_focused_password_element_.nameForAutofill());
   generation_form_data_.reset(new AccountCreationFormData(
       make_linked_ptr(password_form.release()), password_elements));
   is_manually_triggered_ = true;
   ShowGenerationPopup();
 }
 
+const mojom::PasswordManagerDriverPtr&
+PasswordGenerationAgent::GetPasswordManagerDriver() {
+  DCHECK(password_agent_);
+  return password_agent_->GetPasswordManagerDriver();
+}
+
 }  // namespace autofill