[Cronet] Use BindOnce and OnceClosure instead of Bind and Closure.

Bug: 714018
Cq-Include-Trybots: master.tryserver.chromium.android:android_cronet_tester;master.tryserver.chromium.mac:ios-simulator-cronet
Change-Id: Id80f9e1c804ad5026e16060d351ac438e191a8fc
Reviewed-on: https://chromium-review.googlesource.com/868712Reviewed-by: Andrei Kapishnikov <kapishnikov@chromium.org>
Commit-Queue: Misha Efimov <mef@chromium.org>
Cr-Commit-Position: refs/heads/master@{#531917}

components/cronet/cronet_url_request.cc

@@ -105,33 +105,34 @@ void CronetURLRequest::SetUpload(
 void CronetURLRequest::Start() {
   DCHECK(!context_->IsOnNetworkThread());
   context_->PostTaskToNetworkThread(
-      FROM_HERE, base::Bind(&CronetURLRequest::NetworkTasks::Start,
-                            base::Unretained(&network_tasks_),
-                            base::Unretained(context_), initial_method_,
-                            base::Passed(std::move(initial_request_headers_)),
-                            base::Passed(std::move(upload_))));
+      FROM_HERE,
+      base::BindOnce(&CronetURLRequest::NetworkTasks::Start,
+                     base::Unretained(&network_tasks_),
+                     base::Unretained(context_), initial_method_,
+                     base::Passed(std::move(initial_request_headers_)),
+                     base::Passed(std::move(upload_))));
 }
 
 void CronetURLRequest::GetStatus(OnStatusCallback callback) const {
   context_->PostTaskToNetworkThread(
-      FROM_HERE,
-      base::Bind(&CronetURLRequest::NetworkTasks::GetStatus,
-                 base::Unretained(&network_tasks_), base::Passed(&callback)));
+      FROM_HERE, base::BindOnce(&CronetURLRequest::NetworkTasks::GetStatus,
+                                base::Unretained(&network_tasks_),
+                                base::Passed(&callback)));
 }
 
 void CronetURLRequest::FollowDeferredRedirect() {
   context_->PostTaskToNetworkThread(
       FROM_HERE,
-      base::Bind(&CronetURLRequest::NetworkTasks::FollowDeferredRedirect,
-                 base::Unretained(&network_tasks_)));
+      base::BindOnce(&CronetURLRequest::NetworkTasks::FollowDeferredRedirect,
+                     base::Unretained(&network_tasks_)));
 }
 
 bool CronetURLRequest::ReadData(net::IOBuffer* raw_read_buffer, int max_size) {
   scoped_refptr<net::IOBuffer> read_buffer(raw_read_buffer);
   context_->PostTaskToNetworkThread(
       FROM_HERE,
-      base::Bind(&CronetURLRequest::NetworkTasks::ReadData,
-                 base::Unretained(&network_tasks_), read_buffer, max_size));
+      base::BindOnce(&CronetURLRequest::NetworkTasks::ReadData,
+                     base::Unretained(&network_tasks_), read_buffer, max_size));
   return true;
 }
 
@@ -142,9 +143,9 @@ void CronetURLRequest::Destroy(bool send_on_canceled) {
   // within a synchronized block that guarantees no future posts to the
   // network thread with the request pointer.
   context_->PostTaskToNetworkThread(
-      FROM_HERE, base::Bind(&CronetURLRequest::NetworkTasks::Destroy,
-                            base::Unretained(&network_tasks_),
-                            base::Unretained(this), send_on_canceled));
+      FROM_HERE, base::BindOnce(&CronetURLRequest::NetworkTasks::Destroy,
+                                base::Unretained(&network_tasks_),
+                                base::Unretained(this), send_on_canceled));
 }
 
 CronetURLRequest::NetworkTasks::NetworkTasks(std::unique_ptr<Callback> callback,

components/cronet/cronet_url_request_context.cc

@@ -225,10 +225,10 @@ void CronetURLRequestContext::InitRequestContextOnInitThread() {
   g_net_log.Get().EnsureInitializedOnInitThread();
   GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&CronetURLRequestContext::NetworkTasks::Initialize,
-                 base::Unretained(network_tasks_), GetNetworkTaskRunner(),
-                 GetFileThread()->task_runner(),
-                 base::Passed(&proxy_config_service)));
+      base::BindOnce(&CronetURLRequestContext::NetworkTasks::Initialize,
+                     base::Unretained(network_tasks_), GetNetworkTaskRunner(),
+                     GetFileThread()->task_runner(),
+                     base::Passed(&proxy_config_service)));
 }
 
 void CronetURLRequestContext::NetworkTasks::
@@ -250,10 +250,10 @@ void CronetURLRequestContext::ConfigureNetworkQualityEstimatorForTesting(
     bool disable_offline_check) {
   PostTaskToNetworkThread(
       FROM_HERE,
-      base::Bind(&CronetURLRequestContext::NetworkTasks::
-                     ConfigureNetworkQualityEstimatorForTesting,
-                 base::Unretained(network_tasks_), use_local_host_requests,
-                 use_smaller_responses, disable_offline_check));
+      base::BindOnce(&CronetURLRequestContext::NetworkTasks::
+                         ConfigureNetworkQualityEstimatorForTesting,
+                     base::Unretained(network_tasks_), use_local_host_requests,
+                     use_smaller_responses, disable_offline_check));
 }
 
 void CronetURLRequestContext::NetworkTasks::ProvideRTTObservations(
@@ -271,8 +271,9 @@ void CronetURLRequestContext::NetworkTasks::ProvideRTTObservations(
 void CronetURLRequestContext::ProvideRTTObservations(bool should) {
   PostTaskToNetworkThread(
       FROM_HERE,
-      base::Bind(&CronetURLRequestContext::NetworkTasks::ProvideRTTObservations,
-                 base::Unretained(network_tasks_), should));
+      base::BindOnce(
+          &CronetURLRequestContext::NetworkTasks::ProvideRTTObservations,
+          base::Unretained(network_tasks_), should));
 }
 
 void CronetURLRequestContext::NetworkTasks::ProvideThroughputObservations(
@@ -290,7 +291,7 @@ void CronetURLRequestContext::NetworkTasks::ProvideThroughputObservations(
 void CronetURLRequestContext::ProvideThroughputObservations(bool should) {
   PostTaskToNetworkThread(
       FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &CronetURLRequestContext::NetworkTasks::ProvideThroughputObservations,
           base::Unretained(network_tasks_), should));
 }
@@ -450,12 +451,13 @@ void CronetURLRequestContext::NetworkTasks::Initialize(
     // after the bug has been fixed.
     network_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&CronetURLRequestContext::NetworkTasks::InitializeNQEPrefs,
-                   base::Unretained(this)));
+        base::BindOnce(
+            &CronetURLRequestContext::NetworkTasks::InitializeNQEPrefs,
+            base::Unretained(this)));
   }
 
   while (!tasks_waiting_for_context_.empty()) {
-    tasks_waiting_for_context_.front().Run();
+    std::move(tasks_waiting_for_context_.front()).Run();
     tasks_waiting_for_context_.pop();
   }
 }
@@ -476,23 +478,23 @@ net::URLRequestContext* CronetURLRequestContext::GetURLRequestContext() {
 
 void CronetURLRequestContext::PostTaskToNetworkThread(
     const base::Location& posted_from,
-    const base::Closure& callback) {
+    base::OnceClosure callback) {
   GetNetworkTaskRunner()->PostTask(
       posted_from,
-      base::Bind(
+      base::BindOnce(
           &CronetURLRequestContext::NetworkTasks::RunTaskAfterContextInit,
-          base::Unretained(network_tasks_), callback));
+          base::Unretained(network_tasks_), base::Passed(std::move(callback))));
 }
 
 void CronetURLRequestContext::NetworkTasks::RunTaskAfterContextInit(
-    const base::Closure& task_to_run_after_context_init) {
+    base::OnceClosure task_to_run_after_context_init) {
   DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
   if (is_context_initialized_) {
     DCHECK(tasks_waiting_for_context_.empty());
-    task_to_run_after_context_init.Run();
+    std::move(task_to_run_after_context_init).Run();
     return;
   }
-  tasks_waiting_for_context_.push(task_to_run_after_context_init);
+  tasks_waiting_for_context_.push(std::move(task_to_run_after_context_init));
 }
 
 bool CronetURLRequestContext::IsOnNetworkThread() const {
@@ -514,8 +516,8 @@ bool CronetURLRequestContext::StartNetLogToFile(const std::string& file_name,
   }
   PostTaskToNetworkThread(
       FROM_HERE,
-      base::Bind(&CronetURLRequestContext::NetworkTasks::StartNetLog,
-                 base::Unretained(network_tasks_), file_path, log_all));
+      base::BindOnce(&CronetURLRequestContext::NetworkTasks::StartNetLog,
+                     base::Unretained(network_tasks_), file_path, log_all));
   return true;
 }
 
@@ -524,7 +526,7 @@ void CronetURLRequestContext::StartNetLogToDisk(const std::string& dir_name,
                                                 int max_size) {
   PostTaskToNetworkThread(
       FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &CronetURLRequestContext::NetworkTasks::StartNetLogToBoundedFile,
           base::Unretained(network_tasks_), dir_name, log_all, max_size));
 }
@@ -532,15 +534,17 @@ void CronetURLRequestContext::StartNetLogToDisk(const std::string& dir_name,
 void CronetURLRequestContext::StopNetLog() {
   DCHECK(!GetNetworkTaskRunner()->BelongsToCurrentThread());
   PostTaskToNetworkThread(
-      FROM_HERE, base::Bind(&CronetURLRequestContext::NetworkTasks::StopNetLog,
-                            base::Unretained(network_tasks_)));
+      FROM_HERE,
+      base::BindOnce(&CronetURLRequestContext::NetworkTasks::StopNetLog,
+                     base::Unretained(network_tasks_)));
 }
 
 void CronetURLRequestContext::GetCertVerifierData() {
   PostTaskToNetworkThread(
       FROM_HERE,
-      base::Bind(&CronetURLRequestContext::NetworkTasks::GetCertVerifierData,
-                 base::Unretained(network_tasks_)));
+      base::BindOnce(
+          &CronetURLRequestContext::NetworkTasks::GetCertVerifierData,
+          base::Unretained(network_tasks_)));
 }
 
 void CronetURLRequestContext::NetworkTasks::GetCertVerifierData() {
@@ -668,8 +672,9 @@ void CronetURLRequestContext::NetworkTasks::StopNetLog() {
     return;
   net_log_file_observer_->StopObserving(
       GetNetLogInfo(),
-      base::Bind(&CronetURLRequestContext::NetworkTasks::StopNetLogCompleted,
-                 base::Unretained(this)));
+      base::BindOnce(
+          &CronetURLRequestContext::NetworkTasks::StopNetLogCompleted,
+          base::Unretained(this)));
   net_log_file_observer_.reset();
 }
 

components/cronet/cronet_url_request_context.h

@@ -114,7 +114,7 @@ class CronetURLRequestContext {
   // Posts a task that might depend on the context being initialized
   // to the network thread.
   void PostTaskToNetworkThread(const base::Location& posted_from,
-                               const base::Closure& callback);
+                               base::OnceClosure callback);
 
   // Returns true if running on network thread.
   bool IsOnNetworkThread() const;
@@ -182,7 +182,7 @@ class CronetURLRequestContext {
 
     // Runs a task that might depend on the context being initialized.
     void RunTaskAfterContextInit(
-        const base::Closure& task_to_run_after_context_init);
+        base::OnceClosure task_to_run_after_context_init);
 
     // Serializes results of certificate verifications of |context_|'s
     // |cert_verifier|.
@@ -273,7 +273,7 @@ class CronetURLRequestContext {
     std::unique_ptr<base::DictionaryValue> effective_experimental_options_;
 
     // A queue of tasks that need to be run after context has been initialized.
-    base::queue<base::Closure> tasks_waiting_for_context_;
+    base::queue<base::OnceClosure> tasks_waiting_for_context_;
 
     // Task runner that runs network tasks.
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;