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 <set>
@@ skipping 62 matching lines @@
 
     // Set of memory dump modes allowed for the tracing session. The explicitly
     // triggered dumps will be successful only if the dump mode is allowed in
     // the config.
     std::set<MemoryDumpLevelOfDetail> allowed_dump_modes;
 
     std::vector<Trigger> triggers;
     HeapProfiler heap_profiler_options;
   };
 
+  class EventFilterConfig {
+   public:
+    EventFilterConfig(const std::string& predicate_name);
+    EventFilterConfig(const EventFilterConfig& tc);
+
+    ~EventFilterConfig();
+
+    EventFilterConfig& operator=(const EventFilterConfig& rhs);
+
+    void AddIncludedCategory(const std::string& category);
+    void AddExcludedCategory(const std::string& category);
+    void SetArgs(std::unique_ptr<base::DictionaryValue> args);
+
+    bool IsCategoryGroupEnabled(const char* category_group_name) const;
+
+    const std::string& predicate_name() const { return predicate_name_; }
+    base::DictionaryValue* filter_args() const { return args_.get(); }
+    const StringList& included_categories() const {
+      return included_categories_;
+    }
+    const StringList& excluded_categories() const {
+      return excluded_categories_;
+    }
+
+   private:
+    std::string predicate_name_;
+    StringList included_categories_;
+    StringList excluded_categories_;
+    std::unique_ptr<base::DictionaryValue> args_;
+  };
+  typedef std::vector<EventFilterConfig> EventFilters;
+
   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.
   //
   // Category filters can also be used to configure synthetic delays.
@@ skipping 96 matching lines @@
 
   // 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. This is used to determine if the category filters are
   // enabled in the TRACE_* macros.
-  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();
 
   // Clears and resets the memory dump config.
   void ResetMemoryDumpConfig(const MemoryDumpConfig& memory_dump_config);
 
   const MemoryDumpConfig& memory_dump_config() const {
     return memory_dump_config_;
   }
 
+  const EventFilters& event_filters() const { return event_filters_; }
+
  private:
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromValidLegacyFormat);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest,
                            TraceConfigFromInvalidLegacyStrings);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromValidString);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromInvalidString);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest,
                            IsEmptyOrContainsLeadingOrTrailingWhitespace);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromMemoryConfigString);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, LegacyStringToMemoryDumpConfig);
@@ skipping 20 matching lines @@
   void SetCategoriesFromExcludedList(const ListValue& excluded_list);
   void SetSyntheticDelaysFromList(const ListValue& list);
   void AddCategoryToDict(DictionaryValue* dict,
                          const char* param,
                          const StringList& categories) const;
 
   void SetMemoryDumpConfigFromConfigDict(
       const DictionaryValue& memory_dump_config);
   void SetDefaultMemoryDumpConfig();
 
+  void SetEventFilters(const base::ListValue& event_filters);
   std::unique_ptr<DictionaryValue> ToDict() 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 11 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_;
+  EventFilters event_filters_;
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_CONFIG_H_