Print more information when slow-path/fast-path rects mismatch

third_party/WebKit/Source/core/layout/PaintInvalidationState.cpp

 // Copyright 2014 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.
 
 #include "core/layout/PaintInvalidationState.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/LayoutSVGModelObject.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/paint/PaintLayer.h"
 
 // We can't enable this by default because saturated operations of LayoutUnit
 // don't conform commutative law for overflowing results, preventing us from
 // making fast-path and slow-path always return the same result.
 #define ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH (0 && ENABLE(ASSERT))
 
 namespace blink {
 
+#if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
+// Make sure that the fast path and the slow path generate the same rect.
+void assertRectsEqual(const LayoutObject& object, const LayoutBoxModelObject& ancestor, const LayoutRect& rect, const LayoutRect& slowPathRect)
+{
+    // TODO(wangxianzhu): This is for cases that a sub-frame creates a root PaintInvalidationState
+    // which doesn't inherit clip from ancestor frames.
+    // Remove the condition when we eliminate the latter case of PaintInvalidationState(const LayoutView&, ...).
+    if (object.isLayoutView())
+        return;
+
+    // TODO(crbug.com/597903): Fast path and slow path should generate equal empty rects.
+    if (rect.isEmpty() && slowPathRect.isEmpty())
+        return;
+
+    if (rect == slowPathRect)
+        return;
+
+    // Tolerate the difference between the two paths when crossing frame boundaries.
+    if (object.view() != ancestor.view()) {
+        LayoutRect inflatedRect = rect;
+        inflatedRect.inflate(1);
+        if (inflatedRect.contains(slowPathRect))
+            return;
+        LayoutRect inflatedSlowPathRect = slowPathRect;
+        inflatedSlowPathRect.inflate(1);
+        if (inflatedSlowPathRect.contains(rect))
+            return;
+    }
+
+#ifndef NDEBUG
+    WTFLogAlways("Fast-path paint invalidation rect differs from slow-path: %s vs %s", rect.toString().ascii().data(), slowPathRect.toString().ascii().data());
+    showLayoutTree(&object);
+#endif
+    ASSERT_NOT_REACHED();
+}
+#endif
+
 static bool isAbsolutePositionUnderRelativePositionInline(const LayoutObject& object)
 {
     if (object.styleRef().position() != AbsolutePosition)
         return false;
     if (LayoutObject* container = object.container())
         return container->isAnonymousBlock() && container->styleRef().position() == RelativePosition;
     return false;
 }
 
 static bool supportsCachedOffsets(const LayoutObject& object)
@@ skipping 225 matching lines @@
 LayoutRect PaintInvalidationState::computePaintInvalidationRectInBackingForSVG() const
 {
     LayoutRect rect;
     if (m_cachedOffsetsEnabled) {
         FloatRect svgRect = SVGLayoutSupport::localOverflowRectForPaintInvalidation(m_currentObject);
         rect = SVGLayoutSupport::transformPaintInvalidationRect(m_currentObject, m_svgTransform, svgRect);
         rect.move(m_paintOffset);
         if (m_clipped)
             rect.intersect(m_clipRect);
 #if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
+        // TODO(crbug.com/597902): Slow path misses clipping of paintInvalidationContainer.
         LayoutRect slowPathRect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, m_paintInvalidationContainer);
-        // TODO(crbug.com/597902): Slow path misses clipping of paintInvalidationContainer.
         if (m_clipped)
             slowPathRect.intersect(m_clipRect);
-        // TODO(crbug.com/597903): Fast path and slow path should generate equal empty rects.
-        ASSERT((rect.isEmpty() && slowPathRect.isEmpty()) || rect == slowPathRect);
+        assertRectsEqual(m_currentObject, m_paintInvalidationContainer, rect, slowPathRect);
 #endif
     } else {
         // TODO(wangxianzhu): Sometimes m_cachedOffsetsEnabled==false doesn't mean we can't use cached
         // m_svgTransform. We can use hybrid fast-path (for SVG) and slow-path (for things above the SVGRoot).
         rect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, m_paintInvalidationContainer);
     }
 
     if (m_paintInvalidationContainer.layer()->groupedMapping())
         PaintLayer::mapRectInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, rect);
     return rect;
 }
 
 static void slowMapToVisualRectInAncestorSpace(const LayoutObject& object, const LayoutBoxModelObject& ancestor, LayoutRect& rect)
 {
-    // TODO(crbug.com/597965): LayoutBox::mapToVisualRectInAncestorSpace() incorrectly flips a rect
-    // in its own space for writing mode. Here flip to workaround the flip.
-    if (object.isBox() && (toLayoutBox(object).isWritingModeRoot() || (ancestor == object && object.styleRef().isFlippedBlocksWritingMode())))

[chrishtr, 2016/03/31 00:27:12]

Put this into the CL description (at the top since it's a behavior change).

This change caused no tests to fail though. Sort of along those lines, can you
add an explicit test for mapToVisualRectInAncestorSpace alongside the other few
we have that exercises flipped blocks?

[Xianzhu, 2016/03/31 00:48:08]

It's wrong to change this in this CL. Reverted to Patch Set 3. Will address this
in another CL.

-        toLayoutBox(object).flipForWritingMode(rect);
-
     if (object.isLayoutView()) {
         toLayoutView(object).mapToVisualRectInAncestorSpace(&ancestor, rect, InputIsInFrameCoordinates, DefaultVisualRectFlags);
     } else if (object.isSVGRoot()) {
         // TODO(crbug.com/597813): This is to avoid the extra clip applied in LayoutSVGRoot::mapVisibleRectInAncestorSpace().
         toLayoutSVGRoot(object).LayoutReplaced::mapToVisualRectInAncestorSpace(&ancestor, rect);
     } else {
         object.mapToVisualRectInAncestorSpace(&ancestor, rect);
     }
 }
 
 void PaintInvalidationState::mapLocalRectToPaintInvalidationBacking(LayoutRect& rect) const
 {
     ASSERT(!m_didUpdateForChildren);
 
     if (m_cachedOffsetsEnabled) {
 #if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
         LayoutRect slowPathRect(rect);
         slowMapToVisualRectInAncestorSpace(m_currentObject, m_paintInvalidationContainer, slowPathRect);
 #endif
         rect.move(m_paintOffset);
         if (m_clipped)
             rect.intersect(m_clipRect);
 #if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
-        // Make sure that the fast path and the slow path generate the same rect.
         // TODO(crbug.com/597902): Slow path misses clipping of paintInvalidationContainer.
         if (m_clipped)
             slowPathRect.intersect(m_clipRect);
-        // TODO(wangxianzhu): The isLayoutView() condition is for cases that a sub-frame creates a
-        // root PaintInvalidationState which doesn't inherit clip from ancestor frames.
-        // Remove the condition when we eliminate the latter case of PaintInvalidationState(const LayoutView&, ...).
-        // TODO(crbug.com/597903): Fast path and slow path should generate equal empty rects.
-        ASSERT(m_currentObject.isLayoutView() || (rect.isEmpty() && slowPathRect.isEmpty()) || rect == slowPathRect);
+        assertRectsEqual(m_currentObject, m_paintInvalidationContainer, rect, slowPathRect);
 #endif
     } else {
         slowMapToVisualRectInAncestorSpace(m_currentObject, m_paintInvalidationContainer, rect);
     }
 
     if (m_paintInvalidationContainer.layer()->groupedMapping())
         PaintLayer::mapRectInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, rect);
 }
 
 void PaintInvalidationState::addClipRectRelativeToPaintOffset(const LayoutRect& localClipRect)
@@ skipping 10 matching lines @@
 
 PaintLayer& PaintInvalidationState::enclosingSelfPaintingLayer(const LayoutObject& layoutObject) const
 {
     if (layoutObject.hasLayer() && toLayoutBoxModelObject(layoutObject).hasSelfPaintingLayer())
         return *toLayoutBoxModelObject(layoutObject).layer();
 
     return m_enclosingSelfPaintingLayer;
 }
 
 } // namespace blink