Revert of [Android] Add --blacklist-file as a command-line option.

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 argparse
 import collections
 import logging
 import os
 import shutil
 import signal
 import sys
 import threading
 import unittest
 
 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.device import device_blacklist
 from pylib.device import device_errors
 from pylib.device import device_utils
 from pylib.gtest import gtest_config
 # TODO(jbudorick): Remove this once we stop selectively enabling platform mode.
 from pylib.gtest import gtest_test_instance
 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
@@ skipping 144 matching lines @@
 def AddDeviceOptions(parser):
   """Adds device options to |parser|."""
   group = parser.add_argument_group(title='Device Options')
   group.add_argument('--tool',
                      dest='tool',
                      help=('Run the test under a tool '
                            '(use --tool help to list them)'))
   group.add_argument('-d', '--device', dest='test_device',
                      help=('Target device for the test suite '
                            'to run on.'))
-  group.add_argument('--blacklist-file', help='Device blacklist file.')
 
 
 def AddGTestOptions(parser):
   """Adds gtest options to |parser|."""
 
   gtest_suites = list(gtest_config.STABLE_TEST_SUITES
                       + gtest_config.EXPERIMENTAL_TEST_SUITES)
 
   group = parser.add_argument_group('GTest Options')
   group.add_argument('-s', '--suite', dest='suite_name',
@@ skipping 559 matching lines @@
   if args.json_results_file:
     json_results.GenerateJsonResultsFile(results, args.json_results_file)
 
   return exit_code
 
 
 def _RunUIAutomatorTests(args, devices):
   """Subcommand of RunTestsCommands which runs uiautomator tests."""
   uiautomator_options = ProcessUIAutomatorOptions(args)
 
-  runner_factory, tests = uiautomator_setup.Setup(uiautomator_options, devices)
+  runner_factory, tests = uiautomator_setup.Setup(uiautomator_options)
 
   results, exit_code = test_dispatcher.RunTests(
       tests, runner_factory, devices, shard=True, test_timeout=None,
       num_retries=args.num_retries)
 
   report_results.LogFull(
       results=results,
       test_type='UIAutomator',
       test_package=os.path.basename(args.test_jar),
       annotation=args.annotations,
@@ skipping 35 matching lines @@
       results=results,
       test_type='Monkey',
       test_package='Monkey')
 
   if args.json_results_file:
     json_results.GenerateJsonResultsFile(results, args.json_results_file)
 
   return exit_code
 
 
-def _RunPerfTests(args, active_devices):
+def _RunPerfTests(args):
   """Subcommand of RunTestsCommands which runs perf tests."""
   perf_options = ProcessPerfTestOptions(args)
 
   # Just save a simple json with a list of test names.
   if perf_options.output_json_list:
     return perf_test_runner.OutputJsonList(
         perf_options.steps, perf_options.output_json_list)
 
   # Just print the results from a single previously executed step.
   if perf_options.print_step:
     return perf_test_runner.PrintTestOutput(
         perf_options.print_step, perf_options.output_chartjson_data)
 
-  runner_factory, tests, devices = perf_setup.Setup(
-      perf_options, active_devices)
+  runner_factory, tests, devices = perf_setup.Setup(perf_options)
 
   # shard=False means that each device will get the full list of tests
   # and then each one will decide their own affinity.
   # shard=True means each device will pop the next test available from a queue,
   # which increases throughput but have no affinity.
   results, _ = test_dispatcher.RunTests(
       tests, runner_factory, devices, shard=False, test_timeout=None,
       num_retries=args.num_retries)
 
   report_results.LogFull(
@@ skipping 24 matching lines @@
   try:
     suite = unittest.TestSuite()
     suite.addTests(unittest.defaultTestLoader.loadTestsFromName(m)
                    for m in suite_test_modules)
     runner = unittest.TextTestRunner(verbosity=1+args.verbose_count)
     return 0 if runner.run(suite).wasSuccessful() else 1
   finally:
     sys.path = sys.path[1:]
 
 
-def _GetAttachedDevices(blacklist_file, test_device):
+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.
   """
-  if not blacklist_file:
-    # TODO(jbudorick): Remove this once bots pass the blacklist file.
-    blacklist_file = device_blacklist.BLACKLIST_JSON
-    logging.warning('Using default device blacklist %s',
-                    device_blacklist.BLACKLIST_JSON)
-
-  blacklist = device_blacklist.Blacklist(blacklist_file)
-  attached_devices = device_utils.DeviceUtils.HealthyDevices(blacklist)
+  attached_devices = device_utils.DeviceUtils.HealthyDevices()
   if test_device:
     test_device = [d for d in attached_devices if d == test_device]
     if not test_device:
       raise device_errors.DeviceUnreachableError(
           'Did not find device %s among attached device. Attached devices: %s'
           % (test_device, ', '.join(attached_devices)))
     return test_device
 
   else:
     if not attached_devices:
@@ skipping 18 matching lines @@
   command = args.command
 
   ProcessCommonOptions(args)
 
   if args.enable_platform_mode:
     return RunTestsInPlatformMode(args, parser)
 
   if command in constants.LOCAL_MACHINE_TESTS:
     devices = []
   else:
-    devices = _GetAttachedDevices(args.blacklist_file, args.test_device)
+    devices = _GetAttachedDevices(args.test_device)
 
   forwarder.Forwarder.RemoveHostLog()
   if not ports.ResetTestServerPortAllocation():
     raise Exception('Failed to reset test server port.')
 
   if command == 'gtest':
     if args.suite_name[0] in gtest_test_instance.BROWSER_TEST_SUITES:
       return RunTestsInPlatformMode(args, parser)
     return _RunGTests(args, devices)
   elif command == 'linker':
     return _RunLinkerTests(args, devices)
   elif command == 'instrumentation':
     return _RunInstrumentationTests(args, devices)
   elif command == 'uiautomator':
     return _RunUIAutomatorTests(args, devices)
   elif command == 'junit':
     return _RunJUnitTests(args)
   elif command == 'monkey':
     return _RunMonkeyTests(args, devices)
   elif command == 'perf':
-    return _RunPerfTests(args, devices)
+    return _RunPerfTests(args)
   elif command == 'python':
     return _RunPythonTests(args)
   else:
     raise Exception('Unknown test type.')
 
 
 _SUPPORTED_IN_PLATFORM_MODE = [
   # TODO(jbudorick): Add support for more test types.
   'gtest',
   'instrumentation',
@@ skipping 90 matching lines @@
     if e.is_infra_error:
       return constants.INFRA_EXIT_CODE
     return constants.ERROR_EXIT_CODE
   except: # pylint: disable=W0702
     logging.exception('Unrecognized error occurred.')
     return constants.ERROR_EXIT_CODE
 
 
 if __name__ == '__main__':
   sys.exit(main())