[memory-infra] Move periodic timer to dump thread

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"
 #include "build/build_config.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 // Threshold on increase in memory from last dump beyond which a new dump must
 // be triggered.
 int64_t kDefaultMemoryIncreaseThreshold = 50 * 1024 * 1024;  // 50MiB
 const uint32_t kMemoryTotalsPollingInterval = 25;
 uint32_t g_polling_interval_ms_for_testing = 0;
 }  // namespace
 
 // static
+bool MemoryDumpScheduler::periodic_timer_disabled_for_testing_ = false;
+
+// static
 MemoryDumpScheduler* MemoryDumpScheduler::GetInstance() {
   static MemoryDumpScheduler* instance = new MemoryDumpScheduler();
   return instance;
 }
 
 MemoryDumpScheduler::MemoryDumpScheduler() : mdm_(nullptr), is_setup_(false) {}
 MemoryDumpScheduler::~MemoryDumpScheduler() {}
 
 void MemoryDumpScheduler::Setup(
     MemoryDumpManager* mdm,
@@ skipping 46 matching lines @@
 }
 
 void MemoryDumpScheduler::EnablePeriodicTriggerIfNeeded() {
   DCHECK(is_setup_);
   if (!periodic_state_->is_configured || periodic_state_->timer.IsRunning())
     return;
   periodic_state_->light_dumps_rate = periodic_state_->light_dump_period_ms /
                                       periodic_state_->min_timer_period_ms;
   periodic_state_->heavy_dumps_rate = periodic_state_->heavy_dump_period_ms /
                                       periodic_state_->min_timer_period_ms;
+  periodic_state_->dump_count = 0;
+  periodic_state_->is_enabled_for_testing = true;
 
-  periodic_state_->dump_count = 0;
+  if (periodic_timer_disabled_for_testing_)
+    return;
+  polling_task_runner_->PostTask(
+      FROM_HERE, Bind(&MemoryDumpScheduler::EnablePeriodicTimerOnPollingThread,
+                      Unretained(this)));
+}
+
+void MemoryDumpScheduler::EnablePeriodicTimerOnPollingThread() {
   periodic_state_->timer.Start(
       FROM_HERE,
       TimeDelta::FromMilliseconds(periodic_state_->min_timer_period_ms),
       Bind(&MemoryDumpScheduler::RequestPeriodicGlobalDump, Unretained(this)));
 }
 
 void MemoryDumpScheduler::EnablePollingIfNeeded() {
   DCHECK(is_setup_);
   if (polling_state_->current_state != PollingTriggerState::CONFIGURED)
     return;
@@ skipping 17 matching lines @@
 
   if (!polling_state_ ||
       polling_state_->current_state != PollingTriggerState::ENABLED) {
     return;
   }
 
   polling_state_->ResetTotals();
 }
 
 void MemoryDumpScheduler::DisableAllTriggers() {
+  if (polling_task_runner_) {
+    polling_task_runner_->PostTask(
+        FROM_HERE, Bind(&MemoryDumpScheduler::DisableTriggersOnPollingThread,
+                        Unretained(this)));
+    polling_task_runner_ = nullptr;
+  }
+  is_setup_ = false;
+}
+
+void MemoryDumpScheduler::DisableTriggersOnPollingThread() {
   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)));
-    polling_task_runner_ = nullptr;
-  }
-  is_setup_ = false;
-}
-
-void MemoryDumpScheduler::DisablePollingOnPollingThread() {
   polling_state_->current_state = PollingTriggerState::DISABLED;
   polling_state_.reset();
 }
 
 // static
 void MemoryDumpScheduler::SetPollingIntervalForTesting(uint32_t interval) {
   g_polling_interval_ms_for_testing = interval;
 }
 
+void MemoryDumpScheduler::DisablePeriodicTimerForTesting(bool disable) {
+  periodic_timer_disabled_for_testing_ = disable;
+}
+
 bool MemoryDumpScheduler::IsPeriodicTimerRunningForTesting() {
-  return periodic_state_->timer.IsRunning();
+  return periodic_state_->is_enabled_for_testing;
 }
 
 void MemoryDumpScheduler::RequestPeriodicGlobalDump() {
+  // In case it's called after timer stopped.
+  if (!periodic_state_)
+    return;
+
   MemoryDumpLevelOfDetail level_of_detail = MemoryDumpLevelOfDetail::BACKGROUND;
   if (periodic_state_->light_dumps_rate > 0 &&
       periodic_state_->dump_count % periodic_state_->light_dumps_rate == 0)
     level_of_detail = MemoryDumpLevelOfDetail::LIGHT;
   if (periodic_state_->heavy_dumps_rate > 0 &&
       periodic_state_->dump_count % periodic_state_->heavy_dumps_rate == 0)
     level_of_detail = MemoryDumpLevelOfDetail::DETAILED;
   ++periodic_state_->dump_count;
 
   mdm_->RequestGlobalDump(MemoryDumpType::PERIODIC_INTERVAL, level_of_detail);
 }
 
 void MemoryDumpScheduler::PollMemoryOnPollingThread() {
-  if (polling_state_->current_state != PollingTriggerState::ENABLED)
+  if (!polling_state_)
     return;
 
   uint64_t polled_memory = 0;
   bool res = mdm_->PollFastMemoryTotal(&polled_memory);
   DCHECK(res);
   if (polling_state_->level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
     TRACE_COUNTER1(MemoryDumpManager::kTraceCategory, "PolledMemoryMB",
                    polled_memory / 1024 / 1024);
   }
 
@@ skipping 81 matching lines @@
          (3.69 * 3.69 * variance);
 }
 
 MemoryDumpScheduler::PeriodicTriggerState::PeriodicTriggerState()
     : is_configured(false),
       dump_count(0),
       min_timer_period_ms(std::numeric_limits<uint32_t>::max()),
       light_dumps_rate(0),
       heavy_dumps_rate(0),
       light_dump_period_ms(0),
-      heavy_dump_period_ms(0) {}
+      heavy_dump_period_ms(0),
+      is_enabled_for_testing(false) {}
 
 MemoryDumpScheduler::PeriodicTriggerState::~PeriodicTriggerState() {
   DCHECK(!timer.IsRunning());
 }
 
 MemoryDumpScheduler::PollingTriggerState::PollingTriggerState()
     : current_state(DISABLED),
       level_of_detail(MemoryDumpLevelOfDetail::FIRST),
       polling_interval_ms(g_polling_interval_ms_for_testing
                               ? g_polling_interval_ms_for_testing
@@ skipping 30 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