sandwich: Refactor to use more existing code.

tools/android/loading/run_sandwich.py

 #! /usr/bin/env python
 # 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.
 
 """Instructs Chrome to load series of web pages and reports results.
 
 When running Chrome is sandwiched between preprocessed disk caches and
 WepPageReplay serving all connections.
 
@@ skipping 17 matching lines @@
 
 sys.path.append(os.path.join(_SRC_DIR, 'third_party', 'catapult', 'devil'))
 from devil.android import device_utils
 
 sys.path.append(os.path.join(_SRC_DIR, 'build', 'android'))
 from pylib import constants
 import devil_chromium
 
 import device_setup
 import devtools_monitor
-import json
+import options
 import page_track
 import pull_sandwich_metrics
+import trace_recorder
 import tracing
 
 
+# Use options layer to access contants.

[Benoit L, 2016/02/22 10:26:13]

nit: s/contants/constants/

[gabadie, 2016/02/22 11:05:06]

Done.

+OPTIONS = options.OPTIONS
+
 _JOB_SEARCH_PATH = 'sandwich_jobs'
 
 # Directory name under --output to save the cache from the device.
 _CACHE_DIRECTORY_NAME = 'cache'
 
 # Name of cache subdirectory on the device where the cache index is stored.
 _INDEX_DIRECTORY_NAME = 'index-dir'
 
 # Name of the file containing the cache index. This file is stored on the device
 # in the cache directory under _INDEX_DIRECTORY_NAME.
 _REAL_INDEX_FILE_NAME = 'the-real-index'
 
-# Name of the chrome package.
-_CHROME_PACKAGE = (
-    constants.PACKAGE_INFO[device_setup.DEFAULT_CHROME_PACKAGE].package)
-
 # An estimate of time to wait for the device to become idle after expensive
 # operations, such as opening the launcher activity.
 _TIME_TO_DEVICE_IDLE_SECONDS = 2
 
-# Cache directory's path on the device.
-_REMOTE_CACHE_DIRECTORY = '/data/data/' + _CHROME_PACKAGE + '/cache/Cache'
+
+def _RemoteCacheDirectory():
+  return '/data/data/{}/cache/Cache'.format(OPTIONS.chrome_package_name)
 
 
 def _ReadUrlsFromJobDescription(job_name):
   """Retrieves the list of URLs associated with the job name."""
   try:
     # Extra sugar: attempt to load from a relative path.
     json_file_name = os.path.join(os.path.dirname(__file__), _JOB_SEARCH_PATH,
         job_name)
     with open(json_file_name) as f:
       json_data = json.load(f)
   except IOError:
     # Attempt to read by regular file name.
     with open(job_name) as f:
       json_data = json.load(f)
 
   key = 'urls'
   if json_data and key in json_data:
     url_list = json_data[key]
     if isinstance(url_list, list) and len(url_list) > 0:
       return url_list
   raise Exception('Job description does not define a list named "urls"')
 
 
-def _SaveChromeTrace(events, target_directory):
-  """Saves the trace events, ignores IO errors.
-
-  Args:
-    events: a dict as returned by TracingTrack.ToJsonDict()
-    target_directory: Directory path where trace is created.
-  """
-  filename = os.path.join(target_directory, 'trace.json')
-  try:
-    os.makedirs(target_directory)
-    with open(filename, 'w') as f:
-      json.dump({'traceEvents': events['events'], 'metadata': {}}, f, indent=2)
-  except IOError:
-    logging.warning('Could not save a trace: %s' % filename)
-    # Swallow the exception.
-
-
 def _UpdateTimestampFromAdbStat(filename, stat):
   os.utime(filename, (stat.st_time, stat.st_time))
 
 
 def _AdbShell(adb, cmd):
   adb.Shell(subprocess.list2cmdline(cmd))
 
 
 def _AdbUtime(adb, filename, timestamp):
   """Adb equivalent of os.utime(filename, (timestamp, timestamp))
   """
   touch_stamp = datetime.fromtimestamp(timestamp).strftime('%Y%m%d.%H%M%S')
   _AdbShell(adb, ['touch', '-t', touch_stamp, filename])
 
 
 def _PullBrowserCache(device):
   """Pulls the browser cache from the device and saves it locally.
 
   Cache is saved with the same file structure as on the device. Timestamps are
   important to preserve because indexing and eviction depends on them.
 
   Returns:
     Temporary directory containing all the browser cache.
   """
   save_target = tempfile.mkdtemp(suffix='.cache')
-  for filename, stat in device.adb.Ls(_REMOTE_CACHE_DIRECTORY):
+  for filename, stat in device.adb.Ls(_RemoteCacheDirectory()):
     if filename == '..':
       continue
     if filename == '.':
       cache_directory_stat = stat
       continue
-    original_file = os.path.join(_REMOTE_CACHE_DIRECTORY, filename)
+    original_file = os.path.join(_RemoteCacheDirectory(), filename)
     saved_file = os.path.join(save_target, filename)
     device.adb.Pull(original_file, saved_file)
     _UpdateTimestampFromAdbStat(saved_file, stat)
     if filename == _INDEX_DIRECTORY_NAME:
       # The directory containing the index was pulled recursively, update the
       # timestamps for known files. They are ignored by cache backend, but may
       # be useful for debugging.
       index_dir_stat = stat
       saved_index_dir = os.path.join(save_target, _INDEX_DIRECTORY_NAME)
       saved_index_file = os.path.join(saved_index_dir, _REAL_INDEX_FILE_NAME)
@@ skipping 11 matching lines @@
 
 
 def _PushBrowserCache(device, local_cache_path):
   """Pushes the browser cache saved locally to the device.
 
   Args:
     device: Android device.
     local_cache_path: The directory's path containing the cache locally.
   """
   # Clear previous cache.
-  _AdbShell(device.adb, ['rm', '-rf', _REMOTE_CACHE_DIRECTORY])
-  _AdbShell(device.adb, ['mkdir', _REMOTE_CACHE_DIRECTORY])
+  _AdbShell(device.adb, ['rm', '-rf', _RemoteCacheDirectory()])
+  _AdbShell(device.adb, ['mkdir', _RemoteCacheDirectory()])
 
   # Push cache content.
-  device.adb.Push(local_cache_path, _REMOTE_CACHE_DIRECTORY)
+  device.adb.Push(local_cache_path, _RemoteCacheDirectory())
 
   # Walk through the local cache to update mtime on the device.
   def MirrorMtime(local_path):
     cache_relative_path = os.path.relpath(local_path, start=local_cache_path)
-    remote_path = os.path.join(_REMOTE_CACHE_DIRECTORY, cache_relative_path)
+    remote_path = os.path.join(_RemoteCacheDirectory(), cache_relative_path)
     _AdbUtime(device.adb, remote_path, os.stat(local_path).st_mtime)
 
   for local_directory_path, dirnames, filenames in os.walk(
         local_cache_path, topdown=False):
     for filename in filenames:
       MirrorMtime(os.path.join(local_directory_path, filename))
     for dirname in dirnames:
       MirrorMtime(os.path.join(local_directory_path, dirname))
   MirrorMtime(local_cache_path)
 
@@ skipping 82 matching lines @@
       int(dirname)
     except ValueError:
       continue
     shutil.rmtree(directory_path)
 
 
 def main():
   logging.basicConfig(level=logging.INFO)
   devil_chromium.Initialize()
 
+  # Don't give the argument yet. All we are interested in for now is accessing
+  # the default values of OPTIONS.
+  OPTIONS.ParseArgs([])
+
   parser = argparse.ArgumentParser()
   parser.add_argument('--job', required=True,
                       help='JSON file with job description.')
   parser.add_argument('--output', required=True,
                       help='Name of output directory to create.')
   parser.add_argument('--repeat', default=1, type=int,
                       help='How many times to run the job')
   parser.add_argument('--cache-op',
                       choices=['clear', 'save', 'push', 'reload'],
                       default='clear',
@@ skipping 33 matching lines @@
     assert os.path.isfile(local_cache_archive_path)
     local_cache_directory_path = tempfile.mkdtemp(suffix='.cache')
     _UnzipDirectoryContent(local_cache_archive_path, local_cache_directory_path)
 
   with device_setup.WprHost(device, args.wpr_archive, args.wpr_record,
       args.disable_wpr_script_injection) as additional_flags:
     def _RunNavigation(url, clear_cache, trace_id):
       with device_setup.DeviceConnection(
           device=device,
           additional_flags=additional_flags) as connection:
-        if clear_cache:
-          connection.ClearCache()
-        page_track.PageTrack(connection)
-        tracing_track = tracing.TracingTrack(connection,
+        loading_trace = trace_recorder.MonitorUrl(
+            connection, url,
+            clear_cache=clear_cache,
             categories=pull_sandwich_metrics.CATEGORIES)
-        connection.SetUpMonitoring()
-        connection.SendAndIgnoreResponse('Page.navigate', {'url': url})
-        connection.StartMonitoring()
         if trace_id != None:
-          trace_target_directory = os.path.join(args.output, str(trace_id))
-          _SaveChromeTrace(tracing_track.ToJsonDict(), trace_target_directory)
+          loading_trace_path = os.path.join(
+              args.output, str(trace_id), 'trace.json')
+          os.makedirs(os.path.dirname(loading_trace_path))
+          loading_trace.SaveToJsonFile(loading_trace_path)
 
     for _ in xrange(args.repeat):
       for url in job_urls:
         clear_cache = False
         if args.cache_op == 'clear':
           clear_cache = True
         elif args.cache_op == 'push':
-          device.KillAll(_CHROME_PACKAGE, quiet=True)
+          device.KillAll(OPTIONS.chrome_package_name, quiet=True)
           _PushBrowserCache(device, local_cache_directory_path)
         elif args.cache_op == 'reload':
           _RunNavigation(url, clear_cache=True, trace_id=None)
         elif args.cache_op == 'save':
           clear_cache = not run_infos['urls']
         _RunNavigation(url, clear_cache=clear_cache,
                        trace_id=len(run_infos['urls']))
         run_infos['urls'].append(url)
 
   if local_cache_directory_path:
     shutil.rmtree(local_cache_directory_path)
 
   if args.cache_op == 'save':
     # Move Chrome to background to allow it to flush the index.
     device.adb.Shell('am start com.google.android.launcher')
     time.sleep(_TIME_TO_DEVICE_IDLE_SECONDS)
-    device.KillAll(_CHROME_PACKAGE, quiet=True)
+    device.KillAll(OPTIONS.chrome_package_name, quiet=True)
     time.sleep(_TIME_TO_DEVICE_IDLE_SECONDS)
 
     cache_directory_path = _PullBrowserCache(device)
     _ZipDirectoryContent(cache_directory_path, local_cache_archive_path)
     shutil.rmtree(cache_directory_path)
 
   with open(os.path.join(args.output, 'run_infos.json'), 'w') as file_output:
     json.dump(run_infos, file_output, indent=2)
 
 
 if __name__ == '__main__':
   sys.exit(main())