[telemetry_mini] Add story runner options

experimental/telemetry_mini/telemetry_mini.py

 #!/usr/bin/env python
 # Copyright 2017 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.
 
 # This is intended to be a very trimmed down, single-file, hackable, and easy
 # to understand version of Telemetry. It's able to run simple user stories on
 # Android, grab traces, and extract metrics from them. May be useful to
 # diagnose issues with Chrome, reproduce regressions or prototype new user
 # stories.
@@ skipping 389 matching lines @@
 
 class ChromiumApp(AndroidApp):
   PACKAGE_NAME = 'org.chromium.chrome'
   APK_FILENAME = 'ChromePublic.apk'
   COMMAND_LINE_FILE = '/data/local/tmp/chrome-command-line'
   TRACE_CONFIG_FILE = '/data/local/chrome-trace-config.json'
 
   def __init__(self, *args, **kwargs):
     super(ChromiumApp, self).__init__(*args, **kwargs)
     self._devtools_local_port = None
+    self._browser_flags = None
+    self._trace_config = None
     self.startup_time = None
 
   def RemoveProfile(self):
     # TODO: Path to profile may need to be updated on newer Android versions.
     profile_dir = posixpath.join('/data/data', self.PACKAGE_NAME)
     filenames = self.device.ListPath(profile_dir)
     args = ['rm', '-r']
     args.extend(
         posixpath.join(profile_dir, f)
         for f in filenames if f not in ['.', '..', 'lib'])
     self.device.RunShellCommand(*args)
 
   @contextlib.contextmanager
-  def CommandLineFlags(self, flags):
-    self.device.WriteText(' '.join(['_'] + flags), self.COMMAND_LINE_FILE)
+  def CommandLineFlags(self):
+    command_line = ' '.join(['_'] + self._browser_flags)
+    self.device.WriteText(command_line, self.COMMAND_LINE_FILE)
     try:
       yield
     finally:
       self.device.RunShellCommand('rm', '-f', self.COMMAND_LINE_FILE)
 
+  def SetBrowserFlags(self, browser_flags):
+    self._browser_flags = browser_flags
+
+  def SetTraceConfig(self, trace_config):
+    self._trace_config = trace_config
+
   def SetDevToolsLocalPort(self, port):
     self._devtools_local_port = port
 
   def GetDevToolsLocalAddr(self, host='localhost'):
     assert self._devtools_local_port is not None
     return '%s:%d' % (host, self._devtools_local_port)
 
   def GetDevToolsRemoteAddr(self):
     return 'localabstract:chrome_devtools_remote'
 
   @contextlib.contextmanager
   def PortForwarding(self):
     """Setup port forwarding to connect with DevTools on remote device."""
     local = self.GetDevToolsLocalAddr('tcp')
     remote = self.GetDevToolsRemoteAddr()
     self.device.RunCommand('forward', '--no-rebind', local, remote)
     try:
       yield
     finally:
       self.device.RunCommand('forward', '--remove', local)
 
   @contextlib.contextmanager
-  def StartupTracing(self, trace_config):
+  def StartupTracing(self):
     self.device.WriteText(
-        json.dumps({'trace_config': trace_config}), self.TRACE_CONFIG_FILE)
+        json.dumps({'trace_config': self._trace_config}),
+        self.TRACE_CONFIG_FILE)
     try:
       yield
     finally:
       self.device.RunShellCommand('rm', '-f', self.TRACE_CONFIG_FILE)
 
   @contextlib.contextmanager
-  def Session(self, flags, trace_config):
+  def Session(self):
     """A context manager to guard the lifetime of a browser process.
 
     Ensures that command line flags and port forwarding are ready, the browser
     is not alive before starting, it has a clear profile to begin with, and is
     finally closed when done.
 
     It does not, however, launch the browser itself. This must be done by the
     context managed code.
 
     To the extent possible, measurements from browsers launched within
     different sessions are meant to be independent of each other.
     """
     # Removing the profile breaks Chrome Shortcuts on the Home Screen.
     # TODO: Figure out a way to automatically create the shortcuts before
     # running the story.
     # self.RemoveProfile()
-    with self.CommandLineFlags(flags):
-      with self.StartupTracing(trace_config):
+    with self.CommandLineFlags():
+      with self.StartupTracing():
         # Ensure browser is closed after setting command line flags and
         # trace config to ensure they are read on startup.
         self.ForceStop()
         with self.PortForwarding():
           try:
             yield
           finally:
             self.ForceStop()
 
   def WaitForCurrentPageReady(self):
@@ skipping 60 matching lines @@
     logging.warning('Disabling %s', self.PACKAGE_NAME)
     self.device.RunShellCommand('pm', 'disable', self.PACKAGE_NAME)
 
 
 class UserStory(object):
   def __init__(self, browser):
     self.device = browser.device
     self.browser = browser
     self.actions = AndroidActions(self.device)
 
-  def Run(self, browser_flags, trace_config, trace_file):
-    with self.browser.Session(browser_flags, trace_config):
+  def Run(self, trace_file):
+    with self.browser.Session():
       self.RunPrepareSteps()
       try:
         self.RunStorySteps()
         self.browser.CollectTrace(trace_file)
       except Exception as exc:
         # Helps to pin point in the logs the moment where the story failed,
         # before any of the finally blocks get to be executed.
         logging.error('Aborting story due to %s.', type(exc).__name__)
         raise
       finally:
@@ skipping 31 matching lines @@
     if event['ph'] == 'v':
       # Extract any metrics you may need from the trace.
       value = event['args']['dumps']['allocators'][
           'java_heap/allocated_objects']['attrs']['size']
       assert value['units'] == 'bytes'
       processes[event['pid']]['java_heap'] = int(value['value'], 16)
     elif event['ph'] == 'M' and event['name'] == 'process_name':
       processes[event['pid']]['name'] = event['args']['name']
 
   return processes.values()
+
+
+def RunStories(browser, stories, repeat, output_dir):
+  for repeat_idx in range(1, repeat + 1):
+    for story_cls in stories:
+      trace_file = os.path.join(
+          output_dir, 'trace_%s_%d.json' % (story_cls.NAME, repeat_idx))
+      print '[ RUN      ]', story_cls.NAME
+      status = '[       OK ]'
+      start = time.time()
+      try:
+        story_cls(browser).Run(trace_file)
+      except Exception:  # pylint: disable=broad-except
+        logging.exception('Exception raised while running story')
+        status = '[  FAILED  ]'
+      finally:
+        elapsed = '(%.1f secs)' % (time.time() - start)
+        print status, story_cls.NAME, elapsed