Add ability to specify extra browser args and a prefix for SKP names to webpages_playback.py

tools/skp/webpages_playback.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Archives or replays webpages and creates SKPs in a Google Storage location.
 
 To archive webpages and store SKP files (archives should be rarely updated):
 
 cd skia
@@ skipping 120 matching lines @@
   return s
 
 
 class SkPicturePlayback(object):
   """Class that archives or replays webpages and creates SKPs."""
 
   def __init__(self, parse_options):
     """Constructs a SkPicturePlayback BuildStep instance."""
     assert parse_options.browser_executable, 'Must specify --browser_executable'
     self._browser_executable = parse_options.browser_executable
+    self._browser_args = '--disable-setuid-sandbox'
+    if parse_options.browser_extra_args:
+      self._browser_args = '%s %s' % (
+          self._browser_args, parse_options.browser_extra_args)
 
     self._chrome_page_sets_path = os.path.join(parse_options.chrome_src_path,
                                                CHROMIUM_PAGE_SETS_PATH)
     self._all_page_sets_specified = parse_options.page_sets == 'all'
     self._page_sets = self._ParsePageSets(parse_options.page_sets)
 
     self._record = parse_options.record
     self._skia_tools = parse_options.skia_tools
     self._non_interactive = parse_options.non_interactive
     self._upload = parse_options.upload
+    self._skp_prefix = parse_options.skp_prefix
     data_store_location = parse_options.data_store
     if data_store_location.startswith(gs_utils.GS_PREFIX):
       self.gs = GoogleStorageDataStore(data_store_location)
     else:
       self.gs = LocalFileSystemDataStore(data_store_location)
     self._alternate_upload_dir = parse_options.alternate_upload_dir
     self._telemetry_binaries_dir = os.path.join(parse_options.chrome_src_path,
                                                 'tools', 'perf')
 
     self._local_skp_dir = os.path.join(
@@ skipping 79 matching lines @@
 
       if self._IsChromiumPageSet(page_set):
         print 'Using Chromium\'s captured archives for Chromium\'s page sets.'
       elif self._record:
         # Create an archive of the specified webpages if '--record=True' is
         # specified.
         record_wpr_cmd = (
           'PYTHONPATH=%s:$PYTHONPATH' % page_set_dir,
           'DISPLAY=%s' % X11_DISPLAY,
           os.path.join(self._telemetry_binaries_dir, 'record_wpr'),
-          '--extra-browser-args=--disable-setuid-sandbox',
+          '--extra-browser-args="%s"' % self._browser_args,
           '--browser=exact',
           '--browser-executable=%s' % self._browser_executable,
           '%s_page_set' % page_set_basename,
           '--page-set-base-dir=%s' % page_set_dir
         )
         for _ in range(RETRY_RECORD_WPR_COUNT):
           try:
             shell_utils.run(' '.join(record_wpr_cmd), shell=True)
 
             # Move over the created archive into the local webpages archive
@@ skipping 18 matching lines @@
 
       else:
         # Get the webpages archive so that it can be replayed.
         self._DownloadWebpagesArchive(wpr_data_file, page_set_json_name)
 
       run_benchmark_cmd = (
           'PYTHONPATH=%s:$PYTHONPATH' % page_set_dir,
           'DISPLAY=%s' % X11_DISPLAY,
           'timeout', '300',
           os.path.join(self._telemetry_binaries_dir, 'run_benchmark'),
-          '--extra-browser-args=--disable-setuid-sandbox',
+          '--extra-browser-args="%s"' % self._browser_args,
           '--browser=exact',
           '--browser-executable=%s' % self._browser_executable,
           SKP_BENCHMARK,
           '--page-set-name=%s' % page_set_basename,
           '--page-set-base-dir=%s' % page_set_dir,
           '--skp-outdir=%s' % TMP_SKP_DIR,
           '--also-run-disabled-tests'
       )
 
       for _ in range(RETRY_RUN_MEASUREMENT_COUNT):
@@ skipping 102 matching lines @@
     .skp in there to be this page_set's representative .skp.
     """
     subdirs = glob.glob(os.path.join(TMP_SKP_DIR, '*'))
     for site in subdirs:
       if self._IsChromiumPageSet(page_set):
         filename = self._GetChromiumSkpFileName(page_set, site)
       else:
         filename = self._GetSkiaSkpFileName(page_set)
       filename = filename.lower()
 
+      if self._skp_prefix:
+        filename = '%s%s' % (self._skp_prefix, filename)
+
       # We choose the largest .skp as the most likely to be interesting.
       largest_skp = max(glob.glob(os.path.join(site, '*.skp')),
                         key=lambda path: os.stat(path).st_size)
       dest = os.path.join(self._local_skp_dir, filename)
       print 'Moving', largest_skp, 'to', dest
       shutil.move(largest_skp, dest)
       self._skp_files.append(filename)
       shutil.rmtree(site)
 
   def _CreateLocalStorageDirs(self):
@@ skipping 117 matching lines @@
   option_parser.add_option(
       '', '--output_dir',
       help=('Temporary directory where SKPs and webpage archives will be '
             'outputted to.'),
       default=tempfile.gettempdir())
   option_parser.add_option(
       '', '--browser_executable',
       help='The exact browser executable to run.',
       default=None)
   option_parser.add_option(
+      '', '--browser_extra_args',
+      help='Additional arguments to pass to the browser.',
+      default=None)
+  option_parser.add_option(
       '', '--chrome_src_path',
       help='Path to the chromium src directory.',
       default=None)
   option_parser.add_option(
       '', '--non-interactive', action='store_true',
       help='Runs the script without any prompts. If this flag is specified and '
            '--skia_tools is specified then the debugger is not run.',
       default=False)
+  option_parser.add_option(
+      '', '--skp_prefix',
+      help='Prefix to add to the names of generated SKPs.',
+      default=None)
   options, unused_args = option_parser.parse_args()
 
   playback = SkPicturePlayback(options)
   sys.exit(playback.Run())