[Android] Remove fast_and_loose option from the gtest runner.

build/android/run_tests.py

 #!/usr/bin/env python
 #
 # 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.
 
 """Runs all the native unit tests.
 
 1. Copy over test binary to /data/local on device.
 2. Resources: chrome/unit_tests requires resources (chrome.pak and en-US.pak)
@@ skipping 94 matching lines @@
                       'Ensure it has been built.\n' %
                       (t, q, _TEST_SUITES))
   return qualified_test_suites
 
 
 class TestSharder(BaseTestSharder):
   """Responsible for sharding the tests on the connected devices."""
 
   def __init__(self, attached_devices, test_suite, gtest_filter,
                test_arguments, timeout, cleanup_test_files, tool,
-               log_dump_name, fast_and_loose, build_type, in_webkit_checkout,
+               log_dump_name, build_type, in_webkit_checkout,
                flakiness_server=None):
     BaseTestSharder.__init__(self, attached_devices, build_type)
     self.test_suite = test_suite
     self.gtest_filter = gtest_filter or ''
     self.test_arguments = test_arguments
     self.timeout = timeout
     self.cleanup_test_files = cleanup_test_files
     self.tool = tool
     self.log_dump_name = log_dump_name
-    self.fast_and_loose = fast_and_loose
     self.in_webkit_checkout = in_webkit_checkout
     self.flakiness_server = flakiness_server
     self.all_tests = []
     if not self.gtest_filter:
       # No filter has been specified, let's add all tests then.
       self.all_tests, self.attached_devices = self._GetAllEnabledTests()
     self.tests = self.all_tests
 
   def _GetAllEnabledTests(self):
     """Get all enabled tests and available devices.
@@ skipping 26 matching lines @@
     test_runner = SingleTestRunner(
         device,
         self.test_suite,
         self.gtest_filter,
         self.test_arguments,
         self.timeout,
         self.cleanup_test_files,
         self.tool,
         0,
         not not self.log_dump_name,
-        self.fast_and_loose,
         self.build_type,
         self.in_webkit_checkout)
     # The executable/apk needs to be copied before we can call GetAllTests.
     test_runner.test_package.StripAndCopyExecutable()
     all_tests = test_runner.test_package.GetAllTests()
     disabled_list = test_runner.GetDisabledTests()
     # Only includes tests that do not have any match in the disabled list.
     all_tests = filter(lambda t:
                        not any([fnmatch.fnmatch(t, disabled_pattern)
                                 for disabled_pattern in disabled_list]),
@@ skipping 15 matching lines @@
     shard_test_list = self.tests[index * shard_size : (index + 1) * shard_size]
     test_filter = ':'.join(shard_test_list) + self.gtest_filter
     return SingleTestRunner(
         device,
         self.test_suite,
         test_filter,
         self.test_arguments,
         self.timeout,
         self.cleanup_test_files, self.tool, index,
         not not self.log_dump_name,
-        self.fast_and_loose,
         self.build_type,
         self.in_webkit_checkout)
 
   def OnTestsCompleted(self, test_runners, test_results):
     """Notifies that we completed the tests."""
     test_results.LogFull(
         test_type='Unit test',
         test_package=test_runners[0].test_package.test_suite_basename,
         build_type=self.build_type,
         all_tests=self.all_tests,
@@ skipping 27 matching lines @@
   attached_devices = []
   buildbot_emulators = []
 
   if options.use_emulator:
     for n in range(options.emulator_count):
       t = time_profile.TimeProfile('Emulator launch %d' % n)
       avd_name = None
       if n > 0:
         # Creates a temporary AVD for the extra emulators.
         avd_name = 'run_tests_avd_%d' % n
-      buildbot_emulator = emulator.Emulator(avd_name, options.fast_and_loose)
+      buildbot_emulator = emulator.Emulator(avd_name)
       buildbot_emulator.Launch(kill_all_emulators=n == 0)
       t.Stop()
       buildbot_emulators.append(buildbot_emulator)
       attached_devices.append(buildbot_emulator.device)
     # Wait for all emulators to boot completed.
     map(lambda buildbot_emulator: buildbot_emulator.ConfirmLaunch(True),
         buildbot_emulators)
   elif options.test_device:
     attached_devices = [options.test_device]
   else:
@@ skipping 15 matching lines @@
 
   sharder = TestSharder(
       attached_devices,
       options.test_suite,
       options.gtest_filter,
       options.test_arguments,
       options.timeout,
       options.cleanup_test_files,
       options.tool,
       options.log_dump,
-      options.fast_and_loose,
       options.build_type,
       options.webkit,
       options.flakiness_dashboard_server)
   test_results = sharder.RunShardedTests()
 
   for buildbot_emulator in buildbot_emulators:
     buildbot_emulator.Shutdown()
 
   return len(test_results.failed)
 
@@ skipping 64 matching lines @@
   # the batch (this happens because the exit status is a sum of all failures
   # from all suites, but the buildbot associates the exit status only with the
   # most recent step).
   if options.exit_code:
     return failed_tests_count
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))