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
 # in the documentation and/or other materials provided with the
 # distribution.
 #     * Neither the name of Google Inc. nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # 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
+import re
 
 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_overlay_invalidation_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 32 matching lines @@
     FILENAME_SUFFIX_ACTUAL = "-actual"
     FILENAME_SUFFIX_EXPECTED = "-expected"
     FILENAME_SUFFIX_DIFF = "-diff"
     FILENAME_SUFFIX_STDERR = "-stderr"
     FILENAME_SUFFIX_CRASH_LOG = "-crash-log"
     FILENAME_SUFFIX_SAMPLE = "-sample"
     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 79 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_overlay_invalidation_result(self, actual_text, expected_text):

[Dirk Pranke, 2014/02/27 20:57:44]

Can you pull this whole function out of this file and create a new file for it?
I would like to keep it separate from the other logic in this file (we should do
that for write_image_diff_files, as well, but not as part of this change).

+        repaintPattern = re.compile('^\(repaint rects$')
+        repaintMatch = repaintPattern.search(expected_text)

[Dirk Pranke, 2014/02/27 20:57:44]

this can probably be just re.search('^\(repaint rects$', expected_text).

compilling the re doesn't buy you anything if you're only going to use re once
in the function and recompile it every time.

+        if repaintMatch == 'None':
+            return
+
+        def make_js_rect(input_str):
+            rect_pattern = '\(rect\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\)'
+            ret = '['
+            count = 0
+            for m in re.finditer(rect_pattern, input_str):

[Dirk Pranke, 2014/02/27 20:57:44]

hm. didn't know about finditer(); nifty.

+                if count > 0:
+                    ret += ','
+                count += 1
+
+                ret += '[' + m.group(1) + ','
+                ret += m.group(2) + ','
+                ret += m.group(3) + ','
+                ret += m.group(4) + ']'
+            return ret + ']'

[Dirk Pranke, 2014/02/27 20:57:44]

hm. didn't know about finditer(); nifty.

This can probably be written as 

def make_js_rect(input_str):
    rect_pattern = '\(rect\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\)'
    rects = []
    for m in re.finditer(rect_pattern, input_str):
        rects.append('[' + ','.join(m.groups()) + ']')
    return '[' + ','.join(rects) + ']'

(You could probably do it w/ a nested list comprehension or two, even, but I
wouldn't).

+
+        expected_rects = make_js_rect(expected_text)
+        actual_rects = make_js_rect(actual_text)
+
+        html = """<!DOCTYPE HTML>

[Dirk Pranke, 2014/02/27 20:57:44]

I defer to ojan re: the html template, but it looks more or less plausible to me
:).

+<html>
+<head>
+<title>%(title)s</title>
+<style>
+    body {
+        margin: 0;
+        padding: 0;
+    }
+    iframe {
+      position: absolute;
+      top: 30px;
+      left: 0;
+      border: 0;
+      z-index: -1;
+    }
+    canvas {
+      z-index: 1;
+      top: 30px;
+      left: 0;
+      position: absolute;
+    }
+    #actual { display: none; }
+</style>
+</head>
+<body>
+<span id='type'>Expected Difference</span>
+<div id=overlay>
+  <canvas id='expected' width='800' height='600'></canvas>
+  <canvas id='actual' width='800' height='600'></canvas>
+</div>
+<script>
+(function() {
+    var expected_rects = %(expected_rects)s;
+    var actual_rects = %(actual_rects)s;
+
+    var path = decodeURIComponent(location.search).substr(1);
+    var iframe = document.createElement('iframe');
+    iframe.width = 800;
+    iframe.height = 600;
+    iframe.src = path;
+
+    var overlay = document.getElementById('overlay');
+    overlay.appendChild(iframe);
+
+    for (var i = expected_rects.length - 1; i >= 0; i--) {
+      var expected_rect = expected_rects[i];
+      for (var k = actual_rects.length - 1; k >= 0; k--) {
+        var actual_rect = actual_rects[k];
+        if ((actual_rect[0] == expected_rect[0]) &&
+            (actual_rect[1] == expected_rect[1]) &&
+            (actual_rect[2] == expected_rect[2]) &&
+            (actual_rect[3] == expected_rect[3])) {
+          expected_rects.splice(i, 1);
+          actual_rects.splice(k, 1);
+        }
+      }
+    }
+
+    var expected_canvas = document.getElementById('expected');
+    var expected_ctx = expected_canvas.getContext("2d");
+    expected_ctx.fillStyle = 'rgba(255, 0, 0, 0.25)';
+    for (var i = 0; i < expected_rects.length; i++) {
+        var rect = expected_rects[i];
+        expected_ctx.fillRect(rect[0], rect[1], rect[2], rect[3]);
+    }
+
+    var actual_canvas = document.getElementById('actual');
+    var actual_ctx = actual_canvas.getContext("2d");
+    actual_ctx.fillStyle = 'rgba(0, 255, 0, 0.25)';
+    for (var i = 0; i < actual_rects.length; i++) {
+        var rect = actual_rects[i];
+        actual_ctx.fillRect(rect[0], rect[1], rect[2], rect[3]);
+    }
+
+    var type = document.getElementById('type');
+    var expected_showing = true;
+    var flip = function() {
+        if (expected_showing) {
+            type.innerText = 'Actual Difference';

[ojan, 2014/02/25 00:43:42]

Nit: innerText is crazy. Use textContent.

+            expected_canvas.style.display = 'none';
+            actual_canvas.style.display = 'block';
+        } else {
+            type.innerText = 'Expected Difference';
+            actual_canvas.style.display = 'none';
+            expected_canvas.style.display = 'block';
+        }
+        expected_showing = !expected_showing
+        setTimeout(flip, 3000);
+    }
+    setTimeout(flip, 3000);
+})();
+</script>
+</body>
+</html>
+""" % {
+            'title': self._test_name,
+            'expected_rects': expected_rects,
+            'actual_rects': actual_rects,
+        }
+        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))