Android test_runner.py: Add --enable-device-cache to speed up file pushing

build/android/pylib/local/device/local_device_environment.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.
 
 import logging
+import os
 import threading
 
 from devil.android import device_blacklist
 from devil.android import device_errors
 from devil.android import device_utils
 from devil.utils import parallelizer
+from pylib import constants
 from pylib.base import environment
 
 
+def _DeviceCachePath(device):
+  file_name = 'device_cache_%s.json' % device.adb.GetDeviceSerial()
+  return os.path.join(constants.GetOutDirectory(), file_name)
+
+
 class LocalDeviceEnvironment(environment.Environment):
 
   def __init__(self, args, _error_func):
     super(LocalDeviceEnvironment, self).__init__()
     self._blacklist = (device_blacklist.Blacklist(args.blacklist_file)
                        if args.blacklist_file
                        else None)
     self._device_serial = args.test_device
     self._devices_lock = threading.Lock()
     self._devices = []
     self._max_tries = 1 + args.num_retries
     self._tool_name = args.tool
+    self._enable_device_cache = args.enable_device_cache
 
   #override
   def SetUp(self):
     available_devices = device_utils.DeviceUtils.HealthyDevices(
-        self._blacklist)
+        self._blacklist, enable_device_files_cache=self._enable_device_cache)
     if not available_devices:
       raise device_errors.NoDevicesError
     if self._device_serial:
       self._devices = [d for d in available_devices
                        if d.adb.GetDeviceSerial() == self._device_serial]
       if not self._devices:
         raise device_errors.DeviceUnreachableError(
             'Could not find device %r' % self._device_serial)
     else:
       self._devices = available_devices
 
+    if self._enable_device_cache:
+      for d in self._devices:
+        cache_path = _DeviceCachePath(d)
+        if os.path.exists(cache_path):
+          logging.info('Using device cache: %s', cache_path)
+          with open(cache_path) as f:
+            d.LoadCacheData(f.read())
+          os.unlink(cache_path)
+
   @property
   def devices(self):
     if not self._devices:
       raise device_errors.NoDevicesError()
     return self._devices
 
   @property
   def parallel_devices(self):
     return parallelizer.SyncParallelizer(self.devices)
 
   @property
   def max_tries(self):
     return self._max_tries
 
   @property
   def tool(self):
     return self._tool_name
 
   #override
   def TearDown(self):
-    pass
+    # Write the cache even when not using it so that it will be ready the first
+    # time that it is enabled. Writing it every time is also necessary so that
+    # an invalid cache can be flushed just by disabling it for one run.
+    for d in self._devices:
+      cache_path = _DeviceCachePath(d)
+      with open(cache_path, 'w') as f:
+        f.write(d.DumpCacheData())
+        logging.info('Wrote device cache: %s', cache_path)
 
   def BlacklistDevice(self, device):
     if not self._blacklist:
       logging.warning(
           'Attempted to blacklist %s, but no blacklist was provided.',
           str(device))
       return
 
     device_serial = device.adb.GetDeviceSerial()
     self._blacklist.Extend([device_serial])
     with self._devices_lock:
       self._devices = [d for d in self._devices if str(d) != device_serial]