[tracing] Add filtering mode in TraceLog

base/trace_event/memory_dump_manager.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/memory_dump_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/allocator/features.h"
@@ skipping 183 matching lines @@
 // Enable the core dump providers.
 #if defined(MALLOC_MEMORY_TRACING_SUPPORTED)
   RegisterDumpProvider(MallocDumpProvider::GetInstance(), "Malloc", nullptr);
 #endif
 
 #if defined(OS_ANDROID)
   RegisterDumpProvider(JavaHeapDumpProvider::GetInstance(), "JavaHeap",
                        nullptr);
 #endif
 
+  TRACE_EVENT0(kTraceCategory, "init");  // Add to trace-viewer category list.
+
+  // TODO(ssid): This should be done in EnableHeapProfiling so that we capture
+  // more allocations (crbug.com/625170).
+  if (heap_profiling_enabled_ &&
+      !TraceLog::GetInstance()->HaveActiveFilters()) {

[Primiano Tucci (use gerrit), 2016/09/23 18:34:31]

can you expand what is the sense of the HaveActiveFilters() check here?

[ssid, 2016/09/26 18:39:53]

So, filters are a list and adding more objects to list while trace events are
accessing this list from other threads causes races. So, adding / removing
filters while filters were enabled is not supported. This would happen if
startup tracing config has filters enabled and this filters will not get added.
So, we can't support the case where we start with startup tracing and try
tracing again with chrome://tracing.

+    TraceConfig::EventFilterConfig heap_profiler_filter_config(
+        TraceLog::TraceEventFilter::kHeapProfilerPredicate);
+    heap_profiler_filter_config.AddIncludedCategory("*");
+    heap_profiler_filter_config.AddIncludedCategory(
+        MemoryDumpManager::kTraceCategory);
+    TraceConfig::EventFilters filters;
+    filters.push_back(heap_profiler_filter_config);
+    TraceConfig filtering_trace_config;
+    filtering_trace_config.SetEventFilterConfigs(filters);
+    TraceLog::GetInstance()->SetEnabled(filtering_trace_config,
+                                        TraceLog::FILTERING_MODE);
+  }
+
   // If tracing was enabled before initializing MemoryDumpManager, we missed the
   // OnTraceLogEnabled() event. Synthetize it so we can late-join the party.
-  bool is_tracing_already_enabled = TraceLog::GetInstance()->IsEnabled();
-  TRACE_EVENT0(kTraceCategory, "init");  // Add to trace-viewer category list.
+  bool tracing_already_enabled = TraceLog::GetInstance()->IsEnabled();
   TraceLog::GetInstance()->AddEnabledStateObserver(this);
-  if (is_tracing_already_enabled)
+  if (tracing_already_enabled)
     OnTraceLogEnabled();
 }
 
 void MemoryDumpManager::RegisterDumpProvider(
     MemoryDumpProvider* mdp,
     const char* name,
     scoped_refptr<SingleThreadTaskRunner> task_runner,
     MemoryDumpProvider::Options options) {
   options.dumps_on_single_thread_task_runner = true;
   RegisterDumpProviderInternal(mdp, name, std::move(task_runner), options);
@@ skipping 645 matching lines @@
   if (heavy_dump_rate_ > 0 && periodic_dumps_count_ % heavy_dump_rate_ == 0)
     level_of_detail = MemoryDumpLevelOfDetail::DETAILED;
   ++periodic_dumps_count_;
 
   MemoryDumpManager::GetInstance()->RequestGlobalDump(
       MemoryDumpType::PERIODIC_INTERVAL, level_of_detail);
 }
 
 }  // namespace trace_event
 }  // namespace base