Add instance-level in-memory cache for PushIfNeeded().

build/android/pylib/android_commands.py

 # Copyright (c) 2012 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 an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 
 import collections
@@ skipping 235 matching lines @@
     self._device = device
     self._logcat = None
     self.logcat_process = None
     self._logcat_tmpoutfile = None
     self._pushed_files = []
     self._device_utc_offset = None
     self._potential_push_size = 0
     self._actual_push_size = 0
     self._external_storage = ''
     self._util_wrapper = ''
+    self._push_if_needed_cache = {}
 
   def _LogShell(self, cmd):
     """Logs the adb shell command."""
     if self._device:
       device_repr = self._device[-4:]
     else:
       device_repr = '????'
     logging.info('[%s]> %s', device_repr, cmd)
 
   def Adb(self):
@@ skipping 644 matching lines @@
     """Pushes |host_path| to |device_path|.
 
     Works for files and directories. This method skips copying any paths in
     |test_data_paths| that already exist on the device with the same hash.
 
     All pushed files can be removed by calling RemovePushedFiles().
     """
     MAX_INDIVIDUAL_PUSHES = 50
     assert os.path.exists(host_path), 'Local path not found %s' % host_path
 
+    # See if the file on the host changed since the last push (if any) and
+    # return early if it didn't. Note that this shortcut assumes that the tests
+    # on the device don't modify the files.
+    if not os.path.isdir(host_path):
+      if host_path in self._push_if_needed_cache:
+        host_path_mtime = self._push_if_needed_cache[host_path]
+        if host_path_mtime == os.stat(host_path).st_mtime:
+          return
+
     def GetHostSize(path):
       return int(cmd_helper.GetCmdOutput(['du', '-sb', path]).split()[0])
 
     size = GetHostSize(host_path)
     self._pushed_files.append(device_path)
     self._potential_push_size += size
 
     changed_files = self.GetFilesChanged(host_path, device_path)
     logging.info('Found %d files that need to be pushed to %s',
         len(changed_files), device_path)
     if not changed_files:
       return
 
     def Push(host, device):
       # NOTE: We can't use adb_interface.Push() because it hardcodes a timeout
       # of 60 seconds which isn't sufficient for a lot of users of this method.
       push_command = 'push %s %s' % (host, device)
       self._LogShell(push_command)
 
       # Retry push with increasing backoff if the device is busy.
       retry = 0
       while True:
         output = self._adb.SendCommand(push_command, timeout_time=30 * 60)
         if _HasAdbPushSucceeded(output):
+          if not os.path.isdir(host_path):

[craigdh, 2013/12/10 19:23:32]

If we're only doing this for single files, then instead of doing this in the
loop (calling os.path.isdir for every file when we're pushing large directories)
just stick it at the end of PushIfNeeded (line 980). An exception is raised if
the push fails so this will only be cached if the file is successfully pushed.

+            self._push_if_needed_cache[host] = os.stat(host).st_mtime
           return
         if retry < 3:
           retry += 1
           wait_time = 5 * retry
           logging.error('Push failed, retrying in %d seconds: %s' %
                         (wait_time, output))
           time.sleep(wait_time)
         else:
           raise Exception('Push failed: %s' % output)
 
@@ skipping 759 matching lines @@
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()