memory-infra: Switch to MemoryPeakDetector and simplify MemoryDumpScheduler

base/trace_event/memory_dump_manager_unittest.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/memory_dump_manager.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 226 matching lines @@
   // Turns a Closure into a MemoryDumpCallback, keeping track of the callback
   // result and taking care of posting the closure on the correct task runner.
   void DumpCallbackAdapter(scoped_refptr<SingleThreadTaskRunner> task_runner,
                            Closure closure,
                            uint64_t dump_guid,
                            bool success) {
     last_callback_success_ = success;
     task_runner->PostTask(FROM_HERE, closure);
   }
 
-  void PollFastMemoryTotal(uint64_t* memory_total) {
-    mdm_->PollFastMemoryTotal(memory_total);
-  }
-
  protected:
   void InitializeMemoryDumpManager(bool is_coordinator) {
     mdm_->set_dumper_registrations_ignored_for_testing(true);
     delegate_ = new MemoryDumpManagerDelegateForTesting(is_coordinator);
     mdm_->Initialize(base::WrapUnique(delegate_));
   }
 
   void RequestGlobalDumpAndWait(MemoryDumpType dump_type,
                                 MemoryDumpLevelOfDetail level_of_detail) {
     RunLoop run_loop;
@@ skipping 10 matching lines @@
   }
 
   void EnableTracingWithTraceConfig(const std::string& trace_config) {
     TraceLog::GetInstance()->SetEnabled(TraceConfig(trace_config),
                                         TraceLog::RECORDING_MODE);
   }
 
   void DisableTracing() { TraceLog::GetInstance()->SetDisabled(); }
 
   bool IsPeriodicDumpingEnabled() const {
-    return MemoryDumpScheduler::GetInstance()
-        ->IsPeriodicTimerRunningForTesting();
+    return MemoryDumpScheduler::GetInstance()->IsEnabledForTesting();
   }
 
   int GetMaxConsecutiveFailuresCount() const {
     return MemoryDumpManager::kMaxConsecutiveFailuresCount;
   }
 
   const MemoryDumpProvider::Options kDefaultOptions;
   std::unique_ptr<MemoryDumpManager> mdm_;
   MemoryDumpManagerDelegateForTesting* delegate_;
   bool last_callback_success_;
@@ skipping 508 matching lines @@
   EXPECT_CALL(*mdp1, PollFastMemoryTotal(_))
       .Times(testing::AtLeast(kPollsToQuit))
       .WillRepeatedly(Invoke(poll_function1));
 
   // Depending on the order of PostTask calls the mdp2 might be registered after
   // all polls or in between polls.
   EXPECT_CALL(*mdp2, PollFastMemoryTotal(_))
       .Times(Between(0, kPollsToQuit - 1))
       .WillRepeatedly(Return());
 
-  MemoryDumpScheduler::SetPollingIntervalForTesting(1);
+  // TODO here MemoryDumpScheduler::SetPollingIntervalForTesting(1);
   EnableTracingWithTraceConfig(
       TraceConfigMemoryTestUtil::GetTraceConfig_PeakDetectionTrigger(3));
 
   int last_poll_to_request_dump = -2;
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _))
       .Times(testing::AtLeast(2))
       .WillRepeatedly(Invoke([&last_poll_to_request_dump, &call_count](
                                  const MemoryDumpRequestArgs& args,
                                  const MemoryDumpCallback& callback) -> void {
         // Minimum number of polls between dumps must be 3 (polling interval is
@@ skipping 480 matching lines @@
   thread.Start();
   RegisterDumpProvider(&mdp1, thread.task_runner(), kDefaultOptions,
                        "BlacklistTestDumpProvider");
   // Unregistering on wrong thread should not crash.
   mdm_->UnregisterDumpProvider(&mdp1);
   thread.Stop();
 }
 
 }  // namespace trace_event
 }  // namespace base