[SPv2] Implement CSS clip property

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

 // Copyright 2015 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/paint/PaintPropertyTreeBuilder.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ObjectPaintProperties.h"
@@ skipping 196 matching lines @@
 static PassRefPtr<EffectPaintPropertyNode> createEffectIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     const ComputedStyle& style = object.styleRef();
     if (!style.hasOpacity())
         return nullptr;
     RefPtr<EffectPaintPropertyNode> newEffectNode = EffectPaintPropertyNode::create(style.opacity(), context.currentEffect);
     context.currentEffect = newEffectNode.get();
     return newEffectNode.release();
 }
 
+static PassRefPtr<ClipPaintPropertyNode> createCSSClipIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+{
+    if (!object.hasClip())
+        return nullptr;
+    ASSERT(object.canContainAbsolutePositionObjects());
+
+    // Create clip node for descendants that are not fixed position.
+    // We don't have to setup context.clipForAbsolutePosition here because this object must be
+    // a container for absolute position descendants, and will copy from in-flow context later
+    // at updateOutOfFlowContext() step.
+    LayoutRect clipRect = toLayoutBox(object).clipRect(context.paintOffset);
+    RefPtr<ClipPaintPropertyNode> newClipNodeForCSSClip = ClipPaintPropertyNode::create(
+        context.currentTransform,
+        FloatRoundedRect(FloatRect(clipRect)),
+        context.currentClip);
+    context.currentClip = newClipNodeForCSSClip.get();
+
+    return newClipNodeForCSSClip.release();
+}
+
 // TODO(trchen): Remove this once we bake the paint offset into frameRect.
 static PassRefPtr<TransformPaintPropertyNode> createScrollbarPaintOffsetIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     IntPoint roundedPaintOffset = roundedIntPoint(context.paintOffset);
     if (roundedPaintOffset == IntPoint())
         return nullptr;
 
     if (!object.isBoxModelObject())
         return nullptr;
     PaintLayerScrollableArea* scrollableArea = toLayoutBoxModelObject(object).getScrollableArea();
@@ skipping 75 matching lines @@
     if (scrollOffset.isZero() && !layer->scrollsOverflow())
         return nullptr;
 
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = TransformPaintPropertyNode::create(
         TransformationMatrix().translate(-scrollOffset.width(), -scrollOffset.height()),
         FloatPoint3D(), context.currentTransform);
     context.currentTransform = newTransformNodeForScrollTranslation.get();
     return newTransformNodeForScrollTranslation.release();
 }
 
-static void updateOutOfFlowContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+static void updateOutOfFlowContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context, ClipPaintPropertyNode* newClipNodeForCSSClip, RefPtr<ClipPaintPropertyNode>& newClipNodeForCSSClipFixedPosition)
 {
     // At the html->svg boundary (see: createPaintOffsetTranslationIfNeeded) the currentTransform is
     // up-to-date for all children of the svg root element. Additionally, inside SVG, all positioning
     // uses transforms. Therefore, we only need to check createdNewTransform and isSVGRoot() to
     // ensure out-of-flow and fixed positioning is correct at the svg->html boundary.
 
     if (object.canContainAbsolutePositionObjects()) {
         context.transformForAbsolutePosition = context.currentTransform;
         context.paintOffsetForAbsolutePosition = context.paintOffset;
         context.clipForAbsolutePosition = context.currentClip;
     }
 
     // TODO(pdr): Remove the !object.isLayoutView() condition when removing FrameView
     // paint properties for rootLayerScrolls.
     if (!object.isLayoutView() && object.canContainFixedPositionObjects()) {
         context.transformForFixedPosition = context.currentTransform;
         context.paintOffsetForFixedPosition = context.paintOffset;
         context.clipForFixedPosition = context.currentClip;
+    } else if (newClipNodeForCSSClip) {
+        // CSS clip applies to all descendants, even if this object is not a containing block
+        // ancestor of the descendant. It is okay for absolute-position descendants because
+        // having CSS clip implies being absolute position container. However for fixed-position
+        // descendants we need to insert the clip here if we are not a containing block ancestor
+        // of them.
+
+        // Before we actually create anything, check whether in-flow context and fixed-position
+        // context has exactly the same clip. Reuse if possible.
+        if (context.clipForFixedPosition == newClipNodeForCSSClip->parent()) {
+            context.clipForFixedPosition = newClipNodeForCSSClip;
+            return;
+        }
+
+        newClipNodeForCSSClipFixedPosition = ClipPaintPropertyNode::create(
+            const_cast<TransformPaintPropertyNode*>(newClipNodeForCSSClip->localTransformSpace()),
+            newClipNodeForCSSClip->clipRect(),
+            context.clipForFixedPosition);
+        context.clipForFixedPosition = newClipNodeForCSSClipFixedPosition.get();
     }
 }
 
 static PassOwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> recordTreeContextIfNeeded(LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
 {
     // Note: Currently only layer painter makes use of the pre-computed context.
     // This condition may be loosened with no adverse effects beside memory use.
     if (!object.hasLayer())
         return nullptr;
 
     OwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> recordedContext = adoptPtr(new ObjectPaintProperties::LocalBorderBoxProperties);
     recordedContext->paintOffset = context.paintOffset;
     recordedContext->transform = context.currentTransform;
     recordedContext->clip = context.currentClip;
     recordedContext->effect = context.currentEffect;
     return recordedContext.release();
 }
 
 void PaintPropertyTreeBuilder::walk(LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
 {
     PaintPropertyTreeBuilderContext localContext(context);
 
     deriveBorderBoxFromContainerContext(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPaintOffsetTranslation = createPaintOffsetTranslationIfNeeded(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = createTransformIfNeeded(object, localContext);
     RefPtr<EffectPaintPropertyNode> newEffectNode = createEffectIfNeeded(object, localContext);
+    RefPtr<ClipPaintPropertyNode> newClipNodeForCSSClip = createCSSClipIfNeeded(object, localContext);
     OwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> newRecordedContext = recordTreeContextIfNeeded(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollbarPaintOffset = createScrollbarPaintOffsetIfNeeded(object, localContext);
     RefPtr<ClipPaintPropertyNode> newClipNodeForOverflowClip = createOverflowClipIfNeeded(object, localContext);
     // TODO(trchen): Insert flattening transform here, as specified by
     // http://www.w3.org/TR/css3-transforms/#transform-style-property
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPerspective = createPerspectiveIfNeeded(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = createScrollTranslationIfNeeded(object, localContext);
-    updateOutOfFlowContext(object, localContext);
+    RefPtr<ClipPaintPropertyNode> newClipNodeForCSSClipFixedPosition;
+    updateOutOfFlowContext(object, localContext, newClipNodeForCSSClip.get(), newClipNodeForCSSClipFixedPosition);
 
-    if (newTransformNodeForPaintOffsetTranslation || newTransformNodeForTransform || newEffectNode || newClipNodeForOverflowClip || newTransformNodeForPerspective || newTransformNodeForScrollTranslation || newTransformNodeForScrollbarPaintOffset || newRecordedContext) {
+    if (newTransformNodeForPaintOffsetTranslation || newTransformNodeForTransform || newEffectNode || newClipNodeForCSSClip || newClipNodeForCSSClipFixedPosition || newClipNodeForOverflowClip || newTransformNodeForPerspective || newTransformNodeForScrollTranslation || newTransformNodeForScrollbarPaintOffset || newRecordedContext) {
         OwnPtr<ObjectPaintProperties> updatedPaintProperties = ObjectPaintProperties::create(
             newTransformNodeForPaintOffsetTranslation.release(),
             newTransformNodeForTransform.release(),
             newEffectNode.release(),
+            newClipNodeForCSSClip.release(),
+            newClipNodeForCSSClipFixedPosition.release(),
             newClipNodeForOverflowClip.release(),
             newTransformNodeForPerspective.release(),
             newTransformNodeForScrollTranslation.release(),
             newTransformNodeForScrollbarPaintOffset.release(),
             newRecordedContext.release());
         object.setObjectPaintProperties(updatedPaintProperties.release());
     } else {
         object.clearObjectPaintProperties();
     }
 
     for (LayoutObject* child = object.slowFirstChild(); child; child = child->nextSibling()) {
         if (child->isBoxModelObject() || child->isSVG())
             walk(*child, localContext);
     }
 
     if (object.isLayoutPart()) {
         Widget* widget = toLayoutPart(object).widget();
         if (widget && widget->isFrameView())
             walk(*toFrameView(widget), localContext);
         // TODO(pdr): Investigate RemoteFrameView (crbug.com/579281).
     }
 }
 
 } // namespace blink