Tracing pre-filtering

base/trace_event/trace_log.h

Index: base/trace_event/trace_log.h
diff --git a/base/trace_event/trace_log.h b/base/trace_event/trace_log.h
index e4407e81bdcf35c7e1d793bd8b397ddaa4a193c7..08f5378bb3e239941399129861afcbc5ec6990e6 100644
--- a/base/trace_event/trace_log.h
+++ b/base/trace_event/trace_log.h
@@ -60,7 +60,9 @@ class BASE_EXPORT TraceLog : public MemoryDumpProvider {
     // 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
+    ENABLED_FOR_ETW_EXPORT = 1 << 3,
+    // TODO description

[Primiano Tucci (use gerrit), 2016/05/27 17:47:06]

mind the todo :)

+    ENABLED_FOR_FILTERING = 1 << 4
   };
 
   static TraceLog* GetInstance();
@@ -286,6 +288,10 @@ class BASE_EXPORT TraceLog : public MemoryDumpProvider {
                                 const char* name,
                                 TraceEventHandle handle);
 
+  void EndFilteredEvent(const unsigned char* category_group_enabled,
+                        const char* name,
+                        TraceEventHandle handle);
+
   // For every matching event, the callback will be called.
   typedef base::Callback<void()> WatchEventCallback;
   void SetWatchEvent(const std::string& category_name,
@@ -306,6 +312,21 @@ class BASE_EXPORT TraceLog : public MemoryDumpProvider {
   // Allows deleting our singleton instance.
   static void DeleteForTesting();
 
+  class TraceEventFilter {
+   public:
+    TraceEventFilter() {}
+    virtual ~TraceEventFilter() {}
+    virtual bool FilterTraceEvent(const TraceEvent& trace_event) const = 0;

[Primiano Tucci (use gerrit), 2016/05/31 15:41:24]

Maybe call these
// Returns true if the event should be appended to the buffer, false if should
be discarded.
bool OnEventBegin(..)

// ... only for duration events.
void OnDurationEventEnd() {}

so it's more clear they are callbacks when you see their implementation.

Also I'm not sure you want to make the method const. This enforces that the
overriding class shall not change its state when filtering events. But they
might need to do that (e.g. to implement hit-count filtering) no?

+    virtual void EndEvent(const char* category_group, const char* name) {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(TraceEventFilter);
+  };
+  typedef std::unique_ptr<TraceEventFilter> (
+      *TraceEventFilterConstructorForTesting)(void);
+  static void SetTraceEventFilterConstructorForTesting(
+      TraceEventFilterConstructorForTesting predicate);
+
   // Allow tests to inspect TraceEvents.
   TraceEvent* GetEventByHandle(TraceEventHandle handle);