customtabs: Add support for speculated_url in the benchmark scripts.

tools/android/customtabs_benchmark/scripts/customtabs_benchmark.py

 #!/usr/bin/python
 #
 # 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.
 
 """Loops Custom Tabs tests and outputs the results into a CSV file."""
 
 import collections
 import contextlib
@@ skipping 23 matching lines @@
 import device_setup
 
 
 # Local build of Chrome (not Chromium).
 _CHROME_PACKAGE = 'com.google.android.apps.chrome'
 _COMMAND_LINE_FILE = 'chrome-command-line'
 _TEST_APP_PACKAGE_NAME = 'org.chromium.customtabs.test'
 _INVALID_VALUE = -1
 
 
-def RunOnce(device, url, warmup, speculation_mode, delay_to_may_launch_url,
-            delay_to_launch_url, cold, chrome_args, reset_chrome_state):
+def RunOnce(device, url, speculated_url, warmup, speculation_mode,
+            delay_to_may_launch_url, delay_to_launch_url, cold, chrome_args,
+            reset_chrome_state):
   """Runs a test on a device once.
 
   Args:
     device: (DeviceUtils) device to run the tests on.
     url: (str) URL to load.
+    speculated_url: (str) Speculated URL.
     warmup: (bool) Whether to call warmup.
     speculation_mode: (str) Speculation Mode.
     delay_to_may_launch_url: (int) Delay to mayLaunchUrl() in ms.
     delay_to_launch_url: (int) Delay to launchUrl() in ms.
     cold: (bool) Whether the page cache should be dropped.
     chrome_args: ([str]) List of arguments to pass to Chrome.
     reset_chrome_state: (bool) Whether to reset the Chrome local state before
                         the run.
 
   Returns:
     The output line (str), like this (one line only):
     <warmup>,<prerender_mode>,<delay_to_may_launch_url>,<delay_to_launch>,
       <intent_sent_ms>,<page_load_started_ms>,<page_load_finished_ms>,
       <first_contentful_paint>
     or None on error.
   """
   if not device.HasRoot():
     device.EnableRoot()
 
   timeout_s = 20
   logcat_timeout = int(timeout_s + delay_to_may_launch_url / 1000.
                        + delay_to_launch_url / 1000.) + 3;
 
   with flag_changer.CustomCommandLineFlags(
       device, _COMMAND_LINE_FILE, chrome_args):
     launch_intent = intent.Intent(
         action='android.intent.action.MAIN',
         package=_TEST_APP_PACKAGE_NAME,
         activity='org.chromium.customtabs.test.MainActivity',
-        extras={'url': str(url), 'warmup': warmup,
+        extras={'url': str(url),
+                'speculated_url': str(speculated_url),
+                'warmup': warmup,
                 'speculation_mode': str(speculation_mode),
                 'delay_to_may_launch_url': delay_to_may_launch_url,
                 'delay_to_launch_url': delay_to_launch_url,
                 'timeout': timeout_s})
     result_line_re = re.compile(r'CUSTOMTABSBENCH.*: (.*)')
     logcat_monitor = device.GetLogcatMonitor(clear=True)
     logcat_monitor.Start()
     device.ForceStop(_CHROME_PACKAGE)
     device.ForceStop(_TEST_APP_PACKAGE_NAME)
 
@@ skipping 69 matching lines @@
               '--force-fieldtrials=trial/group',
               '--force-fieldtrial-params=trial.group:mode/no_state_prefetch',
               '--enable-features=NoStatePrefetch<trial'])
         elif config['speculation_mode'] == 'speculative_prefetch':
           # Speculative Prefetch is enabled through an experiment.
           chrome_args.extend([
               '--force-fieldtrials=trial/group',
               '--force-fieldtrial-params=trial.group:mode/external-prefetching',
               '--enable-features=SpeculativeResourcePrefetching<trial'])
 
-        result = RunOnce(device, config['url'], config['warmup'],
-                         config['speculation_mode'],
+        result = RunOnce(device, config['url'], config['speculated_url'],
+                         config['warmup'], config['speculation_mode'],
                          config['delay_to_may_launch_url'],
                          config['delay_to_launch_url'], config['cold'],
                          chrome_args, reset_chrome_state=True)
         if result is not None:
           out.write(result + '\n')
           out.flush()
         if once:
           return
         if should_stop is not None:
           should_stop.wait(10.)
@@ skipping 29 matching lines @@
   result['plt'] = data[:, 5]
   result['first_contentful_paint'] = data[:, 6]
   return result
 
 
 def _CreateOptionParser():
   parser = optparse.OptionParser(description='Loops Custom Tabs tests on a '
                                  'device, and outputs the navigation timings '
                                  'in a CSV file.')
   parser.add_option('--device', help='Device ID')
+  parser.add_option('--speculated_url',
+                    help='URL to call mayLaunchUrl() with.',)
   parser.add_option('--url', help='URL to navigate to.',
                     default='https://www.android.com')
   parser.add_option('--warmup', help='Call warmup.', default=False,
                     action='store_true')
   parser.add_option('--speculation_mode', default='prerender',
                     help='The speculation mode (prerender, '
                     'speculative_prefetch or no_state_prefetch).',
                     choices=['disabled', 'prerender', 'hidden_tab'])
   parser.add_option('--delay_to_may_launch_url',
                     help='Delay before calling mayLaunchUrl() in ms.',
@@ skipping 51 matching lines @@
     sys.exit(0)
   if options.device is not None:
     matching_devices = [d for d in devices if str(d) == options.device]
     if not matching_devices:
       logging.error('Device not found.')
       sys.exit(0)
     device = matching_devices[0]
 
   config = {
       'url': options.url,
+      'speculated_url': options.speculated_url or options.url,
       'warmup': options.warmup,
       'speculation_mode': options.speculation_mode,
       'delay_to_may_launch_url': options.delay_to_may_launch_url,
       'delay_to_launch_url': options.delay_to_launch_url,
       'cold': options.cold,
   }
   LoopOnDevice(device, [config], options.output_file, options.wpr_archive,
                options.record, options.network_condition, options.wpr_log,
                once=options.once)
 
 
 if __name__ == '__main__':
   main()