[DO NOT COMMIT] Refactor systrace to support new clock sync design

devil/devil/android/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 696 matching lines @@
     """
     if self.build_version_sdk < required_sdk_level:
       raise device_errors.DeviceVersionError(
           ('Requires SDK level %s, device is SDK level %s' %
            (required_sdk_level, self.build_version_sdk)),
            device_serial=self.adb.GetDeviceSerial())
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def RunShellCommand(self, cmd, check_return=False, cwd=None, env=None,
                       as_root=False, single_line=False, large_output=False,
-                      timeout=None, retries=None):
+                      timeout=None, retries=None, split_lines=True):
     """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
     without having to worry about getting quoting right. Whenever possible, it
@@ skipping 16 matching lines @@
       cwd: The device directory in which the command should be run.
       env: The environment variables with which the command should be run.
       as_root: A boolean indicating whether the shell command should be run
         with root privileges.
       single_line: A boolean indicating if only a single line of output is
         expected.
       large_output: Uses a work-around for large shell command output. Without
         this large output will be truncated.
       timeout: timeout in seconds
       retries: number of retries
+      split_lines: Whether to split the output into a list of lines.
 
     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:
       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
@@ skipping 54 matching lines @@
       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 = self._Su('sh -c %s' % cmd_helper.SingleQuote(cmd))
 
-    output = handle_large_output(cmd, large_output).splitlines()
+    output = handle_large_output(cmd, large_output)
 
-    if single_line:
+    if split_lines:
+      output = output.splitlines()
+
+    if split_lines and single_line:
       if not output:
         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
 
@@ skipping 1328 matching lines @@
       on: bool to decide state to switch to. True = on False = off.
     """
     def screen_test():
       return self.IsScreenOn() == on
 
     if screen_test():
       logging.info('Screen already in expected state.')
       return
     self.RunShellCommand('input keyevent 26')
     timeout_retry.WaitFor(screen_test, wait_period=1)