Pass MapCoordinatesFlags through SVGLayoutSupport::mapLocalToAncestor

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/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 62 matching lines @@
     , m_svgTransform(parentState.m_svgTransform)
     , m_pendingDelayedPaintInvalidations(parentState.m_pendingDelayedPaintInvalidations)
     , m_paintingLayer(currentObject.hasLayer() && toLayoutBoxModelObject(currentObject).hasSelfPaintingLayer() ? *toLayoutBoxModelObject(currentObject).layer() : parentState.m_paintingLayer)
 #if ENABLE(ASSERT)
     , m_didUpdateForChildren(false)
 #endif
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
     , m_canCheckFastPathSlowPathEquality(parentState.m_canCheckFastPathSlowPathEquality)
 #endif
 {
-    ASSERT(&m_paintingLayer == currentObject.paintingLayer());
+    DCHECK(&m_paintingLayer == currentObject.paintingLayer());
 
     if (currentObject == parentState.m_currentObject) {
         // Sometimes we create a new PaintInvalidationState from parentState on the same object
         // (e.g. LayoutView, and the HorriblySlowRectMapping cases in LayoutBlock::invalidatePaintOfSubtreesIfNeeded()).
         // TODO(wangxianzhu): Avoid this for RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled().
 #if ENABLE(ASSERT)
         m_didUpdateForChildren = parentState.m_didUpdateForChildren;
 #endif
         return;
     }
 
-    ASSERT(parentState.m_didUpdateForChildren);
+#if ENABLE(ASSERT)
+    DCHECK(parentState.m_didUpdateForChildren);
+#endif
 
     if (currentObject.isPaintInvalidationContainer()) {
         m_paintInvalidationContainer = toLayoutBoxModelObject(&currentObject);
         if (currentObject.styleRef().isStackingContext())
             m_paintInvalidationContainerForStackedContents = toLayoutBoxModelObject(&currentObject);
     } else if (currentObject.isLayoutView()) {
         // m_paintInvalidationContainerForStackedContents is only for stacked descendants in its own frame,
         // because it doesn't establish stacking context for stacked contents in sub-frames.
         // Contents stacked in the root stacking context in this frame should use this frame's paintInvalidationContainer.
         m_paintInvalidationContainerForStackedContents = m_paintInvalidationContainer;
@@ skipping 20 matching lines @@
 
     if (m_cachedOffsetsEnabled || currentObject == m_paintInvalidationContainer)
         m_cachedOffsetsEnabled = supportsCachedOffsets(currentObject);
 
     if (currentObject.isSVG()) {
         if (currentObject.isSVGRoot()) {
             m_svgTransform = toLayoutSVGRoot(currentObject).localToBorderBoxTransform();
             // Don't early return here, because the SVGRoot object needs to execute the later code
             // as a normal LayoutBox.
         } else {
-            ASSERT(currentObject != m_paintInvalidationContainer);
+            DCHECK(currentObject != m_paintInvalidationContainer);
             m_svgTransform *= currentObject.localToSVGParentTransform();
             return;
         }
     }
 
     if (currentObject == m_paintInvalidationContainer) {
         // When we hit a new paint invalidation container, we don't need to
         // continue forcing a check for paint invalidation, since we're
         // descending into a different invalidation container. (For instance if
         // our parents were moved, the entire container will just move.)
@@ skipping 28 matching lines @@
 
     updateForCurrentObject(parentState);
 }
 
 void PaintInvalidationState::updateForCurrentObject(const PaintInvalidationState& parentState)
 {
     if (!m_cachedOffsetsEnabled)
         return;
 
     if (m_currentObject.isLayoutView()) {
-        ASSERT(&parentState.m_currentObject == toLayoutView(m_currentObject).frame()->ownerLayoutObject());
+        DCHECK(&parentState.m_currentObject == toLayoutView(m_currentObject).frame()->ownerLayoutObject());
         m_paintOffset += toLayoutBox(parentState.m_currentObject).contentBoxOffset();
         // a LayoutView paints with a defined size but a pixel-rounded offset.
         m_paintOffset = LayoutSize(roundedIntSize(m_paintOffset));
         return;
     }
 
     EPosition position = m_currentObject.styleRef().position();
 
     if (position == FixedPosition) {
         if (m_paintInvalidationContainer != m_currentObject.view() && m_paintInvalidationContainer->view() == m_currentObject.view()) {
@@ skipping 40 matching lines @@
     if (m_currentObject.isBox())
         m_paintOffset += toLayoutBox(m_currentObject).locationOffset();
 
     if (m_currentObject.isInFlowPositioned() && m_currentObject.hasLayer())
         m_paintOffset += toLayoutBoxModelObject(m_currentObject).layer()->offsetForInFlowPosition();
 }
 
 void PaintInvalidationState::updateForChildren(PaintInvalidationReason reason)
 {
 #if ENABLE(ASSERT)
-    ASSERT(!m_didUpdateForChildren);
+    DCHECK(!m_didUpdateForChildren);
     m_didUpdateForChildren = true;
 #endif
 
     switch (reason) {
     case PaintInvalidationDelayedFull:
         m_pendingDelayedPaintInvalidations.append(&m_currentObject);
         break;
     case PaintInvalidationSubtree:
         m_forcedSubtreeInvalidationFlags |= (FullInvalidation | FullInvalidationForStackedContents);
         break;
@@ skipping 51 matching lines @@
     }
 
     if (!m_currentObject.hasOverflowClip())
         return;
 
     const LayoutBox& box = toLayoutBox(m_currentObject);
 
     // Do not clip or scroll for the paint invalidation container, if it scrolls overflow, because it will always use composited
     // scrolling in this case.
     if (box == m_paintInvalidationContainer && box.scrollsOverflow()) {
-        ASSERT(!m_clipped); // The box establishes paint invalidation container, so no m_clipped inherited.
+        DCHECK(!m_clipped); // The box establishes paint invalidation container, so no m_clipped inherited.
     } else {
         addClipRectRelativeToPaintOffset(box.overflowClipRect(LayoutPoint()));
         m_paintOffset -= box.scrolledContentOffset();
     }
 
     // FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.
 }
 
 static FloatPoint slowLocalToAncestorPoint(const LayoutObject& object, const LayoutBoxModelObject& ancestor, const FloatPoint& point)
 {
     if (object.isLayoutView())
         return toLayoutView(object).localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries | InputIsInFrameCoordinates);
     FloatPoint result = object.localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries);
     // Paint invalidation does not include scroll of the ancestor.
     if (ancestor.isBox()) {
         const LayoutBox* box = toLayoutBox(&ancestor);
         if (box->hasOverflowClip())
             result.move(box->scrolledContentOffset());
     }
     return result;
 }
 
 LayoutPoint PaintInvalidationState::computePositionFromPaintInvalidationBacking() const
 {
-    ASSERT(!m_didUpdateForChildren);
+#if ENABLE(ASSERT)
+    DCHECK(!m_didUpdateForChildren);
+#endif
 
     FloatPoint point;
     if (m_paintInvalidationContainer != &m_currentObject) {
         if (m_cachedOffsetsEnabled) {
             if (m_currentObject.isSVG() && !m_currentObject.isSVGRoot())
                 point = m_svgTransform.mapPoint(point);
             point += FloatPoint(m_paintOffset);
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-            // TODO(wangxianzhu): We can't enable this ASSERT for now because of crbug.com/597745.
-            // ASSERT(point == slowLocalOriginToAncestorPoint(m_currentObject, m_paintInvalidationContainer, FloatPoint());
+            DCHECK(point == slowLocalOriginToAncestorPoint(m_currentObject, m_paintInvalidationContainer, FloatPoint());
 #endif
         } else {
             point = slowLocalToAncestorPoint(m_currentObject, *m_paintInvalidationContainer, FloatPoint());
         }
     }
 
     if (m_paintInvalidationContainer->layer()->groupedMapping())
         PaintLayer::mapPointInPaintInvalidationContainerToBacking(*m_paintInvalidationContainer, point);
 
     return LayoutPoint(point);
 }
 
 LayoutRect PaintInvalidationState::computePaintInvalidationRectInBacking() const
 {
-    ASSERT(!m_didUpdateForChildren);
+#if ENABLE(ASSERT)
+    DCHECK(!m_didUpdateForChildren);
+#endif
 
     if (m_currentObject.isSVG() && !m_currentObject.isSVGRoot())
         return computePaintInvalidationRectInBackingForSVG();
 
     LayoutRect rect = m_currentObject.localOverflowRectForPaintInvalidation();
     mapLocalRectToPaintInvalidationBacking(rect);
     return rect;
 }
 
 LayoutRect PaintInvalidationState::computePaintInvalidationRectInBackingForSVG() const
@@ skipping 30 matching lines @@
         toLayoutBox(&object)->flipForWritingMode(rect);
 
     if (object.isLayoutView())
         toLayoutView(object).mapToVisualRectInAncestorSpace(&ancestor, rect, InputIsInFrameCoordinates, DefaultVisualRectFlags);
     else
         object.mapToVisualRectInAncestorSpace(&ancestor, rect);
 }
 
 void PaintInvalidationState::mapLocalRectToPaintInvalidationContainer(LayoutRect& rect) const
 {
-    ASSERT(!m_didUpdateForChildren);
+#if ENABLE(ASSERT)
+    DCHECK(!m_didUpdateForChildren);
+#endif
 
     if (m_cachedOffsetsEnabled) {
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
         LayoutRect slowPathRect(rect);
         slowMapToVisualRectInAncestorSpace(m_currentObject, *m_paintInvalidationContainer, slowPathRect);
 #endif
         rect.move(m_paintOffset);
         if (m_clipped)
             rect.intersect(m_clipRect);
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
@@ skipping 19 matching lines @@
     if (m_clipped) {
         m_clipRect.intersect(clipRect);
     } else {
         m_clipRect = clipRect;
         m_clipped = true;
     }
 }
 
 PaintLayer& PaintInvalidationState::paintingLayer() const
 {
-    ASSERT(&m_paintingLayer == m_currentObject.paintingLayer());
+    DCHECK(&m_paintingLayer == m_currentObject.paintingLayer());
     return m_paintingLayer;
 }
 
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
 
 static bool mayHaveBeenSaturated(LayoutUnit value)
 {
     // This is not accurate, just to avoid too big values.
     return value.abs() >= LayoutUnit::max() / 2;
 }
@@ skipping 36 matching lines @@
     WTFLogAlways("Fast path paint invalidation rect differs from slow path: fast: %s vs slow: %s",
         fastPathRect.toString().ascii().data(), slowPathRect.toString().ascii().data());
     showLayoutTree(&m_currentObject);
 
     ASSERT_NOT_REACHED();
 }
 
 #endif // CHECK_FAST_PATH_SLOW_PATH_EQUALITY
 
 } // namespace blink