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

base/trace_event/trace_config_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 <stddef.h>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/trace_event/memory_dump_manager.h"
@@ skipping 19 matching lines @@
     "\"enable_systrace\":true,"
     "\"event_filters\":["
     "{"
     "\"excluded_categories\":[\"unfiltered_cat\"],"
     "\"filter_args\":{\"event_name_whitelist\":[\"a snake\",\"a dog\"]},"
     "\"filter_predicate\":\"event_whitelist_predicate\","
     "\"included_categories\":[\"*\"]"
     "}"
     "],"
     "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
-    "\"included_categories\":[\"included\","
+    "\"included_categories\":["
+    "\"included\","
     "\"inc_pattern*\","
     "\"disabled-by-default-cc\","
     "\"disabled-by-default-memory-infra\"],"
     "\"memory_dump_config\":{"
     "\"allowed_dump_modes\":[\"background\",\"light\",\"detailed\"],"
     "\"heap_profiler_options\":{"
     "\"breakdown_threshold_bytes\":10240"
     "},"
     "\"triggers\":["
-    "{\"mode\":\"light\",\"periodic_interval_ms\":50},"
-    "{\"mode\":\"detailed\",\"periodic_interval_ms\":1000}"
+    "{"
+    "\"min_time_between_dumps_ms\":50,"
+    "\"mode\":\"light\","
+    "\"type\":\"periodic_interval\""
+    "},"
+    "{"
+    "\"min_time_between_dumps_ms\":1000,"
+    "\"mode\":\"detailed\","
+    "\"type\":\"peak_memory_usage\""
+    "}"
     "]"
     "},"
     "\"record_mode\":\"record-continuously\","
     "\"synthetic_delays\":[\"test.Delay1;16\",\"test.Delay2;32\"]"
     "}";
 
 void CheckDefaultTraceConfigBehavior(const TraceConfig& tc) {
   EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
   EXPECT_FALSE(tc.IsSystraceEnabled());
   EXPECT_FALSE(tc.IsArgumentFilterEnabled());
@@ skipping 548 matching lines @@
 
   tc.EnableSystrace();
   EXPECT_TRUE(tc.IsSystraceEnabled());
 }
 
 TEST(TraceConfigTest, TraceConfigFromMemoryConfigString) {
   std::string tc_str1 =
       TraceConfigMemoryTestUtil::GetTraceConfig_PeriodicTriggers(200, 2000);
   TraceConfig tc1(tc_str1);
   EXPECT_EQ(tc_str1, tc1.ToString());
+  TraceConfig tc2(
+      TraceConfigMemoryTestUtil::GetTraceConfig_LegacyPeriodicTriggers(200,
+                                                                       2000));
+  EXPECT_EQ(tc_str1, tc2.ToString());
+
   EXPECT_TRUE(tc1.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
   ASSERT_EQ(2u, tc1.memory_dump_config_.triggers.size());
 
-  EXPECT_EQ(200u, tc1.memory_dump_config_.triggers[0].periodic_interval_ms);
+  EXPECT_EQ(200u,
+            tc1.memory_dump_config_.triggers[0].min_time_between_dumps_ms);
   EXPECT_EQ(MemoryDumpLevelOfDetail::LIGHT,
             tc1.memory_dump_config_.triggers[0].level_of_detail);
 
-  EXPECT_EQ(2000u, tc1.memory_dump_config_.triggers[1].periodic_interval_ms);
+  EXPECT_EQ(2000u,
+            tc1.memory_dump_config_.triggers[1].min_time_between_dumps_ms);
   EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
             tc1.memory_dump_config_.triggers[1].level_of_detail);
   EXPECT_EQ(
       2048u,
       tc1.memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes);
 
-  std::string tc_str2 =
+  std::string tc_str3 =
       TraceConfigMemoryTestUtil::GetTraceConfig_BackgroundTrigger(
           1 /* period_ms */);
-  TraceConfig tc2(tc_str2);
-  EXPECT_EQ(tc_str2, tc2.ToString());
-  EXPECT_TRUE(tc2.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
-  ASSERT_EQ(1u, tc2.memory_dump_config_.triggers.size());
-  EXPECT_EQ(1u, tc2.memory_dump_config_.triggers[0].periodic_interval_ms);
+  TraceConfig tc3(tc_str3);
+  EXPECT_EQ(tc_str3, tc3.ToString());
+  EXPECT_TRUE(tc3.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
+  ASSERT_EQ(1u, tc3.memory_dump_config_.triggers.size());
+  EXPECT_EQ(1u, tc3.memory_dump_config_.triggers[0].min_time_between_dumps_ms);
   EXPECT_EQ(MemoryDumpLevelOfDetail::BACKGROUND,
-            tc2.memory_dump_config_.triggers[0].level_of_detail);
+            tc3.memory_dump_config_.triggers[0].level_of_detail);
+
+  std::string tc_str4 =
+      TraceConfigMemoryTestUtil::GetTraceConfig_PeakDetectionTrigger(
+          1 /*heavy_period */);
+  TraceConfig tc4(tc_str4);
+  EXPECT_EQ(tc_str4, tc4.ToString());
+  ASSERT_EQ(1u, tc4.memory_dump_config_.triggers.size());
+  EXPECT_EQ(1u, tc4.memory_dump_config_.triggers[0].min_time_between_dumps_ms);
+  EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
+            tc4.memory_dump_config_.triggers[0].level_of_detail);
 }
 
 TEST(TraceConfigTest, EmptyMemoryDumpConfigTest) {
   // Empty trigger list should also be specified when converting back to string.
   TraceConfig tc(TraceConfigMemoryTestUtil::GetTraceConfig_EmptyTriggers());
   EXPECT_EQ(TraceConfigMemoryTestUtil::GetTraceConfig_EmptyTriggers(),
             tc.ToString());
   EXPECT_EQ(0u, tc.memory_dump_config_.triggers.size());
   EXPECT_EQ(TraceConfig::MemoryDumpConfig::HeapProfiler
             ::kDefaultBreakdownThresholdBytes,
             tc.memory_dump_config_.heap_profiler_options
             .breakdown_threshold_bytes);
 }
 
 TEST(TraceConfigTest, LegacyStringToMemoryDumpConfig) {
   TraceConfig tc(MemoryDumpManager::kTraceCategory, "");
   EXPECT_TRUE(tc.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
   EXPECT_NE(std::string::npos, tc.ToString().find("memory_dump_config"));
   EXPECT_EQ(2u, tc.memory_dump_config_.triggers.size());
   EXPECT_EQ(TraceConfig::MemoryDumpConfig::HeapProfiler
             ::kDefaultBreakdownThresholdBytes,
             tc.memory_dump_config_.heap_profiler_options
             .breakdown_threshold_bytes);
 }
 
 }  // namespace trace_event
 }  // namespace base