memory-infra: Switch to MemoryPeakDetector and simplify MemoryDumpScheduler

base/trace_event/memory_peak_detector.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_peak_detector.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 50 matching lines @@
   // Fallback, mostly for test environments where AmountOfPhysicalMemory() is
   // broken.
   static_threshold_bytes_ =
       std::max(static_threshold_bytes_, static_cast<uint64_t>(5 * 1024 * 1024));
 }
 
 void MemoryPeakDetector::TearDown() {
   if (task_runner_) {
     task_runner_->PostTask(
         FROM_HERE,
-        Bind(&MemoryPeakDetector::TearDownInternal, Unretained(this)));
+        BindOnce(&MemoryPeakDetector::TearDownInternal, Unretained(this)));
   }
   task_runner_ = nullptr;
 }
 
 void MemoryPeakDetector::Start(MemoryPeakDetector::Config config) {
   if (!config.polling_interval_ms) {
     NOTREACHED();
     return;
   }
-  task_runner_->PostTask(FROM_HERE, Bind(&MemoryPeakDetector::StartInternal,
-                                         Unretained(this), config));
+  task_runner_->PostTask(FROM_HERE, BindOnce(&MemoryPeakDetector::StartInternal,
+                                             Unretained(this), config));
 }
 
 void MemoryPeakDetector::Stop() {
   task_runner_->PostTask(
-      FROM_HERE, Bind(&MemoryPeakDetector::StopInternal, Unretained(this)));
+      FROM_HERE, BindOnce(&MemoryPeakDetector::StopInternal, Unretained(this)));
 }
 
 void MemoryPeakDetector::Throttle() {
   if (!task_runner_)
     return;  // Can be called before Setup().
   task_runner_->PostTask(
-      FROM_HERE, Bind(&MemoryPeakDetector::ResetPollHistory, Unretained(this),
-                      true /* keep_last_sample */));
+      FROM_HERE, BindOnce(&MemoryPeakDetector::ResetPollHistory,
+                          Unretained(this), true /* keep_last_sample */));
 }
 
 void MemoryPeakDetector::NotifyMemoryDumpProvidersChanged() {
   if (!task_runner_)
     return;  // Can be called before Setup().
   task_runner_->PostTask(
       FROM_HERE,
-      Bind(&MemoryPeakDetector::ReloadDumpProvidersAndStartPollingIfNeeded,
-           Unretained(this)));
+      BindOnce(&MemoryPeakDetector::ReloadDumpProvidersAndStartPollingIfNeeded,
+               Unretained(this)));
 }
 
 void MemoryPeakDetector::StartInternal(MemoryPeakDetector::Config config) {
   DCHECK_EQ(DISABLED, state_);
   state_ = ENABLED;
   config_ = config;
   ResetPollHistory();
 
   // If there are any dump providers available,
   // NotifyMemoryDumpProvidersChanged will fetch them and start the polling.
   // Otherwise this will remain in the ENABLED state and the actual polling
   // will start on the next call to
   // ReloadDumpProvidersAndStartPollingIfNeeded().
   // Depending on the sandbox model, it is possible that no polling-capable
   // dump providers will be ever available.
   ReloadDumpProvidersAndStartPollingIfNeeded();
 }
 
 void MemoryPeakDetector::StopInternal() {
   DCHECK_NE(NOT_INITIALIZED, state_);
   state_ = DISABLED;
   ++generation_;
+  for (const scoped_refptr<MemoryDumpProviderInfo>& mdp_info : dump_providers_)
+    mdp_info->dump_provider->SuspendFastMemoryPolling();
   dump_providers_.clear();
 }
 
 void MemoryPeakDetector::TearDownInternal() {
   StopInternal();
   get_dump_providers_function_.Reset();
   on_peak_detected_callback_.Reset();
   state_ = NOT_INITIALIZED;
 }
 
 void MemoryPeakDetector::ReloadDumpProvidersAndStartPollingIfNeeded() {
   if (state_ == DISABLED || state_ == NOT_INITIALIZED)
     return;  // Start() will re-fetch the MDP list later.
 
   DCHECK((state_ == RUNNING && !dump_providers_.empty()) ||
          (state_ == ENABLED && dump_providers_.empty()));
 
   dump_providers_.clear();
 
   // This is really MemoryDumpManager::GetDumpProvidersForPolling, % testing.
   get_dump_providers_function_.Run(&dump_providers_);
 
   if (state_ == ENABLED && !dump_providers_.empty()) {
     // It's now time to start polling for realz.
     state_ = RUNNING;
-    task_runner_->PostTask(FROM_HERE,
-                           Bind(&MemoryPeakDetector::PollMemoryAndDetectPeak,
-                                Unretained(this), ++generation_));
+    task_runner_->PostTask(
+        FROM_HERE, BindOnce(&MemoryPeakDetector::PollMemoryAndDetectPeak,
+                            Unretained(this), ++generation_));
   } else if (state_ == RUNNING && dump_providers_.empty()) {
     // Will cause the next PollMemoryAndDetectPeak() task to early return.
     state_ = ENABLED;
     ++generation_;
   }
 }
 
 void MemoryPeakDetector::PollMemoryAndDetectPeak(uint32_t expected_generation) {
   if (state_ != RUNNING || generation_ != expected_generation)
     return;
@@ skipping 29 matching lines @@
     is_peak =
         diff_from_last_dump > static_cast<int64_t>(static_threshold_bytes_);
 
     if (!is_peak)
       is_peak = DetectPeakUsingSlidingWindowStddev(polled_mem_bytes);
   }
 
   DCHECK_GT(config_.polling_interval_ms, 0u);
   SequencedTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      Bind(&MemoryPeakDetector::PollMemoryAndDetectPeak, Unretained(this),
-           expected_generation),
+      BindOnce(&MemoryPeakDetector::PollMemoryAndDetectPeak, Unretained(this),
+               expected_generation),
       TimeDelta::FromMilliseconds(config_.polling_interval_ms));
 
   if (!is_peak)
     return;
   TRACE_EVENT_INSTANT1(MemoryDumpManager::kTraceCategory,
                        "Peak memory detected", TRACE_EVENT_SCOPE_PROCESS,
                        "PolledMemoryMB", polled_mem_bytes / 1024 / 1024);
   ResetPollHistory(true /* keep_last_sample */);
   last_dump_memory_total_ = polled_mem_bytes;
   on_peak_detected_callback_.Run();
@@ skipping 48 matching lines @@
         config_.polling_interval_ms;
   }
 }
 
 void MemoryPeakDetector::SetStaticThresholdForTesting(
     uint64_t static_threshold_bytes) {
   DCHECK_EQ(DISABLED, state_);
   static_threshold_bytes_ = static_threshold_bytes;
 }
 
+MemoryPeakDetector::MemoryPeakDetector::Config::Config()
+    : Config(0, 0, false) {}
+
+MemoryPeakDetector::MemoryPeakDetector::Config::Config(
+    uint32_t polling_interval_ms,
+    uint32_t min_time_between_peaks_ms,
+    bool enable_verbose_poll_tracing)
+    : polling_interval_ms(polling_interval_ms),
+      min_time_between_peaks_ms(min_time_between_peaks_ms),
+      enable_verbose_poll_tracing(enable_verbose_poll_tracing) {}
+
 }  // namespace trace_event
 }  // namespace base