[base] Apply BindOnceRewriter in //ppapi

This change applies the BindOnceRewriter in //ppapi.
This rewriter replaces calls to base::Bind and base::BindRepeating with
calls to base::BindOnce, in case the result is immediately assigned to a
base::OnceCallback. Given that base::RepeatingCallback is implicitly
convertible to base::OnceCallback, there is no change in functionality.

Steps:
  1. run_tool.py --tool base_bind_rewriters \
                 --tool-arg='--rewriter=bind_to_bind_once'
  2. git cl format

This CL was uploaded by git cl split.

R=bbudge@chromium.org

Bug: 714018
Change-Id: If865855e4a21b08c359bc48f08ce3db258e41ffa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2132411Reviewed-by: Bill Budge <bbudge@chromium.org>
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#760440}

ppapi/proxy/file_io_resource.cc

@@ -305,12 +305,9 @@ int32_t FileIOResource::Write(int64_t offset,
       int64_t result =
           file_system_resource_->AsPPB_FileSystem_API()->RequestQuota(
               increase,
-              base::Bind(&FileIOResource::OnRequestWriteQuotaComplete,
-                         this,
-                         offset,
-                         base::Passed(&copy),
-                         bytes_to_write,
-                         callback));
+              base::BindOnce(&FileIOResource::OnRequestWriteQuotaComplete, this,
+                             offset, base::Passed(&copy), bytes_to_write,
+                             callback));
       if (result == PP_OK_COMPLETIONPENDING)
         return PP_OK_COMPLETIONPENDING;
       DCHECK(result == increase);
@@ -339,9 +336,8 @@ int32_t FileIOResource::SetLength(int64_t length,
       int32_t result =
           file_system_resource_->AsPPB_FileSystem_API()->RequestQuota(
               increase,
-              base::Bind(&FileIOResource::OnRequestSetLengthQuotaComplete,
-                         this,
-                         length, callback));
+              base::BindOnce(&FileIOResource::OnRequestSetLengthQuotaComplete,
+                             this, length, callback));
       if (result == PP_OK_COMPLETIONPENDING) {
         state_manager_.SetPendingOperation(
             FileIOStateManager::OPERATION_EXCLUSIVE);

ppapi/proxy/file_system_resource_unittest.cc

@@ -233,8 +233,8 @@ TEST_F(FileSystemResourceTest, RequestQuota) {
 
   MockRequestQuotaCallback cb1;
   int64_t result = file_system_api->RequestQuota(
-      kQuotaRequestAmount1,
-      base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1)));
+      kQuotaRequestAmount1, base::BindOnce(&MockRequestQuotaCallback::Callback,
+                                           base::Unretained(&cb1)));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 
   // Should have sent a "reserve quota" message, with the amount of the request
@@ -257,8 +257,8 @@ TEST_F(FileSystemResourceTest, RequestQuota) {
   // Make another request while the "reserve quota" message is pending.
   MockRequestQuotaCallback cb2;
   result = file_system_api->RequestQuota(
-      kQuotaRequestAmount2,
-      base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2)));
+      kQuotaRequestAmount2, base::BindOnce(&MockRequestQuotaCallback::Callback,
+                                           base::Unretained(&cb2)));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   // No new "reserve quota" message should be sent while one is pending.
   ASSERT_FALSE(sink().GetFirstResourceCallMatching(
@@ -283,12 +283,12 @@ TEST_F(FileSystemResourceTest, RequestQuota) {
   // All requests should fail when insufficient quota is returned to satisfy
   // the first request.
   result = file_system_api->RequestQuota(
-      kQuotaRequestAmount1,
-      base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1)));
+      kQuotaRequestAmount1, base::BindOnce(&MockRequestQuotaCallback::Callback,
+                                           base::Unretained(&cb1)));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = file_system_api->RequestQuota(
-      kQuotaRequestAmount2,
-      base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2)));
+      kQuotaRequestAmount2, base::BindOnce(&MockRequestQuotaCallback::Callback,
+                                           base::Unretained(&cb2)));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 
   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
@@ -314,12 +314,12 @@ TEST_F(FileSystemResourceTest, RequestQuota) {
   // A new request should be made if the quota reservation is enough to satisfy
   // at least one request.
   result = file_system_api->RequestQuota(
-      kQuotaRequestAmount1,
-      base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1)));
+      kQuotaRequestAmount1, base::BindOnce(&MockRequestQuotaCallback::Callback,
+                                           base::Unretained(&cb1)));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = file_system_api->RequestQuota(
-      kQuotaRequestAmount2,
-      base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2)));
+      kQuotaRequestAmount2, base::BindOnce(&MockRequestQuotaCallback::Callback,
+                                           base::Unretained(&cb2)));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 
   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
@@ -362,8 +362,8 @@ TEST_F(FileSystemResourceTest, RequestQuota) {
   // There is kQuotaRequestAmount1 of quota left, and a request for it should
   // succeed immediately.
   result = file_system_api->RequestQuota(
-      kQuotaRequestAmount1,
-      base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1)));
+      kQuotaRequestAmount1, base::BindOnce(&MockRequestQuotaCallback::Callback,
+                                           base::Unretained(&cb1)));
   ASSERT_EQ(kQuotaRequestAmount1, result);
 }
 

ppapi/proxy/ppb_message_loop_proxy.cc

@@ -135,8 +135,8 @@ int32_t MessageLoopResource::PostWork(PP_CompletionCallback callback,
   if (destroyed_)
     return PP_ERROR_FAILED;
   PostClosure(FROM_HERE,
-              base::Bind(callback.func, callback.user_data,
-                         static_cast<int32_t>(PP_OK)),
+              base::BindOnce(callback.func, callback.user_data,
+                             static_cast<int32_t>(PP_OK)),
               delay_ms);
   return PP_OK;
 }
@@ -151,8 +151,9 @@ int32_t MessageLoopResource::PostQuit(PP_Bool should_destroy) {
   if (IsCurrent() && nested_invocations_ > 0) {
     run_loop_->QuitWhenIdle();
   } else {
-    PostClosure(FROM_HERE, base::Bind(&MessageLoopResource::QuitRunLoopWhenIdle,
-                                      Unretained(this)),
+    PostClosure(FROM_HERE,
+                base::BindOnce(&MessageLoopResource::QuitRunLoopWhenIdle,
+                               Unretained(this)),
                 0);
   }
   return PP_OK;