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

tools/android/loading/sandwich_task_builder.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 csv
 import json
 import os
 import shutil
 
 import chrome_cache
@@ skipping 19 matching lines @@
   def Transformer(runner):
     assert isinstance(runner, sandwich_runner.SandwichRunner)
     runner.network_condition = network_condition
   return Transformer
 
 
 class SandwichTaskBuilder(task_manager.Builder):
   """A builder for a graph of tasks, each prepares or invokes a SandwichRunner.
   """
 
-  def __init__(self, output_directory, android_device, job_path, url_repeat):
+  def __init__(self, output_directory, android_device, job_path):
     """Constructor.
 
     Args:
       output_directory: As in task_manager.Builder.__init__
       android_device: The android DeviceUtils to run sandwich on or None to run
         it locally.
       job_path: Path of the sandwich's job.
-      url_repeat: Non null integer controlling how many times the URLs should be
-        repeated in the benchmarks.
     """
     task_manager.Builder.__init__(self, output_directory)
     self._android_device = android_device
     self._job_path = job_path
-    self._url_repeat = url_repeat
     self._default_final_tasks = []
 
     self._original_wpr_task = None
     self._patched_wpr_task = None
     self._reference_cache_task = None
     self._subresources_for_urls_run_task = None
     self._subresources_for_urls_task = None
 
   @property
   def default_final_tasks(self):
@@ skipping 87 matching lines @@
 
     self._patched_wpr_task = BuildPatchedWpr
     self._reference_cache_task = BuildReferenceCache
     self._subresources_for_urls_run_task = UrlsResourcesRun
     self._subresources_for_urls_task = ListUrlsResources
 
     self._default_final_tasks.append(ValidateReferenceCache)
     return ValidateReferenceCache
 
   def PopulateLoadBenchmark(self, subresource_discoverer,
-                            runner_transformer_name, runner_transformer):
+                            runner_transformer_name, runner_transformers):
     """Populate benchmarking tasks from its setup tasks.
 
     Args:
       subresource_discoverer: Name of a subresources discoverer.
-      runner_transformer: A function that takes an instance of SandwichRunner as
-          parameter, would be applied immediately before SandwichRunner.Run().
       runner_transformer_name: Name of the runner transformer used to generate

[pasko, 2016/04/28 16:07:50]

nit: transformer_names: A string describing the transformers, will be used in
Task names (prefer names without spaces and special characters).

[gabadie, 2016/04/28 16:24:01]

Done.

           task names.
-      benchmark_name: The benchmark's name for that runner modifier.
+      runner_transformers: An ordered list of function that takes an instance of
+          SandwichRunner as parameter, would be applied immediately before
+          SandwichRunner.Run() in the given order.
 
     Here is the full dependency of the added tree for the returned task:
     <runner_transformer_name>/<subresource_discoverer>-metrics.csv
       depends on: <runner_transformer_name>/<subresource_discoverer>-run/
         depends on: common/<subresource_discoverer>-cache.zip
           depends on: some tasks saved by PopulateCommonPipelines()
           depends on: common/<subresource_discoverer>-setup.json
             depends on: some tasks saved by PopulateCommonPipelines()
 
     Returns:
@@ skipping 32 matching lines @@
       setup = json.load(open(SetupBenchmark.path))
       chrome_cache.ApplyUrlWhitelistToCacheArchive(
           cache_archive_path=self._reference_cache_task.path,
           whitelisted_urls=setup['cache_whitelist'],
           output_cache_archive_path=BuildBenchmarkCacheArchive.path)
 
     @self.RegisterTask(task_prefix + '-run/',
                        dependencies=[BuildBenchmarkCacheArchive])
     def RunBenchmark():
       runner = self._CreateSandwichRunner()
-      # runner.record_video = True
-      runner.job_repeat = self._url_repeat
-      runner_transformer(runner)
+      for runner_transformer in runner_transformers:
+        runner_transformer(runner)
       runner.wpr_archive_path = self._patched_wpr_task.path
       runner.wpr_out_log_path = os.path.join(RunBenchmark.path, 'wpr.log')
       runner.cache_archive_path = BuildBenchmarkCacheArchive.path
       runner.cache_operation = 'push'
       runner.trace_output_directory = RunBenchmark.path
       runner.Run()
 
     @self.RegisterTask(task_prefix + '-metrics.csv',
                        dependencies=[RunBenchmark])
     def ExtractMetrics():
       sandwich_misc.VerifyBenchmarkOutputDirectory(
           SetupBenchmark.path, RunBenchmark.path)
       trace_metrics_list = \
           sandwich_metrics.ExtractMetricsFromRunnerOutputDirectory(
               RunBenchmark.path)
       trace_metrics_list.sort(key=lambda e: e['repeat_id'])
       with open(ExtractMetrics.path, 'w') as csv_file:
         writer = csv.DictWriter(csv_file,
                                 fieldnames=sandwich_metrics.CSV_FIELD_NAMES)
         writer.writeheader()
         for trace_metrics in trace_metrics_list:
           writer.writerow(trace_metrics)
 
     self._default_final_tasks.append(ExtractMetrics)
     return ExtractMetrics