Clean up remaining DumpRenderTree references and flags.

Tools/Scripts/webkitpy/layout_tests/controllers/layout_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 300 matching lines @@
         self._caller.post('finished_test', result)
 
         self._clean_up_after_test(test_input, result)
 
     def stop(self):
         _log.debug("%s cleaning up" % self._name)
         self._kill_driver()
 
     def _timeout(self, test_input):
         """Compute the appropriate timeout value for a test."""
-        # The DumpRenderTree watchdog uses 2.5x the timeout; we want to be
+        # The driver watchdog uses 2.5x the timeout; we want to be
         # larger than that. We also add a little more padding if we're
         # running tests in a separate thread.
         #
         # Note that we need to convert the test timeout from a
         # string value in milliseconds to a float for Python.
         driver_timeout_sec = 3.0 * float(test_input.timeout) / 1000.0
         if not self._options.run_singly:
             return driver_timeout_sec
 
         thread_padding_sec = 1.0
@@ skipping 11 matching lines @@
 
     def _run_test_with_timeout(self, test_input, timeout, stop_when_done):
         if self._options.run_singly:
             return self._run_test_in_another_thread(test_input, timeout, stop_when_done)
         return self._run_test_in_this_thread(test_input, stop_when_done)
 
     def _clean_up_after_test(self, test_input, result):
         test_name = test_input.test_name
 
         if result.failures:
-            # Check and kill DumpRenderTree if we need to.
+            # Check and kill the driver if we need to.
             if any([f.driver_needs_restart() for f in result.failures]):
                 self._kill_driver()
                 # Reset the batch count since the shell just bounced.
                 self._batch_count = 0
 
             # Print the error message(s).
             _log.debug("%s %s failed:" % (self._name, test_name))
             for f in result.failures:
                 _log.debug("%s  %s" % (self._name, f.message()))
         elif result.type == test_expectations.SKIP:
@@ skipping 26 matching lines @@
             def run(self):
                 self.result = worker._run_single_test(driver, test_input, stop_when_done)
 
         thread = SingleTestThread()
         thread.start()
         thread.join(thread_timeout_sec)
         result = thread.result
         failures = []
         if thread.isAlive():
             # If join() returned with the thread still running, the
-            # DumpRenderTree is completely hung and there's nothing
+            # driver is completely hung and there's nothing
             # more we can do with it.  We have to kill all the
-            # DumpRenderTrees to free it up. If we're running more than
-            # one DumpRenderTree thread, we'll end up killing the other
-            # DumpRenderTrees too, introducing spurious crashes. We accept
+            # drivers to free it up. If we're running more than
+            # one driver thread, we'll end up killing the other
+            # drivers too, introducing spurious crashes. We accept
             # that tradeoff in order to avoid losing the rest of this
             # thread's results.
-            _log.error('Test thread hung: killing all DumpRenderTrees')
+            _log.error('Test thread hung: killing all drivers')
             failures = [test_failures.FailureTimeout()]
 
         driver.stop()
 
         if not result:
             result = test_results.TestResult(test_input.test_name, failures=failures, test_run_time=0)
         return result
 
     def _run_test_in_this_thread(self, test_input, stop_when_done):
-        """Run a single test file using a shared DumpRenderTree process.
+        """Run a single test file using a shared driver process.
 
         Args:
           test_input: Object containing the test filename, uri and timeout
 
         Returns: a TestResult object.
         """
         if self._driver and self._driver.has_crashed():
             self._kill_driver()
         if not self._driver:
             self._driver = self._port.create_driver(self._worker_number)
@@ skipping 147 matching lines @@
         def split_at(seq, index):
             return (seq[:index], seq[index:])
 
         num_old_per_new = divide_and_round_up(len(old_shards), max_new_shards)
         new_shards = []
         remaining_shards = old_shards
         while remaining_shards:
             some_shards, remaining_shards = split_at(remaining_shards, num_old_per_new)
             new_shards.append(TestShard('%s_%d' % (shard_name_prefix, len(new_shards) + 1), extract_and_flatten(some_shards)))
         return new_shards