Convert base::Bind and base::Callback in components/nacl/renderer to Once/Repeating

Bug: 1007703
Change-Id: I83939762da698fe83204e88781fe3cbc9fa8998e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2336431Reviewed-by: Mark Seaborn <mseaborn@chromium.org>
Commit-Queue: Yoichi Osato <yoichio@chromium.org>
Cr-Commit-Position: refs/heads/master@{#795257}

components/nacl/renderer/manifest_downloader.cc

@@ -23,10 +23,10 @@ ManifestDownloader::ManifestDownloader(
     Callback cb)
     : url_loader_(std::move(url_loader)),
       is_installed_(is_installed),
-      cb_(cb),
+      cb_(std::move(cb)),
       status_code_(-1),
       pp_nacl_error_(PP_NACL_ERROR_LOAD_SUCCESS) {
-  CHECK(!cb.is_null());
+  CHECK(!cb_.is_null());
 }
 
 ManifestDownloader::~ManifestDownloader() { }
@@ -60,7 +60,7 @@ void ManifestDownloader::Close() {
                       "NaCl.HttpStatusCodeClass.Manifest.NotInstalledApp",
       status_code_);
 
-  cb_.Run(pp_nacl_error_, buffer_);
+  std::move(cb_).Run(pp_nacl_error_, buffer_);
   delete this;
 }
 

components/nacl/renderer/manifest_downloader.h

@@ -28,7 +28,7 @@ namespace nacl {
 // caller through a callback.
 class ManifestDownloader : public blink::WebAssociatedURLLoaderClient {
  public:
-  typedef base::Callback<void(PP_NaClError, const std::string&)> Callback;
+  typedef base::OnceCallback<void(PP_NaClError, const std::string&)> Callback;
 
   // This is a pretty arbitrary limit on the byte size of the NaCl manifest
   // file.

components/nacl/renderer/manifest_service_channel.cc

@@ -76,8 +76,7 @@ void ManifestServiceChannel::OnStartupInitializationComplete() {
 void ManifestServiceChannel::OnOpenResource(
     const std::string& key, IPC::Message* reply) {
   delegate_->OpenResource(
-      key,
-      base::Bind(&ManifestServiceChannel::DidOpenResource,
+      key, base::BindOnce(&ManifestServiceChannel::DidOpenResource,
                           weak_ptr_factory_.GetWeakPtr(), reply));
 }
 

components/nacl/renderer/pnacl_translation_resource_host.cc

@@ -57,7 +57,8 @@ void PnaclTranslationResourceHost::RequestNexeFd(
   io_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&PnaclTranslationResourceHost::SendRequestNexeFd, this,
-                     render_view_id, instance, cache_info, callback));
+                     render_view_id, instance, cache_info,
+                     std::move(callback)));
   return;
 }
 
@@ -70,12 +71,12 @@ void PnaclTranslationResourceHost::SendRequestNexeFd(
   if (!sender_ || !sender_->Send(new NaClHostMsg_NexeTempFileRequest(
           render_view_id, instance, cache_info))) {
     PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
-        FROM_HERE,
-        base::BindOnce(callback, static_cast<int32_t>(PP_ERROR_FAILED), false,
+        FROM_HERE, base::BindOnce(std::move(callback),
+                                  static_cast<int32_t>(PP_ERROR_FAILED), false,
                                   PP_kInvalidFileHandle));
     return;
   }
-  pending_cache_requests_.insert(std::make_pair(instance, callback));
+  pending_cache_requests_.insert(std::make_pair(instance, std::move(callback)));
 }
 
 void PnaclTranslationResourceHost::ReportTranslationFinished(
@@ -122,7 +123,8 @@ void PnaclTranslationResourceHost::OnNexeTempFileReply(
       status = PP_OK;
     }
     PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
-        FROM_HERE, base::BindOnce(it->second, status, is_hit, file_handle));
+        FROM_HERE,
+        base::BindOnce(std::move(it->second), status, is_hit, file_handle));
     pending_cache_requests_.erase(it);
   } else {
     DLOG(ERROR) << "Could not find pending request for reply";
@@ -134,9 +136,9 @@ void PnaclTranslationResourceHost::CleanupCacheRequests() {
   for (auto it = pending_cache_requests_.begin();
        it != pending_cache_requests_.end(); ++it) {
     PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
-        FROM_HERE,
-        base::BindOnce(it->second, static_cast<int32_t>(PP_ERROR_ABORTED),
-                       false, PP_kInvalidFileHandle));
+        FROM_HERE, base::BindOnce(std::move(it->second),
+                                  static_cast<int32_t>(PP_ERROR_ABORTED), false,
+                                  PP_kInvalidFileHandle));
   }
   pending_cache_requests_.clear();
 }

components/nacl/renderer/pnacl_translation_resource_host.h

@@ -33,7 +33,7 @@ struct PnaclCacheInfo;
 // needs from the browser since "Resource" is a Pepper thing...
 class PnaclTranslationResourceHost : public IPC::MessageFilter {
  public:
-  typedef base::Callback<void(int32_t, bool, PP_FileHandle)>
+  typedef base::OnceCallback<void(int32_t, bool, PP_FileHandle)>
       RequestNexeFdCallback;
 
   explicit PnaclTranslationResourceHost(

components/nacl/renderer/ppb_nacl_private_impl.cc

@@ -545,7 +545,7 @@ void PPBNaClPrivate::LaunchSelLdr(
     std::unique_ptr<ManifestServiceChannel> manifest_service_channel(
         new ManifestServiceChannel(
             launch_result.manifest_service_ipc_channel_handle,
-            base::Bind(&PostPPCompletionCallback, callback),
+            base::BindOnce(&PostPPCompletionCallback, callback),
             std::move(manifest_service_proxy),
             content::RenderThread::Get()->GetShutdownEvent()));
     load_manager->set_manifest_service_channel(
@@ -688,11 +688,11 @@ void GetNexeFd(PP_Instance instance,
                const std::string& etag,
                bool has_no_store_header,
                bool use_subzero,
-               base::Callback<void(int32_t, bool, PP_FileHandle)> callback) {
+               PnaclTranslationResourceHost::RequestNexeFdCallback callback) {
   if (!InitializePnaclResourceHost()) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
-        FROM_HERE,
-        base::BindOnce(callback, static_cast<int32_t>(PP_ERROR_FAILED), false,
+        FROM_HERE, base::BindOnce(std::move(callback),
+                                  static_cast<int32_t>(PP_ERROR_FAILED), false,
                                   PP_kInvalidFileHandle));
     return;
   }
@@ -710,11 +710,8 @@ void GetNexeFd(PP_Instance instance,
   cache_info.sandbox_isa = GetSandboxArch();
   cache_info.extra_flags = GetCpuFeatures();
 
-  g_pnacl_resource_host.Get()->RequestNexeFd(
-      GetRoutingID(instance),
-      instance,
-      cache_info,
-      callback);
+  g_pnacl_resource_host.Get()->RequestNexeFd(GetRoutingID(instance), instance,
+                                             cache_info, std::move(callback));
 }
 
 void LogTranslationFinishedUMA(const std::string& uma_suffix,
@@ -1021,7 +1018,7 @@ void DownloadManifestToBuffer(PP_Instance instance,
   // ManifestDownloader deletes itself after invoking the callback.
   ManifestDownloader* manifest_downloader = new ManifestDownloader(
       std::move(url_loader), load_manager->is_installed(),
-      base::Bind(DownloadManifestToBufferCompletion, instance, callback,
+      base::BindOnce(DownloadManifestToBufferCompletion, instance, callback,
                      base::Time::Now()));
   manifest_downloader->Load(request);
 }
@@ -1631,10 +1628,10 @@ class PexeDownloader : public blink::WebAssociatedURLLoaderClient {
         has_no_store_header = true;
     }
 
-    GetNexeFd(
-        instance_, pexe_url_, pexe_opt_level_, last_modified_time, etag,
+    GetNexeFd(instance_, pexe_url_, pexe_opt_level_, last_modified_time, etag,
               has_no_store_header, use_subzero_,
-        base::Bind(&PexeDownloader::didGetNexeFd, weak_factory_.GetWeakPtr()));
+              base::BindOnce(&PexeDownloader::didGetNexeFd,
+                             weak_factory_.GetWeakPtr()));
   }
 
   void didGetNexeFd(int32_t pp_error,