Implement Paint Containment

third_party/WebKit/Source/core/layout/compositing/CompositingInputsUpdater.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 "config.h"
 #include "core/layout/compositing/CompositingInputsUpdater.h"
 
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
@@ skipping 19 matching lines @@
 }
 
 static const PaintLayer* findParentLayerOnClippingContainerChain(const PaintLayer* layer)
 {
     LayoutObject* current = layer->layoutObject();
     while (current) {
         if (current->style()->position() == FixedPosition) {
             for (current = current->parent(); current && !current->canContainFixedPositionObjects(); current = current->parent()) {
                 // All types of clips apply to fixed-position descendants of other fixed-position elements.
                 // Note: it's unclear whether this is what the spec says. Firefox does not clip, but Chrome does.
-                if (current->style()->position() == FixedPosition && current->hasClipOrOverflowClip()) {
+                if (current->style()->position() == FixedPosition && current->hasClipRelatedProperty()) {
                     ASSERT(current->hasLayer());
                     return static_cast<const LayoutBoxModelObject*>(current)->layer();
                 }
 
                 // CSS clip applies to fixed position elements even for ancestors that are not what the
                 // fixed element is positioned with respect to.
                 if (current->hasClip()) {
                     ASSERT(current->hasLayer());
                     return static_cast<const LayoutBoxModelObject*>(current)->layer();
                 }
             }
         } else {
             current = current->containingBlock();
         }
 
         if (current->hasLayer())
             return static_cast<const LayoutBoxModelObject*>(current)->layer();
         // Having clip or overflow clip forces the LayoutObject to become a layer.
-        ASSERT(!current->hasClipOrOverflowClip());
+        ASSERT(!current->hasClipRelatedProperty());
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 static const PaintLayer* findParentLayerOnContainingBlockChain(const LayoutObject* object)
 {
     for (const LayoutObject* current = object; current; current = current->containingBlock()) {
         if (current->hasLayer())
             return static_cast<const LayoutBoxModelObject*>(current)->layer();
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 static bool hasClippedStackingAncestor(const PaintLayer* layer, const PaintLayer* clippingLayer)
 {
     if (layer == clippingLayer)
         return false;
     bool foundInterveningClip = false;
     const LayoutObject* clippingLayoutObject = clippingLayer->layoutObject();
     for (const PaintLayer* current = layer->compositingContainer(); current; current = current->compositingContainer()) {
         if (current == clippingLayer)
             return foundInterveningClip;
 
-        if (current->layoutObject()->hasClipOrOverflowClip() && !clippingLayoutObject->isDescendantOf(current->layoutObject()))
+        if (current->layoutObject()->hasClipRelatedProperty() && !clippingLayoutObject->isDescendantOf(current->layoutObject()))
             foundInterveningClip = true;
 
         if (const LayoutObject* container = current->clippingContainer()) {
             if (clippingLayoutObject != container && !clippingLayoutObject->isDescendantOf(container))
                 foundInterveningClip = true;
         }
     }
     return false;
 }
 
@@ skipping 27 matching lines @@
             IntRect clipRect = pixelSnappedIntRect(layer->clipper().backgroundClipRect(ClipRectsContext(m_rootLayer, AbsoluteClipRects)).rect());
             properties.clippedAbsoluteBoundingBox.intersect(clipRect);
 
             const PaintLayer* parent = layer->parent();
             properties.opacityAncestor = parent->isTransparent() ? parent : parent->opacityAncestor();
             properties.transformAncestor = parent->hasTransformRelatedProperty() ? parent : parent->transformAncestor();
             properties.filterAncestor = parent->hasFilter() ? parent : parent->filterAncestor();
             bool layerIsFixedPosition = layer->layoutObject()->style()->position() == FixedPosition;
             properties.nearestFixedPositionLayer = layerIsFixedPosition ? layer : parent->nearestFixedPositionLayer();
 
-            if (info.hasAncestorWithClipOrOverflowClip) {
+            if (info.hasAncestorWithClipRelatedProperty) {
                 const PaintLayer* parentLayerOnClippingContainerChain = findParentLayerOnClippingContainerChain(layer);
-                const bool parentHasClipOrOverflowClip = parentLayerOnClippingContainerChain->layoutObject()->hasClipOrOverflowClip();
-                properties.clippingContainer = parentHasClipOrOverflowClip ? parentLayerOnClippingContainerChain->layoutObject() : parentLayerOnClippingContainerChain->clippingContainer();
+                const bool parentHasClipRelatedProperty = parentLayerOnClippingContainerChain->layoutObject()->hasClipRelatedProperty();
+                properties.clippingContainer = parentHasClipRelatedProperty ? parentLayerOnClippingContainerChain->layoutObject() : parentLayerOnClippingContainerChain->clippingContainer();
             }
 
             if (info.lastScrollingAncestor) {
                 const LayoutObject* containingBlock = layer->layoutObject()->containingBlock();
                 const PaintLayer* parentLayerOnContainingBlockChain = findParentLayerOnContainingBlockChain(containingBlock);
 
                 properties.ancestorScrollingLayer = parentLayerOnContainingBlockChain->ancestorScrollingLayer();
                 if (parentLayerOnContainingBlockChain->scrollsOverflow())
                     properties.ancestorScrollingLayer = parentLayerOnContainingBlockChain;
 
@@ skipping 13 matching lines @@
         properties.hasAncestorWithClipPath = info.hasAncestorWithClipPath;
         layer->updateAncestorDependentCompositingInputs(properties);
     }
 
     if (layer->stackingNode()->isStackingContext())
         info.ancestorStackingContext = layer;
 
     if (layer->scrollsOverflow())
         info.lastScrollingAncestor = layer;
 
-    if (layer->layoutObject()->hasClipOrOverflowClip())
-        info.hasAncestorWithClipOrOverflowClip = true;
+    if (layer->layoutObject()->hasClipRelatedProperty())
+        info.hasAncestorWithClipRelatedProperty = true;
 
     if (layer->layoutObject()->hasClipPath())
         info.hasAncestorWithClipPath = true;
 
     PaintLayer::DescendantDependentCompositingInputs descendantProperties;
     for (PaintLayer* child = layer->firstChild(); child; child = child->nextSibling()) {
         updateRecursive(child, updateType, info);
 
         descendantProperties.hasDescendantWithClipPath |= child->hasDescendantWithClipPath() || child->layoutObject()->hasClipPath();
         descendantProperties.hasNonIsolatedDescendantWithBlendMode |= (!child->stackingNode()->isStackingContext() && child->hasNonIsolatedDescendantWithBlendMode()) || child->layoutObject()->style()->hasBlendMode();
@@ skipping 12 matching lines @@
     ASSERT(!layer->childNeedsCompositingInputsUpdate());
     ASSERT(!layer->needsCompositingInputsUpdate());
 
     for (PaintLayer* child = layer->firstChild(); child; child = child->nextSibling())
         assertNeedsCompositingInputsUpdateBitsCleared(child);
 }
 
 #endif
 
 } // namespace blink