Apply SVG root viewport clips in PaintLayerClipper.

third_party/WebKit/Source/core/paint/PaintLayerClipper.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 28 matching lines @@
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "core/paint/PaintLayerClipper.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutView.h"
+#include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/paint/PaintLayer.h"
 
 namespace blink {
 
 static void adjustClipRectsForChildren(const LayoutBoxModelObject& layoutObject, ClipRects& clipRects)
 {
     EPosition position = layoutObject.styleRef().position();
     // A fixed object is essentially the root of its containing block hierarchy, so when
     // we encounter such an object, we reset our clip rects to the fixedClipRect.
     if (position == FixedPosition) {
         clipRects.setPosClipRect(clipRects.fixedClipRect());
         clipRects.setOverflowClipRect(clipRects.fixedClipRect());
         clipRects.setFixed(true);
     } else if (position == RelativePosition) {
         clipRects.setPosClipRect(clipRects.overflowClipRect());
     } else if (position == AbsolutePosition) {
         clipRects.setOverflowClipRect(clipRects.posClipRect());
     }
 }
 
 static void applyClipRects(const ClipRectsContext& context, const LayoutBoxModelObject& layoutObject, LayoutPoint offset, ClipRects& clipRects)
 {
-    ASSERT(layoutObject.hasClipRelatedProperty());
+    DCHECK(layoutObject.hasClipRelatedProperty() || (layoutObject.isSVGRoot() && toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip()));
     LayoutView* view = layoutObject.view();
-    ASSERT(view);
+    DCHECK(view);
     if (clipRects.fixed() && context.rootLayer->layoutObject() == view)
         offset -= toIntSize(view->frameView()->scrollPosition());
-    if (layoutObject.hasOverflowClip() || (layoutObject.styleRef().containsPaint() && layoutObject.isBox())) {
+    if (layoutObject.hasOverflowClip()
+        || (layoutObject.isSVGRoot() && toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip())
+        || (layoutObject.styleRef().containsPaint() && layoutObject.isBox())) {
         ClipRect newOverflowClip = toLayoutBox(layoutObject).overflowClipRect(offset, context.overlayScrollbarClipBehavior);
         newOverflowClip.setHasRadius(layoutObject.styleRef().hasBorderRadius());
         clipRects.setOverflowClipRect(intersection(newOverflowClip, clipRects.overflowClipRect()));
         if (layoutObject.isPositioned())
             clipRects.setPosClipRect(intersection(newOverflowClip, clipRects.posClipRect()));
         if (layoutObject.isLayoutView())
             clipRects.setFixedClipRect(intersection(newOverflowClip, clipRects.fixedClipRect()));
         if (layoutObject.styleRef().containsPaint()) {
             clipRects.setPosClipRect(intersection(newOverflowClip, clipRects.posClipRect()));
             clipRects.setFixedClipRect(intersection(newOverflowClip, clipRects.fixedClipRect()));
         }
     }
     if (layoutObject.hasClip()) {
         LayoutRect newClip = toLayoutBox(layoutObject).clipRect(offset);
         clipRects.setPosClipRect(intersection(newClip, clipRects.posClipRect()).setIsClippedByClipCss());
         clipRects.setOverflowClipRect(intersection(newClip, clipRects.overflowClipRect()).setIsClippedByClipCss());
         clipRects.setFixedClipRect(intersection(newClip, clipRects.fixedClipRect()).setIsClippedByClipCss());
     }
 }
 
 ClipRects* PaintLayerClipper::clipRectsIfCached(const ClipRectsContext& context) const
 {
-    ASSERT(context.usesCache());
+    DCHECK(context.usesCache());
     if (!m_layer.clipRectsCache())
         return nullptr;
     ClipRectsCache::Entry& entry = m_layer.clipRectsCache()->get(context.cacheSlot());
     // FIXME: We used to ASSERT that we always got a consistent root layer.
     // We should add a test that has an inconsistent root. See
     // http://crbug.com/366118 for an example.
     if (context.rootLayer != entry.root)
         return 0;
-    ASSERT(entry.overlayScrollbarClipBehavior == context.overlayScrollbarClipBehavior);
+    DCHECK(entry.overlayScrollbarClipBehavior == context.overlayScrollbarClipBehavior);
 #ifdef CHECK_CACHED_CLIP_RECTS
     // This code is useful to check cached clip rects, but is too expensive to leave enabled in debug builds by default.
     ClipRectsContext tempContext(context);
     tempContext.cacheSlot = UncachedClipRects;
     RefPtr<ClipRects> clipRects = ClipRects::create();
     calculateClipRects(tempContext, *clipRects);
-    ASSERT(clipRects == *entry.clipRects);
+    DCHECK(clipRects == *entry.clipRects);
 #endif
     return entry.clipRects.get();
 }
 
 ClipRects& PaintLayerClipper::storeClipRectsInCache(const ClipRectsContext& context, ClipRects* parentClipRects, const ClipRects& clipRects) const
 {
     ClipRectsCache::Entry& entry = m_layer.ensureClipRectsCache().get(context.cacheSlot());
     entry.root = context.rootLayer;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     entry.overlayScrollbarClipBehavior = context.overlayScrollbarClipBehavior;
 #endif
     if (parentClipRects) {
         // If our clip rects match the clip rects of our parent, we share storage.
         if (clipRects == *parentClipRects) {
             entry.clipRects = parentClipRects;
             return *parentClipRects;
         }
     }
     entry.clipRects = ClipRects::create(clipRects);
@@ skipping 119 matching lines @@
     PaintLayer* parentLayer = !isClippingRoot ? m_layer.parent() : nullptr;
     // Ensure that our parent's clip has been calculated so that we can examine the values.
     if (parentLayer) {
         parentLayer->clipper().getOrCalculateClipRects(context, clipRects);
     } else {
         clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
     }
 
     adjustClipRectsForChildren(layoutObject, clipRects);
 
-    if ((layoutObject.hasOverflowClip() && shouldRespectOverflowClip(context)) || layoutObject.hasClip() || layoutObject.styleRef().containsPaint()) {
+    if ((layoutObject.hasOverflowClip() && shouldRespectOverflowClip(context))
+        || (layoutObject.isSVGRoot() && toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip())
+        || layoutObject.hasClip() || layoutObject.styleRef().containsPaint()) {
         // This offset cannot use convertToLayerCoords, because sometimes our rootLayer may be across
         // some transformed layer boundary, for example, in the PaintLayerCompositor overlapMap, where
         // clipRects are needed in view space.
         applyClipRects(context, layoutObject, roundedLayoutPoint(layoutObject.localToAncestorPoint(FloatPoint(), context.rootLayer->layoutObject())), clipRects);
     }
 }
 
 static ClipRect backgroundClipRectForPosition(const ClipRects& parentRects, EPosition position)
 {
     if (position == FixedPosition)
         return parentRects.fixedClipRect();
 
     if (position == AbsolutePosition)
         return parentRects.posClipRect();
 
     return parentRects.overflowClipRect();
 }
 
 ClipRect PaintLayerClipper::backgroundClipRect(const ClipRectsContext& context) const
 {
-    ASSERT(m_layer.parent());
+    DCHECK(m_layer.parent());
     LayoutView* layoutView = m_layer.layoutObject()->view();
-    ASSERT(layoutView);
+    DCHECK(layoutView);
 
     RefPtr<ClipRects> parentClipRects = ClipRects::create();
     if (&m_layer == context.rootLayer)
         parentClipRects->reset(LayoutRect(LayoutRect::infiniteIntRect()));
     else
         m_layer.parent()->clipper().getOrCalculateClipRects(context, *parentClipRects);
 
     ClipRect result = backgroundClipRectForPosition(*parentClipRects, m_layer.layoutObject()->styleRef().position());
 
     // Note: infinite clipRects should not be scrolled here, otherwise they will accidentally no longer be considered infinite.
@@ skipping 27 matching lines @@
 
 ClipRects& PaintLayerClipper::paintingClipRects(const PaintLayer* rootLayer, ShouldRespectOverflowClipType respectOverflowClip, const LayoutSize& subpixelAccumulation) const
 {
     ClipRectsContext context(rootLayer, PaintingClipRects, IgnoreOverlayScrollbarSize, subpixelAccumulation);
     if (respectOverflowClip == IgnoreOverflowClip)
         context.setIgnoreOverflowClip();
     return getClipRects(context);
 }
 
 } // namespace blink