[tracing] Add memory dump config to TraceConfig

base/trace_event/trace_config.cc

Index: base/trace_event/trace_config.cc
diff --git a/base/trace_event/trace_config.cc b/base/trace_event/trace_config.cc
index 974e40fe4b79e8fc362b0664f91d0c1bc0b941d2..2930daf2dd10531561f249f2dcdc897f0e97c507 100644
--- a/base/trace_event/trace_config.cc
+++ b/base/trace_event/trace_config.cc
@@ -10,6 +10,7 @@
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/stringprintf.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
@@ -37,6 +38,23 @@ const char kSyntheticDelaysParam[] = "synthetic_delays";
 
 const char kSyntheticDelayCategoryFilterPrefix[] = "DELAY(";
 
+// String parameters that is used to parse memory dump config in trace config
+// string.
+const char kMemoryDumpConfigParam[] = "memory_dump_config";
+const char kTriggersParam[] = "triggers";
+const char kPeriodicIntervalParam[] = "periodic_interval_ms";
+const char kLevelOfDetailParam[] = "level_of_detail";
+const char kHighDetailParam[] = "high";
+const char kLowDetailParam[] = "low";
+
+// Default configuration of memory dumps.
+const TraceConfig::MemoryDumpTriggerConfig kDefaultHeavyMemoryDumpTrigger = {
+    2000,  // periodic_interval_ms
+    MemoryDumpArgs::LevelOfDetail::HIGH};
+const TraceConfig::MemoryDumpTriggerConfig kDefaultLightMemoryDumpTrigger = {
+    250,  // periodic_interval_ms
+    MemoryDumpArgs::LevelOfDetail::LOW};
+
 }  // namespace
 
 TraceConfig::TraceConfig() {
@@ -82,11 +100,11 @@ TraceConfig::TraceConfig(const TraceConfig& tc)
       enable_sampling_(tc.enable_sampling_),
       enable_systrace_(tc.enable_systrace_),
       enable_argument_filter_(tc.enable_argument_filter_),
+      memory_dump_config_(tc.memory_dump_config_),
       included_categories_(tc.included_categories_),
       disabled_categories_(tc.disabled_categories_),
       excluded_categories_(tc.excluded_categories_),
-      synthetic_delays_(tc.synthetic_delays_) {
-}
+      synthetic_delays_(tc.synthetic_delays_) {}
 
 TraceConfig::~TraceConfig() {
 }
@@ -99,6 +117,7 @@ TraceConfig& TraceConfig::operator=(const TraceConfig& rhs) {
   enable_sampling_ = rhs.enable_sampling_;
   enable_systrace_ = rhs.enable_systrace_;
   enable_argument_filter_ = rhs.enable_argument_filter_;
+  memory_dump_config_ = rhs.memory_dump_config_;
   included_categories_ = rhs.included_categories_;
   disabled_categories_ = rhs.disabled_categories_;
   excluded_categories_ = rhs.excluded_categories_;
@@ -207,6 +226,10 @@ void TraceConfig::Merge(const TraceConfig& config) {
     included_categories_.clear();
   }
 
+  memory_dump_config_.insert(memory_dump_config_.end(),
+                             config.memory_dump_config_.begin(),
+                             config.memory_dump_config_.end());
+
   disabled_categories_.insert(disabled_categories_.end(),
                               config.disabled_categories_.begin(),
                               config.disabled_categories_.end());
@@ -227,6 +250,7 @@ void TraceConfig::Clear() {
   disabled_categories_.clear();
   excluded_categories_.clear();
   synthetic_delays_.clear();
+  memory_dump_config_.clear();
 }
 
 void TraceConfig::InitializeDefault() {
@@ -279,14 +303,19 @@ void TraceConfig::InitializeFromConfigString(const std::string& config_string) {
   else
     enable_argument_filter_ = enable_argument_filter;
 
-
-  base::ListValue* category_list = NULL;
+  base::ListValue* category_list = nullptr;
   if (dict->GetList(kIncludedCategoriesParam, &category_list))
     SetCategoriesFromIncludedList(*category_list);
   if (dict->GetList(kExcludedCategoriesParam, &category_list))
     SetCategoriesFromExcludedList(*category_list);
   if (dict->GetList(kSyntheticDelaysParam, &category_list))
     SetSyntheticDelaysFromList(*category_list);
+

[Primiano Tucci (use gerrit), 2015/08/25 18:27:37]

This should gracefully handle also the legacy category.
Something like:

  if (GetDictionary) {
     just read the dictionary, ignore disabled-by-default-memory-infra category
  } else if (disabled-by-default-memory-infra) {
    SetDefaultDumpCOnfig...
  }

[ssid, 2015/08/26 10:19:51]

Done.

+  base::DictionaryValue* memory_dump_config = nullptr;
+  if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory) &&
+      dict->GetDictionary(kMemoryDumpConfigParam, &memory_dump_config)) {
+    SetMemoryDumpConfig(*memory_dump_config);
+  }
 }
 
 void TraceConfig::InitializeFromStrings(
@@ -353,6 +382,12 @@ void TraceConfig::InitializeFromStrings(
       }
     }
   }
+
+  if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
+    memory_dump_config_.clear();

[Primiano Tucci (use gerrit), 2015/08/25 18:27:37]

Move these 3 lines into a SetDefaultMemoryDefaultConfig or similar, as you will
need this up there.

[ssid, 2015/08/26 10:19:51]

Done.

+    memory_dump_config_.push_back(kDefaultHeavyMemoryDumpTrigger);
+    memory_dump_config_.push_back(kDefaultLightMemoryDumpTrigger);
+  }
 }
 
 void TraceConfig::SetCategoriesFromIncludedList(
@@ -412,6 +447,42 @@ void TraceConfig::AddCategoryToDict(base::DictionaryValue& dict,
   dict.Set(param, list.Pass());
 }
 
+void TraceConfig::SetMemoryDumpConfig(
+    const base::DictionaryValue& memory_dump_config) {
+  memory_dump_config_.clear();
+
+  const base::ListValue* trigger_list = nullptr;
+  if (!memory_dump_config.GetList(kTriggersParam, &trigger_list) ||
+      trigger_list->GetSize() == 0) {
+    return;
+  }
+
+  for (size_t i = 0; i < trigger_list->GetSize(); ++i) {
+    const base::DictionaryValue* trigger = nullptr;
+    if (!trigger_list->GetDictionary(i, &trigger))
+      continue;
+
+    MemoryDumpTriggerConfig dump_config;
+    std::string dump_type;
+    int interval = 0;
+
+    if (!trigger->GetInteger(kPeriodicIntervalParam, &interval)) {
+      continue;
+    }
+    DCHECK_GT(interval, 0);
+    dump_config.periodic_interval_ms = static_cast<uint32>(interval);
+    dump_config.level_of_detail = MemoryDumpArgs::LevelOfDetail::LOW;
+
+    if (trigger->GetString(kLevelOfDetailParam, &dump_type)) {
+      if (dump_type == kHighDetailParam) {
+        dump_config.level_of_detail = MemoryDumpArgs::LevelOfDetail::HIGH;
+      }
+    }
+
+    memory_dump_config_.push_back(dump_config);
+  }
+}
+
 void TraceConfig::ToDict(base::DictionaryValue& dict) const {
   switch (record_mode_) {
     case RECORD_UNTIL_FULL:
@@ -452,6 +523,33 @@ void TraceConfig::ToDict(base::DictionaryValue& dict) const {
   AddCategoryToDict(dict, kIncludedCategoriesParam, categories);
   AddCategoryToDict(dict, kExcludedCategoriesParam, excluded_categories_);
   AddCategoryToDict(dict, kSyntheticDelaysParam, synthetic_delays_);
+
+  if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory) &&

[Primiano Tucci (use gerrit), 2015/08/25 18:27:37]

remove this check here.
instead you have to make sure that you propagate (only if set) also the
disabled-by-default-memory-infra category

[ssid, 2015/08/26 10:19:51]

Done.

+      memory_dump_config_.size() != 0) {
+    scoped_ptr<base::DictionaryValue> memory_dump_config(
+        new base::DictionaryValue());
+    scoped_ptr<base::ListValue> triggers_list(new base::ListValue());
+    for (const MemoryDumpTriggerConfig& config : memory_dump_config_) {
+      scoped_ptr<base::DictionaryValue> trigger_dict(
+          new base::DictionaryValue());
+      trigger_dict->SetInteger(kPeriodicIntervalParam,
+                               static_cast<int>(config.periodic_interval_ms));
+
+      switch (config.level_of_detail) {
+        case MemoryDumpArgs::LevelOfDetail::LOW:
+          trigger_dict->SetString(kLevelOfDetailParam, kLowDetailParam);
+          break;
+        case MemoryDumpArgs::LevelOfDetail::HIGH:
+          trigger_dict->SetString(kLevelOfDetailParam, kHighDetailParam);
+          break;
+        default:
+          NOTREACHED();
+      }
+      triggers_list->Append(trigger_dict.Pass());
+    }
+    memory_dump_config->Set(kTriggersParam, triggers_list.Pass());
+    dict.Set(kMemoryDumpConfigParam, memory_dump_config.Pass());
+  }
 }
 
 std::string TraceConfig::ToTraceOptionsString() const {