[Android] Move getting the list of devices out of test_dispatcher.

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 logging
 import optparse
 import os
 import shutil
 import sys
 
+from pylib import android_commands
 from pylib import constants
 from pylib import ports
 from pylib.base import base_test_result
 from pylib.base import test_dispatcher
 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.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
@@ skipping 418 matching lines @@
   Returns:
     A PerfOptions named tuple which contains all options relevant to
     perf tests.
   """
   if not options.steps and not options.print_step:
     error_func('Please specify --steps or --print-step')
   return perf_test_options.PerfOptions(
       options.steps, options.flaky_steps, options.print_step)
 
 
-
-def _RunGTests(options, error_func):
+def _RunGTests(options, error_func, devices):
   """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.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)
+    runner_factory, tests = gtest_setup.Setup(gtest_options, devices)
 
     results, test_exit_code = test_dispatcher.RunTests(
-        tests, runner_factory, False, options.test_device,
-        shard=True,
-        test_timeout=None,
+        tests, runner_factory, devices, shard=True, 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,
         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):
+def _RunInstrumentationTests(options, error_func, devices):
   """Subcommand of RunTestsCommands which runs instrumentation tests."""
   instrumentation_options = ProcessInstrumentationOptions(options, error_func)
 
+  if len(devices) > 1 and options.wait_for_debugger:
+    logging.warning('Debugger can not be sharded, using first available device')
+    devices = devices[:1]
+
   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,
-        test_timeout=None,
+        tests, runner_factory, devices, shard=True, 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.host_driven_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,
-          test_timeout=None,
+          tests, runner_factory, devices, shard=True, 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,
       flakiness_server=options.flakiness_dashboard_server)
 
   return exit_code
 
 
-def _RunUIAutomatorTests(options, error_func):
+def _RunUIAutomatorTests(options, error_func, devices):
   """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,
-      test_timeout=None,
+      tests, runner_factory, devices, shard=True, 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,
       flakiness_server=options.flakiness_dashboard_server)
 
   return exit_code
 
 
-def _RunMonkeyTests(options, error_func):
+def _RunMonkeyTests(options, error_func, devices):
   """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, test_timeout=None)
+      tests, runner_factory, devices, shard=False, test_timeout=None)
 
   report_results.LogFull(
       results=results,
       test_type='Monkey',
       test_package='Monkey')
 
   return exit_code
 
 
-def _RunPerfTests(options, error_func):
+def _RunPerfTests(options, error_func, devices):
   """Subcommand of RunTestsCommands which runs perf tests."""
   perf_options = ProcessPerfTestOptions(options, error_func)
     # Just print the results from a single previously executed step.
   if perf_options.print_step:
     return perf_test_runner.PrintTestOutput(perf_options.print_step)
 
   runner_factory, tests = perf_setup.Setup(perf_options)
 
   results, _ = test_dispatcher.RunTests(
-      tests, runner_factory, False, None, shard=True, test_timeout=None)
+      tests, runner_factory, devices, shard=True, test_timeout=None)
 
   report_results.LogFull(
       results=results,
       test_type='Perf',
       test_package='Perf')
   # Always return 0 on the sharding stage. Individual tests exit_code
   # will be returned on the print_step stage.
   return 0
 
 
+def _GetAttachedDevices(test_device=None):
+  """Get all attached devices.
+
+  Args:
+    test_device: Name of a specific device to use.
+
+  Returns:
+    A list of attached devices.
+  """
+  attached_devices = []
+
+  attached_devices = android_commands.GetAttachedDevices()
+  if test_device:
+    assert test_device in attached_devices, (
+        'Did not find device %s among attached device. Attached devices: %s'
+        % (test_device, ', '.join(attached_devices)))
+    attached_devices = [test_device]
+
+  assert attached_devices, 'No devices attached.'
+
+  return sorted(attached_devices)
+
+
 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
         this function.
     options: optparse options dictionary.
     args: List of extra args from optparse.
     option_parser: optparse.OptionParser object.
 
   Returns:
     Integer indicated exit code.
 
   Raises:
     Exception: Unknown command name passed in, or an exception from an
         individual test runner.
   """
 
   # Check for extra arguments
   if len(args) > 2:
     option_parser.error('Unrecognized arguments: %s' % (' '.join(args[2:])))
     return constants.ERROR_EXIT_CODE
 
   ProcessCommonOptions(options)
 
+  devices = _GetAttachedDevices(options.test_device)
+
   if command == 'gtest':
-    return _RunGTests(options, option_parser.error)
+    return _RunGTests(options, option_parser.error, devices)
   elif command == 'instrumentation':
-    return _RunInstrumentationTests(options, option_parser.error)
+    return _RunInstrumentationTests(options, option_parser.error, devices)
   elif command == 'uiautomator':
-    return _RunUIAutomatorTests(options, option_parser.error)
+    return _RunUIAutomatorTests(options, option_parser.error, devices)
   elif command == 'monkey':
-    return _RunMonkeyTests(options, option_parser.error)
+    return _RunMonkeyTests(options, option_parser.error, devices)
   elif command == 'perf':
-    return _RunPerfTests(options, option_parser.error)
+    return _RunPerfTests(options, option_parser.error, devices)
   else:
     raise Exception('Unknown test type.')
 
 
 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.
@@ skipping 89 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))