Update to Chromium //base at Chromium commit 3e81715e6d3a4324362635aea46ce1f1a163cca1.

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 kModeParam[] = "mode";
+const char kDetailedParam[] = "detailed";
+const char kLightParam[] = "light";
+
+// 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() {
   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_(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() {
 }
 
 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_ = rhs.memory_dump_config_;
   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_.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());
   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_.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)) {
+    // If dump triggers not set, the client is using the legacy with just
+    // category enabled. So, use the default periodic dump config.
+    base::DictionaryValue* memory_dump_config = nullptr;
+    if (dict->GetDictionary(kMemoryDumpConfigParam, &memory_dump_config))
+      SetMemoryDumpConfig(*memory_dump_config);
+    else
+      SetDefaultMemoryDumpConfig();
+  }
 }
 
 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)) {
+    SetDefaultMemoryDumpConfig();
+  }
 }
 
 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::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(kModeParam, &dump_type)) {
+      if (dump_type == kDetailedParam) {
+        dump_config.level_of_detail = MemoryDumpArgs::LevelOfDetail::HIGH;
+      }
+    }
+
+    memory_dump_config_.push_back(dump_config);
+  }
+}
+
+void TraceConfig::SetDefaultMemoryDumpConfig() {
+  memory_dump_config_.clear();
+  memory_dump_config_.push_back(kDefaultHeavyMemoryDumpTrigger);
+  memory_dump_config_.push_back(kDefaultLightMemoryDumpTrigger);
+}
+
 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)) {
+    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(kModeParam, kLightParam);
+          break;
+        case MemoryDumpArgs::LevelOfDetail::HIGH:
+          trigger_dict->SetString(kModeParam, kDetailedParam);
+          break;
+        default:
+          NOTREACHED();
+      }
+      triggers_list->Append(trigger_dict.Pass());
+    }
+
+    // Empty triggers will still be specified explicitly since it means that
+    // the periodic dumps are not enabled.
+    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