Convert base::Bind and base::Callback in //ppapi/thunk to Once or Repeating

This CL converts base::Bind and base::Callback in //ppapi/thunk to Once
or Repeating

Bug: 1007819
Change-Id: Ib46aaf7a3465a0e9e55b73d58e73e6ed905cabac
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2078906
Commit-Queue: Jun Cai <juncai@chromium.org>
Reviewed-by: Bill Budge <bbudge@chromium.org>
Cr-Commit-Position: refs/heads/master@{#746057}

content/renderer/pepper/ppb_flash_message_loop_impl.cc

@@ -29,9 +29,9 @@ class PPB_Flash_MessageLoop_Impl::State
   }
   base::OnceClosure& quit_closure() { return quit_closure_; }
 
-  const RunFromHostProxyCallback& run_callback() const { return run_callback_; }
-  void set_run_callback(const RunFromHostProxyCallback& run_callback) {
-    run_callback_ = run_callback;
+  RunFromHostProxyCallback run_callback() { return std::move(run_callback_); }
+  void set_run_callback(RunFromHostProxyCallback run_callback) {
+    run_callback_ = std::move(run_callback);
   }
 
  private:
@@ -68,21 +68,21 @@ int32_t PPB_Flash_MessageLoop_Impl::Run() {
 }
 
 void PPB_Flash_MessageLoop_Impl::RunFromHostProxy(
-    const RunFromHostProxyCallback& callback) {
-  InternalRun(callback);
+    RunFromHostProxyCallback callback) {
+  InternalRun(std::move(callback));
 }
 
 void PPB_Flash_MessageLoop_Impl::Quit() { InternalQuit(PP_OK); }
 
 int32_t PPB_Flash_MessageLoop_Impl::InternalRun(
-    const RunFromHostProxyCallback& callback) {
+    RunFromHostProxyCallback callback) {
   if (state_->run_called()) {
-    if (!callback.is_null())
-      callback.Run(PP_ERROR_FAILED);
+    if (callback)
+      std::move(callback).Run(PP_ERROR_FAILED);
     return PP_ERROR_FAILED;
   }
   state_->set_run_called();
-  state_->set_run_callback(callback);
+  state_->set_run_callback(std::move(callback));
 
   base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
   state_->set_quit_closure(run_loop.QuitClosure());
@@ -108,8 +108,9 @@ void PPB_Flash_MessageLoop_Impl::InternalQuit(int32_t result) {
 
   std::move(state_->quit_closure()).Run();
 
-  if (!state_->run_callback().is_null())
-    state_->run_callback().Run(result);
+  RunFromHostProxyCallback run_callback = state_->run_callback();
+  if (run_callback)
+    std::move(run_callback).Run(result);
 }
 
 }  // namespace content

content/renderer/pepper/ppb_flash_message_loop_impl.h

@@ -28,7 +28,7 @@ class PPB_Flash_MessageLoop_Impl
   // PPB_Flash_MessageLoop_API implementation.
   int32_t Run() override;
   void Quit() override;
-  void RunFromHostProxy(const RunFromHostProxyCallback& callback) override;
+  void RunFromHostProxy(RunFromHostProxyCallback callback) override;
 
  private:
   class State;
@@ -40,7 +40,7 @@ class PPB_Flash_MessageLoop_Impl
   // to quit, and the result passed into it will be the same value as what this
   // method returns.
   // Please note that |callback| happens before this method returns.
-  int32_t InternalRun(const RunFromHostProxyCallback& callback);
+  int32_t InternalRun(RunFromHostProxyCallback callback);
   void InternalQuit(int32_t result);
 
   scoped_refptr<State> state_;

ppapi/proxy/file_system_resource.cc

@@ -23,13 +23,15 @@ namespace proxy {
 
 FileSystemResource::QuotaRequest::QuotaRequest(
     int64_t amount_arg,
-    const RequestQuotaCallback& callback_arg)
-    : amount(amount_arg),
-      callback(callback_arg) {
-}
+    RequestQuotaCallback callback_arg)
+    : amount(amount_arg), callback(std::move(callback_arg)) {}
 
-FileSystemResource::QuotaRequest::~QuotaRequest() {
-}
+FileSystemResource::QuotaRequest::QuotaRequest(QuotaRequest&& other) = default;
+
+FileSystemResource::QuotaRequest& FileSystemResource::QuotaRequest::operator=(
+    QuotaRequest&& other) = default;
+
+FileSystemResource::QuotaRequest::~QuotaRequest() = default;
 
 FileSystemResource::FileSystemResource(Connection connection,
                                        PP_Instance instance,
@@ -104,9 +106,8 @@ void FileSystemResource::CloseQuotaFile(PP_Resource file_io) {
   files_.erase(file_io);
 }
 
-int64_t FileSystemResource::RequestQuota(
-    int64_t amount,
-    const RequestQuotaCallback& callback) {
+int64_t FileSystemResource::RequestQuota(int64_t amount,
+                                         RequestQuotaCallback callback) {
   DCHECK(amount >= 0);
   if (!reserving_quota_ && reserved_quota_ >= amount) {
     reserved_quota_ -= amount;
@@ -114,7 +115,7 @@ int64_t FileSystemResource::RequestQuota(
   }
 
   // Queue up a pending quota request.
-  pending_quota_requests_.push(QuotaRequest(amount, callback));
+  pending_quota_requests_.push(QuotaRequest(amount, std::move(callback)));
 
   // Reserve more quota if we haven't already.
   if (!reserving_quota_)
@@ -222,11 +223,11 @@ void FileSystemResource::ReserveQuotaComplete(
   while (!pending_quota_requests_.empty()) {
     QuotaRequest& request = pending_quota_requests_.front();
     if (fail_all) {
-      request.callback.Run(0);
+      std::move(request.callback).Run(0);
       pending_quota_requests_.pop();
     } else if (reserved_quota_ >= request.amount) {
       reserved_quota_ -= request.amount;
-      request.callback.Run(request.amount);
+      std::move(request.callback).Run(request.amount);
       pending_quota_requests_.pop();
     } else {
       // Refresh the quota reservation for the first pending request that we

ppapi/proxy/file_system_resource.h

@@ -55,9 +55,9 @@ class PPAPI_PROXY_EXPORT FileSystemResource : public PluginResource,
   PP_FileSystemType GetType() override;
   void OpenQuotaFile(PP_Resource file_io) override;
   void CloseQuotaFile(PP_Resource file_io) override;
-  typedef base::Callback<void(int64_t)> RequestQuotaCallback;
-  int64_t RequestQuota(int64_t amount,
-                       const RequestQuotaCallback& callback) override;
+  int64_t RequestQuota(
+      int64_t amount,
+      thunk::PPB_FileSystem_API::RequestQuotaCallback callback) override;
 
   int32_t InitIsolatedFileSystem(const std::string& fsid,
                                  PP_IsolatedFileSystemType_Private type,
@@ -65,11 +65,13 @@ class PPAPI_PROXY_EXPORT FileSystemResource : public PluginResource,
  private:
   struct QuotaRequest {
     QuotaRequest(int64_t amount,
-                 const RequestQuotaCallback& callback);
+                 thunk::PPB_FileSystem_API::RequestQuotaCallback callback);
+    QuotaRequest(QuotaRequest&& other);
+    QuotaRequest& operator=(QuotaRequest&& other);
     ~QuotaRequest();
 
     int64_t amount;
-    RequestQuotaCallback callback;
+    thunk::PPB_FileSystem_API::RequestQuotaCallback callback;
   };
 
   // Called when the host has responded to our open request.

ppapi/proxy/ppb_flash_message_loop_proxy.cc

@@ -30,10 +30,10 @@ class FlashMessageLoop : public PPB_Flash_MessageLoop_API, public Resource {
   // Resource overrides.
   PPB_Flash_MessageLoop_API* AsPPB_Flash_MessageLoop_API() override;
 
-  // PPB_Flash_MesssageLoop_API implementation.
+  // PPB_Flash_MessageLoop_API implementation.
   int32_t Run() override;
   void Quit() override;
-  void RunFromHostProxy(const RunFromHostProxyCallback& callback) override;
+  void RunFromHostProxy(RunFromHostProxyCallback callback) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlashMessageLoop);
@@ -65,8 +65,7 @@ void FlashMessageLoop::Quit() {
           API_ID_PPB_FLASH_MESSAGELOOP, host_resource()));
 }
 
-void FlashMessageLoop::RunFromHostProxy(
-    const RunFromHostProxyCallback& callback) {
+void FlashMessageLoop::RunFromHostProxy(RunFromHostProxyCallback callback) {
   // This should never be called on the plugin side.
   NOTREACHED();
 }
@@ -134,15 +133,15 @@ void PPB_Flash_MessageLoop_Proxy::OnMsgRun(
     return;
 
   PPB_Flash_MessageLoop_API::RunFromHostProxyCallback callback =
-      base::Bind(&PPB_Flash_MessageLoop_Proxy::WillQuitSoon, AsWeakPtr(),
-                 base::Passed(std::unique_ptr<IPC::Message>(reply)));
+      base::BindOnce(&PPB_Flash_MessageLoop_Proxy::WillQuitSoon, AsWeakPtr(),
+                     base::Passed(std::unique_ptr<IPC::Message>(reply)));
 
   EnterHostFromHostResource<PPB_Flash_MessageLoop_API>
       enter(flash_message_loop);
   if (enter.succeeded())
-    enter.object()->RunFromHostProxy(callback);
+    enter.object()->RunFromHostProxy(std::move(callback));
   else
-    callback.Run(PP_ERROR_BADRESOURCE);
+    std::move(callback).Run(PP_ERROR_BADRESOURCE);
 }
 
 void PPB_Flash_MessageLoop_Proxy::OnMsgQuit(

ppapi/thunk/ppb_file_system_api.h

@@ -26,9 +26,9 @@ class PPB_FileSystem_API {
   virtual PP_FileSystemType GetType() = 0;
   virtual void OpenQuotaFile(PP_Resource file_io) = 0;
   virtual void CloseQuotaFile(PP_Resource file_io) = 0;
-  typedef base::Callback<void(int64_t)> RequestQuotaCallback;
+  typedef base::OnceCallback<void(int64_t)> RequestQuotaCallback;
   virtual int64_t RequestQuota(int64_t amount,
-                               const RequestQuotaCallback& callback) = 0;
+                               RequestQuotaCallback callback) = 0;
 };
 
 }  // namespace thunk

ppapi/thunk/ppb_flash_message_loop_api.h

@@ -23,9 +23,8 @@ class PPB_Flash_MessageLoop_API {
   // This is used by the proxy at the host side to call into the implementation.
   // |callback| is called when the message loop is signaled to quit but before
   // the method returns.
-  typedef base::Callback<void (int32_t)> RunFromHostProxyCallback;
-  virtual void RunFromHostProxy(
-      const RunFromHostProxyCallback& callback) = 0;
+  typedef base::OnceCallback<void(int32_t)> RunFromHostProxyCallback;
+  virtual void RunFromHostProxy(RunFromHostProxyCallback callback) = 0;
 };
 
 }  // namespace thunk