[memory_infra] Fix trace rerun options in memory benchmarks

tools/perf/benchmarks/memory_infra.py

 # 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.
 
 import re
 
 from core import perf_benchmark
 
 from telemetry import benchmark
 from telemetry.timeline import tracing_category_filter
@@ skipping 22 matching lines @@
     # Enable only memory-infra, to get memory dumps, and blink.console, to get
     # the timeline markers used for mapping threads to tabs.
     trace_memory = tracing_category_filter.TracingCategoryFilter(
         filter_string='-*,blink.console,disabled-by-default-memory-infra')
     tbm_options = timeline_based_measurement.Options(
         overhead_level=trace_memory)
     tbm_options.config.enable_android_graphics_memtrack = True
     return tbm_options
 
   @classmethod
-  def HasBenchmarkTraceRerunDebugOption(cls):
+  def HasTraceRerunDebugOption(cls):

[perezju, 2016/03/10 13:45:47]

The bug was caused by this method having the wrong name.

     return True
 
   def SetupBenchmarkDefaultTraceRerunOptions(self, tbm_options):
-    # TODO(perezju): Call this function for TBM benchmarks: crbug.com/593678
     tbm_options.SetLegacyTimelineBasedMetrics((
         memory_timeline.MemoryTimelineMetric(),
     ))
 
 
 # TODO(bashi): Workaround for http://crbug.com/532075
 # @benchmark.Enabled('android') shouldn't be needed.
 @benchmark.Enabled('android')
 class MemoryHealthPlan(_MemoryInfra):
   """Timeline based benchmark for the Memory Health Plan."""
@@ skipping 73 matching lines @@
 
   def CreateTimelineBasedMeasurementOptions(self):
     v8_categories = [
         'blink.console', 'renderer.scheduler', 'v8', 'webkit.console']
     memory_categories = 'blink.console,disabled-by-default-memory-infra'
     category_filter = tracing_category_filter.TracingCategoryFilter(
         memory_categories)
     for category in v8_categories:
       category_filter.AddIncludedCategory(category)
     options = timeline_based_measurement.Options(category_filter)
-    options.SetLegacyTimelineBasedMetrics([
+    return options
+
+  def SetupBenchmarkDefaultTraceRerunOptions(self, tbm_options):
+    tbm_options.SetLegacyTimelineBasedMetrics((
         v8_gc_latency.V8GCLatency(),
-        memory_timeline.MemoryTimelineMetric()])
-    return options
+        memory_timeline.MemoryTimelineMetric(),
+    ))

[nednguyen, 2016/03/10 16:33:32]

We also need to set the categories properly, I think?

[perezju, 2016/03/14 11:55:03]

So, you mean all of the code to set category filters from
CreateTimelineBasedMeasurementOptions should be moved into
SetupBenchmarkDefaultTraceRerunOptions?

I understand the idea is that when passing --rerun-with-debug-trace (when
SetupBenchmarkDefaultTraceRerunOptions is *not* called) we don't exclude as much
categories/metrics, etc. But I'm not quite sure as to what should be passed in
either case to ensure memory infra is still always enabled.

cc'ing Primiano to help us figure this one out.

[nednguyen, 2016/03/14 15:10:49]

Ah, I just look at the code. It looks like you don't need to anything else,
since this method is for adding more options to the non-debug one: 
https://github.com/catapult-project/catapult/blob/master/telemetry/telemetry/...

So I think you can leave this function as-is, or override it only if you want
more metrics/categories enabled.

 
   @classmethod
   def Name(cls):
     return 'memory.long_running_idle_gmail_tbm'
 
   @classmethod
   def ShouldTearDownStateAfterEachStoryRun(cls):
     return True