[android] Make build_type a singleton.

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.
@@ skipping 73 matching lines @@
                                  'Use this at own risk for speeding up test '
                                  'execution on local machine.'))
   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)
+  constants.SetBuildType(options.build_type)
 
 
 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
@@ skipping 160 matching lines @@
   else:
     options.test_apk_path = os.path.join(_SDK_OUT_DIR,
                                          options.build_type,
                                          constants.SDK_BUILD_APKS_DIR,
                                          '%s.apk' % options.test_apk)
     options.test_apk_jar_path = os.path.join(
         _SDK_OUT_DIR, options.build_type, constants.SDK_BUILD_TEST_JAVALIB_DIR,
         '%s.jar' %  options.test_apk)
 
   return instrumentation_test_options.InstrumentationOptions(
-      options.build_type,
       options.tool,
       options.cleanup_test_files,
       options.push_deps,
       options.annotations,
       options.exclude_annotations,
       options.test_filter,
       options.test_data,
       options.save_perf_json,
       options.screenshot_failures,
       options.wait_for_debugger,
@@ skipping 48 matching lines @@
     options.uiautomator_jar = options.test_jar
   else:
     options.uiautomator_jar = os.path.join(
         _SDK_OUT_DIR, options.build_type, constants.SDK_BUILD_JAVALIB_DIR,
         '%s.dex.jar' % options.test_jar)
   options.uiautomator_info_jar = (
       options.uiautomator_jar[:options.uiautomator_jar.find('.dex.jar')] +
       '_java.jar')
 
   return uiautomator_test_options.UIAutomatorOptions(
-      options.build_type,
       options.tool,
       options.cleanup_test_files,
       options.push_deps,
       options.annotations,
       options.exclude_annotations,
       options.test_filter,
       options.test_data,
       options.save_perf_json,
       options.screenshot_failures,
       options.uiautomator_jar,
@@ skipping 46 matching lines @@
     monkey tests.
   """
   if not options.package_name:
     error_func('Package name is required.')
 
   category = options.category
   if category:
     category = options.category.split(',')
 
   return monkey_test_options.MonkeyOptions(
-      options.build_type,
       options.verbose_count,
       options.package_name,
       options.activity_name,
       options.event_count,
       category,
       options.throttle,
       options.seed,
       options.extra_args)
 
 
 def _RunGTests(options, error_func):
   """Subcommand of RunTestsCommands which runs gtests."""
   ProcessGTestOptions(options)
 
   exit_code = 0
   for suite_name in options.suite_name:
     # TODO(gkanwar): Move this into ProcessGTestOptions once we require -s for
     # the gtest command.
     gtest_options = gtest_test_options.GTestOptions(
-        options.build_type,
         options.tool,
         options.cleanup_test_files,
         options.push_deps,
         options.test_filter,
         options.test_arguments,
         options.timeout,
         suite_name)
     runner_factory, tests = gtest_setup.Setup(gtest_options)
 
     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 _RunInstrumentationTests(options, error_func):
   """Subcommand of RunTestsCommands which runs instrumentation tests."""
   instrumentation_options = ProcessInstrumentationOptions(options, error_func)
 
   results = base_test_result.TestRunResults()
   exit_code = 0
 
   if options.run_java_tests:
     runner_factory, tests = instrumentation_setup.Setup(instrumentation_options)
 
     test_results, exit_code = test_dispatcher.RunTests(
         tests, runner_factory, options.wait_for_debugger,
         options.test_device,
         shard=True,
-        build_type=options.build_type,
         test_timeout=None,
         num_retries=options.num_retries)
 
     results.AddTestRunResults(test_results)
 
   if options.run_python_tests:
     runner_factory, tests = host_driven_setup.InstrumentationSetup(
         options.python_test_root, options.official_build,
         instrumentation_options)
 
     if tests:
       test_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)
 
       results.AddTestRunResults(test_results)
 
       # Only allow exit code escalation
       if test_exit_code and exit_code != constants.ERROR_EXIT_CODE:
         exit_code = test_exit_code
 
   report_results.LogFull(
       results=results,
       test_type='Instrumentation',
       test_package=os.path.basename(options.test_apk),
       annotation=options.annotations,
-      build_type=options.build_type,
       flakiness_server=options.flakiness_dashboard_server)
 
   return exit_code
 
 
 def _RunUIAutomatorTests(options, error_func):
   """Subcommand of RunTestsCommands which runs uiautomator tests."""
   uiautomator_options = ProcessUIAutomatorOptions(options, error_func)
 
   runner_factory, tests = uiautomator_setup.Setup(uiautomator_options)
 
   results, 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)
 
   report_results.LogFull(
       results=results,
       test_type='UIAutomator',
       test_package=os.path.basename(options.test_jar),
       annotation=options.annotations,
-      build_type=options.build_type,
       flakiness_server=options.flakiness_dashboard_server)
 
   return exit_code
 
 
 def _RunMonkeyTests(options, error_func):
   """Subcommand of RunTestsCommands which runs monkey tests."""
   monkey_options = ProcessMonkeyTestOptions(options, error_func)
 
   runner_factory, tests = monkey_setup.Setup(monkey_options)
 
   results, exit_code = test_dispatcher.RunTests(
       tests, runner_factory, False, None, shard=False)
 
   report_results.LogFull(
       results=results,
       test_type='Monkey',
-      test_package='Monkey',
-      build_type=options.build_type)
+      test_package='Monkey')
 
   return exit_code
 
 
 
 def RunTestsCommand(command, options, args, option_parser):
   """Checks test type and dispatches to the appropriate function.
 
   Args:
     command: String indicating the command that was received to trigger
@@ skipping 123 matching lines @@
     option_parser.error('Invalid command.')
   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))