[tracing] Introduce "allowed_dump_modes" for memory dump config

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 <stddef.h>
 
 #include <utility>
 
@@ skipping 29 matching lines @@
 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 kAllowedDumpModesParam[] = "allowed_dump_modes";
 const char kTriggersParam[] = "triggers";
 const char kPeriodicIntervalParam[] = "periodic_interval_ms";
 const char kModeParam[] = "mode";
 const char kHeapProfilerOptions[] = "heap_profiler_options";
 const char kBreakdownThresholdBytes[] = "breakdown_threshold_bytes";
 
 // Default configuration of memory dumps.
 const TraceConfig::MemoryDumpConfig::Trigger kDefaultHeavyMemoryDumpTrigger = {
     2000,  // periodic_interval_ms
     MemoryDumpLevelOfDetail::DETAILED};
 const TraceConfig::MemoryDumpConfig::Trigger kDefaultLightMemoryDumpTrigger = {
     250,  // periodic_interval_ms
     MemoryDumpLevelOfDetail::LIGHT};
 
 class ConvertableTraceConfigToTraceFormat
     : public base::trace_event::ConvertableToTraceFormat {
  public:
   explicit ConvertableTraceConfigToTraceFormat(const TraceConfig& trace_config)
       : trace_config_(trace_config) {}
   ~ConvertableTraceConfigToTraceFormat() override {}
   void AppendAsTraceFormat(std::string* out) const override {
     out->append(trace_config_.ToString());
   }
 
  private:
   const TraceConfig trace_config_;
 };
 
+std::set<MemoryDumpLevelOfDetail> GetDefaultAllowedMemoryDumpModes() {
+  const MemoryDumpLevelOfDetail kDefaultAllowedDumpModes[] = {
+      MemoryDumpLevelOfDetail::BACKGROUND, MemoryDumpLevelOfDetail::LIGHT,
+      MemoryDumpLevelOfDetail::DETAILED};
+  std::set<MemoryDumpLevelOfDetail> modes(kDefaultAllowedDumpModes,

[Primiano Tucci (use gerrit), 2016/06/09 18:46:39]

Hmm I'll make this a bit more self-maintaining and do:

std::set<MemoryDumpLevelOfDetail> all_modes;
for (auto mode = MemoryDumpLevelOfDetails::FIRST; mode <= ..::LAST; mode =
static_cast<LevelOfDetail>(static_cast<uint32_t>(mode) + 1)) {
  all_modes.add(i)
}

I know that the double cast is now awesome, but better than having to remember
to edit two places.

[ssid, 2016/06/09 21:34:15]

didn't know I could iterate here, thanks.

+                                          kDefaultAllowedDumpModes + 3);
+  // To keep the |kDefaultAllowedDumpModes| updated with new modes added.
+  DCHECK_EQ(static_cast<uint32_t>(MemoryDumpLevelOfDetail::LAST),

[Primiano Tucci (use gerrit), 2016/06/09 18:46:39]

at which point you get rid of the dcheck

[ssid, 2016/06/09 21:34:15]

Done.

+            modes.size() - 1);
+  return modes;
+}
+
 }  // namespace
 
 
 TraceConfig::MemoryDumpConfig::HeapProfiler::HeapProfiler() :
     breakdown_threshold_bytes(kDefaultBreakdownThresholdBytes) {};
 
 void TraceConfig::MemoryDumpConfig::HeapProfiler::Clear() {
   breakdown_threshold_bytes = kDefaultBreakdownThresholdBytes;
 }
 
 void TraceConfig::ResetMemoryDumpConfig(
     const TraceConfig::MemoryDumpConfig& memory_dump_config) {
   memory_dump_config_.Clear();
   memory_dump_config_ = memory_dump_config;
 }
 
 TraceConfig::MemoryDumpConfig::MemoryDumpConfig() {};
 
 TraceConfig::MemoryDumpConfig::MemoryDumpConfig(
     const MemoryDumpConfig& other) = default;
 
 TraceConfig::MemoryDumpConfig::~MemoryDumpConfig() {};
 
 void TraceConfig::MemoryDumpConfig::Clear() {
+  allowed_dump_modes.clear();
   triggers.clear();
   heap_profiler_options.Clear();
 }
 
 TraceConfig::TraceConfig() {
   InitializeDefault();
 }
 
 TraceConfig::TraceConfig(const std::string& category_filter_string,
                          const std::string& trace_options_string) {
@@ skipping 398 matching lines @@
        ci != categories.end();
        ++ci) {
     list->AppendString(*ci);
   }
 
   dict.Set(param, std::move(list));
 }
 
 void TraceConfig::SetMemoryDumpConfigFromConfigDict(
     const base::DictionaryValue& memory_dump_config) {
+  // Set allowed dump modes.
+  memory_dump_config_.allowed_dump_modes.clear();
+  const base::ListValue* allowed_modes_list;
+  if (memory_dump_config.GetList(kAllowedDumpModesParam, &allowed_modes_list)) {
+    for (size_t i = 0; i < allowed_modes_list->GetSize(); ++i) {
+      std::string level_of_detail_str;
+      allowed_modes_list->GetString(i, &level_of_detail_str);
+      memory_dump_config_.allowed_dump_modes.insert(
+          StringToMemoryDumpLevelOfDetail(level_of_detail_str));
+    }
+  } else {
+    // If allowed modes param is not given then allow all modes by default.
+    memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes();
+  }
+
   // Set triggers
   memory_dump_config_.triggers.clear();
-
   const base::ListValue* trigger_list = nullptr;
   if (memory_dump_config.GetList(kTriggersParam, &trigger_list) &&
       trigger_list->GetSize() > 0) {
     for (size_t i = 0; i < trigger_list->GetSize(); ++i) {
       const base::DictionaryValue* trigger = nullptr;
       if (!trigger_list->GetDictionary(i, &trigger))
         continue;
 
       MemoryDumpConfig::Trigger dump_config;
       int interval = 0;
@@ skipping 25 matching lines @@
       memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
           MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes;
     }
   }
 }
 
 void TraceConfig::SetDefaultMemoryDumpConfig() {
   memory_dump_config_.Clear();
   memory_dump_config_.triggers.push_back(kDefaultHeavyMemoryDumpTrigger);
   memory_dump_config_.triggers.push_back(kDefaultLightMemoryDumpTrigger);
+  memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes();
 }
 
 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;
@@ skipping 26 matching lines @@
   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)) {
     std::unique_ptr<base::DictionaryValue> memory_dump_config(
         new base::DictionaryValue());
+    std::unique_ptr<base::ListValue> allowed_modes_list(new base::ListValue());
+    for (MemoryDumpLevelOfDetail dump_mode :
+         memory_dump_config_.allowed_dump_modes) {
+      allowed_modes_list->AppendString(
+          MemoryDumpLevelOfDetailToString(dump_mode));
+    }
+    memory_dump_config->Set(kAllowedDumpModesParam,
+                            std::move(allowed_modes_list));
+
     std::unique_ptr<base::ListValue> triggers_list(new base::ListValue());
     for (const MemoryDumpConfig::Trigger& config
         : memory_dump_config_.triggers) {
       std::unique_ptr<base::DictionaryValue> trigger_dict(
           new base::DictionaryValue());
       trigger_dict->SetInteger(kPeriodicIntervalParam,
                                static_cast<int>(config.periodic_interval_ms));
       trigger_dict->SetString(
           kModeParam, MemoryDumpLevelOfDetailToString(config.level_of_detail));
       triggers_list->Append(std::move(trigger_dict));
@@ skipping 103 matching lines @@
           str.at(0) == ' ' ||
           str.at(str.length() - 1) == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base