tools: Local tests for the speculative prefetch predictor.

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
 import logging
 import optparse
 import os
 import random
 import re
 import subprocess
 import sys
 import time
 
@@ skipping 12 matching lines @@
 sys.path.append(os.path.join(_SRC_PATH, 'tools', 'android', 'loading'))
 import device_setup
 
 
 # Local build of Chrome (not Chromium).
 _CHROME_PACKAGE = 'com.google.android.apps.chrome'
 _COMMAND_LINE_PATH = '/data/local/tmp/chrome-command-line'
 _TEST_APP_PACKAGE_NAME = 'org.chromium.customtabsclient.test'
 
 # Command line arguments for Chrome.
-_CHROME_ARGS = [
+CHROME_ARGS = [
     # Disable backgound network requests that may pollute WPR archive, pollute
     # HTTP cache generation, and introduce noise in loading performance.
     '--disable-background-networking',
     '--disable-default-apps',
     '--no-proxy-server',
     # TODO(droger): Remove once crbug.com/354743 is fixed.
     '--safebrowsing-disable-auto-update',
 
     # Disables actions that chrome performs only on first run or each launches,
     # which can interfere with page load performance, or even block its
     # execution by waiting for user input.
     '--disable-fre',
     '--no-default-browser-check',
     '--no-first-run',
 ]
 
 
 def ResetChromeLocalState(device):
   """Remove the Chrome Profile and the various disk caches."""
   profile_dirs = ['app_chrome/Default', 'cache', 'app_chrome/ShaderCache',
                   'app_tabs']
   cmd = ['rm', '-rf']
   cmd.extend(
       '/data/data/{}/{}'.format(_CHROME_PACKAGE, d) for d in profile_dirs)
   device.adb.Shell(subprocess.list2cmdline(cmd))
 
 
 def RunOnce(device, url, warmup, speculation_mode, delay_to_may_launch_url,
-            delay_to_launch_url, cold, chrome_args):
+            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.
     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()
@@ skipping 11 matching lines @@
                 '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)
 
-    ResetChromeLocalState(device)
+    if reset_chrome_state:
+      ResetChromeLocalState(device)
 
     if cold:
       cache_control.CacheControl(device).DropRamCaches()
 
     device.StartActivity(launch_intent, blocking=True)
 
     match = None
     try:
       match = logcat_monitor.WaitFor(result_line_re, timeout=logcat_timeout)
     except device_errors.CommandTimeoutError as _:
       logging.warning('Timeout waiting for the result line')
     logcat_monitor.Stop()
     logcat_monitor.Close()
     return match.group(1) if match is not None else None
 
 
+Result = collections.namedtuple('Result', ['warmup', 'speculation_mode',
+                                           'delay_to_may_launch_url',
+                                           'delay_to_launch_url',
+                                           'commit', 'plt',
+                                           'first_contentful_paint'])
+
+
+def ParseResult(result_line):
+  """Parses a result line, and returns it.
+
+  Args:
+    result_line: (str) A result line, as returned by RunOnce().
+
+  Returns:
+    An instance of Result.
+  """
+  tokens = result_line.strip().split(',')
+  assert len(tokens) == 8
+  intent_sent_timestamp = int(tokens[4])
+  return Result(bool(tokens[0]), tokens[1], int(tokens[2]), int(tokens[3]),
+                int(tokens[5]) - intent_sent_timestamp,
+                int(tokens[6]) - intent_sent_timestamp, int(tokens[7]))
+
+
 def LoopOnDevice(device, configs, output_filename, wpr_archive_path=None,
                  wpr_record=None, network_condition=None, wpr_log_path=None,
                  once=False, should_stop=None):
   """Loops the tests on a device.
 
   Args:
     device: (DeviceUtils) device to run the tests on.
     configs: ([dict])
     output_filename: (str) Output filename. '-' for stdout.
     wpr_archive_path: (str) Path to the WPR archive.
@@ skipping 10 matching lines @@
     try:
       while should_stop is None or not should_stop.is_set():
         config = configs[random.randint(0, len(configs) - 1)]
         chrome_args = _CHROME_ARGS + wpr_attributes.chrome_args
         if config['speculation_mode'] == 'no_state_prefetch':
           chrome_args.append('--prerender=prefetch')
         result = RunOnce(device, config['url'], config['warmup'],
                          config['speculation_mode'],
                          config['delay_to_may_launch_url'],
                          config['delay_to_launch_url'], config['cold'],
-                         chrome_args)
+                         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.)
         else:
           time.sleep(10)
     finally:
@@ skipping 111 matching lines @@
       '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()