Remove --performance_test from Android 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)
    to be deployed to the device. We use the device's $EXTERNAL_STORAGE as the
    base dir (which maps to Context.getExternalFilesDir()).
 3. Environment:
 3.1. chrome/unit_tests requires (via chrome_paths.cc) a directory named:
      $EXTERNAL_STORAGE + /chrome/test/data
-3.2. page_cycler_tests have following requirements,
-3.2.1  the following data on host:
-       <chrome_src_dir>/tools/page_cycler
-       <chrome_src_dir>/data/page_cycler
-3.2.2. two data directories to store above test data on device named:
-       $EXTERNAL_STORAGE + /tools/ (for database perf test)
-       $EXTERNAL_STORAGE + /data/ (for other perf tests)
-3.2.3. a http server to serve http perf tests.
-       The http root is host's <chrome_src_dir>/data/page_cycler/, port 8000.
-3.2.4  a tool named forwarder is also required to run on device to
-       forward the http request/response between host and device.
-3.2.5  Chrome is installed on device.
 4. Run the binary in the device and stream the log to the host.
 4.1. Optionally, filter specific tests.
 4.2. If we're running a single test suite and we have multiple devices
      connected, we'll shard the tests.
 5. Clean up the device.
 
 Suppressions:
 
 Individual tests in a test binary can be suppressed by listing it in
 the gtest_filter directory in a file of the same name as the test binary,
@@ skipping 140 matching lines @@
       except:
         pass
       del os.environ['DISPLAY']
       self._pid = 0
 
 
 class TestSharder(BaseTestSharder):
   """Responsible for sharding the tests on the connected devices."""
 
   def __init__(self, attached_devices, test_suite, gtest_filter,
-               test_arguments, timeout, performance_test,
-               cleanup_test_files, tool, log_dump_name, fast_and_loose,
-               build_type, in_webkit_checkout):
+               test_arguments, timeout, cleanup_test_files, tool,
+               log_dump_name, fast_and_loose, build_type, in_webkit_checkout):
     BaseTestSharder.__init__(self, attached_devices, build_type)
     self.test_suite = test_suite
     self.test_suite_basename = os.path.basename(test_suite)
     self.gtest_filter = gtest_filter or ''
     self.test_arguments = test_arguments
     self.timeout = timeout
-    self.performance_test = performance_test
     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.all_tests = []
     if not self.gtest_filter:
       # No filter has been specified, let's add all tests then.
       self.all_tests = self._GetAllEnabledTests()
     self.tests = self.all_tests
@@ skipping 18 matching lines @@
     raise Exception('No device available to get the list of tests.')
 
   def _GetTestsFromDevice(self, device):
     logging.info('Obtaining tests from %s', device)
     test_runner = SingleTestRunner(
         device,
         self.test_suite,
         self.gtest_filter,
         self.test_arguments,
         self.timeout,
-        self.performance_test,
         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()
@@ skipping 18 matching lines @@
     device_num = len(self.attached_devices)
     shard_size = (len(self.tests) + device_num - 1) / device_num
     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.performance_test,
         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('Unit test', os.path.basename(self.test_suite),
                          self.build_type, self.all_tests)
@@ skipping 48 matching lines @@
   if not attached_devices:
     logging.critical('A device must be attached and online.')
     buildbot_report.PrintError()
     return 1
 
   # Reset the test port allocation. It's important to do it before starting
   # to dispatch any tests.
   if not ports.ResetTestServerPortAllocation():
     raise Exception('Failed to reset test server port.')
 
-  if options.performance_test or options.gtest_filter:
+  if options.gtest_filter:
     logging.warning('Sharding is not possible with these configurations.')
     attached_devices = [attached_devices[0]]
 
   sharder = TestSharder(
       attached_devices,
       options.test_suite,
       options.gtest_filter,
       options.test_arguments,
       options.timeout,
-      options.performance_test,
       options.cleanup_test_files,
       options.tool,
       options.log_dump,
       options.fast_and_loose,
       options.build_type,
       options.webkit)
   test_results = sharder.RunShardedTests()
 
   for buildbot_emulator in buildbot_emulators:
     buildbot_emulator.Shutdown()
@@ skipping 50 matching lines @@
                            '(use -s help to list them)')
   option_parser.add_option('--out-directory', dest='out_directory',
                            help='Path to the out/ directory, irrespective of '
                            'the build type. Only for non-Chromium uses.')
   option_parser.add_option('-d', '--device', dest='test_device',
                            help='Target device the test suite to run ')
   option_parser.add_option('-f', '--gtest_filter', dest='gtest_filter',
                            help='gtest filter')
   option_parser.add_option('-a', '--test_arguments', dest='test_arguments',
                            help='Additional arguments to pass to the test')
-  option_parser.add_option('-p', dest='performance_test',
-                           help='Indicator of performance test',
-                           action='store_true')
   option_parser.add_option('-L', dest='log_dump',
                            help='file name of log dump, which will be put in '
                            'subfolder debug_info_dumps under the same '
                            'directory in where the test_suite exists.')
   option_parser.add_option('-e', '--emulator', dest='use_emulator',
                            action='store_true',
                            help='Run tests in a new instance of emulator')
   option_parser.add_option('-n', '--emulator_count',
                            type='int', default=1,
                            help='Number of emulators to launch for running the '
@@ skipping 45 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))