Set tracing categories explicitly in Clovis and Sandwich

tools/android/loading/sandwich_runner.py

 # Copyright 2016 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 logging
 import os
 import shutil
 import sys
 import tempfile
 
@@ skipping 15 matching lines @@
 VIDEO_FILENAME = 'video.mp4'
 WPR_LOG_FILENAME = 'wpr.log'
 
 # Memory dump category used to get memory metrics.
 MEMORY_DUMP_CATEGORY = 'disabled-by-default-memory-infra'
 
 # Devtools timeout of 1 minute to avoid websocket timeout on slow
 # network condition.
 _DEVTOOLS_TIMEOUT = 60
 
+# Categories to enable or disable for all traces collected. Disabled categories
+# are prefixed with '-'.
+_TRACING_CATEGORIES = [
+  'blink',
+  'blink.net',
+  'blink.user_timing',
+  'devtools.timeline',
+  'java',
+  'toplevel',
+  'v8',
+  '-cc',  # A lot of unnecessary events are enabled by default in "cc".
+]

[gabadie, 2016/06/06 16:17:30]

We might probably be able to get rid of devtools.timeline, v8, toplevel and
java. Or have I missed something?

Can be deferred to a separate CL.

[pasko, 2016/06/06 17:30:52]

If we remove toplevel, we would not be able to reason about what happened by
looking at the traces in the traceviewer.

Same for v8: it tells us when the blink thread was busy executing javascript,
which is an important bit of data.

as for 'java' - I did not see any events in our traces in this category, which
means:
1. there is probably a bug somewhere
2. we can easily remove it

I just removed it in the next patchset.

[gabadie, 2016/06/06 17:37:10]

Nice.

 
 def _CleanArtefactsFromPastRuns(output_directories_path):
   """Cleans artifacts generated from past run in the output directory.
 
   Args:
     output_directories_path: The output directory path where to clean the
         previous traces.
   """
   for dirname in os.listdir(output_directories_path):
     directory_path = os.path.join(output_directories_path, dirname)
@@ skipping 93 matching lines @@
       run_id: Id of the run in the output directory. If it is None, then no
         trace or video will be saved.
     """
     run_path = None
     if self.output_dir is not None and run_id is not None:
       run_path = os.path.join(self.output_dir, str(run_id))
       if not os.path.isdir(run_path):
         os.makedirs(run_path)
     self._chrome_ctl.SetNetworkEmulation(
         self._GetEmulatorNetworkCondition('browser'))
-    additional_categories = []
+    categories = _TRACING_CATEGORIES
     if self.record_memory_dumps:
-      additional_categories = [MEMORY_DUMP_CATEGORY]
+      categories += [MEMORY_DUMP_CATEGORY]
     # TODO(gabadie): add a way to avoid recording a trace.
     with self._chrome_ctl.Open() as connection:
       if clear_cache:
         connection.ClearCache()
+
+      # Binds all parameters of RecordUrlNavigation() to avoid repetition.
+      def RecordTrace():
+        return loading_trace.LoadingTrace.RecordUrlNavigation(
+            url=self.url,
+            connection=connection,
+            chrome_metadata=self._chrome_ctl.ChromeMetadata(),
+            categories=categories,
+            timeout_seconds=_DEVTOOLS_TIMEOUT)
+
       if run_path is not None and self.record_video:
         device = self._chrome_ctl.GetDevice()
         if device is None:
           raise RuntimeError('Can only record video on a remote device.')
         video_recording_path = os.path.join(run_path, VIDEO_FILENAME)
         with device_setup.RemoteSpeedIndexRecorder(device, connection,
                                                    video_recording_path):
-          trace = loading_trace.LoadingTrace.RecordUrlNavigation(
-              url=self.url,
-              connection=connection,
-              chrome_metadata=self._chrome_ctl.ChromeMetadata(),
-              additional_categories=additional_categories,
-              timeout_seconds=_DEVTOOLS_TIMEOUT)
+          trace = RecordTrace()
       else:
-        trace = loading_trace.LoadingTrace.RecordUrlNavigation(
-            url=self.url,
-            connection=connection,
-            chrome_metadata=self._chrome_ctl.ChromeMetadata(),
-            additional_categories=additional_categories,
-            timeout_seconds=_DEVTOOLS_TIMEOUT)
+        trace = RecordTrace()
     if run_path is not None:
       trace_path = os.path.join(run_path, TRACE_FILENAME)
       trace.ToJsonFile(trace_path)
 
   def _RunUrl(self, run_id):
     for attempt_id in xrange(self._ATTEMPT_COUNT):
       try:
         self._chrome_ctl.ResetBrowserState()
         clear_cache = False
         if self.cache_operation == CacheOperation.CLEAR:
@@ skipping 82 matching lines @@
     if not os.path.isdir(repeat_dir):
       continue
     try:
       repeat_id = int(node_name)
     except ValueError:
       continue
     yield repeat_id, repeat_dir
     repeated_run_count += 1
   assert repeated_run_count > 0, ('Error: not a sandwich runner output '
                                   'directory: {}').format(runner_output_dir)