tracing: simplify lifetime of TraceEventFilter(s)

base/trace_event/trace_log.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_LOG_H_
 #define BASE_TRACE_EVENT_TRACE_LOG_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 263 matching lines @@
                         TraceEventHandle handle);
 
   int process_id() const { return process_id_; }
 
   uint64_t MangleEventId(uint64_t id);
 
   // Exposed for unittesting:
 
   // Testing factory for TraceEventFilter.
   typedef std::unique_ptr<TraceEventFilter> (*FilterFactoryForTesting)(
-      const std::string& /* predicate_name */);
+      const std::string& /* predicate_name */,
+      std::unique_ptr<TraceEventFilter::Config>);
   void SetFilterFactoryForTesting(FilterFactoryForTesting factory) {
     filter_factory_for_testing_ = factory;
   }
 
   // Allows deleting our singleton instance.
   static void DeleteForTesting();
 
   // Allow tests to inspect TraceEvents.
   TraceEvent* GetEventByHandle(TraceEventHandle handle);
 
@@ skipping 53 matching lines @@
 
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
   friend struct DefaultSingletonTraits<TraceLog>;
 
   // MemoryDumpProvider implementation.
   bool OnMemoryDump(const MemoryDumpArgs& args,
                     ProcessMemoryDump* pmd) override;
 
   // Enable/disable each category group based on the current mode_,
-  // category_filter_ and event_filters_enabled_.
-  // Enable the category group in the recording mode if category_filter_ matches
+  // category_filter_ and state of event filters.
+  void UpdateCategoryRegistry();
+
+  // Enable the category in the recording mode if trace config matches
   // the category group, is not null. Enable category for filtering if any
   // filter in event_filters_enabled_ enables it.
-  void UpdateCategoryRegistry();
   void UpdateCategoryState(TraceCategory* category);
 
-  void CreateFiltersForTraceConfig();
+  // Registers new TraceEventFilter(s) based on the current |trace_config_|.
+  void CreateFiltersAndUpdateFilterRegistry();
 
   // Configure synthetic delays based on the values set in the current
   // trace config.
   void UpdateSyntheticDelaysFromTraceConfig();
 
   InternalTraceOptions GetInternalOptionsFromTraceConfig(
       const TraceConfig& config);
 
   class ThreadLocalEventBuffer;
   class OptionalAutoLock;
@@ skipping 90 matching lines @@
   // XORed with TraceID to make it unlikely to collide with other processes.
   unsigned long long process_id_hash_;
 
   int process_id_;
 
   TimeDelta time_offset_;
 
   subtle::AtomicWord /* Options */ trace_options_;
 
   TraceConfig trace_config_;
-  TraceConfig::EventFilters enabled_event_filters_;
 
   ThreadLocalPointer<ThreadLocalEventBuffer> thread_local_event_buffer_;
   ThreadLocalBoolean thread_blocks_message_loop_;
   ThreadLocalBoolean thread_is_in_trace_event_;
 
   // Contains the message loops of threads that have had at least one event
   // added into the local event buffer. Not using SingleThreadTaskRunner
   // because we need to know the life time of the message loops.
   hash_set<MessageLoop*> thread_message_loops_;
 
@@ skipping 11 matching lines @@
 
   FilterFactoryForTesting filter_factory_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_LOG_H_