Tracing pre-filtering

base/trace_event/trace_config.h

 // Copyright 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.
 
 #ifndef BASE_TRACE_EVENT_TRACE_CONFIG_H_
 #define BASE_TRACE_EVENT_TRACE_CONFIG_H_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 28 matching lines @@
 class BASE_EXPORT TraceConfig {
  public:
   typedef std::vector<std::string> StringList;
 
   // Specifies the memory dump config for tracing. Used only when
   // "memory-infra" category is enabled.
   struct MemoryDumpTriggerConfig {
     uint32_t periodic_interval_ms;
     MemoryDumpLevelOfDetail level_of_detail;
   };
+  typedef std::vector<MemoryDumpTriggerConfig> MemoryDumpConfig;
 
-  typedef std::vector<MemoryDumpTriggerConfig> MemoryDumpConfig;
+  struct CategoryEventFilterConfig {
+    CategoryEventFilterConfig();
+    ~CategoryEventFilterConfig();
+
+    CategoryEventFilterConfig(const CategoryEventFilterConfig& tc);
+    CategoryEventFilterConfig& operator=(const CategoryEventFilterConfig& rhs);
+
+    bool IsCategoryGroupEnabled(const char* category_group_name) const;
+
+    std::string predicate_name;
+    StringList included_categories;
+    StringList excluded_categories;
+    std::unique_ptr<base::DictionaryValue> args;
+  };
+  typedef std::vector<CategoryEventFilterConfig> CategoryEventFilters;
 
   TraceConfig();
 
   // Create TraceConfig object from category filter and trace options strings.
   //
   // |category_filter_string| is a comma-delimited list of category wildcards.
   // A category can have an optional '-' prefix to make it an excluded category.
   // All the same rules apply above, so for example, having both included and
   // excluded categories in the same list would not be supported.
   //
@@ skipping 75 matching lines @@
 
   TraceConfig(const TraceConfig& tc);
 
   ~TraceConfig();
 
   TraceConfig& operator=(const TraceConfig& rhs);
 
   // Return a list of the synthetic delays specified in this category filter.
   const StringList& GetSyntheticDelayValues() const;
 
+  const CategoryEventFilters& GetCategoryEventFilters() const;
+
   TraceRecordMode GetTraceRecordMode() const { return record_mode_; }
   bool IsSamplingEnabled() const { return enable_sampling_; }
   bool IsSystraceEnabled() const { return enable_systrace_; }
   bool IsArgumentFilterEnabled() const { return enable_argument_filter_; }
 
   void SetTraceRecordMode(TraceRecordMode mode) { record_mode_ = mode; }
   void EnableSampling() { enable_sampling_ = true; }
   void EnableSystrace() { enable_systrace_ = true; }
   void EnableArgumentFilter() { enable_argument_filter_ = true; }
 
   // Writes the string representation of the TraceConfig. The string is JSON
   // formatted.
   std::string ToString() const;
 
   // Returns a copy of the TraceConfig wrapped in a ConvertableToTraceFormat
   std::unique_ptr<ConvertableToTraceFormat> AsConvertableToTraceFormat() const;
 
   // Write the string representation of the CategoryFilter part.
   std::string ToCategoryFilterString() const;
 
   // Returns true if at least one category in the list is enabled by this
   // trace config.
-  bool IsCategoryGroupEnabled(const char* category_group) const;
+  bool IsCategoryGroupEnabled(const char* category_group_name) const;
 
   // Merges config with the current TraceConfig
   void Merge(const TraceConfig& config);
 
   void Clear();
 
   const MemoryDumpConfig& memory_dump_config() const {
     return memory_dump_config_;
   }
 
@@ skipping 28 matching lines @@
   void SetCategoriesFromIncludedList(const base::ListValue& included_list);
   void SetCategoriesFromExcludedList(const base::ListValue& excluded_list);
   void SetSyntheticDelaysFromList(const base::ListValue& list);
   void AddCategoryToDict(base::DictionaryValue& dict,
                          const char* param,
                          const StringList& categories) const;
 
   void SetMemoryDumpConfig(const base::DictionaryValue& memory_dump_config);
   void SetDefaultMemoryDumpConfig();
 
+  void SetCategoryEventFilters(const base::ListValue& category_event_filters);
+
   // Convert TraceConfig to the dict representation of the TraceConfig.
   void ToDict(base::DictionaryValue& dict) const;
 
   std::string ToTraceOptionsString() const;
 
   void WriteCategoryFilterString(const StringList& values,
                                  std::string* out,
                                  bool included) const;
   void WriteCategoryFilterString(const StringList& delays,
                                  std::string* out) const;
@@ skipping 10 matching lines @@
   bool enable_sampling_ : 1;
   bool enable_systrace_ : 1;
   bool enable_argument_filter_ : 1;
 
   MemoryDumpConfig memory_dump_config_;
 
   StringList included_categories_;
   StringList disabled_categories_;
   StringList excluded_categories_;
   StringList synthetic_delays_;
+  CategoryEventFilters category_event_filters_;
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_CONFIG_H_