Update from https://crrev.com/303153

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."""
 
 import collections
 import logging
 import optparse
 import os
 import shutil
 import signal
 import sys
 import threading
 import unittest
 
 from pylib import android_commands
 from pylib import constants
 from pylib import forwarder
 from pylib import ports
 from pylib.base import base_test_result
+from pylib.base import environment_factory
 from pylib.base import test_dispatcher
+from pylib.base import test_instance_factory
+from pylib.base import test_run_factory
 from pylib.gtest import gtest_config
 from pylib.gtest import setup as gtest_setup
 from pylib.gtest import test_options as gtest_test_options
 from pylib.linker import setup as linker_setup
 from pylib.host_driven import setup as host_driven_setup
 from pylib.instrumentation import setup as instrumentation_setup
 from pylib.instrumentation import test_options as instrumentation_test_options
 from pylib.junit import setup as junit_setup
 from pylib.junit import test_dispatcher as junit_dispatcher
 from pylib.monkey import setup as monkey_setup
 from pylib.monkey import test_options as monkey_test_options
 from pylib.perf import setup as perf_setup
 from pylib.perf import test_options as perf_test_options
 from pylib.perf import test_runner as perf_test_runner
 from pylib.uiautomator import setup as uiautomator_setup
 from pylib.uiautomator import test_options as uiautomator_test_options
 from pylib.utils import apk_helper
 from pylib.utils import command_option_parser
 from pylib.utils import report_results
 from pylib.utils import reraiser_thread
 from pylib.utils import run_tests_helper
 
 
-HOST_TESTS = ['junit', 'python']
-
-
 def AddCommonOptions(option_parser):
   """Adds all common options to |option_parser|."""
 
   group = optparse.OptionGroup(option_parser, 'Common Options')
   default_build_type = os.environ.get('BUILDTYPE', 'Debug')
   group.add_option('--debug', action='store_const', const='Debug',
                    dest='build_type', default=default_build_type,
                    help=('If set, run test suites under out/Debug. '
                          'Default is env var BUILDTYPE or Debug.'))
   group.add_option('--release', action='store_const',
@@ skipping 10 matching lines @@
   group.add_option('-v',
                    '--verbose',
                    dest='verbose_count',
                    default=0,
                    action='count',
                    help='Verbose level (multiple times for more)')
   group.add_option('--flakiness-dashboard-server',
                    dest='flakiness_dashboard_server',
                    help=('Address of the server that is hosting the '
                          'Chrome for Android flakiness dashboard.'))
+  group.add_option('--enable-platform-mode', action='store_true',
+                   help=('Run the test scripts in platform mode, which '
+                         'conceptually separates the test runner from the '
+                         '"device" (local or remote, real or emulated) on '
+                         'which the tests are running. [experimental]'))
+  group.add_option('-e', '--environment', default='local',
+                   help=('Test environment to run in. Must be one of: %s' %
+                         ', '.join(constants.VALID_ENVIRONMENTS)))
   option_parser.add_option_group(group)
 
 
-def ProcessCommonOptions(options):
+def ProcessCommonOptions(options, error_func):
   """Processes and handles all common options."""
   run_tests_helper.SetLogLevel(options.verbose_count)
   constants.SetBuildType(options.build_type)
   if options.build_directory:
     constants.SetBuildDirectory(options.build_directory)
+  if options.environment not in constants.VALID_ENVIRONMENTS:
+    error_func('--environment must be one of: %s' %
+               ', '.join(constants.VALID_ENVIRONMENTS))
 
 
 def AddDeviceOptions(option_parser):
   group = optparse.OptionGroup(option_parser, 'Device Options')
   group.add_option('-c', dest='cleanup_test_files',
                    help='Cleanup test files on the device after run',
                    action='store_true')
   group.add_option('--tool',
                    dest='tool',
                    help=('Run the test under a tool '
@@ skipping 725 matching lines @@
   # Check for extra arguments
   if len(args) > 2 and command != 'perf':
     option_parser.error('Unrecognized arguments: %s' % (' '.join(args[2:])))
     return constants.ERROR_EXIT_CODE
   if command == 'perf':
     if ((options.single_step and len(args) <= 2) or
         (not options.single_step and len(args) > 2)):
       option_parser.error('Unrecognized arguments: %s' % (' '.join(args)))
       return constants.ERROR_EXIT_CODE
 
-  ProcessCommonOptions(options)
+  ProcessCommonOptions(options, option_parser.error)
 
-  if command in HOST_TESTS:
+  if options.enable_platform_mode:
+    return RunTestsInPlatformMode(command, options, option_parser)
+
+  if command in constants.LOCAL_MACHINE_TESTS:
     devices = []
   else:
     devices = _GetAttachedDevices(options.test_device)
 
   forwarder.Forwarder.RemoveHostLog()
   if not ports.ResetTestServerPortAllocation():
     raise Exception('Failed to reset test server port.')
 
   if command == 'gtest':
     return _RunGTests(options, devices)
   elif command == 'linker':
     return _RunLinkerTests(options, devices)
   elif command == 'instrumentation':
     return _RunInstrumentationTests(options, option_parser.error, devices)
   elif command == 'uiautomator':
     return _RunUIAutomatorTests(options, option_parser.error, devices)
   elif command == 'junit':
     return _RunJUnitTests(options, option_parser.error)
   elif command == 'monkey':
     return _RunMonkeyTests(options, option_parser.error, devices)
   elif command == 'perf':
     return _RunPerfTests(options, args, option_parser.error)
   elif command == 'python':
     return _RunPythonTests(options, option_parser.error)
   else:
     raise Exception('Unknown test type.')
 
 
+_SUPPORTED_IN_PLATFORM_MODE = [
+  # TODO(jbudorick): Add support for more test types.
+  'gtest',
+]
+
+
+def RunTestsInPlatformMode(command, options, option_parser):
+
+  if command not in _SUPPORTED_IN_PLATFORM_MODE:
+    option_parser.error('%s is not yet supported in platform mode' % command)
+
+  with environment_factory.CreateEnvironment(
+      command, options, option_parser.error) as env:
+    with test_instance_factory.CreateTestInstance(
+        command, options, option_parser.error) as test:
+      with test_run_factory.CreateTestRun(
+          options, env, test, option_parser.error) as test_run:
+        results = test_run.RunTests()
+
+        report_results.LogFull(
+            results=results,
+            test_type=test.TestType(),
+            test_package=test_run.TestPackage(),
+            annotation=options.annotations,
+            flakiness_server=options.flakiness_dashboard_server)
+
+  return results
+
+
 def HelpCommand(command, _options, args, option_parser):
   """Display help for a certain command, or overall help.
 
   Args:
     command: String indicating the command that was received to trigger
         this function.
     options: optparse options dictionary. unused.
     args: List of extra args from optparse.
     option_parser: optparse.OptionParser object.
 
@@ skipping 60 matching lines @@
 
 def main():
   signal.signal(signal.SIGUSR1, DumpThreadStacks)
   option_parser = command_option_parser.CommandOptionParser(
       commands_dict=VALID_COMMANDS)
   return command_option_parser.ParseAndExecute(option_parser)
 
 
 if __name__ == '__main__':
   sys.exit(main())