[tracing] Add trace events filtering predicate for heap profiler

base/trace_event/trace_log.cc

 // 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.
 
 #include "base/trace_event/trace_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ skipping 115 matching lines @@
   }
 
  private:
   std::unordered_set<std::string> whitelist_;
 };
 
 base::LazyInstance<
     std::list<std::unique_ptr<TraceLog::TraceEventFilter>>>::Leaky
     g_category_group_filter[MAX_CATEGORY_GROUPS] = {LAZY_INSTANCE_INITIALIZER};
 
+// This filter is used to record trace events as pseudo stack for the heap
+// profiler. It does not filter-out any events from the trace, ie. the behavior
+// of trace events being added to TraceLog remains same: the events are added
+// iff enabled for recording and not filtered-out by any other filter.
+class HeapProfilerFilter : public TraceLog::TraceEventFilter {
+ public:
+  HeapProfilerFilter() {}
+
+  bool FilterTraceEvent(const TraceEvent& trace_event) const override {
+    if (AllocationContextTracker::capture_mode() !=
+        AllocationContextTracker::CaptureMode::PSEUDO_STACK) {
+      return true;
+    }
+
+    // TODO(primiano): Add support for events with copied name crbug.com/581079.
+    if (trace_event.flags() & TRACE_EVENT_FLAG_COPY)
+      return true;
+
+    if (trace_event.phase() == TRACE_EVENT_PHASE_BEGIN ||
+        trace_event.phase() == TRACE_EVENT_PHASE_COMPLETE) {
+      AllocationContextTracker::GetInstanceForCurrentThread()
+          ->PushPseudoStackFrame(trace_event.name());
+    } else if (trace_event.phase() == TRACE_EVENT_PHASE_END) {
+      // The pop for |TRACE_EVENT_PHASE_COMPLETE| events is in |EndEvent|.
+      AllocationContextTracker::GetInstanceForCurrentThread()
+          ->PopPseudoStackFrame(trace_event.name());
+    }
+    // Do not filter-out any events and always return true. TraceLog adds the
+    // event only if it is enabled for recording.
+    return true;
+  }
+
+  void EndEvent(const char* name, const char* category_group) override {
+    if (AllocationContextTracker::capture_mode() ==
+        AllocationContextTracker::CaptureMode::PSEUDO_STACK) {
+      AllocationContextTracker::GetInstanceForCurrentThread()
+          ->PopPseudoStackFrame(name);
+    }
+  }
+};
+
 TraceLog::TraceEventFilterConstructorForTesting
     g_trace_event_filter_constructor_for_testing = nullptr;
 
 // Indexes here have to match the g_category_groups array indexes above.
 const int kCategoryAlreadyShutdown = 1;
 const int kCategoryCategoriesExhausted = 2;
 const int kCategoryMetadata = 3;
 const int kNumBuiltinCategories = 4;
 // Skip default categories.
 base::subtle::AtomicWord g_category_index = kNumBuiltinCategories;
@@ skipping 386 matching lines @@
 
   // Having a filter is an exceptional case, so we avoid
   // the LazyInstance creation in the common case.
   if (!(g_category_group_filter[category_index] == nullptr))
     g_category_group_filter[category_index].Get().clear();
 
   for (const auto& event_filter : trace_config_.event_filters()) {
     if (event_filter.IsCategoryGroupEnabled(category_group)) {
       std::unique_ptr<TraceEventFilter> new_filter;
 
-      if (event_filter.predicate_name() == "event_whitelist_predicate") {
-        new_filter =
-            WrapUnique(new EventNameFilter(event_filter.filter_args()));
+      if (event_filter.predicate_name() ==
+          TraceEventFilter::kEventWhitelistPredicate) {
+        new_filter = MakeUnique<EventNameFilter>(event_filter.filter_args());
+      } else if (event_filter.predicate_name() ==
+                 TraceEventFilter::kHeapProfilerPredicate) {
+        new_filter = MakeUnique<HeapProfilerFilter>();
       } else if (event_filter.predicate_name() == "testing_predicate") {
         CHECK(g_trace_event_filter_constructor_for_testing);
         new_filter = g_trace_event_filter_constructor_for_testing();
       }
 
       if (new_filter) {
         g_category_group_filter[category_index].Get().push_back(
             std::move(new_filter));
         enabled_flag |= ENABLED_FOR_FILTERING;
       }
@@ skipping 780 matching lines @@
   // This is done sooner rather than later, to avoid creating the event and
   // acquiring the lock, which is not needed for ETW as it's already threadsafe.
   if (*category_group_enabled & ENABLED_FOR_ETW_EXPORT)
     TraceEventETWExport::AddEvent(phase, category_group_enabled, name, id,
                                   num_args, arg_names, arg_types, arg_values,
                                   convertable_values);
 #endif  // OS_WIN
 
   std::string console_message;
   std::unique_ptr<TraceEvent> filtered_trace_event;
+  bool disabled_by_filters = false;
   if (*category_group_enabled & ENABLED_FOR_FILTERING) {
     std::unique_ptr<TraceEvent> new_trace_event(new TraceEvent);
     new_trace_event->Initialize(thread_id, offset_event_timestamp, thread_now,
                                 phase, category_group_enabled, name, scope, id,
                                 bind_id, num_args, arg_names, arg_types,
                                 arg_values, convertable_values, flags);
 
     auto filter_list = GetCategoryGroupFilter(category_group_enabled);
     DCHECK(!filter_list->empty());
 
-    bool should_add_event = false;
+    disabled_by_filters = true;
     for (const auto& trace_event_filter : *filter_list) {
       if (trace_event_filter->FilterTraceEvent(*new_trace_event))
-        should_add_event = true;
+        disabled_by_filters = false;
     }
 
-    if (should_add_event)
+    if (!disabled_by_filters)
       filtered_trace_event = std::move(new_trace_event);
   }
 
-  // Add the trace event if we're either *just* recording (and not filtering)
-  // or if we one of our filters indicates the event should be added.
-  if (((*category_group_enabled & ENABLED_FOR_RECORDING) &&
-       (*category_group_enabled & ENABLED_FOR_FILTERING) == 0) ||
-      filtered_trace_event) {
+  // If enabled for recording, the event should be added only if one of the
+  // filters indicates or category is not enabled for filtering.
+  if ((*category_group_enabled & ENABLED_FOR_RECORDING) &&
+      !disabled_by_filters) {
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = NULL;
     if (thread_local_event_buffer) {
       trace_event = thread_local_event_buffer->AddTraceEvent(&handle);
     } else {
       lock.EnsureAcquired();
       trace_event = AddEventToThreadSharedChunkWhileLocked(&handle, true);
     }
 
@@ skipping 42 matching lines @@
         subtle::NoBarrier_Load(&event_callback_));
     if (event_callback) {
       event_callback(
           offset_event_timestamp,
           phase == TRACE_EVENT_PHASE_COMPLETE ? TRACE_EVENT_PHASE_BEGIN : phase,
           category_group_enabled, name, scope, id, num_args, arg_names,
           arg_types, arg_values, flags);
     }
   }
 
-  // TODO(primiano): Add support for events with copied name crbug.com/581078
-  if (!(flags & TRACE_EVENT_FLAG_COPY)) {
-    if (AllocationContextTracker::capture_mode() ==
-        AllocationContextTracker::CaptureMode::PSEUDO_STACK) {
-      if (phase == TRACE_EVENT_PHASE_BEGIN ||
-          phase == TRACE_EVENT_PHASE_COMPLETE) {
-        AllocationContextTracker::GetInstanceForCurrentThread()
-            ->PushPseudoStackFrame(name);
-      } else if (phase == TRACE_EVENT_PHASE_END) {
-        // The pop for |TRACE_EVENT_PHASE_COMPLETE| events
-        // is in |TraceLog::UpdateTraceEventDuration|.
-        AllocationContextTracker::GetInstanceForCurrentThread()
-            ->PopPseudoStackFrame(name);
-      }
-    }
-  }
-
   return handle;
 }
 
 void TraceLog::AddMetadataEvent(
     const unsigned char* category_group_enabled,
     const char* name,
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
@@ skipping 111 matching lines @@
       trace_event->UpdateDuration(now, thread_now);
 #if defined(OS_ANDROID)
       trace_event->SendToATrace();
 #endif
     }
 
     if (trace_options() & kInternalEchoToConsole) {
       console_message =
           EventToConsoleMessage(TRACE_EVENT_PHASE_END, now, trace_event);
     }
-
-    if (AllocationContextTracker::capture_mode() ==
-        AllocationContextTracker::CaptureMode::PSEUDO_STACK) {
-      // The corresponding push is in |AddTraceEventWithThreadIdAndTimestamp|.
-      AllocationContextTracker::GetInstanceForCurrentThread()
-          ->PopPseudoStackFrame(name);
-    }
   }
 
   if (!console_message.empty())
     LOG(ERROR) << console_message;
 
   if (category_group_enabled_local & ENABLED_FOR_EVENT_CALLBACK) {
     EventCallback event_callback = reinterpret_cast<EventCallback>(
         subtle::NoBarrier_Load(&event_callback_));
     if (event_callback) {
       event_callback(
@@ skipping 287 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
                                                 event_handle_);
   }
 }
 
 }  // namespace trace_event_internal