Switch components/password_manager code from IPC messages to Mojo.

components/password_manager/content/browser/credential_manager_impl.cc

 // Copyright 2014 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/password_manager/content/browser/credential_manager_dispatcher.h"
+#include "components/password_manager/content/browser/credential_manager_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/content/browser/content_password_manager_driver.h"
 #include "components/password_manager/content/browser/content_password_manager_driver_factory.h"
-#include "components/password_manager/content/common/credential_manager_messages.h"
+#include "components/password_manager/content/public/cpp/type_converters.h"
 #include "components/password_manager/core/browser/affiliated_match_helper.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/common/credential_manager_types.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
-#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
-#include "ipc/ipc_message_macros.h"
+#include "mojo/common/url_type_converters.h"
 
 namespace password_manager {
 
-// CredentialManagerDispatcher -------------------------------------------------
+namespace {
 
-CredentialManagerDispatcher::CredentialManagerDispatcher(
-    content::WebContents* web_contents,
-    PasswordManagerClient* client)
+void RunMojoGetCallback(const mojom::CredentialManager::GetCallback& callback,
+                        const CredentialInfo& info) {
+  mojom::CredentialInfoPtr credential = mojom::CredentialInfo::From(info);
+  callback.Run(mojom::CredentialManagerError::SUCCESS, std::move(credential));
+}
+
+}  // namespace
+
+// CredentialManagerImpl -------------------------------------------------
+
+CredentialManagerImpl::CredentialManagerImpl(content::WebContents* web_contents,
+                                             PasswordManagerClient* client)
     : WebContentsObserver(web_contents), client_(client), weak_factory_(this) {
   DCHECK(web_contents);
   auto_signin_enabled_.Init(prefs::kCredentialsEnableAutosignin,
                             client_->GetPrefs());
 }
 
-CredentialManagerDispatcher::~CredentialManagerDispatcher() {
+CredentialManagerImpl::~CredentialManagerImpl() {}
+
+void CredentialManagerImpl::BindRequest(
+    mojom::CredentialManagerRequest request) {
+  bindings_.AddBinding(this, std::move(request));
 }
 
-bool CredentialManagerDispatcher::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(CredentialManagerDispatcher, message)
-    IPC_MESSAGE_HANDLER(CredentialManagerHostMsg_Store, OnStore);
-    IPC_MESSAGE_HANDLER(CredentialManagerHostMsg_RequireUserMediation,
-                        OnRequireUserMediation);
-    IPC_MESSAGE_HANDLER(CredentialManagerHostMsg_RequestCredential,
-                        OnRequestCredential);
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
+void CredentialManagerImpl::Store(mojom::CredentialInfoPtr credential,
+                                  const StoreCallback& callback) {
+  CredentialInfo info = credential.To<CredentialInfo>();
+  DCHECK_NE(CredentialType::CREDENTIAL_TYPE_EMPTY, info.type);
 
-void CredentialManagerDispatcher::OnStore(
-    int request_id,
-    const password_manager::CredentialInfo& credential) {
-  DCHECK(credential.type != CredentialType::CREDENTIAL_TYPE_EMPTY);
-  DCHECK(request_id);
-  web_contents()->GetRenderViewHost()->Send(
-      new CredentialManagerMsg_AcknowledgeStore(
-          web_contents()->GetRenderViewHost()->GetRoutingID(), request_id));
+  // Send acknowledge response back.
+  callback.Run();
 
   if (!client_->IsSavingAndFillingEnabledForCurrentPage())
     return;
 
   std::unique_ptr<autofill::PasswordForm> form(
       CreatePasswordFormFromCredentialInfo(
-          credential, web_contents()->GetLastCommittedURL().GetOrigin()));
+          info, web_contents()->GetLastCommittedURL().GetOrigin()));
   form->skip_zero_click = !IsZeroClickAllowed();
 
   form_manager_.reset(new CredentialManagerPasswordFormManager(
       client_, GetDriver(), *form, this));
 }
 
-void CredentialManagerDispatcher::OnProvisionalSaveComplete() {
+void CredentialManagerImpl::OnProvisionalSaveComplete() {
   DCHECK(form_manager_);
   DCHECK(client_->IsSavingAndFillingEnabledForCurrentPage());
 
   if (form_manager_->IsNewLogin()) {
     // If the PasswordForm we were given does not match an existing
     // PasswordForm, ask the user if they'd like to save.
     client_->PromptUserToSaveOrUpdatePassword(
         std::move(form_manager_), CredentialSourceType::CREDENTIAL_SOURCE_API,
         false);
   } else {
     // Otherwise, update the existing form, as we've been told by the site
     // that the new PasswordForm is a functioning credential for the user.
     // We use 'PasswordFormManager::Update(PasswordForm&)' here rather than
     // 'PasswordFormManager::UpdateLogin', as we need to port over the
     // 'skip_zero_click' state to ensure that we don't accidentally start
     // signing users in just because the site asks us to. The simplest way
     // to do so is simply to update the password field of the existing
     // credential.
     form_manager_->Update(*form_manager_->preferred_match());
   }
 }
 
-void CredentialManagerDispatcher::OnRequireUserMediation(int request_id) {
-  DCHECK(request_id);
-
+void CredentialManagerImpl::RequireUserMediation(
+    const RequireUserMediationCallback& callback) {
   PasswordStore* store = GetPasswordStore();
   if (!store || !IsUpdatingCredentialAllowed()) {
-    web_contents()->GetRenderViewHost()->Send(
-        new CredentialManagerMsg_AcknowledgeRequireUserMediation(
-            web_contents()->GetRenderViewHost()->GetRoutingID(), request_id));
+    callback.Run();
     return;
   }
 
   if (store->affiliated_match_helper()) {
     store->affiliated_match_helper()->GetAffiliatedAndroidRealms(
         GetSynthesizedFormForOrigin(),
-        base::Bind(&CredentialManagerDispatcher::ScheduleRequireMediationTask,
-                   weak_factory_.GetWeakPtr(), request_id));
+        base::Bind(&CredentialManagerImpl::ScheduleRequireMediationTask,
+                   weak_factory_.GetWeakPtr(), callback));
   } else {
     std::vector<std::string> no_affiliated_realms;
-    ScheduleRequireMediationTask(request_id, no_affiliated_realms);
+    ScheduleRequireMediationTask(callback, no_affiliated_realms);
   }
 }
 
-void CredentialManagerDispatcher::ScheduleRequireMediationTask(
-    int request_id,
+void CredentialManagerImpl::ScheduleRequireMediationTask(
+    const RequireUserMediationCallback& callback,
     const std::vector<std::string>& android_realms) {
   DCHECK(GetPasswordStore());
   if (!pending_require_user_mediation_) {
     pending_require_user_mediation_.reset(
         new CredentialManagerPendingRequireUserMediationTask(
             this, web_contents()->GetLastCommittedURL().GetOrigin(),
             android_realms));
 
     // This will result in a callback to
-    // CredentialManagerPendingRequireUserMediationTask::OnGetPasswordStoreResults().
+    // CredentialManagerPendingRequireUserMediationTask::
+    // OnGetPasswordStoreResults().
     GetPasswordStore()->GetAutofillableLogins(
         pending_require_user_mediation_.get());
   } else {
     pending_require_user_mediation_->AddOrigin(
         web_contents()->GetLastCommittedURL().GetOrigin());
   }
 
-  web_contents()->GetRenderViewHost()->Send(
-      new CredentialManagerMsg_AcknowledgeRequireUserMediation(
-          web_contents()->GetRenderViewHost()->GetRoutingID(), request_id));
+  // Send acknowledge response back.
+  callback.Run();
 }
 
-void CredentialManagerDispatcher::OnRequestCredential(
-    int request_id,
-    bool zero_click_only,
-    bool include_passwords,
-    const std::vector<GURL>& federations) {
-  DCHECK(request_id);
+void CredentialManagerImpl::Get(bool zero_click_only,
+                                bool include_passwords,
+                                mojo::Array<mojo::String> federations,
+                                const GetCallback& callback) {
   PasswordStore* store = GetPasswordStore();
   if (pending_request_ || !store) {
-    web_contents()->GetRenderViewHost()->Send(
-        new CredentialManagerMsg_RejectCredentialRequest(
-            web_contents()->GetRenderViewHost()->GetRoutingID(), request_id,
-            pending_request_
-                ? blink::WebCredentialManagerPendingRequestError
-                : blink::WebCredentialManagerPasswordStoreUnavailableError));
+    // Callback error.
+    callback.Run(pending_request_
+                     ? mojom::CredentialManagerError::PENDINGREQUEST
+                     : mojom::CredentialManagerError::PASSWORDSTOREUNAVAILABLE,
+                 nullptr);
     return;
   }
 
   // Return an empty credential if zero-click is required but disabled, or if
   // the current page has TLS errors.
   if ((zero_click_only && !IsZeroClickAllowed()) ||
       client_->DidLastPageLoadEncounterSSLErrors()) {
-    web_contents()->GetRenderViewHost()->Send(
-        new CredentialManagerMsg_SendCredential(
-            web_contents()->GetRenderViewHost()->GetRoutingID(), request_id,
-            CredentialInfo()));
+    // Callback with empty credential info.
+    callback.Run(mojom::CredentialManagerError::SUCCESS,
+                 mojom::CredentialInfo::New());
     return;
   }
 
   if (store->affiliated_match_helper()) {
     store->affiliated_match_helper()->GetAffiliatedAndroidRealms(
         GetSynthesizedFormForOrigin(),
-        base::Bind(&CredentialManagerDispatcher::ScheduleRequestTask,
-                   weak_factory_.GetWeakPtr(), request_id, zero_click_only,
-                   include_passwords, federations));
+        base::Bind(&CredentialManagerImpl::ScheduleRequestTask,
+                   weak_factory_.GetWeakPtr(), callback, zero_click_only,
+                   include_passwords, federations.To<std::vector<GURL>>()));
   } else {
     std::vector<std::string> no_affiliated_realms;
-    ScheduleRequestTask(request_id, zero_click_only, include_passwords,
-                        federations, no_affiliated_realms);
+    ScheduleRequestTask(callback, zero_click_only, include_passwords,
+                        federations.To<std::vector<GURL>>(),
+                        no_affiliated_realms);
   }
 }
 
-void CredentialManagerDispatcher::ScheduleRequestTask(
-    int request_id,
+void CredentialManagerImpl::ScheduleRequestTask(
+    const GetCallback& callback,
     bool zero_click_only,
     bool include_passwords,
     const std::vector<GURL>& federations,
     const std::vector<std::string>& android_realms) {
   DCHECK(GetPasswordStore());
   pending_request_.reset(new CredentialManagerPendingRequestTask(
-      this, request_id, zero_click_only,
+      this, base::Bind(&RunMojoGetCallback, callback), zero_click_only,
       web_contents()->GetLastCommittedURL().GetOrigin(), include_passwords,
       federations, android_realms));
 
   // This will result in a callback to
   // PendingRequestTask::OnGetPasswordStoreResults().
   GetPasswordStore()->GetAutofillableLogins(pending_request_.get());
 }
 
-PasswordStore* CredentialManagerDispatcher::GetPasswordStore() {
+PasswordStore* CredentialManagerImpl::GetPasswordStore() {
   return client_ ? client_->GetPasswordStore() : nullptr;
 }
 
-bool CredentialManagerDispatcher::IsZeroClickAllowed() const {
+bool CredentialManagerImpl::IsZeroClickAllowed() const {
   return *auto_signin_enabled_ && !client_->IsOffTheRecord();
 }
 
-GURL CredentialManagerDispatcher::GetOrigin() const {
+GURL CredentialManagerImpl::GetOrigin() const {
   return web_contents()->GetLastCommittedURL().GetOrigin();
 }
 
-base::WeakPtr<PasswordManagerDriver> CredentialManagerDispatcher::GetDriver() {
+base::WeakPtr<PasswordManagerDriver> CredentialManagerImpl::GetDriver() {
   ContentPasswordManagerDriverFactory* driver_factory =
       ContentPasswordManagerDriverFactory::FromWebContents(web_contents());
   DCHECK(driver_factory);
   PasswordManagerDriver* driver =
       driver_factory->GetDriverForFrame(web_contents()->GetMainFrame());
   return driver->AsWeakPtr();
 }
 
-void CredentialManagerDispatcher::SendCredential(int request_id,
-                                                 const CredentialInfo& info) {
+void CredentialManagerImpl::SendCredential(
+    const SendCredentialCallback& send_callback,
+    const CredentialInfo& info) {
   DCHECK(pending_request_);
-  DCHECK_EQ(pending_request_->id(), request_id);
+  DCHECK(send_callback.Equals(pending_request_->send_callback()));
 
-  web_contents()->GetRenderViewHost()->Send(
-      new CredentialManagerMsg_SendCredential(
-          web_contents()->GetRenderViewHost()->GetRoutingID(),
-          pending_request_->id(), info));
+  send_callback.Run(info);
   pending_request_.reset();
 }
 
-void CredentialManagerDispatcher::SendPasswordForm(
-    int request_id,
+void CredentialManagerImpl::SendPasswordForm(
+    const SendCredentialCallback& send_callback,
     const autofill::PasswordForm* form) {
   CredentialInfo info;
   if (form) {
     password_manager::CredentialType type_to_return =
         form->federation_origin.unique()
             ? CredentialType::CREDENTIAL_TYPE_PASSWORD
             : CredentialType::CREDENTIAL_TYPE_FEDERATED;
     info = CredentialInfo(*form, type_to_return);
     if (PasswordStore* store = GetPasswordStore()) {
       if (form->skip_zero_click && IsZeroClickAllowed()) {
         DCHECK(IsUpdatingCredentialAllowed());
         autofill::PasswordForm update_form = *form;
         update_form.skip_zero_click = false;
         store->UpdateLogin(update_form);
       }
     }
   }
-  SendCredential(request_id, info);
+  SendCredential(send_callback, info);
 }
 
-PasswordManagerClient* CredentialManagerDispatcher::client() const {
+PasswordManagerClient* CredentialManagerImpl::client() const {
   return client_;
 }
 
-autofill::PasswordForm
-CredentialManagerDispatcher::GetSynthesizedFormForOrigin() const {
+autofill::PasswordForm CredentialManagerImpl::GetSynthesizedFormForOrigin()
+    const {
   autofill::PasswordForm synthetic_form;
   synthetic_form.origin = web_contents()->GetLastCommittedURL().GetOrigin();
   synthetic_form.signon_realm = synthetic_form.origin.spec();
   synthetic_form.scheme = autofill::PasswordForm::SCHEME_HTML;
   synthetic_form.ssl_valid = synthetic_form.origin.SchemeIsCryptographic() &&
                              !client_->DidLastPageLoadEncounterSSLErrors();
   return synthetic_form;
 }
 
-void CredentialManagerDispatcher::DoneRequiringUserMediation() {
+void CredentialManagerImpl::DoneRequiringUserMediation() {
   DCHECK(pending_require_user_mediation_);
   pending_require_user_mediation_.reset();
 }
 
-bool CredentialManagerDispatcher::IsUpdatingCredentialAllowed() const {
+bool CredentialManagerImpl::IsUpdatingCredentialAllowed() const {
   return !client_->DidLastPageLoadEncounterSSLErrors() &&
          !client_->IsOffTheRecord();
 }
 
 }  // namespace password_manager