[experimental] Add Flipkart/Instagram story

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 12 matching lines @@
 import posixpath
 import re
 import socket
 import subprocess
 import tempfile
 import time
 import websocket  # pylint: disable=import-error
 from xml.etree import ElementTree as element_tree
 
 
+KEYCODE_HOME = 3
 KEYCODE_BACK = 4
+KEYCODE_APP_SWITCH = 187
 
 # Parse rectangle bounds given as: '[left,top][right,bottom]'.
 RE_BOUNDS = re.compile(
     r'\[(?P<left>\d+),(?P<top>\d+)\]\[(?P<right>\d+),(?P<bottom>\d+)\]')
 
 # TODO: Maybe replace with a true on-device temp file.
 UI_DUMP_TEMP = '/data/local/tmp/tm_ui_dump.xml'
 
 
 def RetryOn(exc_type=(), returns_falsy=False, retries=5):
@@ skipping 108 matching lines @@
     if output.startswith('ERROR:'):
       # uiautomator may fail if device is not in idle state, e.g. animations
       # or video playing. Retry if that's the case.
       raise AdbCommandError(output)
 
     with tempfile.NamedTemporaryFile(suffix='.xml') as f:
       f.close()
       self.RunCommand('pull', UI_DUMP_TEMP, f.name)
       return element_tree.parse(f.name)
 
-  @RetryOn(LookupError)
-  def FindUiElement(self, attr_values):
-    """Find a UI element on screen capture, retrying if not yet visible."""
+  def HasUiElement(self, attr_values):
+    """Check whether a UI element is visible on the screen."""
     root = self.GetUiScreenDump()
     for node in root.iter():
       if all(node.get(k) == v for k, v in attr_values):
         return node
-    raise LookupError('Specified UI element not found')
+    return None
+
+  @RetryOn(LookupError)
+  def FindUiElement(self, *args, **kwargs):
+    """Find a UI element on the screen, retrying if not yet visible."""
+    node = self.HasUiElement(*args, **kwargs)
+    if node is None:
+      raise LookupError('Specified UI element not found')
+    return node
 
   def TapUiElement(self, *args, **kwargs):
+    """Tap on a UI element found on screen."""
     node = self.FindUiElement(*args, **kwargs)
     m = RE_BOUNDS.match(node.get('bounds'))
     left, top, right, bottom = (int(v) for v in m.groups())
     x, y = (left + right) / 2, (top + bottom) / 2
     self.RunShellCommand('input', 'tap', str(x), str(y))
 
 
 def _UserAction(f):
   """Decorator to add repeat, and action_delay options to user action methods.
 
   Note: The values (or their defaults) supplied for these extra options will
   also be passed down to the decorated method. It's thus advisable to collect
   them in a catch-all **kwargs, even if just to discard them immediately.
 
   This is a workaround for https://github.com/PyCQA/pylint/issues/258 in which
   decorators confuse pylint and trigger spurious 'unexpected-keyword-arg'
   warnings on method calls that use the extra options.
   """
   @functools.wraps(f)
   def Wrapper(self, *args, **kwargs):
     repeat = kwargs.setdefault('repeat', 1)
     action_delay = kwargs.setdefault('action_delay', None)
     for _ in xrange(repeat):
       f(self, *args, **kwargs)
       self.Idle(action_delay)
   return Wrapper
 
 
 class AndroidActions(object):
+  APP_SWITCHER_CLEAR_ALL = [
+      ('resource-id', 'com.android.systemui:id/button'),
+      ('text', 'CLEAR ALL')]
+  APP_SWITCHER_NO_RECENT = [
+      ('package', 'com.android.systemui'),
+      ('text', 'No recent items')]
+
   def __init__(self, device, user_action_delay=1):
     self.device = device
     self.user_action_delay = user_action_delay
 
   def Idle(self, duration=None):
     if duration is None:
       duration = self.user_action_delay
     if duration:
       time.sleep(duration)
 
   @_UserAction
+  def GoHome(self, **kwargs):
+    del kwargs
+    self.device.RunShellCommand('input', 'keyevent', str(KEYCODE_HOME))
+
+  @_UserAction
   def GoBack(self, **kwargs):
     del kwargs
     self.device.RunShellCommand('input', 'keyevent', str(KEYCODE_BACK))
 
   @_UserAction
+  def GoAppSwitcher(self, **kwargs):
+    del kwargs
+    self.device.RunShellCommand('input', 'keyevent', str(KEYCODE_APP_SWITCH))
+
+  @_UserAction
   def StartActivity(
       self, data_uri, action='android.intent.action.VIEW', **kwargs):
     del kwargs
     self.device.RunShellCommand('am', 'start', '-a', action, '-d', data_uri)
 
   @_UserAction
   def TapUiElement(self, attr_values, **kwargs):
     del kwargs
     self.device.TapUiElement(attr_values)
 
+  def TapHomeScreenShortcut(self, description, **kwargs):
+    self.TapUiElement([
+        ('package', 'com.android.launcher3'),
+        ('class', 'android.widget.TextView'),
+        ('content-desc', description)
+    ], **kwargs)
+
+  def TapAppSwitcherTitle(self, text, **kwargs):
+    self.TapUiElement([
+        ('resource-id', 'com.android.systemui:id/title'),
+        ('text', text)
+    ], **kwargs)
+
+  def TapAppSwitcherClearAll(self, **kwargs):
+    self.TapUiElement(self.APP_SWITCHER_CLEAR_ALL, **kwargs)
+
   @_UserAction
   def SwipeUp(self, **kwargs):
     del kwargs
     # Hardcoded values for 480x854 screen size; should work reasonably on
     # other screen sizes.
     # Command args: swipe <x1> <y1> <x2> <y2> [duration(ms)]
     self.device.RunShellCommand(
         'input', 'swipe', '240', '568', '240', '284', '400')
 
+  @_UserAction
+  def SwipeDown(self, **kwargs):
+    del kwargs
+    # Hardcoded values for 480x854 screen size; should work reasonably on
+    # other screen sizes.
+    # Command args: swipe <x1> <y1> <x2> <y2> [duration(ms)]
+    self.device.RunShellCommand(
+        'input', 'swipe', '240', '284', '240', '568', '400')
+
+  def ClearRecentApps(self):
+    self.GoAppSwitcher()
+    if self.device.HasUiElement(self.APP_SWITCHER_NO_RECENT):
+      self.GoHome()
+    else:
+      self.SwipeDown()
+      self.TapAppSwitcherClearAll()
+
 
 class DevToolsWebSocket(object):
   def __init__(self, url):
     self._url = url
     self._socket = None
     self._cmdid = 0
 
   def __enter__(self):
     self.Open()
     return self
@@ skipping 138 matching lines @@
     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.
     """
-    self.RemoveProfile()
+    # 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):
         # 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()
@@ skipping 44 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 GetExtraStoryApps(self):
-    """Sequence of AndroidApp's, other than the browser, used in the story."""
-    return ()
-
-  def EnsureExtraStoryAppsClosed(self):
-    running_processes = self.device.ProcessStatus()
-    for app in self.GetExtraStoryApps():
-      if app.PACKAGE_NAME in running_processes:
-        app.ForceStop()
-
   def Run(self, browser_flags, trace_config, trace_file):
     with self.browser.Session(browser_flags, trace_config):
-      self.EnsureExtraStoryAppsClosed()
+      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:
-        self.EnsureExtraStoryAppsClosed()
+        self.RunCleanupSteps()
+
+  def RunPrepareSteps(self):
+    """Subclasses may override to perform actions before running the story."""
+    pass
 
   def RunStorySteps(self):
     """Subclasses should override this method to implement the story.
 
     The steps must:
     - at some point cause the browser to be launched, and
     - make sure the browser remains alive when done (even if backgrounded).
     """
     raise NotImplementedError
 
+  def RunCleanupSteps(self):
+    """Subclasses may override to perform actions after running the story.
+
+    Note: This will be called even if an exception was raised during the
+    execution of RunStorySteps (but not for errors in RunPrepareSteps).
+    """
+    pass
+
 
 def ReadProcessMetrics(trace_file):
   """Return a list of {"name": process_name, metric: value} dicts."""
   with open(trace_file) as f:
     trace = json.load(f)
 
   processes = collections.defaultdict(dict)
   for event in trace['traceEvents']:
     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()