[Android] Add PIE support for ICS devices.

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=unused-argument
 
@@ skipping 394 matching lines @@
       should_install = bool(self._GetChangedFilesImpl(apk_path, device_path))
       if should_install and not reinstall:
         self.adb.Uninstall(package_name)
     else:
       should_install = True
     if should_install:
       self.adb.Install(apk_path, reinstall=reinstall)
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def RunShellCommand(self, cmd, check_return=False, cwd=None, env=None,
-                      as_root=False, single_line=False,
+                      as_root=False, with_pie=False, single_line=False,

[perezju, 2015/02/16 10:25:23]

Do we expect many clients needing this option? If we don't expect that many, I
think I would rather have clients calling GetDevicePieWrapper and building the
command themselves.

[jbudorick, 2015/02/17 15:15:10]

I don't, though I do anticipate it being more than one. I chose to include it as
an option since that's how we handle most wrappers.

[perezju, 2015/02/17 16:04:26]

I'm not crazy about this. We're adding this option now, but there are no callers
requiring it yet. Already one of the potential clients (the md5sum tool), will
probably never use this option because it needs to build it's own script anyway.

That feels, to me, like the preferred approach: the helper for the tool
requiring a special wrapper to be run, should just create the appropriate
command as required by the tool itself. Why should RunShellCommand know about
all the different wrappers that different tools might need?

Anyway, I guess you've got more experience, and I might be missing some context,
so I won't press on this point.

[jbudorick, 2015/02/17 16:14:18]

I suppose it makes sense to hold off on adding this until we have a client. I
anticipate that happening soon, but since we don't need it now, I'll take it
out. We can discuss it further when it's relevant.

                       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.
 
     When |cmd| is a sequence, it is assumed to contain the name of the command
     to run followed by its arguments. In this case, arguments are passed to the
     command exactly as given, without any further processing by the shell. This
     allows to easily pass arguments containing spaces or special characters
@@ skipping 46 matching lines @@
       try:
         return self.adb.Shell(cmd)
       except device_errors.AdbCommandFailedError as exc:
         if check_return:
           raise
         else:
           return exc.output
 
     if not isinstance(cmd, basestring):
       cmd = ' '.join(cmd_helper.SingleQuote(s) for s in cmd)
+    if with_pie and (self.build_version_sdk <
+                     constants.ANDROID_SDK_VERSION_CODES.JELLY_BEAN):
+      cmd = '%s %s' % (self.GetDevicePieWrapper(), 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
@@ skipping 13 matching lines @@
         return ''
       elif len(output) == 1:
         return output[0]
       else:
         msg = 'one line of output was expected, but got: %s'
         raise device_errors.CommandFailedError(msg % output, str(self))
     else:
       return output
 
   @decorators.WithTimeoutAndRetriesFromInstance()
+  def GetDevicePieWrapper(self, timeout=None, retries=None):

[jbudorick, 2015/02/14 00:48:54]

Maybe this should be done as a property, wdyt?

[perezju, 2015/02/16 10:25:23]

I would lean a bit towards "No". I would reserve properties to things which are
more or less quick to compute, and do not have many side-effects when reading.
Pushing a file to the device seems to break both of those criteria.

[jbudorick, 2015/02/17 15:15:10]

Acknowledged.

+    """Gets the absolute path to the run_pie wrapper on the device.
+
+    We have to build our device executables to be PIE, but they need to be able
+    to run on versions of android that don't support PIE (i.e. ICS and below).
+    To do so, we push a wrapper to the device that lets older android versions
+    run PIE executables. This method pushes that wrapper to the device if
+    necessary and returns the path to it.
+
+    This is exposed publicly to allow clients to write scripts using run_pie
+    (e.g. md5sum.CalculateDeviceMd5Sum). However, in most cases,
+    RunShellCommand(..., with_pie=True) should suffice.
+
+    Args:
+      timeout: timeout in seconds
+      retries: number of retries
+
+    Returns:
+      The path to the PIE wrapper on the device, or an empty string if the
+      device does not require the wrapper.
+    """
+    if 'run_pie' not in self._cache:
+      pie = ''
+      if (self.build_version_sdk <
+          constants.ANDROID_SDK_VERSION_CODES.JELLY_BEAN):
+        host_pie_path = os.path.join(constants.GetOutDirectory(), 'run_pie')
+        if not os.path.exists(host_pie_path):
+          raise device_errors.CommandFailedError('Please build run_pie')
+        pie = '%s/run_pie' % constants.TEST_EXECUTABLE_DIR
+        self.adb.Push(host_pie_path, pie)
+
+      self._cache['run_pie'] = pie
+
+    return self._cache['run_pie']
+
+  @decorators.WithTimeoutAndRetriesFromInstance()
   def KillAll(self, process_name, signum=9, as_root=False, blocking=False,
               timeout=None, retries=None):
     """Kill all processes with the given name on the device.
 
     Args:
       process_name: A string containing the name of the process to kill.
       signum: An integer containing the signal number to send to kill. Defaults
               to 9 (SIGKILL).
       as_root: A boolean indicating whether the kill should be executed with
                root privileges.
@@ skipping 841 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)