[tracing] Add filtering mode in TraceLog

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 27 matching lines @@
 
 struct BASE_EXPORT TraceLogStatus {
   TraceLogStatus();
   ~TraceLogStatus();
   uint32_t event_capacity;
   uint32_t event_count;
 };
 
 class BASE_EXPORT TraceLog : public MemoryDumpProvider {
  public:
-  enum Mode {
-    DISABLED = 0,
-    RECORDING_MODE
-  };
+  // Argument passed to TrcaeLog::SetEnabled.
+  enum Mode { RECORDING_MODE = 1 << 0, FILTERING_MODE = 1 << 1 };
 
   // The pointer returned from GetCategoryGroupEnabledInternal() points to a
   // value with zero or more of the following bits. Used in this class only.
   // The TRACE_EVENT macros should only use the value as a bool.
   // These values must be in sync with macro values in TraceEvent.h in Blink.
   enum CategoryGroupEnabledFlags {
     // Category group enabled for the recording mode.
     ENABLED_FOR_RECORDING = 1 << 0,
     // Category group enabled by SetEventCallbackEnabled().
     ENABLED_FOR_EVENT_CALLBACK = 1 << 2,
     // Category group enabled to export events to ETW.
     ENABLED_FOR_ETW_EXPORT = 1 << 3,
     // Category group being filtered before logged.
     ENABLED_FOR_FILTERING = 1 << 4
   };
 
   static TraceLog* GetInstance();
 
   // Get set of known category groups. This can change as new code paths are
   // reached. The known category groups are inserted into |category_groups|.
   void GetKnownCategoryGroups(std::vector<std::string>* category_groups);
 
   // Retrieves a copy (for thread-safety) of the current TraceConfig.
   TraceConfig GetCurrentTraceConfig() const;
 
   // Initializes the thread-local event buffer, if not already initialized and
   // if the current thread supports that (has a message loop).
   void InitializeThreadLocalEventBufferIfSupported();
 
-  // Enables normal tracing (recording trace events in the trace buffer).
   // See TraceConfig comments for details on how to control what categories
-  // will be traced. If tracing has already been enabled, |category_filter| will
-  // be merged into the current category filter.
-  void SetEnabled(const TraceConfig& trace_config, Mode mode);
+  // will be traced. SetDisabled must be called for each mode that is enabled.
+  // RECORDING_MODE: Enables normal tracing (recording trace events in the trace
+  //                 buffer).
+  // FILTERING_MODE: Trace events are enabled just for filtering but not for
+  //                 recording. TraceLog::IsEnabled still returns false when
+  //                 running in this mode. Only event filters config of
+  //                 |trace_config| argument is used.
+  // If tracing has already been enabled, category filter (enabled and disabled
+  // categories) will be merged into the current category filter, and trace
+  // event filters will be used only if filtering was not enabled already.
+  void SetEnabled(const TraceConfig& trace_config, Mode new_mode);
 
-  // Disables normal tracing for all categories.
+  // Disables tracing for all categories for the specified |mode| only. Default
+  // |mode| is taken as RECORDING_MODE.
   void SetDisabled();
+  void SetDisabled(Mode mode);
 
-  bool IsEnabled() { return mode_ != DISABLED; }
+  // Returns true if TraceLog is enabled on recording mode.
+  // Note: Returns false even if FILTERING_MODE is enabled.
+  bool IsEnabled() { return mode_ & RECORDING_MODE; }

[oystein (OOO til 10th of July), 2016/09/22 19:21:06]

I think we should rename this to IsEnabledForRecording() now.

[ssid, 2016/09/22 19:37:43]

Do you mind if I do this as a separate clean up CL? I would have to change some
20 files where this is being used. multiple owners will get spammed by
discussion in this CL.

[oystein (OOO til 10th of July), 2016/09/22 20:16:42]

Yep that's fine.

+
+  // Returns true if filters are enabled, irrespective of the recording mode.
+  bool IsFilteringEnabled();

[oystein (OOO til 10th of July), 2016/09/22 19:21:06]

What's the reason for not just checking for filtering mode here, like
IsEnabled(ForRecording?) above? Doing an IsEnabled(Mode).

[ssid, 2016/09/22 19:37:43]

So, I really need to check if filters are enabled rather than if filtering mode
is enabled. This is because if filters were enabled by any mode previously then
we cannot add more filters since it will cause races on the filters vector.
I added an additional function to get mode.

[oystein (OOO til 10th of July), 2016/09/22 20:16:42]

Okay, that makes sense.I think I'd avoid "Enabled" as part of the name in that
case though, to make it clear it's not an equivalent function to IsEnabled??().
"HaveActiveFilters" maybe, up to you!

 
   // The number of times we have begun recording traces. If tracing is off,
   // returns -1. If tracing is on, then it returns the number of times we have
   // recorded a trace. By watching for this number to increment, you can
   // passively discover when a new trace has begun. This is then used to
   // implement the TRACE_EVENT_IS_NEW_TRACE() primitive.
   int GetNumTracesRecorded();
 
 #if defined(OS_ANDROID)
   void StartATrace();
@@ skipping 276 matching lines @@
 
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferGetReturnChunk);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferHalfIteration);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferFullIteration);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture, TraceBufferVectorReportFull);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            ConvertTraceConfigToInternalOptions);
+  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture, TraceFilteringMode);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceRecordAsMuchAsPossibleMode);
 
   // 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;
@@ skipping 32 matching lines @@
   TraceBuffer* trace_buffer() const { return logged_events_.get(); }
   TraceBuffer* CreateTraceBuffer();
 
   std::string EventToConsoleMessage(unsigned char phase,
                                     const TimeTicks& timestamp,
                                     TraceEvent* trace_event);
 
   TraceEvent* AddEventToThreadSharedChunkWhileLocked(TraceEventHandle* handle,
                                                      bool check_buffer_is_full);
   void CheckIfBufferIsFullWhileLocked();
-  void SetDisabledWhileLocked();
+  void SetDisabledWhileLocked(Mode mode);
 
   TraceEvent* GetEventByHandleInternal(TraceEventHandle handle,
                                        OptionalAutoLock* lock);
 
   void FlushInternal(const OutputCallback& cb,
                      bool use_worker_thread,
                      bool discard_events);
 
   // |generation| is used in the following callbacks to check if the callback
   // is called for the flush of the current |logged_events_|.
@@ skipping 28 matching lines @@
   static const InternalTraceOptions kInternalEnableSampling;
   static const InternalTraceOptions kInternalRecordAsMuchAsPossible;
   static const InternalTraceOptions kInternalEnableArgumentFilter;
 
   // This lock protects TraceLog member accesses (except for members protected
   // by thread_info_lock_) from arbitrary threads.
   mutable Lock lock_;
   // This lock protects accesses to thread_names_, thread_event_start_times_
   // and thread_colors_.
   Lock thread_info_lock_;
-  Mode mode_;
+  int mode_;  // See TraceLog::Mode.

[oystein (OOO til 10th of July), 2016/09/22 19:21:06]

nit: Since this is now a bitmask it should probably use a specific sized type
like uint8_t instead. 

[ssid, 2016/09/22 19:37:44]

Done.

   int num_traces_recorded_;
   std::unique_ptr<TraceBuffer> logged_events_;
   std::vector<std::unique_ptr<TraceEvent>> metadata_events_;
   subtle::AtomicWord /* EventCallback */ event_callback_;
   bool dispatching_to_observer_list_;
   std::vector<EnabledStateObserver*> enabled_state_observer_list_;
   std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver>
       async_observers_;
 
   std::string process_name_;
@@ skipping 21 matching lines @@
   std::string watch_event_name_;
 
   subtle::AtomicWord /* Options */ trace_options_;
 
   // Sampling thread handles.
   std::unique_ptr<TraceSamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
   TraceConfig trace_config_;
   TraceConfig event_callback_trace_config_;
+  TraceConfig::EventFilters event_filters_enabled_;
 
   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_;
 
   // For events which can't be added into the thread local buffer, e.g. events
   // from threads without a message loop.
   std::unique_ptr<TraceBufferChunk> thread_shared_chunk_;
   size_t thread_shared_chunk_index_;
 
   // Set when asynchronous Flush is in progress.
   OutputCallback flush_output_callback_;
   scoped_refptr<SingleThreadTaskRunner> flush_task_runner_;
   ArgumentFilterPredicate argument_filter_predicate_;
   subtle::AtomicWord generation_;
   bool use_worker_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_LOG_H_