Update from https://crrev.com/328418

build/android/pylib/remote/device/remote_device_test_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.
 
 """Run specific test on specific environment."""
 
 import json
 import logging
 import os
 import sys
@@ skipping 11 matching lines @@
 class RemoteDeviceTestRun(test_run.TestRun):
   """Run tests on a remote device."""
 
   _TEST_RUN_KEY = 'test_run'
   _TEST_RUN_ID_KEY = 'test_run_id'
 
   WAIT_TIME = 5
   COMPLETE = 'complete'
   HEARTBEAT_INTERVAL = 300
 
+  _RESULTS_FILE = 'appurify_results/result.txt'
+
   def __init__(self, env, test_instance):
     """Constructor.
 
     Args:
       env: Environment the tests will run in.
       test_instance: The test that will be run.
     """
     super(RemoteDeviceTestRun, self).__init__(env, test_instance)
     self._env = env
     self._test_instance = test_instance
@@ skipping 124 matching lines @@
     for test in test_list_res.json()['response']:
       if test['test_type'] == test_name:
         return test['test_id']
     raise remote_device_helper.RemoteDeviceError(
         'No test found with name %s' % (test_name))
 
   def _DownloadTestResults(self, results_path):
     """Download the test results from remote device service.
 
     Args:
-      results_path: path to download results to.
+      results_path: Path to download appurify results zipfile.
     """
     if results_path:
       logging.info('Downloading results to %s.' % results_path)
       if not os.path.exists(os.path.dirname(results_path)):
         os.makedirs(os.path.dirname(results_path))
       with appurify_sanitized.SanitizeLogging(self._env.verbose_count,
                                               logging.WARNING):
         appurify_sanitized.utils.wget(self._results['results']['url'],
                                       results_path)
 
+  def _GetRawTestOutput(self):
+    """Returns the test output."""
+    # TODO(mikecase): Remove getting results from zip when b/18981674 is fixed.
+    results_zipfile = self._env.results_path
+    if results_zipfile and os.path.exists(results_zipfile):
+      with zipfile.ZipFile(results_zipfile) as z:
+        with z.open(self._RESULTS_FILE, 'r') as r:
+          return r.read()
+    else:
+      logging.warning(
+          'If the test output is too long, some test results may get cut off.')
+      logging.warning(
+          'Use the --results-path option to ensure you get the full results.')
+      return self._results['results']['output']
+
   def _GetTestStatus(self, test_run_id):
     """Checks the state of the test, and sets self._results
 
     Args:
       test_run_id: Id of test on on remote service.
     """
 
     with appurify_sanitized.SanitizeLogging(self._env.verbose_count,
                                             logging.WARNING):
       test_check_res = appurify_sanitized.api.tests_check_result(
           self._env.token, test_run_id)
     remote_device_helper.TestHttpResponse(test_check_res,
                                           'Unable to get test status.')
     self._results = test_check_res.json()['response']
     return self._results['status']
 
   def _AmInstrumentTestSetup(self, app_path, test_path, runner_package,
-                             environment_variables):
+                             environment_variables, extra_apks=None):
     config = {'runner': runner_package}
     if environment_variables:
       config['environment_vars'] = ','.join(
           '%s=%s' % (k, v) for k, v in environment_variables.iteritems())
 
     self._app_id = self._UploadAppToDevice(app_path)
 
     data_deps = self._test_instance.GetDataDependencies()
     if data_deps:
       with tempfile.NamedTemporaryFile(suffix='.zip') as test_with_deps:
         sdcard_files = []
+        additional_apks = []
         host_test = os.path.basename(test_path)
         with zipfile.ZipFile(test_with_deps.name, 'w') as zip_file:
           zip_file.write(test_path, host_test, zipfile.ZIP_DEFLATED)
           for h, _ in data_deps:
             if os.path.isdir(h):
               zip_utils.WriteToZipFile(zip_file, h, '.')
               sdcard_files.extend(os.listdir(h))
             else:
               zip_utils.WriteToZipFile(zip_file, h, os.path.basename(h))
               sdcard_files.append(os.path.basename(h))
+          for a in extra_apks or ():
+            zip_utils.WriteToZipFile(zip_file, a, os.path.basename(a));
+            additional_apks.append(os.path.basename(a))
+
         config['sdcard_files'] = ','.join(sdcard_files)
         config['host_test'] = host_test
+        if additional_apks:
+          config['additional_apks'] = ','.join(additional_apks)
         self._test_id = self._UploadTestToDevice(
             'robotium', test_with_deps.name, app_id=self._app_id)
     else:
       self._test_id = self._UploadTestToDevice('robotium', test_path)
 
     logging.info('Setting config: %s' % config)
     appurify_configs = {}
     if self._env.network_config:
       appurify_configs['network'] = self._env.network_config
     self._SetTestConfig('robotium', config, **appurify_configs)
 
   def _UploadAppToDevice(self, app_path):
     """Upload app to device."""
-    logging.info('Uploading %s to remote service.', app_path)
+    logging.info('Uploading %s to remote service as %s.', app_path,
+                 self._test_instance.suite)
     with open(app_path, 'rb') as apk_src:
       with appurify_sanitized.SanitizeLogging(self._env.verbose_count,
                                               logging.WARNING):
         upload_results = appurify_sanitized.api.apps_upload(
             self._env.token, apk_src, 'raw', name=self._test_instance.suite)
       remote_device_helper.TestHttpResponse(
           upload_results, 'Unable to upload %s.' % app_path)
       return upload_results.json()['response']['app_id']
 
   def _UploadTestToDevice(self, test_type, test_path, app_id=None):
@@ skipping 38 matching lines @@
       config_data.extend(
           '%s=%s' % (k, v) for k, v in runner_configs.iteritems())
       config.write(''.join('%s\n' % l for l in config_data))
       config.flush()
       config.seek(0)
       with appurify_sanitized.SanitizeLogging(self._env.verbose_count,
                                               logging.WARNING):
         config_response = appurify_sanitized.api.config_upload(
             self._env.token, config, self._test_id)
       remote_device_helper.TestHttpResponse(
-          config_response, 'Unable to upload test config.')
+          config_response, 'Unable to upload test config.')