[tracing] Introduce config to setup memory-infra peak detection

base/trace_event/memory_dump_manager.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 <algorithm>
 #include <utility>
 
 #include "base/allocator/features.h"
@@ skipping 824 matching lines @@
   // At the moment the periodic support is limited to at most one periodic
   // trigger per dump mode. All intervals should be an integer multiple of the
   // smallest interval specified.
   periodic_dumps_count_ = 0;
   uint32_t min_timer_period_ms = std::numeric_limits<uint32_t>::max();
   uint32_t light_dump_period_ms = 0;
   uint32_t heavy_dump_period_ms = 0;
   DCHECK_LE(triggers_list.size(), 3u);
   auto* mdm = MemoryDumpManager::GetInstance();
   for (const TraceConfig::MemoryDumpConfig::Trigger& config : triggers_list) {
-    DCHECK_NE(0u, config.periodic_interval_ms);
+    DCHECK_NE(0u, config.min_time_between_dumps_ms);
+    DCHECK_EQ(MemoryDumpType::PERIODIC_INTERVAL, config.trigger_type)

[Primiano Tucci (use gerrit), 2016/12/16 12:13:55]

just double checking, this is something that will go away soon (with peaks),
right?

[ssid, 2016/12/16 19:19:52]

yes this will be removed in next cls.

+        << "Only periodic_interval triggers are suppported";
     switch (config.level_of_detail) {
       case MemoryDumpLevelOfDetail::BACKGROUND:
         DCHECK(mdm->IsDumpModeAllowed(MemoryDumpLevelOfDetail::BACKGROUND));
         break;
       case MemoryDumpLevelOfDetail::LIGHT:
         DCHECK_EQ(0u, light_dump_period_ms);
         DCHECK(mdm->IsDumpModeAllowed(MemoryDumpLevelOfDetail::LIGHT));
-        light_dump_period_ms = config.periodic_interval_ms;
+        light_dump_period_ms = config.min_time_between_dumps_ms;
         break;
       case MemoryDumpLevelOfDetail::DETAILED:
         DCHECK_EQ(0u, heavy_dump_period_ms);
         DCHECK(mdm->IsDumpModeAllowed(MemoryDumpLevelOfDetail::DETAILED));
-        heavy_dump_period_ms = config.periodic_interval_ms;
+        heavy_dump_period_ms = config.min_time_between_dumps_ms;
         break;
     }
     min_timer_period_ms =
-        std::min(min_timer_period_ms, config.periodic_interval_ms);
+        std::min(min_timer_period_ms, config.min_time_between_dumps_ms);
   }
 
   DCHECK_EQ(0u, light_dump_period_ms % min_timer_period_ms);
   light_dump_rate_ = light_dump_period_ms / min_timer_period_ms;
   DCHECK_EQ(0u, heavy_dump_period_ms % min_timer_period_ms);
   heavy_dump_rate_ = heavy_dump_period_ms / min_timer_period_ms;
 
   timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(min_timer_period_ms),
                base::Bind(&PeriodicGlobalDumpTimer::RequestPeriodicGlobalDump,
                           base::Unretained(this)));
@@ skipping 16 matching lines @@
   if (heavy_dump_rate_ > 0 && periodic_dumps_count_ % heavy_dump_rate_ == 0)
     level_of_detail = MemoryDumpLevelOfDetail::DETAILED;
   ++periodic_dumps_count_;
 
   MemoryDumpManager::GetInstance()->RequestGlobalDump(
       MemoryDumpType::PERIODIC_INTERVAL, level_of_detail);
 }
 
 }  // namespace trace_event
 }  // namespace base