[tracing] Add memory dump config to TraceConfig

base/trace_event/trace_config.cc

 // Copyright (c) 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/trace_config.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/pattern.h"
 #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 {
 namespace trace_event {
 
 namespace {
 
 // String options that can be used to initialize TraceOptions.
 const char kRecordUntilFull[] = "record-until-full";
 const char kRecordContinuously[] = "record-continuously";
 const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
 const char kTraceToConsole[] = "trace-to-console";
 const char kEnableSampling[] = "enable-sampling";
 const char kEnableSystrace[] = "enable-systrace";
 const char kEnableArgumentFilter[] = "enable-argument-filter";
 
 // String parameters that can be used to parse the trace config string.
 const char kRecordModeParam[] = "record_mode";
 const char kEnableSamplingParam[] = "enable_sampling";
 const char kEnableSystraceParam[] = "enable_systrace";
 const char kEnableArgumentFilterParam[] = "enable_argument_filter";
 const char kIncludedCategoriesParam[] = "included_categories";
 const char kExcludedCategoriesParam[] = "excluded_categories";
 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 kDumpTypeParam[] = "dump_type";
+const char kHeavyDumpTypeParam[] = "heavy";
+const char kLightDumpTypeParam[] = "light";
+
+// Default configuration of memory dumps.
+const TraceConfig::MemoryDumpConfig kDefaultHeavyMemoryDumpConfig = {
+    2000,  // periodic_interval_ms
+    MemoryDumpArgs::LevelOfDetail::HIGH};
+const TraceConfig::MemoryDumpConfig kDefaultLightMemoryDumpConfig = {
+    250,  // periodic_interval_ms
+    MemoryDumpArgs::LevelOfDetail::LOW};
+
 }  // namespace
 
 TraceConfig::TraceConfig() {
   InitializeDefault();
 }
 
 TraceConfig::TraceConfig(const std::string& category_filter_string,
                          const std::string& trace_options_string) {
   InitializeFromStrings(category_filter_string, trace_options_string);
 }
@@ skipping 25 matching lines @@
     InitializeFromConfigString(config_string);
   else
     InitializeDefault();
 }
 
 TraceConfig::TraceConfig(const TraceConfig& tc)
     : record_mode_(tc.record_mode_),
       enable_sampling_(tc.enable_sampling_),
       enable_systrace_(tc.enable_systrace_),
       enable_argument_filter_(tc.enable_argument_filter_),
+      memory_dump_config_list_(tc.memory_dump_config_list_),
       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() {
 }
 
 TraceConfig& TraceConfig::operator=(const TraceConfig& rhs) {
   if (this == &rhs)
     return *this;
 
   record_mode_ = rhs.record_mode_;
   enable_sampling_ = rhs.enable_sampling_;
   enable_systrace_ = rhs.enable_systrace_;
   enable_argument_filter_ = rhs.enable_argument_filter_;
+  memory_dump_config_list_ = rhs.memory_dump_config_list_;
   included_categories_ = rhs.included_categories_;
   disabled_categories_ = rhs.disabled_categories_;
   excluded_categories_ = rhs.excluded_categories_;
   synthetic_delays_ = rhs.synthetic_delays_;
   return *this;
 }
 
 const TraceConfig::StringList& TraceConfig::GetSyntheticDelayValues() const {
   return synthetic_delays_;
 }
@@ skipping 88 matching lines @@
   // Otherwise, one of the filter was specifying "*" and we want to honor the
   // broadest filter.
   if (HasIncludedPatterns() && config.HasIncludedPatterns()) {
     included_categories_.insert(included_categories_.end(),
                                 config.included_categories_.begin(),
                                 config.included_categories_.end());
   } else {
     included_categories_.clear();
   }
 
+  memory_dump_config_list_.insert(memory_dump_config_list_.end(),
+                                  config.memory_dump_config_list_.begin(),
+                                  config.memory_dump_config_list_.end());
+
   disabled_categories_.insert(disabled_categories_.end(),
                               config.disabled_categories_.begin(),
                               config.disabled_categories_.end());
   excluded_categories_.insert(excluded_categories_.end(),
                               config.excluded_categories_.begin(),
                               config.excluded_categories_.end());
   synthetic_delays_.insert(synthetic_delays_.end(),
                            config.synthetic_delays_.begin(),
                            config.synthetic_delays_.end());
 }
 
 void TraceConfig::Clear() {
   record_mode_ = RECORD_UNTIL_FULL;
   enable_sampling_ = false;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
   included_categories_.clear();
   disabled_categories_.clear();
   excluded_categories_.clear();
   synthetic_delays_.clear();
+  memory_dump_config_list_.clear();
 }
 
 void TraceConfig::InitializeDefault() {
   record_mode_ = RECORD_UNTIL_FULL;
   enable_sampling_ = false;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
   excluded_categories_.push_back("*Debug");
   excluded_categories_.push_back("*Test");
 }
@@ skipping 32 matching lines @@
     enable_systrace_ = false;
   else
     enable_systrace_ = enable_systrace;
 
   bool enable_argument_filter;
   if (!dict->GetBoolean(kEnableArgumentFilterParam, &enable_argument_filter))
     enable_argument_filter_ = false;
   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);
+
+  if (!IsCategoryEnabled(MemoryDumpManager::kTraceCategory))
+    return;

[Primiano Tucci (use gerrit), 2015/08/24 11:58:35]

probably in this case you might not want an early return, better an if.
It looks likely that sometbody might add code below. if that is the case, this
early return might subtly break things.

[ssid, 2015/08/24 15:29:30]

Done.

+
+  base::DictionaryValue* memory_dump_config = nullptr;
+  if (dict->GetDictionary(kMemoryDumpConfigParam, &memory_dump_config)) {
+    SetMemoryDumpConfigList(*memory_dump_config);
+  }
 }
 
 void TraceConfig::InitializeFromStrings(
     const std::string& category_filter_string,
     const std::string& trace_options_string) {
   if (!category_filter_string.empty()) {
     std::vector<std::string> split = base::SplitString(
         category_filter_string, ",", base::TRIM_WHITESPACE,
         base::SPLIT_WANT_ALL);
     std::vector<std::string>::iterator iter;
@@ skipping 46 matching lines @@
         record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
       } else if (*iter == kEnableSampling) {
         enable_sampling_ = true;
       } else if (*iter == kEnableSystrace) {
         enable_systrace_ = true;
       } else if (*iter == kEnableArgumentFilter) {
         enable_argument_filter_ = true;
       }
     }
   }
+
+  if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
+    memory_dump_config_list_.clear();
+    memory_dump_config_list_.push_back(kDefaultHeavyMemoryDumpConfig);
+    memory_dump_config_list_.push_back(kDefaultLightMemoryDumpConfig);
+  }
 }
 
 void TraceConfig::SetCategoriesFromIncludedList(
     const base::ListValue& included_list) {
   included_categories_.clear();
   for (size_t i = 0; i < included_list.GetSize(); ++i) {
     std::string category;
     if (!included_list.GetString(i, &category))
       continue;
     if (category.compare(0, strlen(TRACE_DISABLED_BY_DEFAULT("")),
@@ skipping 39 matching lines @@
   scoped_ptr<base::ListValue> list(new base::ListValue());
   for (StringList::const_iterator ci = categories.begin();
        ci != categories.end();
        ++ci) {
     list->AppendString(*ci);
   }
 
   dict.Set(param, list.Pass());
 }
 
+void TraceConfig::SetMemoryDumpConfigList(
+    base::DictionaryValue& memory_dump_config) {

[Primiano Tucci (use gerrit), 2015/08/24 11:58:35]

+const

[ssid, 2015/08/24 15:29:30]

Done.

+  base::ListValue* trigger_list = nullptr;
+  if (!memory_dump_config.GetList(kTriggersParam, &trigger_list) ||
+      trigger_list->GetSize() == 0) {
+    // If triggers are not set, use the default config.

[Primiano Tucci (use gerrit), 2015/08/24 11:58:36]

Don't you want to just disable the periodic dumps if they are empty?

[ssid, 2015/08/24 15:29:30]

yes, I forgot that part, changed.

+    memory_dump_config_list_.push_back(kDefaultHeavyMemoryDumpConfig);
+    memory_dump_config_list_.push_back(kDefaultLightMemoryDumpConfig);
+    return;
+  }
+
+  for (size_t i = 0; i < trigger_list->GetSize(); ++i) {
+    base::DictionaryValue* trigger = nullptr;
+    if (!trigger_list->GetDictionary(i, &trigger))
+      continue;
+
+    MemoryDumpConfig dump_config;
+    std::string dump_type;
+    int interval;

[Primiano Tucci (use gerrit), 2015/08/24 11:58:35]

= 0;

[ssid, 2015/08/24 15:29:30]

Done.

+
+    if (!trigger->GetInteger(kPeriodicIntervalParam, &interval)) {
+      continue;
+    }
+    DCHECK_GT(interval, 0);
+    dump_config.periodic_interval_ms = static_cast<uint32>(interval);
+
+    if (trigger->GetString(kDumpTypeParam, &dump_type)) {
+      if (dump_type == kHeavyDumpTypeParam) {
+        dump_config.dump_level_of_detail = MemoryDumpArgs::LevelOfDetail::HIGH;
+      } else if (dump_type == kLightDumpTypeParam) {
+        dump_config.dump_level_of_detail = MemoryDumpArgs::LevelOfDetail::LOW;
+      }
+    } else {
+      // If dump type is not specified use light.
+      dump_config.dump_level_of_detail = MemoryDumpArgs::LevelOfDetail::LOW;

[Primiano Tucci (use gerrit), 2015/08/24 11:58:36]

I'd probably rework this by making LOW the default assignment (before the if of
line 478) and then assign high only if the dump_type is not null and == "heavy"

This should be backwards compatible, if in future we introduce level="foo" and
foo does not exist in this version of chrome, level of detail here will not be
left unassigned

[ssid, 2015/08/24 15:29:30]

Done.

+    }
+
+    memory_dump_config_list_.push_back(dump_config);
+  }
+}
+
 void TraceConfig::ToDict(base::DictionaryValue& dict) const {
   switch (record_mode_) {
     case RECORD_UNTIL_FULL:
       dict.SetString(kRecordModeParam, kRecordUntilFull);
       break;
     case RECORD_CONTINUOUSLY:
       dict.SetString(kRecordModeParam, kRecordContinuously);
       break;
     case RECORD_AS_MUCH_AS_POSSIBLE:
       dict.SetString(kRecordModeParam, kRecordAsMuchAsPossible);
@@ skipping 20 matching lines @@
   else
     dict.SetBoolean(kEnableArgumentFilterParam, false);
 
   StringList categories(included_categories_);
   categories.insert(categories.end(),
                     disabled_categories_.begin(),
                     disabled_categories_.end());
   AddCategoryToDict(dict, kIncludedCategoriesParam, categories);
   AddCategoryToDict(dict, kExcludedCategoriesParam, excluded_categories_);
   AddCategoryToDict(dict, kSyntheticDelaysParam, synthetic_delays_);
+
+  if (!IsCategoryEnabled(MemoryDumpManager::kTraceCategory) ||
+      memory_dump_config_list_.size() == 0) {
+    return;

[Primiano Tucci (use gerrit), 2015/08/24 11:58:35]

same reason of above here, not sure if I'f I'd do the early return here.

[ssid, 2015/08/24 15:29:30]

Done.

+  }
+
+  scoped_ptr<base::DictionaryValue> memory_dump_config(
+      new base::DictionaryValue());
+  scoped_ptr<base::ListValue> triggers_list(new base::ListValue());
+  for (const MemoryDumpConfig& config : memory_dump_config_list_) {
+    scoped_ptr<base::DictionaryValue> trigger_dict(new base::DictionaryValue());
+    trigger_dict->SetInteger(kPeriodicIntervalParam,
+                             static_cast<int>(config.periodic_interval_ms));
+
+    switch (config.dump_level_of_detail) {
+      case MemoryDumpArgs::LevelOfDetail::LOW:
+        trigger_dict->SetString(kDumpTypeParam, kLightDumpTypeParam);
+        break;
+      case MemoryDumpArgs::LevelOfDetail::HIGH:
+        trigger_dict->SetString(kDumpTypeParam, kHeavyDumpTypeParam);
+        break;
+      default:
+        NOTREACHED();

[Primiano Tucci (use gerrit), 2015/08/24 11:58:35]

I think that you don't need the default: case here, as per our code style:

http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Loops_and_Swi...

* If not conditional on an enumerated value, switch statements should always
have a default case (in the case of an enumerated value, the compiler will warn
you if any values are not handled).

[ssid, 2015/08/24 15:29:31]

Yes, but I added the default case since the other enums in this file have
default case. Just added to be consistent with them.

+    }
+    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 {
   std::string ret;
   switch (record_mode_) {
     case RECORD_UNTIL_FULL:
       ret = kRecordUntilFull;
       break;
     case RECORD_CONTINUOUSLY:
       ret = kRecordContinuously;
@@ skipping 75 matching lines @@
           str.at(0) == ' ' ||
           str.at(str.length() - 1) == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base