Implement -webkit-box-reflect as a filter.

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 233 matching lines @@
         if (hasCompositedLayerMapping())
             compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
     }
 
     if (CompositedLayerMapping* compositedLayerMapping = this->compositedLayerMapping())
         compositedLayerMapping->contentChanged(changeType);
 }
 
 bool PaintLayer::paintsWithFilters() const
 {
-    if (!layoutObject()->hasFilter())
+    if (!layoutObject()->hasFilterInducingProperty())
         return false;
 
     // https://code.google.com/p/chromium/issues/detail?id=343759
     DisableCompositingQueryAsserts disabler;
     return !compositedLayerMapping() || compositingState() != PaintsIntoOwnBacking;
 }
 
 bool PaintLayer::paintsWithBackdropFilters() const
 {
     if (!layoutObject()->hasBackdropFilter())
@@ skipping 791 matching lines @@
 
     m_shouldIsolateCompositedDescendants = shouldIsolateCompositedDescendants;
 
     if (hasCompositedLayerMapping())
         compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
 }
 
 bool PaintLayer::hasAncestorWithFilterOutsets() const
 {
     for (const PaintLayer* curr = this; curr; curr = curr->parent()) {
-        LayoutBoxModelObject* layoutObject = curr->layoutObject();
-        if (layoutObject->style()->hasFilterOutsets())
+        if (curr->hasFilterOutsets())
             return true;
     }
     return false;
 }
 
 static void expandClipRectForDescendantsAndReflection(LayoutRect& clipRect, const PaintLayer* layer, const PaintLayer* rootLayer,
     PaintLayer::TransparencyClipBoxBehavior transparencyBehavior, const LayoutSize& subPixelAccumulation, GlobalPaintFlags globalPaintFlags)
 {
     // If we have a mask, then the clip is limited to the border box area (and there is
     // no need to examine child layers).
@@ skipping 1046 matching lines @@
     return result;
 }
 
 LayoutRect PaintLayer::boundingBoxForCompositingOverlapTest() const
 {
     // Apply NeverIncludeTransformForAncestorLayer, because the geometry map in CompositingInputsUpdater will take care of applying the
     // transform of |this| (== the ancestorLayer argument to boundingBoxForCompositing).
     return overlapBoundsIncludeChildren() ? boundingBoxForCompositing(this, NeverIncludeTransformForAncestorLayer) : fragmentsBoundingBox(this);
 }
 
+bool PaintLayer::overlapBoundsIncludeChildren() const
+{
+    const auto* style = layoutObject()->style();
+    if (style && style->filter().hasFilterThatMovesPixels())
+        return true;
+    if (RuntimeEnabledFeatures::cssBoxReflectFilterEnabled() && layoutObject()->hasReflection())
+        return true;
+    return false;
+}
+
 static void expandRectForReflectionAndStackingChildren(const PaintLayer* ancestorLayer, LayoutRect& result)
 {
-    if (ancestorLayer->reflectionInfo() && !ancestorLayer->reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping())
+    if (ancestorLayer->reflectionInfo() && !ancestorLayer->reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping() && !RuntimeEnabledFeatures::cssBoxReflectFilterEnabled())
         result.unite(ancestorLayer->reflectionInfo()->reflectionLayer()->boundingBoxForCompositing(ancestorLayer));
 
     ASSERT(ancestorLayer->stackingNode()->isStackingContext() || !ancestorLayer->stackingNode()->hasPositiveZOrderList());
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(const_cast<PaintLayer*>(ancestorLayer)->stackingNode());
 #endif
 
     PaintLayerStackingNodeIterator iterator(*ancestorLayer->stackingNode(), AllChildren);
     while (PaintLayerStackingNode* node = iterator.next()) {
@@ skipping 316 matching lines @@
 bool PaintLayer::hasVisibleBoxDecorations() const
 {
     if (!hasVisibleContent())
         return false;
 
     return hasBoxDecorationsOrBackground() || hasOverflowControls();
 }
 
 void PaintLayer::updateFilters(const ComputedStyle* oldStyle, const ComputedStyle& newStyle)
 {
-    if (!newStyle.hasFilter() && (!oldStyle || !oldStyle->hasFilter()))
+    if (!newStyle.hasFilterInducingProperty() && (!oldStyle || !oldStyle->hasFilterInducingProperty()))
         return;
 
     updateOrRemoveFilterClients();
     updateOrRemoveFilterEffectBuilder();
 }
 
 bool PaintLayer::attemptDirectCompositingUpdate(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     CompositingReasons oldPotentialCompositingReasonsFromStyle = potentialCompositingReasonsFromStyle();
     compositor()->updatePotentialCompositingReasonsFromStyle(this);
@@ skipping 112 matching lines @@
         }
     }
 
     return filters;
 }
 
 } // unnamed namespace
 
 FilterOperations PaintLayer::computeFilterOperations(const ComputedStyle& style) const
 {
-    return computeFilterOperationsHandleReferenceFilters(style.filter(), style.effectiveZoom(), enclosingNode());
+    FilterOperations filterOperations = style.filter();
+    if (RuntimeEnabledFeatures::cssBoxReflectFilterEnabled() && layoutObject()->hasReflection() && layoutObject()->isBox()) {
+        // TODO(jbroman): Incorporate the mask image.
+        const auto* reflectStyle = style.boxReflect();
+        FloatRect frameRect(toLayoutBox(layoutObject())->frameRect());
+        ReflectionDirection direction = VerticalReflection;
+        float offset = 0;
+        switch (reflectStyle->direction()) {
+        case ReflectionAbove:
+            direction = VerticalReflection;
+            offset = -floatValueForLength(reflectStyle->offset(), frameRect.height());
+            break;
+        case ReflectionBelow:
+            direction = VerticalReflection;
+            offset = 2 * frameRect.height() + floatValueForLength(reflectStyle->offset(), frameRect.height());
+            break;
+        case ReflectionLeft:
+            direction = HorizontalReflection;
+            offset = -floatValueForLength(reflectStyle->offset(), frameRect.width());
+            break;
+        case ReflectionRight:
+            direction = HorizontalReflection;
+            offset = 2 * frameRect.width() + floatValueForLength(reflectStyle->offset(), frameRect.width());
+            break;
+        }
+
+        // Since the filter origin is the corner of the input bounds, which may
+        // include visual overflow (e.g. due to box-shadow), we must adjust the
+        // offset to also account for this offset (this is equivalent to using
+        // SkLocalMatrixImageFilter, but simpler).
+        // The rect used here should match the one used in FilterPainter.
+        LayoutRect filterInputBounds = physicalBoundingBoxIncludingReflectionAndStackingChildren(LayoutPoint());
+        offset -= 2 * (direction == VerticalReflection ? filterInputBounds.y() : filterInputBounds.x()).toFloat();
+
+        filterOperations.operations().append(BoxReflectFilterOperation::create(direction, offset));
+    }
+    return computeFilterOperationsHandleReferenceFilters(filterOperations, style.effectiveZoom(), enclosingNode());
 }
 
 FilterOperations PaintLayer::computeBackdropFilterOperations(const ComputedStyle& style) const
 {
     return computeFilterOperationsHandleReferenceFilters(style.backdropFilter(), style.effectiveZoom(), enclosingNode());
 }
 
 PaintLayerFilterInfo& PaintLayer::ensureFilterInfo()
 {
     PaintLayerRareData& rareData = ensureRareData();
     if (!rareData.filterInfo)
         rareData.filterInfo = adoptPtr(new PaintLayerFilterInfo(this));
     return *rareData.filterInfo;
 }
 
 void PaintLayer::updateOrRemoveFilterClients()
 {
-    if (!hasFilter() && m_rareData) {
+    const auto& filter = layoutObject()->style()->filter();
+    if (filter.isEmpty() && m_rareData) {
         m_rareData->filterInfo = nullptr;
-    } else if (layoutObject()->style()->filter().hasReferenceFilter()) {
-        ensureFilterInfo().updateReferenceFilterClients(layoutObject()->style()->filter());
+    } else if (filter.hasReferenceFilter()) {
+        ensureFilterInfo().updateReferenceFilterClients(filter);
     } else if (filterInfo()) {
         filterInfo()->clearFilterReferences();
     }
 }
 
 FilterEffectBuilder* PaintLayer::updateFilterEffectBuilder() const
 {
     // TODO(chrishtr): ensure (and assert) that compositing is clean here.
 
     if (!paintsWithFilters())
@@ skipping 17 matching lines @@
 }
 
 FilterEffect* PaintLayer::lastFilterEffect() const
 {
     FilterEffectBuilder* builder = updateFilterEffectBuilder();
     if (!builder)
         return nullptr;
     return builder->lastEffect().get();
 }
 
+bool PaintLayer::hasFilterOutsets() const
+{
+    if (!layoutObject()->hasFilterInducingProperty())
+        return false;
+    const ComputedStyle& style = layoutObject()->styleRef();
+    if (style.hasFilter() && style.filter().hasOutsets())
+        return true;
+    if (RuntimeEnabledFeatures::cssBoxReflectFilterEnabled() && style.hasBoxReflect())
+        return true;
+    return false;
+}
+
 FilterOutsets PaintLayer::filterOutsets() const
 {
-    if (!layoutObject()->hasFilter())
+    if (!layoutObject()->hasFilterInducingProperty())
         return FilterOutsets();
 
     // Ensure the filter-chain is refreshed wrt reference filters.
     updateFilterEffectBuilder();
+
     return layoutObject()->style()->filter().outsets();
 }
 
 void PaintLayer::updateOrRemoveFilterEffectBuilder()
 {
     // FilterEffectBuilder is only used to render the filters in software mode,
     // so we always need to run updateOrRemoveFilterEffectBuilder after the composited
     // mode might have changed for this layer.
     if (!paintsWithFilters()) {
         // Don't delete the whole filter info here, because we might use it
@@ skipping 135 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif