memory-infra: Switch to MemoryPeakDetector and simplify MemoryDumpScheduler

base/trace_event/memory_peak_detector_unittest.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 <memory>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 const TimeDelta kMs = TimeDelta::FromMilliseconds(1);
-const MemoryPeakDetector::Config kConfigNoCallbacks = {
-    1 /* polling_interval_ms */, 60000 /* min_time_between_peaks_ms */,
+const MemoryPeakDetector::Config kConfigNoCallbacks(
+    1 /* polling_interval_ms */,
+    60000 /* min_time_between_peaks_ms */,
     false /* enable_verbose_poll_tracing */
-};
+    );
 
 class MockMemoryDumpProvider : public MemoryDumpProvider {
  public:
   bool OnMemoryDump(const MemoryDumpArgs&, ProcessMemoryDump*) override {
     NOTREACHED();
     return true;
   }
 
   MOCK_METHOD1(PollFastMemoryTotal, void(uint64_t*));
 };
@@ skipping 32 matching lines @@
 
   void SetUp() override {
     get_mdp_call_count_ = 0;
     RestartThreadAndReinitializePeakDetector();
   }
 
   void TearDown() override {
     peak_detector_->TearDown();
     bg_thread_->FlushForTesting();
     EXPECT_EQ(MemoryPeakDetector::NOT_INITIALIZED, GetPeakDetectorState());
+    bg_thread_.reset();
     dump_providers_.clear();
   }
 
   // Calls MemoryPeakDetector::state_for_testing() on the bg thread and returns
   // the result on the current thread.
   MemoryPeakDetector::State GetPeakDetectorState() {
     WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
     MemoryPeakDetector::State res = MemoryPeakDetector::NOT_INITIALIZED;
     auto get_fn = [](MemoryPeakDetector* peak_detector, WaitableEvent* evt,
@@ skipping 344 matching lines @@
   EXPECT_EQ(6u, GetNumGetDumpProvidersCalls());
 }
 
 // Tests the behavior of the static threshold detector, which is supposed to
 // detect a peak whenever an increase >= threshold is detected.
 TEST_F(MemoryPeakDetectorTest, StaticThreshold) {
   const uint32_t kNumSamples = 2 * kSlidingWindowNumSamples;
   constexpr uint32_t kNumSamplesPerStep = 10;
   constexpr uint64_t kThreshold = 1000000;
   peak_detector_->SetStaticThresholdForTesting(kThreshold);
-  const MemoryPeakDetector::Config kConfig = {
+  const MemoryPeakDetector::Config kConfig(
       1 /* polling_interval_ms */, 0 /* min_time_between_peaks_ms */,
       false /* enable_verbose_poll_tracing */
-  };
+      );
 
   // The mocked PollFastMemoryTotal() will return a step function,
   // e.g. (1, 1, 1, 5, 5, 5, ...) where the steps are 2x threshold, in order to
   // trigger only the static threshold logic.
   auto poll_fn = Bind(
       [](const uint32_t kNumSamplesPerStep, const uint64_t kThreshold,
          uint32_t sample_idx) -> uint64_t {
         return (1 + sample_idx / kNumSamplesPerStep) * 2 * kThreshold;
       },
       kNumSamplesPerStep, kThreshold);
   uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
   EXPECT_EQ(kNumSamples / kNumSamplesPerStep - 1, num_peaks);
 }
 
 // Checks the throttling logic of Config's |min_time_between_peaks_ms|.
 TEST_F(MemoryPeakDetectorTest, PeakCallbackThrottling) {
   const size_t kNumSamples = 2 * kSlidingWindowNumSamples;
   constexpr uint64_t kThreshold = 1000000;
   peak_detector_->SetStaticThresholdForTesting(kThreshold);
-  const MemoryPeakDetector::Config kConfig = {
+  const MemoryPeakDetector::Config kConfig(
       1 /* polling_interval_ms */, 4 /* min_time_between_peaks_ms */,
       false /* enable_verbose_poll_tracing */
-  };
+      );
 
   // Each mock value returned is N * 2 * threshold, so all of them would be
   // eligible to be a peak if throttling wasn't enabled.
   auto poll_fn = Bind(
       [](uint64_t kThreshold, uint32_t sample_idx) -> uint64_t {
         return (sample_idx + 1) * 2 * kThreshold;
       },
       kThreshold);
   uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
   const uint32_t kExpectedThrottlingRate =
       kConfig.min_time_between_peaks_ms / kConfig.polling_interval_ms;
   EXPECT_LT(num_peaks, kNumSamples / kExpectedThrottlingRate);
 }
 
 TEST_F(MemoryPeakDetectorTest, StdDev) {
   // Set the threshold to some arbitrarily high value, so that the static
   // threshold logic is not hit in this test.
   constexpr uint64_t kThreshold = 1024 * 1024 * 1024;
   peak_detector_->SetStaticThresholdForTesting(kThreshold);
   const size_t kNumSamples = 3 * kSlidingWindowNumSamples;
-  const MemoryPeakDetector::Config kConfig = {
+  const MemoryPeakDetector::Config kConfig(
       1 /* polling_interval_ms */, 0 /* min_time_between_peaks_ms */,
       false /* enable_verbose_poll_tracing */
-  };
+      );
 
   auto poll_fn = Bind(&PollFunctionThatCausesPeakViaStdDev);
   uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
   EXPECT_EQ(2u, num_peaks);  // 80 MB, 120 MB.
 }
 
 // Tests that Throttle() actually holds back peak notifications.
 TEST_F(MemoryPeakDetectorTest, Throttle) {
   constexpr uint64_t kThreshold = 1024 * 1024 * 1024;
   const uint32_t kNumSamples = 3 * kSlidingWindowNumSamples;
   peak_detector_->SetStaticThresholdForTesting(kThreshold);
-  const MemoryPeakDetector::Config kConfig = {
+  const MemoryPeakDetector::Config kConfig(
       1 /* polling_interval_ms */, 0 /* min_time_between_peaks_ms */,
       false /* enable_verbose_poll_tracing */
-  };
+      );
 
   auto poll_fn = Bind(
       [](MemoryPeakDetector* peak_detector, uint32_t sample_idx) -> uint64_t {
         if (sample_idx % 20 == 20 - 1)
           peak_detector->Throttle();
         return PollFunctionThatCausesPeakViaStdDev(sample_idx);
       },
       Unretained(&*peak_detector_));
   uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
   EXPECT_EQ(0u, num_peaks);
 }
 
 // Tests that the windows stddev state is not carried over through
 // Stop() -> Start() sequences.
 TEST_F(MemoryPeakDetectorTest, RestartClearsState) {
   constexpr uint64_t kThreshold = 1024 * 1024 * 1024;
   peak_detector_->SetStaticThresholdForTesting(kThreshold);
   const size_t kNumSamples = 3 * kSlidingWindowNumSamples;
-  const MemoryPeakDetector::Config kConfig = {
+  const MemoryPeakDetector::Config kConfig(
       1 /* polling_interval_ms */, 0 /* min_time_between_peaks_ms */,
       false /* enable_verbose_poll_tracing */
-  };
+      );
   auto poll_fn = Bind(
       [](MemoryPeakDetector* peak_detector,
          const uint32_t kSlidingWindowNumSamples,
          MemoryPeakDetector::Config kConfig, uint32_t sample_idx) -> uint64_t {
         if (sample_idx % kSlidingWindowNumSamples ==
             kSlidingWindowNumSamples - 1) {
           peak_detector->Stop();
           peak_detector->Start(kConfig);
         }
         return PollFunctionThatCausesPeakViaStdDev(sample_idx);
       },
       Unretained(&*peak_detector_), kSlidingWindowNumSamples, kConfig);
   uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
   EXPECT_EQ(0u, num_peaks);
 }
 
 }  // namespace trace_event
 }  // namespace base