[Android] Allow gtests to pull app data off the device before clearing it.

build/android/pylib/gtest/local_device_gtest_run.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 itertools
 import logging
 import os
+import posixpath
 
 from pylib import constants
 from pylib import ports
 from pylib.base import test_run
 from pylib.device import device_errors
 from pylib.gtest import gtest_test_instance
 
 from pylib.local import local_test_server_spawner
 from pylib.local.device import local_device_environment
 from pylib.local.device import local_device_test_run
@@ skipping 12 matching lines @@
 
 _MAX_SHARD_SIZE = 256
 
 # TODO(jbudorick): Move this up to the test instance if the net test server is
 # handled outside of the APK for the remote_device environment.
 _SUITE_REQUIRES_TEST_SERVER_SPAWNER = [
   'components_browsertests', 'content_unittests', 'content_browsertests',
   'net_unittests', 'unit_tests'
 ]
 
+# TODO(jbudorick): Move this inside _ApkDelegate once TestPackageApk is gone.
+def PullAppFilesImpl(device, package, files, directory):
+  device_dir = device.GetApplicationDataDirectory(package)
+  host_dir = os.path.join(directory, str(device))
+  for f in files:
+    device_file = posixpath.join(device_dir, f)
+    host_file = os.path.join(host_dir, *f.split(posixpath.sep))
+    host_file_base, ext = os.path.splitext(host_file)
+    for i in itertools.count():
+      host_file = '%s_%d%s' % (host_file_base, i, ext)
+      if not os.path.exists(host_file):
+        break
+    device.PullFile(device_file, host_file)
+
 class _ApkDelegate(object):
   def __init__(self, apk):
     self._apk = apk
 
     helper = apk_helper.ApkHelper(self._apk)
     self._activity = helper.GetActivityName()
     self._package = helper.GetPackageName()
     self._runner = helper.GetInstrumentationName()
     self._component = '%s/%s' % (self._package, self._runner)
     self._enable_test_server_spawner = False
 
   def Install(self, device):
     device.Install(self._apk)
 
   def RunWithFlags(self, device, flags, **kwargs):
     with device_temp_file.DeviceTempFile(device.adb) as command_line_file:
       device.WriteFile(command_line_file.name, '_ %s' % flags)
 
       extras = {
         _EXTRA_COMMAND_LINE_FILE: command_line_file.name,
         _EXTRA_NATIVE_TEST_ACTIVITY: self._activity,
       }
 
       return device.StartInstrumentation(
           self._component, extras=extras, raw=False, **kwargs)
 
+  def PullAppFiles(self, device, files, directory):
+    PullAppFilesImpl(device, self._package, files, directory)
+
   def Clear(self, device):
     device.ClearApplicationState(self._package)
 
 
 class _ExeDelegate(object):
   def __init__(self, exe, tr):
     self._exe_host_path = exe
     self._exe_file_name = os.path.split(exe)[-1]
     self._exe_device_path = '%s/%s' % (
         constants.TEST_EXECUTABLE_DIR, self._exe_file_name)
@@ skipping 36 matching lines @@
     # TODO(jbudorick): Switch to just RunShellCommand once perezju@'s CL
     # for long shell commands lands.
     with device_temp_file.DeviceTempFile(device.adb) as script_file:
       script_contents = ' '.join(cmd)
       logging.info('script contents: %r' % script_contents)
       device.WriteFile(script_file.name, script_contents)
       output = device.RunShellCommand(['sh', script_file.name], cwd=cwd,
                                       env=env, **kwargs)
     return output
 
+  def PullAppFiles(self, device, files, directory):
+    pass
+
   def Clear(self, device):
     device.KillAll(self._exe_file_name, blocking=True, timeout=30, quiet=True)
 
 
 class LocalDeviceGtestRun(local_device_test_run.LocalDeviceTestRun):
 
   def __init__(self, env, test_instance):
     assert isinstance(env, local_device_environment.LocalDeviceEnvironment)
     assert isinstance(test_instance, gtest_test_instance.GtestTestInstance)
     super(LocalDeviceGtestRun, self).__init__(env, test_instance)
@@ skipping 60 matching lines @@
     tests = self._test_instance.FilterTests(tests)
     return tests
 
   #override
   def _RunTest(self, device, test):
     # Run the test.
     output = self._delegate.RunWithFlags(
         device, '--gtest_filter=%s' % test, timeout=900, retries=0)
     for s in self._servers[str(device)]:
       s.Reset()
+    if self._test_instance.app_files:
+      self._delegate.PullAppFiles(device, self._test_instance.app_files,
+                                  self._test_instance.app_file_dir)
     self._delegate.Clear(device)
 
     # Parse the output.
     # TODO(jbudorick): Transition test scripts away from parsing stdout.
     results = self._test_instance.ParseGTestOutput(output)
     return results
 
   #override
   def TearDown(self):
     def individual_device_tear_down(dev):
       for s in self._servers[str(dev)]:
         s.TearDown()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)