[tracing] Add filtering mode in TraceLog

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 101 matching lines @@
     const MemoryDumpConfig& other) = default;
 
 TraceConfig::MemoryDumpConfig::~MemoryDumpConfig() {}
 
 void TraceConfig::MemoryDumpConfig::Clear() {
   allowed_dump_modes.clear();
   triggers.clear();
   heap_profiler_options.Clear();
 }
 
+void TraceConfig::MemoryDumpConfig::Merge(
+    const TraceConfig::MemoryDumpConfig& config) {
+  triggers.insert(triggers.end(), config.triggers.begin(),
+                  config.triggers.end());
+  allowed_dump_modes.insert(config.allowed_dump_modes.begin(),
+                            config.allowed_dump_modes.end());
+  heap_profiler_options.breakdown_threshold_bytes =
+      std::min(heap_profiler_options.breakdown_threshold_bytes,
+               config.heap_profiler_options.breakdown_threshold_bytes);
+}
+
 TraceConfig::EventFilterConfig::EventFilterConfig(
     const std::string& predicate_name)
     : predicate_name_(predicate_name) {}
 
 TraceConfig::EventFilterConfig::~EventFilterConfig() {}
 
 TraceConfig::EventFilterConfig::EventFilterConfig(const EventFilterConfig& tc) {
   *this = tc;
 }
 
@@ skipping 216 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_.triggers.insert(memory_dump_config_.triggers.end(),
-                             config.memory_dump_config_.triggers.begin(),
-                             config.memory_dump_config_.triggers.end());
+  memory_dump_config_.Merge(config.memory_dump_config_);
 
   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());
+  event_filters_.insert(event_filters_.end(), config.event_filters().begin(),
+                        config.event_filters().end());
 }
 
 void TraceConfig::Clear() {
   record_mode_ = RECORD_UNTIL_FULL;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
   included_categories_.clear();
   disabled_categories_.clear();
   excluded_categories_.clear();
   synthetic_delays_.clear();
@@ skipping 28 matching lines @@
       dict.GetBoolean(kEnableArgumentFilterParam, &val) ? val : false;
 
   const 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);
 
+  const base::ListValue* category_event_filters = nullptr;
+  if (dict.GetList(kEventFiltersParam, &category_event_filters))
+    SetEventFiltersFromConfigList(*category_event_filters);
+
   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.
     const DictionaryValue* memory_dump_config = nullptr;
     if (dict.GetDictionary(kMemoryDumpConfigParam, &memory_dump_config))
       SetMemoryDumpConfigFromConfigDict(*memory_dump_config);
     else
       SetDefaultMemoryDumpConfig();
   }
-
-  const base::ListValue* category_event_filters = nullptr;
-  if (dict.GetList(kEventFiltersParam, &category_event_filters))
-    SetEventFilters(*category_event_filters);
 }
 
 void TraceConfig::InitializeFromConfigString(StringPiece config_string) {
   auto dict = DictionaryValue::From(JSONReader::Read(config_string));
   if (dict)
     InitializeFromConfigDict(*dict);
   else
     InitializeDefault();
 }
 
@@ skipping 169 matching lines @@
           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();
-
-  if (AllocationContextTracker::capture_mode() ==
-      AllocationContextTracker::CaptureMode::PSEUDO_STACK) {
-    for (const auto& filter : event_filters_) {
-      if (filter.predicate_name() ==
-          TraceLog::TraceEventFilter::kHeapProfilerPredicate)
-        return;
-    }
-    // Adds a filter predicate to filter all categories for the heap profiler.
-    // Note that the heap profiler predicate does not filter-out any events.
-    EventFilterConfig heap_profiler_config(
-        TraceLog::TraceEventFilter::kHeapProfilerPredicate);
-    heap_profiler_config.AddIncludedCategory("*");
-    heap_profiler_config.AddIncludedCategory(MemoryDumpManager::kTraceCategory);
-    event_filters_.push_back(heap_profiler_config);
-  }
 }
 
-void TraceConfig::SetEventFilters(
+void TraceConfig::SetEventFiltersFromConfigList(
     const base::ListValue& category_event_filters) {
   event_filters_.clear();
 
   for (size_t event_filter_index = 0;
        event_filter_index < category_event_filters.GetSize();
        ++event_filter_index) {
     const base::DictionaryValue* event_filter = nullptr;
     if (!category_event_filters.GetDictionary(event_filter_index,
                                               &event_filter))
       continue;
@@ skipping 204 matching lines @@
     StringPiece str) {
   return str.empty() || str.front() == ' ' || str.back() == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base