Update from https://crrev.com/320931

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
 
 import collections
 import itertools
 import logging
 import multiprocessing
 import os
+import posixpath
 import re
+import shutil
 import sys
 import tempfile
 import time
 import zipfile
 
 import pylib.android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib.device import adb_wrapper
 from pylib.device import decorators
@@ skipping 95 matching lines @@
 def _JoinLines(lines):
   # makes sure that the last line is also terminated, and is more memory
   # efficient than first appending an end-line to each line and then joining
   # all of them together.
   return ''.join(s for line in lines for s in (line, '\n'))
 
 
 class DeviceUtils(object):
 
   _MAX_ADB_COMMAND_LENGTH = 512
+  _MAX_ADB_OUTPUT_LENGTH = 32768
   _VALID_SHELL_VARIABLE = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*$')
 
   # Property in /data/local.prop that controls Java assertions.
   JAVA_ASSERT_PROPERTY = 'dalvik.vm.enableassertions'
 
   def __init__(self, device, default_timeout=_DEFAULT_TIMEOUT,
                default_retries=_DEFAULT_RETRIES):
     """DeviceUtils constructor.
 
     Args:
@@ skipping 788 matching lines @@
     Raises:
       CommandFailedError on failure.
       CommandTimeoutError on timeout.
     """
     # Create the base dir if it doesn't exist already
     dirname = os.path.dirname(host_path)
     if dirname and not os.path.exists(dirname):
       os.makedirs(dirname)
     self.adb.Pull(device_path, host_path)
 
+  def _ReadFileWithPull(self, device_path):
+    try:
+      d = tempfile.mkdtemp()
+      host_temp_path = os.path.join(d, 'tmp_ReadFileWithPull')
+      self.adb.Pull(device_path, host_temp_path)
+      with open(host_temp_path, 'r') as host_temp:
+        return host_temp.read()
+    finally:
+      if os.path.exists(d):
+        shutil.rmtree(d)
+
+  _LS_RE = re.compile(
+      r'(?P<perms>\S+) +(?P<owner>\S+) +(?P<group>\S+) +(?:(?P<size>\d+) +)?'
+      + r'(?P<date>\S+) +(?P<time>\S+) +(?P<name>.+)$')
+
   @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.
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
       The contents of |device_path| as a string. Contents are intepreted using
       universal newlines, so the caller will see them encoded as '\n'. Also,
       all lines will be terminated.
 
     Raises:
       AdbCommandFailedError if the file can't be read.
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
-    return _JoinLines(self.RunShellCommand(
-        ['cat', device_path], as_root=as_root, check_return=True))
+    # TODO(jbudorick): Implement a generic version of Stat() that handles
+    # as_root=True, then switch this implementation to use that.
+    size = None
+    ls_out = self.RunShellCommand(['ls', '-l', device_path], as_root=as_root,
+                                  check_return=True)
+    for line in ls_out:
+      m = self._LS_RE.match(line)
+      if m and m.group('name') == posixpath.basename(device_path):
+        size = int(m.group('size'))
+        break
+    else:
+      logging.warning('Could not determine size of %s.', device_path)
+
+    if size is None or size <= self._MAX_ADB_OUTPUT_LENGTH:
+      return _JoinLines(self.RunShellCommand(
+          ['cat', device_path], as_root=as_root, check_return=True))
+    elif as_root and self.NeedsSU():
+      with device_temp_file.DeviceTempFile(self.adb) as device_temp:
+        self.RunShellCommand(['cp', device_path, device_temp.name],
+                             as_root=True, check_return=True)
+        return self._ReadFileWithPull(device_temp.name)
+    else:
+      return self._ReadFileWithPull(device_path)
 
   def _WriteFileWithPush(self, device_path, contents):
     with tempfile.NamedTemporaryFile() as host_temp:
       host_temp.write(contents)
       host_temp.flush()
       self.adb.Push(host_temp.name, device_path)
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def WriteFile(self, device_path, contents, as_root=False, force_push=False,
                 timeout=None, retries=None):
@@ skipping 544 matching lines @@
     """
     if not devices:
       devices = adb_wrapper.AdbWrapper.GetDevices()
       if not devices:
         raise device_errors.NoDevicesError()
     devices = [d if isinstance(d, cls) else cls(d) for d in devices]
     if async:
       return parallelizer.Parallelizer(devices)
     else:
       return parallelizer.SyncParallelizer(devices)