sandwich: Make speed-index and memory measurement optional from run-all

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 json
 import logging
 import os
 import shutil
 import sys
 import tempfile
 
 _SRC_DIR = os.path.abspath(os.path.join(
     os.path.dirname(__file__), '..', '..', '..'))
 
 sys.path.append(os.path.join(_SRC_DIR, 'third_party', 'catapult', 'devil'))
 from devil.android import device_utils
 
 import chrome_cache
 import controller
 import devtools_monitor
 import device_setup
 import loading_trace
 
 
 # Standard filenames in the sandwich runner's output directory.
 TRACE_FILENAME = 'trace.json'
 VIDEO_FILENAME = 'video.mp4'
 
-# List of selected trace event categories when running chrome.
-ADDITIONAL_CATEGORIES = (
-    'disabled-by-default-memory-infra',)  # Used by _GetBrowserDumpEvents()
+# Memory dump category used to get memory metrics.
+MEMORY_DUMP_CATEGORY = 'disabled-by-default-memory-infra'
 
 _JOB_SEARCH_PATH = 'sandwich_jobs'
 
 # Devtools timeout of 1 minute to avoid websocket timeout on slow
 # network condition.
 _DEVTOOLS_TIMEOUT = 60
 
 
 def _ReadUrlsFromJobDescription(job_name):
   """Retrieves the list of URLs associated with the job name."""
@@ skipping 75 matching lines @@
 
     # Output directory where to save the traces. Is str or None.
     self.trace_output_directory = None
 
     # List of urls to run.
     self.urls = []
 
     # Configures whether to record speed-index video.
     self.record_video = False
 
+    # Configures whether to record memory dumps.
+    self.record_memory_dumps = False
+
     # Path to the WPR archive to load or save. Is str or None.
     self.wpr_archive_path = None
 
     # Configures whether the WPR archive should be read or generated.
     self.wpr_record = False
 
     # The android DeviceUtils to run sandwich on or None to run it locally.
     self.android_device = None
 
     self._chrome_ctl = None
@@ skipping 45 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.trace_output_directory is not None and run_id is not None:
       run_path = os.path.join(self.trace_output_directory, str(run_id))
       if not os.path.isdir(run_path):
         os.makedirs(run_path)
     self._chrome_ctl.SetNetworkEmulation(
         self._GetEmulatorNetworkCondition('browser'))
+    additional_categories = \
+        [MEMORY_DUMP_CATEGORY] if self.record_memory_dumps else []

[pasko, 2016/04/28 15:04:59]

More straightforward and does not require awkward backslashes:

additional_categories = []
if self.record_memory_dump:
  additional_categories = [MEMORY_DUMP_CATEGORY]

[gabadie, 2016/04/28 15:56:22]

Done.

     # TODO(gabadie): add a way to avoid recording a trace.
     with self._chrome_ctl.Open() as connection:
       if clear_cache:
         connection.ClearCache()
       if run_path is not None and self.record_video:
         device = self._chrome_ctl.GetDevice()
-        assert device, 'Can only record video on a remote device.'
+        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=url,
               connection=connection,
               chrome_metadata=self._chrome_ctl.ChromeMetadata(),
-              additional_categories=ADDITIONAL_CATEGORIES,
+              additional_categories=additional_categories,
               timeout_seconds=_DEVTOOLS_TIMEOUT)
       else:
         trace = loading_trace.LoadingTrace.RecordUrlNavigation(
             url=url,
             connection=connection,
             chrome_metadata=self._chrome_ctl.ChromeMetadata(),
-            additional_categories=ADDITIONAL_CATEGORIES,
+            additional_categories=additional_categories,
             timeout_seconds=_DEVTOOLS_TIMEOUT)
     if run_path is not None:
       trace_path = os.path.join(run_path, TRACE_FILENAME)
       trace.ToJsonFile(trace_path)
 
   def _RunUrl(self, url, run_id):
     clear_cache = False
     if self.cache_operation == 'clear':
       clear_cache = True
     elif self.cache_operation == 'push':
@@ skipping 45 matching lines @@
           self._RunUrl(url, run_id=len(ran_urls))
           ran_urls.append(url)
 
     if self._local_cache_directory_path:
       shutil.rmtree(self._local_cache_directory_path)
       self._local_cache_directory_path = None
     if self.cache_operation == 'save':
       self._PullCacheFromDevice()
 
     self._chrome_ctl = None