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

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

components/nacl/loader/nacl_ipc_adapter.cc

@@ -356,8 +356,8 @@ NaClIPCAdapter::NaClIPCAdapter(
     : lock_(),
       cond_var_(&lock_),
       task_runner_(runner),
-      resolve_file_token_cb_(resolve_file_token_cb),
-      open_resource_cb_(open_resource_cb),
+      resolve_file_token_cb_(std::move(resolve_file_token_cb)),
+      open_resource_cb_(std::move(open_resource_cb)),
       locked_data_() {
   io_thread_data_.channel_ = IPC::Channel::CreateServer(handle, this, runner);
   // Note, we can not PostTask for ConnectChannelOnIOThread here. If we did,
@@ -527,11 +527,8 @@ bool NaClIPCAdapter::OnMessageReceived(const IPC::Message& msg) {
 
       // resolve_file_token_cb_ must be invoked from the I/O thread.
       resolve_file_token_cb_.Run(
-          token_lo,
-          token_hi,
-          base::Bind(&NaClIPCAdapter::SaveOpenResourceMessage,
-                     this,
-                     msg));
+          token_lo, token_hi,
+          base::BindOnce(&NaClIPCAdapter::SaveOpenResourceMessage, this, msg));
 
       // In this case, we don't release the message to NaCl untrusted code
       // immediately. We defer it until we get an async message back from the
@@ -818,7 +815,7 @@ void NaClIPCAdapter::SendMessageOnIOThread(
     // from the I/O thread.
     if (open_resource_cb_.Run(
             *message.get(), key,
-            base::Bind(&NaClIPCAdapter::SaveOpenResourceMessage, this))) {
+            base::BindOnce(&NaClIPCAdapter::SaveOpenResourceMessage, this))) {
       // The callback sent a reply to the untrusted side.
       return;
     }

components/nacl/loader/nacl_ipc_adapter.h

@@ -72,21 +72,22 @@ class NaClIPCAdapter : public base::RefCountedThreadSafe<NaClIPCAdapter>,
   };
 #pragma pack(pop)
 
-  typedef base::Callback<void(IPC::PlatformFileForTransit, base::FilePath)>
+  typedef base::OnceCallback<void(IPC::PlatformFileForTransit, base::FilePath)>
       ResolveFileTokenReplyCallback;
 
-  typedef base::Callback<void(uint64_t,  // file_token_lo
-                              uint64_t,  // file_token_hi
-                              ResolveFileTokenReplyCallback)>
+  typedef base::RepeatingCallback<void(uint64_t,  // file_token_lo
+                                       uint64_t,  // file_token_hi
+                                       ResolveFileTokenReplyCallback)>
       ResolveFileTokenCallback;
 
-  typedef base::Callback<void(const IPC::Message&,
-                              IPC::PlatformFileForTransit,
-                              base::FilePath)> OpenResourceReplyCallback;
+  typedef base::OnceCallback<
+      void(const IPC::Message&, IPC::PlatformFileForTransit, base::FilePath)>
+      OpenResourceReplyCallback;
 
-  typedef base::Callback<bool(const IPC::Message&,
-                              const std::string&,  // key
-                              OpenResourceReplyCallback)> OpenResourceCallback;
+  typedef base::RepeatingCallback<bool(const IPC::Message&,
+                                       const std::string&,  // key
+                                       OpenResourceReplyCallback)>
+      OpenResourceCallback;
 
   // Creates an adapter, using the thread associated with the given task
   // runner for posting messages. In normal use, the task runner will post to

components/nacl/loader/nacl_listener.cc

@@ -108,9 +108,9 @@ void SetUpIPCAdapter(
     NaClIPCAdapter::ResolveFileTokenCallback resolve_file_token_cb,
     NaClIPCAdapter::OpenResourceCallback open_resource_cb) {
   mojo::MessagePipe pipe;
-  scoped_refptr<NaClIPCAdapter> ipc_adapter(
-      new NaClIPCAdapter(pipe.handle0.release(), task_runner,
-                         resolve_file_token_cb, open_resource_cb));
+  scoped_refptr<NaClIPCAdapter> ipc_adapter(new NaClIPCAdapter(
+      pipe.handle0.release(), task_runner, std::move(resolve_file_token_cb),
+      std::move(open_resource_cb)));
   ipc_adapter->ConnectChannel();
   *handle = pipe.handle1.release();
 
@@ -261,7 +261,7 @@ bool NaClListener::OnOpenResource(
     prefetched_resource_files_.erase(it);
     // A pre-opened resource descriptor is available. Run the reply callback
     // and return true.
-    cb.Run(msg, file, path);
+    std::move(cb).Run(msg, file, path);
     return true;
   }
 
@@ -327,11 +327,12 @@ void NaClListener::OnStart(nacl::NaClStartParams params) {
                   NACL_CHROME_DESC_BASE + 1,
                   NaClIPCAdapter::ResolveFileTokenCallback(),
                   NaClIPCAdapter::OpenResourceCallback());
-  SetUpIPCAdapter(
-      &manifest_service_handle, io_thread_.task_runner(), nap,
-      NACL_CHROME_DESC_BASE + 2,
-      base::Bind(&NaClListener::ResolveFileToken, base::Unretained(this)),
-      base::Bind(&NaClListener::OnOpenResource, base::Unretained(this)));
+  SetUpIPCAdapter(&manifest_service_handle, io_thread_.task_runner(), nap,
+                  NACL_CHROME_DESC_BASE + 2,
+                  base::BindRepeating(&NaClListener::ResolveFileToken,
+                                      base::Unretained(this)),
+                  base::BindRepeating(&NaClListener::OnOpenResource,
+                                      base::Unretained(this)));
 
   mojo::PendingRemote<nacl::mojom::NaClRendererHost> renderer_host;
   if (!Send(new NaClProcessHostMsg_PpapiChannelsCreated(
@@ -437,12 +438,12 @@ void NaClListener::OnStart(nacl::NaClStartParams params) {
 void NaClListener::ResolveFileToken(
     uint64_t token_lo,
     uint64_t token_hi,
-    base::Callback<void(IPC::PlatformFileForTransit, base::FilePath)> cb) {
+    NaClIPCAdapter::ResolveFileTokenReplyCallback cb) {
   if (!Send(new NaClProcessMsg_ResolveFileToken(token_lo, token_hi))) {
-    cb.Run(IPC::PlatformFileForTransit(), base::FilePath());
+    std::move(cb).Run(IPC::PlatformFileForTransit(), base::FilePath());
     return;
   }
-  resolved_cb_ = cb;
+  resolved_cb_ = std::move(cb);
 }
 
 void NaClListener::OnFileTokenResolved(
@@ -450,6 +451,6 @@ void NaClListener::OnFileTokenResolved(
     uint64_t token_hi,
     IPC::PlatformFileForTransit ipc_fd,
     base::FilePath file_path) {
-  resolved_cb_.Run(ipc_fd, file_path);
-  resolved_cb_.Reset();
+  if (resolved_cb_)
+    std::move(resolved_cb_).Run(ipc_fd, file_path);
 }

components/nacl/loader/nacl_listener.h

@@ -20,6 +20,7 @@
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "components/nacl/common/nacl_types.h"
+#include "components/nacl/loader/nacl_ipc_adapter.h"
 #include "components/nacl/loader/nacl_trusted_listener.h"
 #include "ipc/ipc_listener.h"
 
@@ -58,11 +59,9 @@ class NaClListener : public IPC::Listener {
     return trusted_listener_.get();
   }
 
-  typedef base::Callback<void(IPC::PlatformFileForTransit, base::FilePath)>
-      ResolveFileTokenCallback;
   void ResolveFileToken(uint64_t token_lo,
                         uint64_t token_hi,
-                        ResolveFileTokenCallback cb);
+                        NaClIPCAdapter::ResolveFileTokenReplyCallback cb);
   void OnFileTokenResolved(uint64_t token_lo,
                            uint64_t token_hi,
                            IPC::PlatformFileForTransit ipc_fd,
@@ -75,13 +74,9 @@ class NaClListener : public IPC::Listener {
 
   bool OnMessageReceived(const IPC::Message& msg) override;
 
-  typedef base::Callback<void(const IPC::Message&,
-                              IPC::PlatformFileForTransit,
-                              base::FilePath)> OpenResourceReplyCallback;
-
   bool OnOpenResource(const IPC::Message& msg,
                       const std::string& key,
-                      OpenResourceReplyCallback cb);
+                      NaClIPCAdapter::OpenResourceReplyCallback cb);
 
   void OnAddPrefetchedResource(
       const nacl::NaClResourcePrefetchResult& prefetched_resource_file);
@@ -112,7 +107,7 @@ class NaClListener : public IPC::Listener {
 
   std::unique_ptr<NaClTrustedListener> trusted_listener_;
 
-  ResolveFileTokenCallback resolved_cb_;
+  NaClIPCAdapter::ResolveFileTokenReplyCallback resolved_cb_;
 
   // Used to identify what thread we're on.
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;

components/nacl/loader/nonsfi/run_all_unittests.cc

@@ -18,5 +18,5 @@ int RunAllTestsImpl() {
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
   testing::InitGoogleTest(&argc, argv);
-  return base::LaunchUnitTests(argc, argv, base::Bind(&RunAllTestsImpl));
+  return base::LaunchUnitTests(argc, argv, base::BindOnce(&RunAllTestsImpl));
 }