Add configurable limit to allocations in heap profiler.

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 32 matching lines @@
 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 kHeapProfilerOptions[] = "heap_profiler_options";
+const char kBreakdownThresholdBytes[] = "breakdown_threshold_bytes";
 
 // Default configuration of memory dumps.
 const TraceConfig::MemoryDumpTriggerConfig kDefaultHeavyMemoryDumpTrigger = {
     2000,  // periodic_interval_ms
     MemoryDumpLevelOfDetail::DETAILED};
 const TraceConfig::MemoryDumpTriggerConfig 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_;
 };
 
 }  // namespace
 
+
+TraceConfig::HeapProfilerOptions::HeapProfilerOptions() :
+    breakdown_threshold_bytes(kDefaultBreakdownThresholdBytes) {};
+
+TraceConfig::HeapProfilerOptions::~HeapProfilerOptions() {};
+
+void TraceConfig::HeapProfilerOptions::Clear() {
+  breakdown_threshold_bytes = kDefaultBreakdownThresholdBytes;
+}
+
+TraceConfig::MemoryDumpConfig::MemoryDumpConfig() {};
+
+TraceConfig::MemoryDumpConfig::MemoryDumpConfig(
+    const MemoryDumpConfig& other) = default;
+
+TraceConfig::MemoryDumpConfig::~MemoryDumpConfig() {};
+
+void TraceConfig::MemoryDumpConfig::Clear() {
+  triggers.clear();
+  heap_profiler_options.Clear();
+}
+
+
 TraceConfig::TraceConfig() {
   InitializeDefault();
 }
 
 TraceConfig::TraceConfig(const std::string& category_filter_string,
                          const std::string& trace_options_string) {
   InitializeFromStrings(category_filter_string, trace_options_string);
 }
 
 TraceConfig::TraceConfig(const std::string& category_filter_string,
@@ skipping 162 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());
+  memory_dump_config_.triggers.insert(memory_dump_config_.triggers.end(),
+                             config.memory_dump_config_.triggers.begin(),
+                             config.memory_dump_config_.triggers.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();
+  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 187 matching lines @@
        ci != categories.end();
        ++ci) {
     list->AppendString(*ci);
   }
 
   dict.Set(param, std::move(list));
 }
 
 void TraceConfig::SetMemoryDumpConfig(
     const base::DictionaryValue& memory_dump_config) {
-  memory_dump_config_.clear();
+  SetTriggers(memory_dump_config);
+  SetHeapProfilerOptions(memory_dump_config);
+}

[Primiano Tucci (use gerrit), 2016/04/22 14:18:29]

I'd just do everything in this method, just to avoid confusion in TraceCOnfig.
It's a shared place and is not just about memory-infra, so would keep our stuff
self contained.
Also there seems that you never have the need of calling any of the sub-setters,
right?

[Maria, 2016/04/25 18:37:24]

Done.

+
+void TraceConfig::SetTriggers(const base::DictionaryValue& memory_dump_config) {
+  memory_dump_config_.triggers.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;
     int interval = 0;
 
     if (!trigger->GetInteger(kPeriodicIntervalParam, &interval)) {
       continue;
     }
     DCHECK_GT(interval, 0);
     dump_config.periodic_interval_ms = static_cast<uint32_t>(interval);
     std::string level_of_detail_str;
     trigger->GetString(kModeParam, &level_of_detail_str);
     dump_config.level_of_detail =
         StringToMemoryDumpLevelOfDetail(level_of_detail_str);
-    memory_dump_config_.push_back(dump_config);
+    memory_dump_config_.triggers.push_back(dump_config);
+  }
+}
+
+void TraceConfig::SetHeapProfilerOptions(
+    const base::DictionaryValue& memory_dump_config) {
+  const base::DictionaryValue* heap_profiler_options = nullptr;
+  if (!memory_dump_config.GetDictionary(kHeapProfilerOptions,
+                                        &heap_profiler_options))
+    return;
+
+  int min_size_bytes = 0;
+  if (heap_profiler_options->GetInteger(kBreakdownThresholdBytes,
+                                       &min_size_bytes)
+      && min_size_bytes >= 0) {
+    memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
+        static_cast<size_t>(min_size_bytes);
+  } else {
+    memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
+        HeapProfilerOptions::kDefaultBreakdownThresholdBytes;
   }
 }
 
 void TraceConfig::SetDefaultMemoryDumpConfig() {
-  memory_dump_config_.clear();
-  memory_dump_config_.push_back(kDefaultHeavyMemoryDumpTrigger);
-  memory_dump_config_.push_back(kDefaultLightMemoryDumpTrigger);
+  memory_dump_config_.Clear();
+  memory_dump_config_.triggers.push_back(kDefaultHeavyMemoryDumpTrigger);
+  memory_dump_config_.triggers.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;
@@ skipping 27 matching lines @@
                     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> triggers_list(new base::ListValue());
-    for (const MemoryDumpTriggerConfig& config : memory_dump_config_) {
+    for (const MemoryDumpTriggerConfig& 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));
     }
 
     // Empty triggers will still be specified explicitly since it means that
     // the periodic dumps are not enabled.
     memory_dump_config->Set(kTriggersParam, std::move(triggers_list));
+
+    if (memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes !=
+        HeapProfilerOptions::kDefaultBreakdownThresholdBytes) {
+      std::unique_ptr<base::DictionaryValue> heap_profiler_options(
+          new base::DictionaryValue());
+      heap_profiler_options->SetInteger(
+          kBreakdownThresholdBytes,
+          memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes);
+      memory_dump_config->Set(kHeapProfilerOptions,
+                              std::move(heap_profiler_options));
+    }
     dict.Set(kMemoryDumpConfigParam, std::move(memory_dump_config));
   }
 }
 
 std::string TraceConfig::ToTraceOptionsString() const {
   std::string ret;
   switch (record_mode_) {
     case RECORD_UNTIL_FULL:
       ret = kRecordUntilFull;
       break;
@@ skipping 77 matching lines @@
           str.at(0) == ' ' ||
           str.at(str.length() - 1) == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base