Update from https://crrev.com/306655

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 47 matching lines @@
 
 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, an
-              an existing AndroidCommands instance, or nothing.
+      device: Either a device serial, an existing AdbWrapper instance, or an
+              an existing AndroidCommands instance.
       default_timeout: An integer containing the default number of seconds to
                        wait for an operation to complete if no explicit value
                        is provided.
       default_retries: An integer containing the default number or times an
                        operation should be retried on failure if no explicit
                        value is provided.
     """
     self.adb = None
     self.old_interface = None
     if isinstance(device, basestring):
       self.adb = adb_wrapper.AdbWrapper(device)
       self.old_interface = pylib.android_commands.AndroidCommands(device)
     elif isinstance(device, adb_wrapper.AdbWrapper):
       self.adb = device
       self.old_interface = pylib.android_commands.AndroidCommands(str(device))
     elif isinstance(device, pylib.android_commands.AndroidCommands):
       self.adb = adb_wrapper.AdbWrapper(device.GetDevice())
       self.old_interface = device
-    elif not device:
-      self.adb = adb_wrapper.AdbWrapper('')
-      self.old_interface = pylib.android_commands.AndroidCommands()
     else:
-      raise ValueError('Unsupported type passed for argument "device"')
+      raise ValueError('Unsupported device value: %r' % device)
     self._commands_installed = None
     self._default_timeout = default_timeout
     self._default_retries = default_retries
     self._cache = {}
     assert hasattr(self, decorators.DEFAULT_TIMEOUT_ATTR)
     assert hasattr(self, decorators.DEFAULT_RETRIES_ATTR)
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def IsOnline(self, timeout=None, retries=None):
     """Checks whether the device is online.
@@ skipping 25 matching lines @@
     Returns:
       True if adbd has root privileges, False otherwise.
 
     Raises:
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
     try:
       self.RunShellCommand('ls /root', check_return=True)
       return True
-    except device_errors.AdbShellCommandFailedError:
+    except device_errors.AdbCommandFailedError:
       return False
 
   def NeedsSU(self, timeout=None, retries=None):
     """Checks whether 'su' is needed to access protected resources.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
       True if 'su' is available on the device and is needed to to access
         protected resources; False otherwise if either 'su' is not available
         (e.g. because the device has a user build), or not needed (because adbd
         already has root privileges).
 
     Raises:
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
     if 'needs_su' not in self._cache:
       try:
         self.RunShellCommand('su -c ls /root && ! ls /root', check_return=True,
                              timeout=timeout, retries=retries)
         self._cache['needs_su'] = True
-      except device_errors.AdbShellCommandFailedError:
+      except device_errors.AdbCommandFailedError:
         self._cache['needs_su'] = False
     return self._cache['needs_su']
 
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def EnableRoot(self, timeout=None, retries=None):
     """Restarts adbd with root privileges.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
 
     Raises:
       CommandFailedError if root could not be enabled.
       CommandTimeoutError on timeout.
     """
+    if self.IsUserBuild():
+      raise device_errors.CommandFailedError(
+          'Cannot enable root in user builds.', str(self))
     if 'needs_su' in self._cache:
       del self._cache['needs_su']
-    if not self.old_interface.EnableAdbRoot():
-      raise device_errors.CommandFailedError(
-          'Could not enable root.', device=str(self))
+    self.adb.Root()
+    self.adb.WaitForDevice()
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def IsUserBuild(self, timeout=None, retries=None):
     """Checks whether or not the device is running a user build.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
@@ skipping 69 matching lines @@
     Raises:
       CommandFailedError on failure.
       CommandTimeoutError if one of the component waits times out.
       DeviceUnreachableError if the device becomes unresponsive.
     """
     def sd_card_ready():
       try:
         self.RunShellCommand(['test', '-d', self.GetExternalStoragePath()],
                              check_return=True)
         return True
-      except device_errors.AdbShellCommandFailedError:
+      except device_errors.AdbCommandFailedError:
         return False
 
     def pm_ready():
       try:
         return self.GetApplicationPath('android')
       except device_errors.CommandFailedError:
         return False
 
     def boot_completed():
       return self.GetProp('sys.boot_completed') == '1'
@@ skipping 62 matching lines @@
     device_path = self.old_interface.GetApplicationPath(package_name)
     if device_path is not None:
       files_changed = self.old_interface.GetFilesChanged(
           apk_path, device_path, ignore_filenames=True)
       if len(files_changed) > 0:
         should_install = True
         if not reinstall:
           out = self.old_interface.Uninstall(package_name)
           for line in out.splitlines():
             if 'Failure' in line:
-              raise device_errors.CommandFailedError(
-                  line.strip(), device=str(self))
+              raise device_errors.CommandFailedError(line.strip(), str(self))
       else:
         should_install = False
     else:
       should_install = True
     if should_install:
       try:
         out = self.old_interface.Install(apk_path, reinstall=reinstall)
         for line in out.splitlines():
           if 'Failure' in line:
-            raise device_errors.CommandFailedError(
-                line.strip(), device=str(self))
+            raise device_errors.CommandFailedError(line.strip(), str(self))
       except AssertionError as e:
         raise device_errors.CommandFailedError(
-            str(e), device=str(self)), None, sys.exc_info()[2]
+            str(e), str(self)), None, sys.exc_info()[2]
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def RunShellCommand(self, cmd, check_return=False, cwd=None, env=None,
                       as_root=False, single_line=False,
                       timeout=None, retries=None):
     """Run an ADB shell command.
 
     The command to run |cmd| should be a sequence of program arguments or else
     a single string.
 
@@ skipping 26 matching lines @@
         expected.
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
       If single_line is False, the output of the command as a list of lines,
       otherwise, a string with the unique line of output emmited by the command
       (with the optional newline at the end stripped).
 
     Raises:
-      AdbShellCommandFailedError if check_return is True and the exit code of
+      AdbCommandFailedError if check_return is True and the exit code of
         the command run on the device is non-zero.
       CommandFailedError if single_line is True but the output contains two or
         more lines.
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
     def env_quote(key, value):
       if not DeviceUtils._VALID_SHELL_VARIABLE.match(key):
         raise KeyError('Invalid shell variable name %r' % key)
       # using double quotes here to allow interpolation of shell variables
       return '%s=%s' % (key, cmd_helper.DoubleQuote(value))
 
     if not isinstance(cmd, basestring):
       cmd = ' '.join(cmd_helper.SingleQuote(s) for s in cmd)
     if env:
       env = ' '.join(env_quote(k, v) for k, v in env.iteritems())
       cmd = '%s %s' % (env, cmd)
     if cwd:
       cmd = 'cd %s && %s' % (cmd_helper.SingleQuote(cwd), cmd)
     if as_root and self.NeedsSU():
       # "su -c sh -c" allows using shell features in |cmd|
       cmd = 'su -c sh -c %s' % cmd_helper.SingleQuote(cmd)
     if timeout is None:
       timeout = self._default_timeout
 
     try:
       output = self.adb.Shell(cmd)
-    except device_errors.AdbShellCommandFailedError as e:
+    except device_errors.AdbCommandFailedError as e:
       if check_return:
         raise
       else:
         output = e.output
 
     output = output.splitlines()
     if single_line:
       if not output:
         return ''
       elif len(output) == 1:
@@ skipping 21 matching lines @@
       retries: number of retries
 
     Raises:
       CommandFailedError if no process was killed.
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
     pids = self._GetPidsImpl(process_name)
     if not pids:
       raise device_errors.CommandFailedError(
-          'No process "%s"' % process_name, device=str(self))
+          'No process "%s"' % process_name, str(self))
 
     cmd = ['kill', '-%d' % signum] + pids.values()
     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)
@@ skipping 22 matching lines @@
     """
     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, device=str(self))
+        raise device_errors.CommandFailedError(l, 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')
@@ skipping 281 matching lines @@
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
       True if the file exists on the device, False otherwise.
 
     Raises:
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
-    return self.old_interface.FileExistsOnDevice(device_path)
+    try:
+      self.RunShellCommand(['test', '-e', device_path], check_return=True)
+      return True
+    except device_errors.AdbCommandFailedError:
+      return False
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def PullFile(self, device_path, host_path, timeout=None, retries=None):
     """Pull a file from the device.
 
     Args:
       device_path: A string containing the absolute path of the file to pull
                    from the device.
       host_path: A string containing the absolute path of the destination on
                  the host.
       timeout: timeout in seconds
       retries: number of retries
 
     Raises:
       CommandFailedError on failure.
       CommandTimeoutError on timeout.
     """
     try:
       self.old_interface.PullFileFromDevice(device_path, host_path)
     except AssertionError as e:
       raise device_errors.CommandFailedError(
-          str(e), device=str(self)), None, sys.exc_info()[2]
+          str(e), str(self)), None, sys.exc_info()[2]
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def ReadFile(self, device_path, as_root=False, timeout=None, retries=None):
     """Reads the contents of a file from the device.
 
     Args:
       device_path: A string containing the absolute path of the file to read
                    from the device.
       as_root: A boolean indicating whether the read should be executed with
                root privileges.
@@ skipping 111 matching lines @@
       cache: A boolean indicating whether to cache the value of this property.
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
       The value of the device's |property_name| property.
 
     Raises:
       CommandTimeoutError on timeout.
     """
+    assert isinstance(property_name, basestring), (
+        "property_name is not a string: %r" % property_name)
+
     cache_key = '_prop:' + property_name
     if cache and cache_key in self._cache:
       return self._cache[cache_key]
     else:
       # timeout and retries are handled down at run shell, because we don't
       # want to apply them in the other branch when reading from the cache
       value = self.RunShellCommand(['getprop', property_name],
                                    single_line=True, check_return=True,
                                    timeout=timeout, retries=retries)
       if cache or cache_key in self._cache:
@@ skipping 13 matching lines @@
       check: A boolean indicating whether to check that the property was
              successfully set on the device.
       timeout: timeout in seconds
       retries: number of retries
 
     Raises:
       CommandFailedError if check is true and the property was not correctly
         set on the device (e.g. because it is not rooted).
       CommandTimeoutError on timeout.
     """
+    assert isinstance(property_name, basestring), (
+        "property_name is not a string: %r" % property_name)
+    assert isinstance(value, basestring), "value is not a string: %r" % value
+
     self.RunShellCommand(['setprop', property_name, value], check_return=True)
     if property_name in self._cache:
       del self._cache[property_name]
     # TODO(perezju) remove the option and make the check mandatory, but using a
     # single shell script to both set- and getprop.
     if check and value != self.GetProp(property_name):
       raise device_errors.CommandFailedError(
           'Unable to set property %r on the device to %r'
           % (property_name, value), str(self))
 
@@ skipping 96 matching lines @@
         - A dict containing the overall memory usage statistics for the PID.
         - A dict containing memory usage statistics broken down by mapping.
 
     Raises:
       CommandTimeoutError on timeout.
     """
     return self.old_interface.GetMemoryUsageForPid(pid)
 
   def __str__(self):
     """Returns the device serial."""
-    s = self.old_interface.GetDevice()
-    if not s:
-      s = self.old_interface.Adb().GetSerialNumber()
-      if s == 'unknown':
-        raise device_errors.NoDevicesError()
-    return s
+    return self.adb.GetDeviceSerial()
 
   @staticmethod
   def parallel(devices=None, async=False):
     """Creates a Parallelizer to operate over the provided list of devices.
 
     If |devices| is either |None| or an empty list, the Parallelizer will
     operate over all attached devices.
 
     Args:
       devices: A list of either DeviceUtils instances or objects from
                from which DeviceUtils instances can be constructed. If None,
                all attached devices will be used.
       async: If true, returns a Parallelizer that runs operations
              asynchronously.
 
     Returns:
       A Parallelizer operating over |devices|.
     """
     if not devices or len(devices) == 0:
       devices = pylib.android_commands.GetAttachedDevices()
     parallelizer_type = (parallelizer.Parallelizer if async
                          else parallelizer.SyncParallelizer)
     return parallelizer_type([
         d if isinstance(d, DeviceUtils) else DeviceUtils(d)
         for d in devices])