[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.

[Primiano Tucci (use gerrit), 2016/10/12 17:50:17]

I learned only recently that there is a macro for this:

TRACE_EVENT_WARMUP_CATEGORY(kTraceCategory)

while cleaning up things :)

[ssid, 2016/10/12 19:04:43]

Done.

+
+  // TODO(ssid): This should be done in EnableHeapProfiling so that we capture
+  // more allocations (crbug.com/625170).
+  // Adding filters if filtering was already enabled is not supported by
+  // TraceLog. So, in case of startup tracing filtering mode is not enabled.

[Primiano Tucci (use gerrit), 2016/10/12 17:50:17]

s/startup/background/ I think?

[ssid, 2016/10/12 19:04:43]

Actually this is not true. The first comment takes care of all the issues.

+  if (heap_profiling_enabled_ &&
+      !(TraceLog::GetInstance()->enabled_modes() & TraceLog::FILTERING_MODE)) {

[Primiano Tucci (use gerrit), 2016/10/12 17:50:17]

shouldn't you do all this only if enabled for pseudo stack, or do you want to
support hybrid modes soon?

[ssid, 2016/10/12 19:04:43]

Sorry this was mistake. That will be different patch.

+    TraceConfig::EventFilterConfig heap_profiler_filter_config(
+        TraceLog::TraceEventFilter::kHeapProfilerPredicate);
+    heap_profiler_filter_config.AddIncludedCategory("*");

[Primiano Tucci (use gerrit), 2016/10/12 17:50:17]

should you also include here disabled-by-default-* ? maybe in a separate patch
as we never tried that before :)

[ssid, 2016/10/12 19:04:43]

Currently we enable disabled-by-default categories by default for filtering. So,
this is not required.

+    heap_profiler_filter_config.AddIncludedCategory(
+        MemoryDumpManager::kTraceCategory);

[Primiano Tucci (use gerrit), 2016/10/12 17:50:17]

out of curiosity why do yo need to add memory-infra to the filter category list
itself?

[ssid, 2016/10/12 19:04:43]

In case in future we decide to have enabled-categories for filters like
recording mode categories, then we might not filter disabled-by-default
categories. If this filter does not return true for memory-infra and there is
some otehr filter that returns false for memory-infra then we will miss the
memory dumps from tracing. So, this makes sure that the dumps are added.

[oystein (OOO til 10th of July), 2016/10/13 00:34:29]

If this is just in-case we change this in the future, I would just add a comment
about it instead. 

+    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