sandwich: Implements reload cache operation to compare with push.

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 68 matching lines @@
       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, directory, subdirectory):
+def _SaveChromeTrace(events, target_directory):
   """Saves the trace events, ignores IO errors.
 
   Args:
     events: a dict as returned by TracingTrack.ToJsonDict()
-    directory: directory name contining all traces
-    subdirectory: directory name to create this particular trace in
+    target_directory: Directory path where trace is created.
   """
-  target_directory = os.path.join(directory, subdirectory)
   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.
 
 
@@ skipping 173 matching lines @@
   devil_chromium.Initialize()
 
   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'],
+                      choices=['clear', 'save', 'push', 'reload'],
                       default='clear',
                       help='Configures cache operation to do before launching '
                           +'Chrome. (Default is clear).')
   parser.add_argument('--wpr-archive', default=None, type=str,
                       help='Web page replay archive to load job\'s urls from.')
   parser.add_argument('--wpr-record', default=False, action='store_true',
                       help='Record web page replay archive.')
   parser.add_argument('--disable-wpr-script-injection', default=False,
                       action='store_true',
                       help='Disable WPR default script injection such as ' +
@@ skipping 20 matching lines @@
   local_cache_archive_path = os.path.join(args.output, 'cache.zip')
   local_cache_directory_path = None
 
   if args.cache_op == 'push':
     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,
+            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)
+
     for _ in xrange(args.repeat):
       for url in job_urls:
-        if args.cache_op == 'push':
+        clear_cache = False
+        if args.cache_op == 'clear':
+          clear_cache = True
+        elif args.cache_op == 'push':
           device.KillAll(_CHROME_PACKAGE, quiet=True)
           _PushBrowserCache(device, local_cache_directory_path)
-        with device_setup.DeviceConnection(
-            device=device,
-            additional_flags=additional_flags) as connection:
-          if (not run_infos['urls'] and args.cache_op == 'save' or
-              args.cache_op == 'clear'):
-            connection.ClearCache()
-          page_track.PageTrack(connection)
-          tracing_track = tracing.TracingTrack(connection,
-              categories=pull_sandwich_metrics.CATEGORIES)
-          connection.SetUpMonitoring()
-          connection.SendAndIgnoreResponse('Page.navigate', {'url': url})
-          connection.StartMonitoring()
-          _SaveChromeTrace(tracing_track.ToJsonDict(), args.output,
-              str(len(run_infos['urls'])))
-          run_infos['urls'].append(url)
+        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)
     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())