Revert of Add an additional content_shell per worker for running virtual tests.

Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py

 # Copyright (C) 2011 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 25 matching lines @@
 from webkitpy.layout_tests.port.driver import DeviceFailure, DriverInput, DriverOutput
 from webkitpy.layout_tests.models import test_expectations
 from webkitpy.layout_tests.models import test_failures
 from webkitpy.layout_tests.models.test_results import TestResult
 from webkitpy.layout_tests.models import testharness_results
 
 
 _log = logging.getLogger(__name__)
 
 
-def run_single_test(
-        port, options, results_directory, worker_name, primary_driver,
-        secondary_driver, test_input, stop_when_done):
-    runner = SingleTestRunner(
-        port, options, results_directory, worker_name, primary_driver,
-        secondary_driver, test_input, stop_when_done)
+def run_single_test(port, options, results_directory, worker_name, driver, test_input, stop_when_done):
+    runner = SingleTestRunner(port, options, results_directory, worker_name, driver, test_input, stop_when_done)
     try:
         return runner.run()
     except DeviceFailure as e:
         _log.error("device failed: %s", str(e))
         return TestResult(test_input.test_name, device_failed=True)
 
 
 class SingleTestRunner(object):
     (ALONGSIDE_TEST, PLATFORM_DIR, VERSION_DIR, UPDATE) = ('alongside', 'platform', 'version', 'update')
 
-    def __init__(self, port, options, results_directory, worker_name,
-                 primary_driver, secondary_driver, test_input, stop_when_done):
+    def __init__(self, port, options, results_directory, worker_name, driver, test_input, stop_when_done):
         self._port = port
         self._filesystem = port.host.filesystem
         self._options = options
         self._results_directory = results_directory
-        self._driver = primary_driver
-        self._reference_driver = primary_driver
+        self._driver = driver
         self._timeout = test_input.timeout
         self._worker_name = worker_name
         self._test_name = test_input.test_name
         self._should_run_pixel_test = test_input.should_run_pixel_test
         self._reference_files = test_input.reference_files
         self._should_add_missing_baselines = test_input.should_add_missing_baselines
         self._stop_when_done = stop_when_done
 
-        # If this is a virtual test that uses the default flags instead of the
-        # virtual flags for it's references, run it on the secondary driver so
-        # that the primary driver does not need to be restarted.
-        if (self._port.is_virtual_test(self._test_name) and
-                not self._port.lookup_virtual_reference_args(self._test_name)):
-            self._reference_driver = secondary_driver
-
         if self._reference_files:
             # Detect and report a test which has a wrong combination of expectation files.
             # For example, if 'foo.html' has two expectation files, 'foo-expected.html' and
             # 'foo-expected.txt', we should warn users. One test file must be used exclusively
             # in either layout tests or reftests, but not in both.
             for suffix in ('.txt', '.png', '.wav'):
                 expected_filename = self._port.expected_filename(self._test_name, suffix)
                 if self._filesystem.exists(expected_filename):
                     _log.error('%s is a reftest, but has an unused expectation file. Please remove %s.',
                         self._test_name, expected_filename)
@@ skipping 283 matching lines @@
         putAllMismatchBeforeMatch = sorted
         reference_test_names = []
         for expectation, reference_filename in putAllMismatchBeforeMatch(self._reference_files):
             if self._port.lookup_virtual_test_base(self._test_name):
                 args = self._port.lookup_virtual_reference_args(self._test_name)
             else:
                 args = self._port.lookup_physical_reference_args(self._test_name)
             reference_test_name = self._port.relative_test_filename(reference_filename)
             reference_test_names.append(reference_test_name)
             driver_input = DriverInput(reference_test_name, self._timeout, image_hash=None, should_run_pixel_test=True, args=args)
-            reference_output = self._reference_driver.run_test(driver_input, self._stop_when_done)
+            reference_output = self._driver.run_test(driver_input, self._stop_when_done)
             test_result = self._compare_output_with_reference(reference_output, test_output, reference_filename, expectation == '!=')
 
             if (expectation == '!=' and test_result.failures) or (expectation == '==' and not test_result.failures):
                 break
             total_test_time += test_result.test_run_time
 
         assert(reference_output)
         test_result_writer.write_test_result(self._filesystem, self._port, self._results_directory, self._test_name, test_output, reference_output, test_result.failures)
 
         # FIXME: We don't really deal with a mix of reftest types properly. We pass in a set() to reftest_type
@@ skipping 30 matching lines @@
         elif reference_driver_output.image_hash != actual_driver_output.image_hash:
             diff, err_str = self._port.diff_image(reference_driver_output.image, actual_driver_output.image)
             if diff:
                 failures.append(test_failures.FailureReftestMismatch(reference_filename))
             elif err_str:
                 _log.error(err_str)
             else:
                 _log.warning("  %s -> ref test hashes didn't match but diff passed" % self._test_name)
 
         return TestResult(self._test_name, failures, total_test_time, has_stderr, pid=actual_driver_output.pid)