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

base/trace_event/memory_dump_scheduler.cc

 // Copyright 2017 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/memory_dump_scheduler.h"
 
 #include "base/process/process_metrics.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
@@ skipping 87 matching lines @@
 
 void MemoryDumpScheduler::EnablePollingIfNeeded() {
   DCHECK(is_setup_);
   if (polling_state_->current_state != PollingTriggerState::CONFIGURED)
     return;
 
   polling_state_->current_state = PollingTriggerState::ENABLED;
   polling_state_->ResetTotals();
 
   polling_task_runner_->PostTask(
-      FROM_HERE,
-      Bind(&MemoryDumpScheduler::PollMemoryOnPollingThread, Unretained(this)));
+      FROM_HERE, BindOnce(&MemoryDumpScheduler::PollMemoryOnPollingThread,
+                          Unretained(this)));
 }
 
 void MemoryDumpScheduler::NotifyDumpTriggered() {
   if (polling_task_runner_ &&
       !polling_task_runner_->RunsTasksOnCurrentThread()) {
     polling_task_runner_->PostTask(
         FROM_HERE,
-        Bind(&MemoryDumpScheduler::NotifyDumpTriggered, Unretained(this)));
+        BindOnce(&MemoryDumpScheduler::NotifyDumpTriggered, Unretained(this)));
     return;
   }
 
   if (!polling_state_ ||
       polling_state_->current_state != PollingTriggerState::ENABLED) {
     return;
   }
 
   polling_state_->ResetTotals();
 }
 
 void MemoryDumpScheduler::DisableAllTriggers() {
   if (periodic_state_) {
     if (periodic_state_->timer.IsRunning())
       periodic_state_->timer.Stop();
     periodic_state_.reset();
   }
 
   if (polling_task_runner_) {
     DCHECK(polling_state_);
     polling_task_runner_->PostTask(
-        FROM_HERE, Bind(&MemoryDumpScheduler::DisablePollingOnPollingThread,
-                        Unretained(this)));
+        FROM_HERE, BindOnce(&MemoryDumpScheduler::DisablePollingOnPollingThread,
+                            Unretained(this)));
     polling_task_runner_ = nullptr;
   }
   is_setup_ = false;
 }
 
 void MemoryDumpScheduler::DisablePollingOnPollingThread() {
   polling_state_->current_state = PollingTriggerState::DISABLED;
   polling_state_.reset();
 }
 
@@ skipping 39 matching lines @@
                          TRACE_EVENT_SCOPE_PROCESS, "total_usage_MB",
                          polled_memory / 1024 / 1024);
 
     mdm_->RequestGlobalDump(MemoryDumpType::PEAK_MEMORY_USAGE,
                             polling_state_->level_of_detail);
   }
 
   // TODO(ssid): Use RequestSchedulerCallback, crbug.com/607533.
   ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      Bind(&MemoryDumpScheduler::PollMemoryOnPollingThread, Unretained(this)),
+      BindOnce(&MemoryDumpScheduler::PollMemoryOnPollingThread,
+               Unretained(this)),
       TimeDelta::FromMilliseconds(polling_state_->polling_interval_ms));
 }
 
 bool MemoryDumpScheduler::ShouldTriggerDump(uint64_t current_memory_total) {
   // This function tries to detect peak memory usage as discussed in
   // https://goo.gl/0kOU4A.
 
   if (current_memory_total == 0)
     return false;
 
@@ skipping 108 matching lines @@
         last_memory_totals_kb[last_memory_totals_kb_index] * 1024;
   }
   num_polls_from_last_dump = 0;
   for (uint32_t i = 0; i < kMaxNumMemorySamples; ++i)
     last_memory_totals_kb[i] = 0;
   last_memory_totals_kb_index = 0;
 }
 
 }  // namespace trace_event
 }  // namespace base