Implement Paint Containment

third_party/WebKit/Source/core/paint/PaintLayer.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 729 matching lines @@
             }
             curr = curr->parent();
         }
         if (curr->isBox() && curr->isTableRow()) {
             // Put ourselves into the row coordinate space.
             localPoint.moveBy(-toLayoutBox(curr)->topLeftLocation());
         }
     }
 
     // Subtract our parent's scroll offset.
-    if (PaintLayer* positionedParent = layoutObject()->isOutOfFlowPositioned() ? enclosingPositionedAncestor() : nullptr) {
+    if (PaintLayer* positionedParent = layoutObject()->isOutOfFlowPositioned() ? enclosingPositionedOrContainedAncestor() : nullptr) {
         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
         if (positionedParent->layoutObject()->hasOverflowClip()) {
             IntSize offset = positionedParent->layoutBox()->scrolledContentOffset();
             localPoint -= offset;
         }
 
         if (positionedParent->layoutObject()->isInFlowPositioned() && positionedParent->layoutObject()->isLayoutInline()) {
             LayoutSize offset = toLayoutInline(positionedParent->layoutObject())->offsetForInFlowPositionedInline(*toLayoutBox(layoutObject()));
             localPoint += offset;
         }
@@ skipping 50 matching lines @@
     const ComputedStyle& style = layoutObject()->styleRef();
 
     return FloatPoint(floatValueForLength(style.perspectiveOriginX(), borderBox.width().toFloat()), floatValueForLength(style.perspectiveOriginY(), borderBox.height().toFloat()));
 }
 
 static inline bool isFixedPositionedContainer(PaintLayer* layer)
 {
     return layer->isRootLayer() || layer->hasTransformRelatedProperty();
 }
 
-PaintLayer* PaintLayer::enclosingPositionedAncestor(const PaintLayer* ancestor, bool* skippedAncestor) const
+PaintLayer* PaintLayer::enclosingPositionedOrContainedAncestor(const PaintLayer* ancestor, bool* skippedAncestor) const
 {
     ASSERT(!ancestor || skippedAncestor); // If we have specified an ancestor, surely the caller needs to know whether we skipped it.
     if (skippedAncestor)
         *skippedAncestor = false;
     if (layoutObject()->style()->position() == FixedPosition) {
         PaintLayer* curr = parent();
         while (curr && !isFixedPositionedContainer(curr)) {
             if (skippedAncestor && curr == ancestor)
                 *skippedAncestor = true;
             curr = curr->parent();
@@ skipping 433 matching lines @@
         // If the fixed layer's container is the root, just add in the offset of the view. We can obtain this by calling
         // localToAbsolute() on the LayoutView.
         FloatPoint absPos = layoutObject->localToAbsolute(FloatPoint(), IsFixed);
         location += LayoutSize(absPos.x(), absPos.y());
         return ancestorLayer;
     }
 
     PaintLayer* parentLayer;
     if (position == AbsolutePosition || position == FixedPosition) {
         bool foundAncestorFirst;
-        parentLayer = layer->enclosingPositionedAncestor(ancestorLayer, &foundAncestorFirst);
+        parentLayer = layer->enclosingPositionedOrContainedAncestor(ancestorLayer, &foundAncestorFirst);
 
         if (foundAncestorFirst) {
             // Found ancestorLayer before the container of the out-of-flow object, so compute offset
             // of both relative to the container and subtract.
 
             LayoutPoint thisCoords;
             layer->convertToLayerCoords(parentLayer, thisCoords);
 
             LayoutPoint ancestorCoords;
             ancestorLayer->convertToLayerCoords(parentLayer, ancestorCoords);
@@ skipping 1065 matching lines @@
     if (m_stackingNode->zOrderListsDirty())
         return false;
 
     // FIXME: We currently only check the immediate layoutObject,
     // which will miss many cases.
     if (layoutObject()->backgroundIsKnownToBeOpaqueInRect(localRect))
         return true;
 
     // We can't consult child layers if we clip, since they might cover
     // parts of the rect that are clipped out.
-    if (layoutObject()->hasOverflowClip())
+    if (layoutObject()->hasOverflowClip() || layoutObject()->style()->containsPaint())
         return false;
 
     return childBackgroundIsKnownToBeOpaqueInRect(localRect);
 }
 
 bool PaintLayer::childBackgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     PaintLayerStackingNodeReverseIterator revertseIterator(*m_stackingNode, PositiveZOrderChildren | NormalFlowChildren | NegativeZOrderChildren);
     while (PaintLayerStackingNode* child = revertseIterator.next()) {
         const PaintLayer* childLayer = child->layer();
@@ skipping 408 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif