Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/extensions

chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/hash.h"
@@ skipping 155 matching lines @@
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
   std::unique_ptr<MetaDataMap> meta_data(new MetaDataMap());
   for (const MetaDataEntry& entry : params->meta_data)
     (*meta_data)[entry.key] = entry.value;
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::SetMetaData, webrtc_logging_handler_host,
-      base::Passed(&meta_data), callback));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&WebRtcLoggingHandlerHost::SetMetaData,
+                                         webrtc_logging_handler_host,
+                                         base::Passed(&meta_data), callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateStartFunction::RunAsync() {
   std::unique_ptr<Start::Params> params(Start::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::StartLogging, webrtc_logging_handler_host,
-      callback));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&WebRtcLoggingHandlerHost::StartLogging,
+                     webrtc_logging_handler_host, callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateSetUploadOnRenderCloseFunction::RunAsync() {
   std::unique_ptr<SetUploadOnRenderClose::Params> params(
       SetUploadOnRenderClose::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
       LoggingHandlerFromRequest(params->request, params->security_origin));
   if (!webrtc_logging_handler_host.get())
     return false;
 
   webrtc_logging_handler_host->set_upload_log_on_render_close(
       params->should_upload);
 
   // Post a task since this is an asynchronous extension function.
   // TODO(devlin): This is unneccessary; this should just be a
   // UIThreadExtensionFunction. Fix this.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &WebrtcLoggingPrivateSetUploadOnRenderCloseFunction::SendResponse,
           this, true));
   return true;
 }
 
 bool WebrtcLoggingPrivateStopFunction::RunAsync() {
   std::unique_ptr<Stop::Params> params(Stop::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::StopLogging, webrtc_logging_handler_host,
-      callback));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&WebRtcLoggingHandlerHost::StopLogging,
+                     webrtc_logging_handler_host, callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateStoreFunction::RunAsync() {
   std::unique_ptr<Store::Params> params(Store::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
   const std::string local_log_id(HashIdWithOrigin(params->security_origin,
                                                   params->log_id));
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::StoreLog,
-      webrtc_logging_handler_host, local_log_id, callback));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&WebRtcLoggingHandlerHost::StoreLog,
+                     webrtc_logging_handler_host, local_log_id, callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateUploadStoredFunction::RunAsync() {
   std::unique_ptr<UploadStored::Params> params(
       UploadStored::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   scoped_refptr<WebRtcLoggingHandlerHost> logging_handler(
       LoggingHandlerFromRequest(params->request, params->security_origin));
   if (!logging_handler.get())
     return false;
 
   WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind(
       &WebrtcLoggingPrivateUploadStoredFunction::FireCallback, this);
 
   const std::string local_log_id(HashIdWithOrigin(params->security_origin,
                                                   params->log_id));
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::UploadStoredLog, logging_handler, local_log_id,
-      callback));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&WebRtcLoggingHandlerHost::UploadStoredLog,
+                     logging_handler, local_log_id, callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateUploadFunction::RunAsync() {
   std::unique_ptr<Upload::Params> params(Upload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   scoped_refptr<WebRtcLoggingHandlerHost> logging_handler(
       LoggingHandlerFromRequest(params->request, params->security_origin));
   if (!logging_handler.get())
     return false;
 
   WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind(
       &WebrtcLoggingPrivateUploadFunction::FireCallback, this);
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::UploadLog, logging_handler, callback));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&WebRtcLoggingHandlerHost::UploadLog,
+                                         logging_handler, callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateDiscardFunction::RunAsync() {
   std::unique_ptr<Discard::Params> params(Discard::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::DiscardLog, webrtc_logging_handler_host,
-      callback));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&WebRtcLoggingHandlerHost::DiscardLog,
+                     webrtc_logging_handler_host, callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateStartRtpDumpFunction::RunAsync() {
   std::unique_ptr<StartRtpDump::Params> params(
       StartRtpDump::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!params->incoming && !params->outgoing) {
@@ skipping 18 matching lines @@
   WebRtcLoggingHandlerHost::GenericDoneCallback callback = base::Bind(
       &WebrtcLoggingPrivateStartRtpDumpFunction::FireCallback, this);
 
   // This call cannot fail.
   content::RenderProcessHost::WebRtcStopRtpDumpCallback stop_callback =
       host->StartRtpDump(params->incoming,
                          params->outgoing,
                          base::Bind(&WebRtcLoggingHandlerHost::OnRtpPacket,
                                     webrtc_logging_handler_host));
 
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&WebRtcLoggingHandlerHost::StartRtpDump,
-                                     webrtc_logging_handler_host,
-                                     type,
-                                     callback,
-                                     stop_callback));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&WebRtcLoggingHandlerHost::StartRtpDump,
+                     webrtc_logging_handler_host, type, callback,
+                     stop_callback));
   return true;
 }
 
 bool WebrtcLoggingPrivateStopRtpDumpFunction::RunAsync() {
   std::unique_ptr<StopRtpDump::Params> params(
       StopRtpDump::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!params->incoming && !params->outgoing) {
     FireCallback(false, "Either incoming or outgoing must be true.");
@@ skipping 10 matching lines @@
   if (!host)
     return false;
 
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
       base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(
           host, WebRtcLoggingHandlerHost::kWebRtcLoggingHandlerHostKey));
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback = base::Bind(
       &WebrtcLoggingPrivateStopRtpDumpFunction::FireCallback, this);
 
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&WebRtcLoggingHandlerHost::StopRtpDump,
-                                     webrtc_logging_handler_host,
-                                     type,
-                                     callback));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&WebRtcLoggingHandlerHost::StopRtpDump,
+                     webrtc_logging_handler_host, type, callback));
   return true;
 }
 
 bool WebrtcLoggingPrivateStartAudioDebugRecordingsFunction::RunAsync() {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAudioDebugRecordingsFromExtension)) {
     return false;
   }
 
   std::unique_ptr<StartAudioDebugRecordings::Params> params(
@@ skipping 106 matching lines @@
           &WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::FireCallback,
           this),
       base::Bind(&WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::
                      FireErrorCallback,
                  this));
 
   return true;
 }
 
 }  // namespace extensions