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 kMinAllocationSize[] = "min_allocation_size_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
@@ skipping 53 matching lines @@
   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_),
+      min_allocation_size_bytes_(tc.min_allocation_size_bytes_),
       included_categories_(tc.included_categories_),
       disabled_categories_(tc.disabled_categories_),
       excluded_categories_(tc.excluded_categories_),
       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_;
+  min_allocation_size_bytes_ = rhs.min_allocation_size_bytes_;
   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 356 matching lines @@
       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);
   }
+
+  int min_size_bytes = 0;
+  if (memory_dump_config.GetInteger(kMinAllocationSize, &min_size_bytes)
+      && min_size_bytes >= 0) {
+    min_allocation_size_bytes_ = static_cast<size_t>(min_size_bytes);
+  } else {
+    min_allocation_size_bytes_ = kDefaultMinAllocationSizeBytes;
+  }
+
 }
 
 void TraceConfig::SetDefaultMemoryDumpConfig() {
   memory_dump_config_.clear();
   memory_dump_config_.push_back(kDefaultHeavyMemoryDumpTrigger);
   memory_dump_config_.push_back(kDefaultLightMemoryDumpTrigger);
+  min_allocation_size_bytes_ = kDefaultMinAllocationSizeBytes;
 }
 
 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 40 matching lines @@
       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 (min_allocation_size_bytes_ != kDefaultMinAllocationSizeBytes)
+      memory_dump_config->SetInteger(kMinAllocationSize,
+                                     min_allocation_size_bytes_);
     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