Overlay expected and actual repaint rects for LayoutTests.

Tools/Scripts/webkitpy/layout_tests/controllers/test_result_writer.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 11 matching lines @@
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 import logging
 
+from webkitpy.layout_tests.controllers import repaint_overlay
 from webkitpy.layout_tests.models import test_failures
 
 
 _log = logging.getLogger(__name__)
 
 
 def write_test_result(filesystem, port, results_directory, test_name, driver_output,
                       expected_driver_output, failures):
     """Write the test result to the result output directory."""
     root_output_dir = results_directory
     writer = TestResultWriter(filesystem, port, root_output_dir, test_name)
 
     if driver_output.error:
         writer.write_stderr(driver_output.error)
 
     for failure in failures:
         # FIXME: Instead of this long 'if' block, each failure class might
         # have a responsibility for writing a test result.
         if isinstance(failure, (test_failures.FailureMissingResult,
                                 test_failures.FailureTextMismatch,
                                 test_failures.FailureTestHarnessAssertion)):
             writer.write_text_files(driver_output.text, expected_driver_output.text)
             writer.create_text_diff_and_write_result(driver_output.text, expected_driver_output.text)
+            writer.create_repaint_overlay_result(driver_output.text, expected_driver_output.text)
         elif isinstance(failure, test_failures.FailureMissingImage):
             writer.write_image_files(driver_output.image, expected_image=None)
         elif isinstance(failure, test_failures.FailureMissingImageHash):
             writer.write_image_files(driver_output.image, expected_driver_output.image)
         elif isinstance(failure, test_failures.FailureImageHashMismatch):
             writer.write_image_files(driver_output.image, expected_driver_output.image)
             writer.write_image_diff_files(driver_output.image_diff)
         elif isinstance(failure, (test_failures.FailureAudioMismatch,
                                   test_failures.FailureMissingAudio)):
             writer.write_audio_files(driver_output.audio, expected_driver_output.audio)
@@ skipping 35 matching lines @@
     FILENAME_SUFFIX_EXPECTED = "-expected"
     FILENAME_SUFFIX_DIFF = "-diff"
     FILENAME_SUFFIX_STDERR = "-stderr"
     FILENAME_SUFFIX_CRASH_LOG = "-crash-log"
     FILENAME_SUFFIX_SAMPLE = "-sample"
     FILENAME_SUFFIX_LEAK_LOG = "-leak-log"
     FILENAME_SUFFIX_WDIFF = "-wdiff.html"
     FILENAME_SUFFIX_PRETTY_PATCH = "-pretty-diff.html"
     FILENAME_SUFFIX_IMAGE_DIFF = "-diff.png"
     FILENAME_SUFFIX_IMAGE_DIFFS_HTML = "-diffs.html"
+    FILENAME_SUFFIX_OVERLAY = "-overlay.html"
 
     def __init__(self, filesystem, port, root_output_dir, test_name):
         self._filesystem = filesystem
         self._port = port
         self._root_output_dir = root_output_dir
         self._test_name = test_name
 
     def _make_output_directory(self):
         """Creates the output directory (if needed) for a given test filename."""
         fs = self._filesystem
@@ skipping 83 matching lines @@
             wdiff = self._port.wdiff_text(expected_filename, actual_filename)
             wdiff_filename = self.output_filename(self.FILENAME_SUFFIX_WDIFF)
             self._write_file(wdiff_filename, wdiff)
 
         # Use WebKit's PrettyPatch.rb to get an HTML diff.
         if self._port.pretty_patch_available():
             pretty_patch = self._port.pretty_patch_text(diff_filename)
             pretty_patch_filename = self.output_filename(self.FILENAME_SUFFIX_PRETTY_PATCH)
             self._write_file(pretty_patch_filename, pretty_patch)
 
+    def create_repaint_overlay_result(self, actual_text, expected_text):
+        html = repaint_overlay.generate_repaint_overlay_html(self._test_name, actual_text, expected_text)
+        if html:
+            overlay_filename = self.output_filename(self.FILENAME_SUFFIX_OVERLAY)
+            self._write_file(overlay_filename, html)
+
     def write_audio_files(self, actual_audio, expected_audio):
         self.write_output_files('.wav', actual_audio, expected_audio)
 
     def write_image_files(self, actual_image, expected_image):
         self.write_output_files('.png', actual_image, expected_image)
 
     def write_image_diff_files(self, image_diff):
         diff_filename = self.output_filename(self.FILENAME_SUFFIX_IMAGE_DIFF)
         self._write_file(diff_filename, image_diff)
 
@@ skipping 51 matching lines @@
             'diff_filename': self._output_testname(self.FILENAME_SUFFIX_IMAGE_DIFF),
             'prefix': self._output_testname(''),
         }
         self._write_file(diffs_html_filename, html)
 
     def write_reftest(self, src_filepath):
         fs = self._filesystem
         dst_dir = fs.dirname(fs.join(self._root_output_dir, self._test_name))
         dst_filepath = fs.join(dst_dir, fs.basename(src_filepath))
         self._write_file(dst_filepath, fs.read_binary_file(src_filepath))