Update from https://crrev.com/308996

build/android/pylib/device/device_utils.py

 # Copyright 2014 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.
 
 """Provides a variety of device interactions based on adb.
 
 Eventually, this will be based on adb_wrapper.
 """
 # pylint: disable=W0613
 
@@ skipping 54 matching lines @@
     _DEFAULT_TIMEOUT, _DEFAULT_RETRIES)
 def RestartServer():
   """Restarts the adb server.
 
   Raises:
     CommandFailedError if we fail to kill or restart the server.
   """
   pylib.android_commands.AndroidCommands().RestartAdbServer()
 
 
+def _GetTimeStamp():
+  """Return a basic ISO 8601 time stamp with the current local time."""
+  return time.strftime('%Y%m%dT%H%M%S', time.localtime())
+
+
 class DeviceUtils(object):
 
   _VALID_SHELL_VARIABLE = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*$')
 
   def __init__(self, device, default_timeout=_DEFAULT_TIMEOUT,
                default_retries=_DEFAULT_RETRIES):
     """DeviceUtils constructor.
 
     Args:
       device: Either a device serial, an existing AdbWrapper instance, or an
@@ skipping 413 matching lines @@
     self.RunShellCommand(cmd, as_root=as_root, check_return=True)
 
     if blocking:
       wait_period = 0.1
       while self._GetPidsImpl(process_name):
         time.sleep(wait_period)
 
     return len(pids)
 
   @decorators.WithTimeoutAndRetriesFromInstance()
-  def StartActivity(self, intent, blocking=False, trace_file_name=None,
+  def StartActivity(self, intent_obj, blocking=False, trace_file_name=None,
                     force_stop=False, timeout=None, retries=None):
     """Start package's activity on the device.
 
     Args:
-      intent: An Intent to send.
+      intent_obj: An Intent object to send.
       blocking: A boolean indicating whether we should wait for the activity to
                 finish launching.
       trace_file_name: If present, a string that both indicates that we want to
                        profile the activity and contains the path to which the
                        trace should be saved.
       force_stop: A boolean indicating whether we should stop the activity
                   before starting it.
       timeout: timeout in seconds
       retries: number of retries
 
     Raises:
       CommandFailedError if the activity could not be started.
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
-    single_category = (intent.category[0] if isinstance(intent.category, list)
-                                          else intent.category)
-    output = self.old_interface.StartActivity(
-        intent.package, intent.activity, wait_for_completion=blocking,
-        action=intent.action, category=single_category, data=intent.data,
-        extras=intent.extras, trace_file_name=trace_file_name,
-        force_stop=force_stop, flags=intent.flags)
-    for l in output:
-      if l.startswith('Error:'):
-        raise device_errors.CommandFailedError(l, str(self))
+    cmd = ['am', 'start']
+    if blocking:
+      cmd.append('-W')
+    if trace_file_name:
+      cmd.extend(['--start-profiler', trace_file_name])
+    if force_stop:
+      cmd.append('-S')
+    cmd.extend(intent_obj.am_args)
+    for line in self.RunShellCommand(cmd, check_return=True):
+      if line.startswith('Error:'):
+        raise device_errors.CommandFailedError(line, str(self))
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def StartInstrumentation(self, component, finish=True, raw=False,
                            extras=None, timeout=None, retries=None):
     if extras is None:
       extras = {}
 
     cmd = ['am', 'instrument']
     if finish:
       cmd.append('-w')
     if raw:
       cmd.append('-r')
     for k, v in extras.iteritems():
       cmd.extend(['-e', k, v])
     cmd.append(component)
     return self.RunShellCommand(cmd, check_return=True)
 
   @decorators.WithTimeoutAndRetriesFromInstance()
-  def BroadcastIntent(self, intent, timeout=None, retries=None):
+  def BroadcastIntent(self, intent_obj, timeout=None, retries=None):
     """Send a broadcast intent.
 
     Args:
       intent: An Intent to broadcast.
       timeout: timeout in seconds
       retries: number of retries
 
     Raises:
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
-    cmd = ['am', 'broadcast', '-a', intent.action]
-    if intent.extras:
-      for key, value in intent.extras.iteritems():
-        if key:
-          cmd.extend(['-e', key])
-          if value:
-            cmd.append(str(value))
+    cmd = ['am', 'broadcast'] + intent_obj.am_args
     self.RunShellCommand(cmd, check_return=True)
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def GoHome(self, timeout=None, retries=None):
     """Return to the home screen.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
 
@@ skipping 605 matching lines @@
       except IndexError:
         pass
     return procs_pids
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def TakeScreenshot(self, host_path=None, timeout=None, retries=None):
     """Takes a screenshot of the device.
 
     Args:
       host_path: A string containing the path on the host to save the
-                 screenshot to. If None, a file name will be generated.
+                 screenshot to. If None, a file name in the current
+                 directory will be generated.
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
       The name of the file on the host to which the screenshot was saved.
 
     Raises:
       CommandFailedError on failure.
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
-    return self.old_interface.TakeScreenshot(host_path)
+    if not host_path:
+      host_path = os.path.abspath('screenshot-%s.png' % _GetTimeStamp())
+    with device_temp_file.DeviceTempFile(self.adb, suffix='.png') as device_tmp:
+      self.RunShellCommand(['/system/bin/screencap', '-p', device_tmp.name],
+                           check_return=True)
+      self.PullFile(device_tmp.name, host_path)
+    return host_path
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def GetIOStats(self, timeout=None, retries=None):
     """Gets cumulative disk IO stats since boot for all processes.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
@@ skipping 45 matching lines @@
     Returns:
       A Parallelizer operating over |devices|.
     """
     if not devices:
       devices = adb_wrapper.AdbWrapper.GetDevices()
     devices = [d if isinstance(d, cls) else cls(d) for d in devices]
     if async:
       return parallelizer.Parallelizer(devices)
     else:
       return parallelizer.SyncParallelizer(devices)