Use OnceCallback on Mojo interfaces in //components/password_manager

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_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 12 matching lines @@
 #include "components/password_manager/core/browser/password_manager_util.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/web_contents.h"
 
 namespace password_manager {
 
 namespace {
 
-void RunMojoGetCallback(const mojom::CredentialManager::GetCallback& callback,
+void RunMojoGetCallback(mojom::CredentialManager::GetCallback callback,
                         const CredentialInfo& info) {
-  callback.Run(mojom::CredentialManagerError::SUCCESS, info);
+  std::move(callback).Run(mojom::CredentialManagerError::SUCCESS, info);
 }
 
 }  // 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());
 }
 
 CredentialManagerImpl::~CredentialManagerImpl() {}
 
 void CredentialManagerImpl::BindRequest(
     mojom::CredentialManagerRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 void CredentialManagerImpl::Store(const CredentialInfo& credential,
-                                  const StoreCallback& callback) {
+                                  StoreCallback callback) {
   DCHECK_NE(CredentialType::CREDENTIAL_TYPE_EMPTY, credential.type);
 
   if (password_manager_util::IsLoggingActive(client_)) {
     CredentialManagerLogger(client_->GetLogManager())
         .LogStoreCredential(web_contents()->GetLastCommittedURL(),
                             credential.type);
   }
 
   // Send acknowledge response back.
-  callback.Run();
+  std::move(callback).Run();
 
   if (!client_->IsSavingAndFillingEnabledForCurrentPage() ||
       !client_->OnCredentialManagerUsed())
     return;
 
   client_->NotifyStorePasswordCalled();
 
   GURL origin = web_contents()->GetLastCommittedURL().GetOrigin();
   std::unique_ptr<autofill::PasswordForm> form(
       CreatePasswordFormFromCredentialInfo(credential, origin));
@@ skipping 40 matching lines @@
     // us when they sign the user out.
     form_manager_->Update(*form_manager_->preferred_match());
     return;
   }
 
   // Otherwise, this is a new form, so as the user if they'd like to save.
   client_->PromptUserToSaveOrUpdatePassword(std::move(form_manager_), false);
 }
 
 void CredentialManagerImpl::RequireUserMediation(
-    const RequireUserMediationCallback& callback) {
+    RequireUserMediationCallback callback) {
   if (password_manager_util::IsLoggingActive(client_)) {
     CredentialManagerLogger(client_->GetLogManager())
         .LogRequireUserMediation(web_contents()->GetLastCommittedURL());
   }
   // Send acknowledge response back.
-  callback.Run();
+  std::move(callback).Run();
 
   PasswordStore* store = GetPasswordStore();
   if (!store || !client_->IsSavingAndFillingEnabledForCurrentPage() ||
       !client_->OnCredentialManagerUsed())
     return;
 
   if (!pending_require_user_mediation_) {
     pending_require_user_mediation_.reset(
         new CredentialManagerPendingRequireUserMediationTask(this));
   }
   pending_require_user_mediation_->AddOrigin(GetSynthesizedFormForOrigin());
 }
 
 void CredentialManagerImpl::Get(bool zero_click_only,
                                 bool include_passwords,
                                 const std::vector<GURL>& federations,
-                                const GetCallback& callback) {
+                                GetCallback callback) {
   using metrics_util::LogCredentialManagerGetResult;
   metrics_util::CredentialManagerGetMediation mediation_status =
       zero_click_only ? metrics_util::CREDENTIAL_MANAGER_GET_UNMEDIATED
                       : metrics_util::CREDENTIAL_MANAGER_GET_MEDIATED;
   PasswordStore* store = GetPasswordStore();
   if (password_manager_util::IsLoggingActive(client_)) {
     CredentialManagerLogger(client_->GetLogManager())
         .LogRequestCredential(web_contents()->GetLastCommittedURL(),
                               zero_click_only, federations);
   }
   if (pending_request_ || !store) {
     // Callback error.
-    callback.Run(pending_request_
-                     ? mojom::CredentialManagerError::PENDINGREQUEST
-                     : mojom::CredentialManagerError::PASSWORDSTOREUNAVAILABLE,
-                 base::nullopt);
+    std::move(callback).Run(
+        pending_request_
+            ? mojom::CredentialManagerError::PENDINGREQUEST
+            : mojom::CredentialManagerError::PASSWORDSTOREUNAVAILABLE,
+        base::nullopt);
     LogCredentialManagerGetResult(metrics_util::CREDENTIAL_MANAGER_GET_REJECTED,
                                   mediation_status);
     return;
   }
 
   // Return an empty credential if the current page has TLS errors, or if the
   // page is being prerendered.
   if (!client_->IsFillingEnabledForCurrentPage() ||
       !client_->OnCredentialManagerUsed()) {
-    callback.Run(mojom::CredentialManagerError::SUCCESS, CredentialInfo());
+    std::move(callback).Run(mojom::CredentialManagerError::SUCCESS,
+                            CredentialInfo());
     LogCredentialManagerGetResult(metrics_util::CREDENTIAL_MANAGER_GET_NONE,
                                   mediation_status);
     return;
   }
   // Return an empty credential if zero-click is required but disabled.
   if (zero_click_only && !IsZeroClickAllowed()) {
     // Callback with empty credential info.
-    callback.Run(mojom::CredentialManagerError::SUCCESS, CredentialInfo());
+    std::move(callback).Run(mojom::CredentialManagerError::SUCCESS,
+                            CredentialInfo());
     LogCredentialManagerGetResult(
         metrics_util::CREDENTIAL_MANAGER_GET_NONE_ZERO_CLICK_OFF,
         mediation_status);
     return;
   }
 
   pending_request_.reset(new CredentialManagerPendingRequestTask(
-      this, base::Bind(&RunMojoGetCallback, callback), zero_click_only,
-      include_passwords, federations));
+      this, base::Bind(&RunMojoGetCallback, base::Passed(&callback)),
+      zero_click_only, include_passwords, federations));
   // This will result in a callback to
   // PendingRequestTask::OnGetPasswordStoreResults().
   GetPasswordStore()->GetLogins(GetSynthesizedFormForOrigin(),
                                 pending_request_.get());
 }
 
 bool CredentialManagerImpl::IsZeroClickAllowed() const {
   return *auto_signin_enabled_ && !client_->IsIncognito();
 }
 
@@ skipping 72 matching lines @@
 PasswordStore::FormDigest CredentialManagerImpl::GetSynthesizedFormForOrigin()
     const {
   PasswordStore::FormDigest digest = {
       autofill::PasswordForm::SCHEME_HTML, std::string(),
       web_contents()->GetLastCommittedURL().GetOrigin()};
   digest.signon_realm = digest.origin.spec();
   return digest;
 }
 
 }  // namespace password_manager