Rewrite base::Bind into base::BindOnce on trivial cases in base

base/trace_event/trace_log.cc

 // Copyright 2015 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 "base/trace_event/trace_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ skipping 629 matching lines @@
 
     dispatching_to_observer_list_ = true;
     observer_list = enabled_state_observer_list_;
     observer_map = async_observers_;
   }
   // Notify observers outside the lock in case they trigger trace events.
   for (EnabledStateObserver* observer : observer_list)
     observer->OnTraceLogEnabled();
   for (const auto& it : observer_map) {
     it.second.task_runner->PostTask(
-        FROM_HERE, Bind(&AsyncEnabledStateObserver::OnTraceLogEnabled,
-                        it.second.observer));
+        FROM_HERE, BindOnce(&AsyncEnabledStateObserver::OnTraceLogEnabled,
+                            it.second.observer));
   }
 
   {
     AutoLock lock(lock_);
     dispatching_to_observer_list_ = false;
   }
 }
 
 void TraceLog::SetArgumentFilterPredicate(
     const ArgumentFilterPredicate& argument_filter_predicate) {
@@ skipping 79 matching lines @@
       async_observers_;
 
   {
     // Dispatch to observers outside the lock in case the observer triggers a
     // trace event.
     AutoUnlock unlock(lock_);
     for (EnabledStateObserver* observer : observer_list)
       observer->OnTraceLogDisabled();
     for (const auto& it : observer_map) {
       it.second.task_runner->PostTask(
-          FROM_HERE, Bind(&AsyncEnabledStateObserver::OnTraceLogDisabled,
-                          it.second.observer));
+          FROM_HERE, BindOnce(&AsyncEnabledStateObserver::OnTraceLogDisabled,
+                              it.second.observer));
     }
   }
   dispatching_to_observer_list_ = false;
 }
 
 int TraceLog::GetNumTracesRecorded() {
   AutoLock lock(lock_);
   if (!IsEnabled())
     return -1;
   return num_traces_recorded_;
@@ skipping 123 matching lines @@
                                   std::move(thread_shared_chunk_));
     }
 
     for (MessageLoop* loop : thread_message_loops_)
       thread_message_loop_task_runners.push_back(loop->task_runner());
   }
 
   if (!thread_message_loop_task_runners.empty()) {
     for (auto& task_runner : thread_message_loop_task_runners) {
       task_runner->PostTask(
-          FROM_HERE, Bind(&TraceLog::FlushCurrentThread, Unretained(this),
-                          gen, discard_events));
+          FROM_HERE, BindOnce(&TraceLog::FlushCurrentThread, Unretained(this),
+                              gen, discard_events));
     }
     flush_task_runner_->PostDelayedTask(
-        FROM_HERE, Bind(&TraceLog::OnFlushTimeout, Unretained(this), gen,
-                        discard_events),
+        FROM_HERE,
+        BindOnce(&TraceLog::OnFlushTimeout, Unretained(this), gen,
+                 discard_events),
         TimeDelta::FromMilliseconds(kThreadFlushTimeoutMs));
     return;
   }
 
   FinishFlush(gen, discard_events);
 }
 
 // Usually it runs on a different thread.
 void TraceLog::ConvertTraceEventsToTraceFormat(
     std::unique_ptr<TraceBuffer> logged_events,
@@ skipping 50 matching lines @@
   if (discard_events) {
     if (!flush_output_callback.is_null()) {
       scoped_refptr<RefCountedString> empty_result = new RefCountedString;
       flush_output_callback.Run(empty_result, false);
     }
     return;
   }
 
   if (use_worker_thread_) {
     base::PostTaskWithTraits(
-        FROM_HERE, base::TaskTraits()
-                       .MayBlock()
-                       .WithPriority(base::TaskPriority::BACKGROUND)
-                       .WithShutdownBehavior(
-                           base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
-        Bind(&TraceLog::ConvertTraceEventsToTraceFormat,
-             Passed(&previous_logged_events), flush_output_callback,
-             argument_filter_predicate));
+        FROM_HERE,
+        base::TaskTraits()
+            .MayBlock()
+            .WithPriority(base::TaskPriority::BACKGROUND)
+            .WithShutdownBehavior(
+                base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+        BindOnce(&TraceLog::ConvertTraceEventsToTraceFormat,
+                 Passed(&previous_logged_events), flush_output_callback,
+                 argument_filter_predicate));
     return;
   }
 
   ConvertTraceEventsToTraceFormat(std::move(previous_logged_events),
                                   flush_output_callback,
                                   argument_filter_predicate);
 }
 
 // Run in each thread holding a local event buffer.
 void TraceLog::FlushCurrentThread(int generation, bool discard_events) {
   {
     AutoLock lock(lock_);
     if (!CheckGeneration(generation) || !flush_task_runner_) {
       // This is late. The corresponding flush has finished.
       return;
     }
   }
 
   // This will flush the thread local buffer.
   delete thread_local_event_buffer_.Get();
 
   AutoLock lock(lock_);
   if (!CheckGeneration(generation) || !flush_task_runner_ ||
       !thread_message_loops_.empty())
     return;
 
   flush_task_runner_->PostTask(
-      FROM_HERE, Bind(&TraceLog::FinishFlush, Unretained(this), generation,
-                      discard_events));
+      FROM_HERE, BindOnce(&TraceLog::FinishFlush, Unretained(this), generation,
+                          discard_events));
 }
 
 void TraceLog::OnFlushTimeout(int generation, bool discard_events) {
   {
     AutoLock lock(lock_);
     if (!CheckGeneration(generation) || !flush_task_runner_) {
       // Flush has finished before timeout.
       return;
     }
 
@@ skipping 714 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
                                                 event_handle_);
   }
 }
 
 }  // namespace trace_event_internal