Independently enable recording and event callback

base/debug/trace_event_impl.h

 // Copyright (c) 2012 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_DEBUG_TRACE_EVENT_IMPL_H_
 #define BASE_DEBUG_TRACE_EVENT_IMPL_H_
 
 #include <stack>
 #include <string>
@@ skipping 363 matching lines @@
     // Enable the sampling profiler in the recording mode.
     ENABLE_SAMPLING = 1 << 2,
 
     // Enable the sampling profiler in the monitoring mode.
     MONITOR_SAMPLING = 1 << 3,
 
     // Echo to console. Events are discarded.
     ECHO_TO_CONSOLE = 1 << 4,
   };
 
+  // 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.
+  enum CategoryGroupEnabledFlags {
+    // Normal enabled flag for category groups enabled by SetEnabled().
+    ENABLED_FOR_RECORDING = 1 << 0,
+    // Category group enabled by SetEventCallbackEnabled().
+    ENABLED_FOR_EVENT_CALLBACK = 1 << 1,
+  };
+
   static TraceLog* GetInstance();
 
   // Convert the given string to trace options. Defaults to RECORD_UNTIL_FULL if
   // the string does not provide valid options.
   static Options TraceOptionsFromString(const std::string& str);
 
   // 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 the current CategoryFilter.
-  const CategoryFilter& GetCurrentCategoryFilter();
+  // Retrieves a copy (for thread-safety) of the current CategoryFilter.
+  CategoryFilter GetCurrentCategoryFilter();
 
   Options trace_options() const {
     return static_cast<Options>(subtle::NoBarrier_Load(&trace_options_));
   }
 
-  // Enables tracing. See CategoryFilter comments for details
-  // on how to control what categories will be traced.
+  // Enables normal tracing (recording trace events in the trace buffer).
+  // See CategoryFilter 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 CategoryFilter& category_filter, Options options);
 
-  // Disables tracing for all categories.
+  // Disables normal tracing for all categories.
   void SetDisabled();
-  bool IsEnabled() { return !!enable_count_; }
+
+  bool IsEnabled() { return enabled_; }
 
   // 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 24 matching lines @@
   // time and from any thread. WARNING: It is possible for the previously set
   // callback to be called during OR AFTER a call to SetNotificationCallback.
   // Therefore, the target of the callback must either be a global function,
   // ref-counted object or a LazyInstance with Leaky traits (or equivalent).
   typedef base::Callback<void(int)> NotificationCallback;
   void SetNotificationCallback(const NotificationCallback& cb);
 
   // Not using base::Callback because of its limited by 7 parameters.
   // Also, using primitive type allows directly passing callback from WebCore.
   // WARNING: It is possible for the previously set callback to be called
-  // after a call to SetEventCallback() that replaces or clears the callback.
+  // after a call to SetEventCallbackEnabled() that replaces or a call to
+  // SetEventCallbackDisabled() that disables the callback.
   // This callback may be invoked on any thread.
-  // TODO(wangxianzhu): For now for TRACE_EVENT_PHASE_COMPLETE events, the
-  // client will still receive pairs of TRACE_EVENT_PHASE_BEGIN and
-  // TRACE_EVENT_PHASE_END events. Should send TRACE_EVENT_PHASE_COMPLETE
-  // directly to clients if it is beneficial and feasible.
+  // For TRACE_EVENT_PHASE_COMPLETE events, the client will still receive pairs
+  // of TRACE_EVENT_PHASE_BEGIN and TRACE_EVENT_PHASE_END events to keep the
+  // interface simple.
   typedef void (*EventCallback)(TimeTicks timestamp,
                                 char phase,
                                 const unsigned char* category_group_enabled,
                                 const char* name,
                                 unsigned long long id,
                                 int num_args,
                                 const char* const arg_names[],
                                 const unsigned char arg_types[],
                                 const unsigned long long arg_values[],
                                 unsigned char flags);
-  void SetEventCallback(EventCallback cb);
+
+  // Enable tracing for EventCallback.
+  void SetEventCallbackEnabled(const CategoryFilter& category_filter,
+                               EventCallback cb);
+  void SetEventCallbackDisabled();
 
   // Flush all collected events to the given output callback. The callback will
   // be called one or more times either synchronously or asynchronously from
   // the current thread with IPC-bite-size chunks. The string format is
   // undefined. Use TraceResultBuffer to convert one or more trace strings to
   // JSON. The callback can be null if the caller doesn't want any data.
   // Due to the implementation of thread-local buffers, flush can't be
   // done when tracing is enabled. If called when tracing is enabled, the
   // callback will be called directly with (empty_string, false) to indicate
   // the end of this unsuccessful flush.
@@ skipping 38 matching lines @@
       unsigned char flags);
   static void AddTraceEventEtw(char phase,
                                const char* category_group,
                                const void* id,
                                const char* extra);
   static void AddTraceEventEtw(char phase,
                                const char* category_group,
                                const void* id,
                                const std::string& extra);
 
-  void UpdateTraceEventDuration(TraceEventHandle handle);
+  void UpdateTraceEventDuration(const unsigned char* category_group_enabled,
+                                const char* name,
+                                TraceEventHandle handle);
 
   // For every matching event, a notification will be fired. NOTE: the
   // notification will fire for each matching event that has already occurred
   // since tracing was started (including before tracing if the process was
   // started with tracing turned on).
   void SetWatchEvent(const std::string& category_name,
                      const std::string& event_name);
   // Cancel the watch event. If tracing is enabled, this may race with the
   // watch event notification firing.
   void CancelWatchEvent();
@@ skipping 47 matching lines @@
                            TraceBufferRingBufferGetReturnChunk);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferHalfIteration);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferFullIteration);
 
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
   friend struct DefaultSingletonTraits<TraceLog>;
 
-  // Enable/disable each category group based on the current enable_count_
-  // and category_filter_. Disable the category group if enabled_count_ is 0, or
-  // if the category group contains a category that matches an included category
-  // pattern, that category group will be enabled.
-  // On Android, ATRACE_ENABLED flag will be applied if atrace is started.
+  // Enable/disable each category group based on the current enabled_,
+  // category_filter_, event_callback_ and event_callback_category_filter_.
+  // Enable the category group if enabled_ is true and category_filter_ matches
+  // the category group, or event_callback_ is not null and
+  // event_callback_category_filter_ matches the category group.
   void UpdateCategoryGroupEnabledFlags();
   void UpdateCategoryGroupEnabledFlag(int category_index);
 
   // Helper class for managing notification_thread_count_ and running
   // notification callbacks. This is very similar to a reader-writer lock, but
   // shares the lock with TraceLog and manages the notification flags.
   class NotificationHelper {
    public:
     inline explicit NotificationHelper(TraceLog* trace_log);
     inline ~NotificationHelper();
@@ skipping 56 matching lines @@
   TimeTicks OffsetNow() const {
     return OffsetTimestamp(TimeTicks::NowFromSystemTraceTime());
   }
   TimeTicks OffsetTimestamp(const TimeTicks& timestamp) const {
     return timestamp - time_offset_;
   }
 
   // This lock protects TraceLog member accesses from arbitrary threads.
   Lock lock_;
   int locked_line_;
-  int enable_count_;
+  bool enabled_;
   int num_traces_recorded_;
   subtle::AtomicWord /* bool */ buffer_is_full_;
   NotificationCallback notification_callback_;
   scoped_ptr<TraceBuffer> logged_events_;
   subtle::AtomicWord /* EventCallback */ event_callback_;
   bool dispatching_to_observer_list_;
   std::vector<EnabledStateObserver*> enabled_state_observer_list_;
 
   std::string process_name_;
   base::hash_map<int, std::string> process_labels_;
@@ skipping 16 matching lines @@
   subtle::AtomicWord /* const unsigned char* */ watch_category_;
   std::string watch_event_name_;
 
   subtle::AtomicWord /* Options */ trace_options_;
 
   // Sampling thread handles.
   scoped_ptr<TraceSamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
   CategoryFilter category_filter_;
+  CategoryFilter event_callback_category_filter_;
 
   ThreadLocalPointer<ThreadLocalEventBuffer> thread_local_event_buffer_;
   ThreadLocalBoolean thread_blocks_message_loop_;
 
   // Contains the message loops of threads that have had at least one event
   // added into the local event buffer. Not using MessageLoopProxy 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.
   scoped_ptr<TraceBufferChunk> thread_shared_chunk_;
   size_t thread_shared_chunk_index_;
 
   // Set when asynchronous Flush is in progress.
   OutputCallback flush_output_callback_;
   scoped_refptr<MessageLoopProxy> flush_message_loop_proxy_;
   subtle::AtomicWord generation_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_