[Android] Dedup content_browsertests test setup from gtests.

build/android/test_runner.py

 #!/usr/bin/env python
 #
 # Copyright 2013 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 types of tests from one unified interface.
 
 TODO(gkanwar):
 * Add options to run Monkey tests.
 """
 
 import collections
 import optparse
 import os
 import shutil
 import sys
 
 from pylib import cmd_helper
 from pylib import constants
 from pylib import ports
 from pylib.base import base_test_result
 from pylib.base import test_dispatcher
-from pylib.browsertests import setup as browsertests_setup
 from pylib.gtest import setup as gtest_setup
 from pylib.gtest import gtest_config
 from pylib.host_driven import run_python_tests as python_dispatch
 from pylib.instrumentation import setup as instrumentation_setup
 from pylib.uiautomator import setup as uiautomator_setup
 from pylib.utils import report_results
 from pylib.utils import run_tests_helper
 
 
 _SDK_OUT_DIR = os.path.join(constants.DIR_SOURCE_ROOT, 'out')
@@ skipping 55 matching lines @@
   option_parser.add_option('-d', '--device', dest='test_device',
                            help=('Target device for the test suite '
                                  'to run on.'))
 
 
 def ProcessCommonOptions(options):
   """Processes and handles all common options."""
   run_tests_helper.SetLogLevel(options.verbose_count)
 
 
-def AddCoreGTestOptions(option_parser):
-  """Add options specific to the gtest framework to |option_parser|."""
-
-  # TODO(gkanwar): Consolidate and clean up test filtering for gtests and
-  # content_browsertests.
-  option_parser.add_option('-f', '--gtest_filter', dest='test_filter',
-                           help='googletest-style filter string.')
-  option_parser.add_option('-a', '--test_arguments', dest='test_arguments',
-                           help='Additional arguments to pass to the test.')
-  option_parser.add_option('--exe', action='store_true',
-                           help='If set, use the exe test runner instead of '
-                           'the APK.')
-  option_parser.add_option('-t', dest='timeout',
-                           help='Timeout to wait for each test',
-                           type='int',
-                           default=60)
-
-
-def AddContentBrowserTestOptions(option_parser):
-  """Adds Content Browser test options to |option_parser|."""
-
-  option_parser.usage = '%prog content_browsertests [options]'
-  option_parser.command_list = []
-  option_parser.example = '%prog content_browsertests'
-
-  AddCoreGTestOptions(option_parser)
-  AddCommonOptions(option_parser)
-
-
 def AddGTestOptions(option_parser):
   """Adds gtest options to |option_parser|."""
 
   option_parser.usage = '%prog gtest [options]'
   option_parser.command_list = []
   option_parser.example = '%prog gtest -s base_unittests'
 
   # TODO(gkanwar): Make this option required
   option_parser.add_option('-s', '--suite', dest='suite_name',
                            help=('Executable name of the test suite to run '
                                  '(use -s help to list them).'))
-  AddCoreGTestOptions(option_parser)
+  option_parser.add_option('-f', '--gtest_filter', dest='test_filter',
+                           help='googletest-style filter string.')
+  option_parser.add_option('-a', '--test_arguments', dest='test_arguments',
+                           help='Additional arguments to pass to the test.')
+  option_parser.add_option('-t', dest='timeout',
+                           help='Timeout to wait for each test',
+                           type='int',
+                           default=60)
   # TODO(gkanwar): Move these to Common Options once we have the plumbing
   # in our other test types to handle these commands
   AddCommonOptions(option_parser)
 
 
 def ProcessGTestOptions(options):
   """Intercept test suite help to list test suites.
 
   Args:
     options: Command line options.
 
   Returns:
     True if the command should continue.
   """
   if options.suite_name == 'help':
     print 'Available test suites are:'
-    for test_suite in gtest_config.STABLE_TEST_SUITES:
-      print test_suite.name
+    for test_suite in (gtest_config.STABLE_TEST_SUITES +
+                       gtest_config.EXPERIMENTAL_TEST_SUITES):
+      print test_suite
     return False
 
   # Convert to a list, assuming all test suites if nothing was specified.
   # TODO(gkanwar): Require having a test suite
   if options.suite_name:
     options.suite_name = [options.suite_name]
   else:
-    options.suite_name = [suite.name
-                          for suite in gtest_config.STABLE_TEST_SUITES]
+    options.suite_name = [s for s in gtest_config.STABLE_TEST_SUITES]
   return True
 
 
 def AddJavaTestOptions(option_parser):
   """Adds the Java test options to |option_parser|."""
 
   option_parser.add_option('-f', '--test_filter', dest='test_filter',
                            help=('Test filter (if not fully qualified, '
                                  'will run all matches).'))
   option_parser.add_option(
@@ skipping 165 matching lines @@
 
 
 def _RunGTests(options, error_func):
   """Subcommand of RunTestsCommands which runs gtests."""
   if not ProcessGTestOptions(options):
     return 0
 
   exit_code = 0
   for suite_name in options.suite_name:
     runner_factory, tests = gtest_setup.Setup(
-        options.exe, suite_name, options.test_arguments,
+        suite_name, options.test_arguments,
         options.timeout, options.cleanup_test_files, options.tool,
         options.build_type, options.push_deps, options.test_filter)
 
     results, test_exit_code = test_dispatcher.RunTests(
         tests, runner_factory, False, options.test_device,
         shard=True,
         build_type=options.build_type,
         test_timeout=None,
         num_retries=options.num_retries)
 
     if test_exit_code and exit_code != constants.ERROR_EXIT_CODE:
       exit_code = test_exit_code
 
     report_results.LogFull(
         results=results,
         test_type='Unit test',
         test_package=suite_name,
         build_type=options.build_type,
         flakiness_server=options.flakiness_dashboard_server)
 
   if os.path.isdir(constants.ISOLATE_DEPS_DIR):
     shutil.rmtree(constants.ISOLATE_DEPS_DIR)
 
   return exit_code
 
 
-def _RunContentBrowserTests(options, error_func):
-  """Subcommand of RunTestsCommands which runs content_browsertests."""
-  runner_factory, tests = browsertests_setup.Setup(
-      options.test_arguments, options.timeout, options.cleanup_test_files,
-      options.tool, options.build_type, options.push_deps,
-      options.test_filter)
-
-  # TODO(nileshagrawal): remove this abnormally long setup timeout once fewer
-  # files are pushed to the devices for content_browsertests: crbug.com/138275
-  setup_timeout = 20 * 60  # 20 minutes
-  results, exit_code = test_dispatcher.RunTests(
-      tests, runner_factory, False, options.test_device,
-      shard=True,
-      build_type=options.build_type,
-      test_timeout=None,
-      setup_timeout=setup_timeout,
-      num_retries=options.num_retries)
-
-  report_results.LogFull(
-      results=results,
-      test_type='Unit test',
-      test_package=constants.BROWSERTEST_SUITE_NAME,
-      build_type=options.build_type,
-      flakiness_server=options.flakiness_dashboard_server)
-
-  if os.path.isdir(constants.ISOLATE_DEPS_DIR):
-    shutil.rmtree(constants.ISOLATE_DEPS_DIR)
-
-  return exit_code
-
-
 def _RunInstrumentationTests(options, error_func):
   """Subcommand of RunTestsCommands which runs instrumentation tests."""
   ProcessInstrumentationOptions(options, error_func)
 
   results = base_test_result.TestRunResults()
   exit_code = 0
 
   if options.run_java_tests:
     runner_factory, tests = instrumentation_setup.Setup(
         options.test_apk_path, options.test_apk_jar_path, options.annotations,
@@ skipping 99 matching lines @@
 
   # Check for extra arguments
   if len(args) > 2:
     option_parser.error('Unrecognized arguments: %s' % (' '.join(args[2:])))
     return constants.ERROR_EXIT_CODE
 
   ProcessCommonOptions(options)
 
   if command == 'gtest':
     return _RunGTests(options, option_parser.error)
-  elif command == 'content_browsertests':
-    return _RunContentBrowserTests(options, option_parser.error)
   elif command == 'instrumentation':
     return _RunInstrumentationTests(options, option_parser.error)
   elif command == 'uiautomator':
     return _RunUIAutomatorTests(options, option_parser.error)
   else:
     raise Exception('Unknown test type.')
 
   return exit_code
 
 
@@ skipping 38 matching lines @@
   return 0
 
 
 # Define a named tuple for the values in the VALID_COMMANDS dictionary so the
 # syntax is a bit prettier. The tuple is two functions: (add options, run
 # command).
 CommandFunctionTuple = collections.namedtuple(
     'CommandFunctionTuple', ['add_options_func', 'run_command_func'])
 VALID_COMMANDS = {
     'gtest': CommandFunctionTuple(AddGTestOptions, RunTestsCommand),
-    'content_browsertests': CommandFunctionTuple(
-        AddContentBrowserTestOptions, RunTestsCommand),
     'instrumentation': CommandFunctionTuple(
         AddInstrumentationTestOptions, RunTestsCommand),
     'uiautomator': CommandFunctionTuple(
         AddUIAutomatorTestOptions, RunTestsCommand),
     'help': CommandFunctionTuple(lambda option_parser: None, HelpCommand)
     }
 
 
 class CommandOptionParser(optparse.OptionParser):
   """Wrapper class for OptionParser to help with listing commands."""
@@ skipping 32 matching lines @@
     return 0
   command = argv[1]
   VALID_COMMANDS[command].add_options_func(option_parser)
   options, args = option_parser.parse_args(argv)
   return VALID_COMMANDS[command].run_command_func(
       command, options, args, option_parser)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))