LayoutBox::mapContentsRectToVisibleRectInBorderBoxSpace()

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))
+#define ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH (1 && ENABLE(ASSERT))
 
 namespace blink {
 
 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;
@@ skipping 227 matching lines @@
 {
     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
         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);
 #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 slowMapToVisibleRectInAncestorSpace(const LayoutObject& object, const LayoutBoxModelObject& ancestor, LayoutRect& rect)
 {
-    // TODO(crbug.com/597965): LayoutBox::mapToVisibleRectInAncestorSpace() 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())))
-        toLayoutBox(object).flipForWritingMode(rect);
-
     if (object.isLayoutView()) {
         toLayoutView(object).mapToVisibleRectInAncestorSpace(&ancestor, rect, InputIsInFrameCoordinates, DefaultVisibleRectFlags);
     } else if (object.isSVGRoot()) {
         // TODO(crbug.com/597813): This is to avoid the extra clip applied in LayoutSVGRoot::mapVisibleRectInAncestorSpace().
         toLayoutSVGRoot(object).LayoutReplaced::mapToVisibleRectInAncestorSpace(&ancestor, rect);
     } else {
         object.mapToVisibleRectInAncestorSpace(&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);
         slowMapToVisibleRectInAncestorSpace(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);
 #endif
     } else {
         slowMapToVisibleRectInAncestorSpace(m_currentObject, m_paintInvalidationContainer, rect);
     }
 
@@ skipping 15 matching lines @@
 
 PaintLayer& PaintInvalidationState::enclosingSelfPaintingLayer(const LayoutObject& layoutObject) const
 {
     if (layoutObject.hasLayer() && toLayoutBoxModelObject(layoutObject).hasSelfPaintingLayer())
         return *toLayoutBoxModelObject(layoutObject).layer();
 
     return m_enclosingSelfPaintingLayer;
 }
 
 } // namespace blink