[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};
 
+class HeapProfilerFilter : public TraceLog::TraceEventFilter {
+ public:
+  HeapProfilerFilter() {}
+
+  bool FilterTraceEvent(const TraceEvent& trace_event) const override {
+    // TODO(primiano): Add support for events with copied name crbug.com/581078
+    if (!(trace_event.flags() & TRACE_EVENT_FLAG_COPY)) {
+      if (AllocationContextTracker::capture_mode() ==
+          AllocationContextTracker::CaptureMode::PSEUDO_STACK) {
+        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());
+      }
+    }
+    // This predicate does not filter any events, but only records the events.
+    // So, it should return true iff the category is enabled for recoding.
+    return (*trace_event.category_group_enabled() &
+            TraceLog::ENABLED_FOR_RECORDING);
+  }
+  void EndEvent(const char* name, const char* category_group) override {
+    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 389 matching lines @@
   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()));
+      } else if (event_filter.predicate_name() == "heap_profiler_predicate") {
+        new_filter = WrapUnique(new 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 867 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