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;
@@ skipping 22 matching lines @@
 
     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