[Android] Fix miscellaneous small issues with gtest platform mode.

build/android/pylib/local/device/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 os
 import posixpath
 
 from devil.android import device_errors
 from devil.android import device_temp_file
 from devil.android import ports
 from pylib import constants
 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
 
 _COMMAND_LINE_FLAGS_SUPPORTED = True
 
 _EXTRA_COMMAND_LINE_FILE = (
     'org.chromium.native_test.NativeTestActivity.CommandLineFile')
 _EXTRA_COMMAND_LINE_FLAGS = (
     'org.chromium.native_test.NativeTestActivity.CommandLineFlags')
+_EXTRA_SHARD_NANO_TIMEOUT = (
+    'org.chromium.native_test.NativeTestInstrumentationTestRunner'
+        '.ShardNanoTimeout')
 _EXTRA_TEST_LIST = (
     'org.chromium.native_test.NativeTestInstrumentationTestRunner'
         '.TestList')
 
 _MAX_SHARD_SIZE = 256
+_SECONDS_TO_NANOS = int(1e9)
 
 # 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):
@@ skipping 19 matching lines @@
 
     self._component = '%s/%s' % (self._package, self._runner)
     self._extras = test_instance.extras
 
   def Install(self, device):
     device.Install(self._apk, permissions=self._permissions)
 
   def Run(self, test, device, flags=None, **kwargs):
     extras = dict(self._extras)
 
+    if 'timeout' in kwargs:
+      # Make sure the instrumentation doesn't kill the test before the
+      # scripts do. The provided timeout value is in seconds, but the
+      # instrumentation deals with nanoseconds because that's how Android
+      # handles time.
+      extras[_EXTRA_SHARD_NANO_TIMEOUT] = int(

[jbudorick, 2015/09/23 20:36:45]

kjellander: this is the change that should prevent the webrtc_perf_tests from
timing out.

+          kwargs['timeout'] * _SECONDS_TO_NANOS)
+
     with device_temp_file.DeviceTempFile(device.adb) as command_line_file:
       device.WriteFile(command_line_file.name, '_ %s' % flags if flags else '_')
       extras[_EXTRA_COMMAND_LINE_FILE] = command_line_file.name
 
       with device_temp_file.DeviceTempFile(device.adb) as test_list_file:
         if test:
           device.WriteFile(test_list_file.name, '\n'.join(test))
           extras[_EXTRA_TEST_LIST] = test_list_file.name
 
         return device.StartInstrumentation(
@@ skipping 133 matching lines @@
       tests = gtest_test_instance.ParseGTestListTests(tests)
       tests = self._test_instance.FilterTests(tests)
       return tests
 
     test_lists = self._env.parallel_devices.pMap(list_tests).pGet(None)
     tests = list(sorted(set().union(*[set(tl) for tl in test_lists if tl])))
     return tests
 
   #override
   def _RunTest(self, device, test):
-    # Run the test.
-    timeout = 900 * self.GetTool(device).GetTimeoutScale()
+    if self._test_instance.suite in gtest_test_instance.BROWSER_TEST_SUITES:
+      timeout = 900
+    else:
+      timeout = 60
+    timeout *= self.GetTool(device).GetTimeoutScale()
+
     output = self._delegate.Run(
         test, device, timeout=timeout, 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):
     @local_device_test_run.handle_shard_failures
     def individual_device_tear_down(dev):
-      for s in self._servers[str(dev)]:
+      for s in self._servers.get(str(dev), []):
         s.TearDown()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)