Revert of Tracking filter mutation via SVGElementProxy

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>
@@ skipping 31 matching lines @@
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "core/paint/PaintLayer.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
 #include "core/css/PseudoStyleRequest.h"
 #include "core/dom/Document.h"
 #include "core/dom/shadow/ShadowRoot.h"
+#include "core/frame/DeprecatedScheduleStyleRecalcDuringLayout.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
+#include "core/html/HTMLFrameElement.h"
 #include "core/layout/FragmentainerIterator.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/HitTestingTransformState.h"
 #include "core/layout/LayoutFlowThread.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutTreeAsText.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutPartItem.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/layout/svg/LayoutSVGResourceClipper.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/paint/BoxReflectionUtils.h"
 #include "core/paint/FilterEffectBuilder.h"
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintTiming.h"
 #include "platform/LengthFunctions.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/FloatPoint3D.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/CompositorFilterOperations.h"
 #include "platform/graphics/filters/Filter.h"
+#include "platform/graphics/filters/SkiaImageFilterBuilder.h"
 #include "platform/tracing/TraceEvent.h"
+#include "platform/transforms/ScaleTransformOperation.h"
 #include "platform/transforms/TransformationMatrix.h"
+#include "platform/transforms/TranslateTransformOperation.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/allocator/Partitions.h"
 #include "wtf/text/CString.h"
 
 namespace blink {
 
 namespace {
 
 static CompositingQueryMode gCompositingQueryMode =
@@ skipping 81 matching lines @@
   if (!layoutObject->slowFirstChild() && layoutObject->style()) {
     m_isVisibleContentDirty = false;
     m_hasVisibleContent =
         layoutObject->style()->visibility() == EVisibility::Visible;
   }
 
   updateScrollableArea();
 }
 
 PaintLayer::~PaintLayer() {
-  if (m_rareData && m_rareData->filterInfo) {
-    layoutObject()->styleRef().filter().removeClient(m_rareData->filterInfo);
+  if (m_rareData && m_rareData->filterInfo)
     m_rareData->filterInfo->clearLayer();
-  }
   if (layoutObject()->frame() && layoutObject()->frame()->page()) {
     if (ScrollingCoordinator* scrollingCoordinator =
             layoutObject()->frame()->page()->scrollingCoordinator())
       scrollingCoordinator->willDestroyLayer(this);
   }
 
   if (groupedMapping()) {
     DisableCompositingQueryAsserts disabler;
     setGroupedMapping(0, InvalidateLayerAndRemoveFromMapping);
   }
@@ skipping 2447 matching lines @@
 
 void PaintLayer::ensureCompositedLayerMapping() {
   if (m_rareData && m_rareData->compositedLayerMapping)
     return;
 
   ensureRareData().compositedLayerMapping =
       wrapUnique(new CompositedLayerMapping(*this));
   m_rareData->compositedLayerMapping->setNeedsGraphicsLayerUpdate(
       GraphicsLayerUpdateSubtree);
 
-  if (PaintLayerFilterInfo* filterInfo = this->filterInfo())
-    filterInfo->invalidateFilterChain();
+  updateOrRemoveFilterEffect();
 }
 
 void PaintLayer::clearCompositedLayerMapping(bool layerBeingDestroyed) {
   if (!layerBeingDestroyed) {
     // We need to make sure our decendants get a geometry update. In principle,
     // we could call setNeedsGraphicsLayerUpdate on our children, but that would
     // require walking the z-order lists to find them. Instead, we
     // over-invalidate by marking our parent as needing a geometry update.
     if (PaintLayer* compositingParent =
             enclosingLayerWithCompositedLayerMapping(ExcludeSelf))
       compositingParent->compositedLayerMapping()->setNeedsGraphicsLayerUpdate(
           GraphicsLayerUpdateSubtree);
   }
 
   if (m_rareData)
     m_rareData->compositedLayerMapping.reset();
 
-  if (layerBeingDestroyed)
-    return;
-
-  if (PaintLayerFilterInfo* filterInfo = this->filterInfo())
-    filterInfo->invalidateFilterChain();
+  if (!layerBeingDestroyed)
+    updateOrRemoveFilterEffect();
 }
 
 void PaintLayer::setGroupedMapping(CompositedLayerMapping* groupedMapping,
                                    SetGroupMappingOptions options) {
   CompositedLayerMapping* oldGroupedMapping = this->groupedMapping();
   if (groupedMapping == oldGroupedMapping)
     return;
 
   if (options == InvalidateLayerAndRemoveFromMapping && oldGroupedMapping) {
     oldGroupedMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
@@ skipping 182 matching lines @@
     return false;
 
   return hasBoxDecorationsOrBackground() || hasOverflowControls();
 }
 
 void PaintLayer::updateFilters(const ComputedStyle* oldStyle,
                                const ComputedStyle& newStyle) {
   if (!newStyle.hasFilterInducingProperty() &&
       (!oldStyle || !oldStyle->hasFilterInducingProperty()))
     return;
-  const bool hadFilterInfo = filterInfo();
-  if (newStyle.hasFilterInducingProperty())
-    newStyle.filter().addClient(&ensureFilterInfo());
-  if (hadFilterInfo && oldStyle)
-    oldStyle->filter().removeClient(filterInfo());
-  if (!newStyle.hasFilterInducingProperty()) {
-    removeFilterInfo();
-    return;
-  }
-  if (PaintLayerFilterInfo* filterInfo = this->filterInfo())
-    filterInfo->invalidateFilterChain();
+
+  updateOrRemoveFilterClients();
+  updateOrRemoveFilterEffect();
 }
 
 bool PaintLayer::attemptDirectCompositingUpdate(StyleDifference diff,
                                                 const ComputedStyle* oldStyle) {
   CompositingReasons oldPotentialCompositingReasonsFromStyle =
       potentialCompositingReasonsFromStyle();
   compositor()->updatePotentialCompositingReasonsFromStyle(this);
 
   // This function implements an optimization for transforms and opacity.
   // A common pattern is for a touchmove handler to update the transform
   // and/or an opacity of an element every frame while the user moves their
   // finger across the screen. The conditions below recognize when the
   // compositing state is set up to receive a direct transform or opacity
   // update.
 
   if (!diff.hasAtMostPropertySpecificDifferences(
           StyleDifference::TransformChanged | StyleDifference::OpacityChanged))
     return false;
   // The potentialCompositingReasonsFromStyle could have changed without
   // a corresponding StyleDifference if an animation started or ended.
   if (potentialCompositingReasonsFromStyle() !=
       oldPotentialCompositingReasonsFromStyle)
     return false;
+  // If we're unwinding a scheduleSVGFilterLayerUpdateHack(), then we can't
+  // perform a direct compositing update because the filters code is going
+  // to produce different output this time around. We can remove this code
+  // once we fix the chicken/egg bugs in the filters code and delete the
+  // scheduleSVGFilterLayerUpdateHack().
+  if (layoutObject()->node() &&
+      layoutObject()->node()->svgFilterNeedsLayerUpdate())
+    return false;
   if (!m_rareData || !m_rareData->compositedLayerMapping)
     return false;
 
   // To cut off almost all the work in the compositing update for
   // this case, we treat inline transforms has having assumed overlap
   // (similar to how we treat animated transforms). Notice that we read
   // CompositingReasonInlineTransform from the m_compositingReasons, which
   // means that the inline transform actually triggered assumed overlap in
   // the overlap map.
   if (diff.transformChanged() &&
@@ skipping 93 matching lines @@
   return builder.buildFilterOperations(style.backdropFilter());
 }
 
 PaintLayerFilterInfo& PaintLayer::ensureFilterInfo() {
   PaintLayerRareData& rareData = ensureRareData();
   if (!rareData.filterInfo)
     rareData.filterInfo = new PaintLayerFilterInfo(this);
   return *rareData.filterInfo;
 }
 
-void PaintLayer::removeFilterInfo() {
-  if (!m_rareData || !m_rareData->filterInfo)
-    return;
-  m_rareData->filterInfo->clearLayer();
-  m_rareData->filterInfo = nullptr;
-}
-
 void PaintLayer::removeAncestorOverflowLayer(const PaintLayer* removedLayer) {
   // If the current ancestor overflow layer does not match the removed layer
   // the ancestor overflow layer has changed so we can stop searching.
   if (ancestorOverflowLayer() && ancestorOverflowLayer() != removedLayer)
     return;
 
   if (ancestorOverflowLayer()) {
     // TODO(pdr): When slimming paint v2 is enabled, we will need to
     // invalidate the scroll paint property subtree for this so main
     // thread scroll reasons are recomputed.
     ancestorOverflowLayer()
         ->getScrollableArea()
         ->invalidateStickyConstraintsFor(this);
   }
   updateAncestorOverflowLayer(nullptr);
   PaintLayer* current = m_first;
   while (current) {
     current->removeAncestorOverflowLayer(removedLayer);
     current = current->nextSibling();
   }
 }
 
-FilterEffect* PaintLayer::lastFilterEffect() const {
+void PaintLayer::updateOrRemoveFilterClients() {
+  const auto& filter = layoutObject()->style()->filter();
+  if (filter.isEmpty() && m_rareData && m_rareData->filterInfo) {
+    m_rareData->filterInfo->clearLayer();
+    m_rareData->filterInfo = nullptr;
+  } else if (filter.hasReferenceFilter()) {
+    ensureFilterInfo().updateReferenceFilterClients(filter);
+  } else if (filterInfo()) {
+    filterInfo()->clearFilterReferences();
+  }
+}
+
+FilterEffect* PaintLayer::updateFilterEffect() const {
   // TODO(chrishtr): ensure (and assert) that compositing is clean here.
+
   if (!paintsWithFilters())
     return nullptr;
+
   PaintLayerFilterInfo* filterInfo = this->filterInfo();
+
+  // Should have been added by updateOrRemoveFilterEffect().
   DCHECK(filterInfo);
 
   if (filterInfo->lastEffect())
     return filterInfo->lastEffect();
 
   const ComputedStyle& style = layoutObject()->styleRef();
   FloatRect zoomedReferenceBox;
   if (style.filter().hasReferenceFilter())
     zoomedReferenceBox = boxForFilter();
   FilterEffectBuilder builder(enclosingNode(), zoomedReferenceBox,
                               style.effectiveZoom());
   filterInfo->setLastEffect(
       builder.buildFilterEffect(addReflectionToFilterOperations(style)));
   return filterInfo->lastEffect();
 }
 
+FilterEffect* PaintLayer::lastFilterEffect() const {
+  return updateFilterEffect();
+}
+
 FloatRect PaintLayer::mapRectForFilter(const FloatRect& rect) const {
   if (!hasFilterThatMovesPixels())
     return rect;
 
   // Ensure the filter-chain is refreshed wrt reference filters.
-  // TODO(fs): Avoid having this side-effect inducing call.
-  lastFilterEffect();
+  updateFilterEffect();
 
   FilterOperations filterOperations =
       addReflectionToFilterOperations(layoutObject()->styleRef());
   return filterOperations.mapRect(rect);
 }
 
 LayoutRect PaintLayer::mapLayoutRectForFilter(const LayoutRect& rect) const {
   if (!hasFilterThatMovesPixels())
     return rect;
   return enclosingLayoutRect(mapRectForFilter(FloatRect(rect)));
 }
 
 bool PaintLayer::hasFilterThatMovesPixels() const {
   if (!hasFilterInducingProperty())
     return false;
   const ComputedStyle& style = layoutObject()->styleRef();
   if (style.hasFilter() && style.filter().hasFilterThatMovesPixels())
     return true;
   if (style.hasBoxReflect())
     return true;
   return false;
 }
 
+void PaintLayer::updateOrRemoveFilterEffect() {
+  // FilterEffectBuilder is only used to render the filters in software mode,
+  // so we always need to run updateOrRemoveFilterEffect after the composited
+  // mode might have changed for this layer.
+  if (!paintsWithFilters()) {
+    if (PaintLayerFilterInfo* filterInfo = this->filterInfo())
+      filterInfo->setLastEffect(nullptr);
+    return;
+  }
+
+  ensureFilterInfo().setLastEffect(nullptr);
+}
+
+void PaintLayer::filterNeedsPaintInvalidation() {
+  {
+    DeprecatedScheduleStyleRecalcDuringLayout marker(
+        layoutObject()->document().lifecycle());
+    // It's possible for scheduleSVGFilterLayerUpdateHack to schedule a style
+    // recalc, which is a problem because this function can be called right
+    // before performing layout but after style recalc.
+    //
+    // See LayoutView::layout() and the call to
+    // invalidateSVGRootsWithRelativeLengthDescendents(). This violation is
+    // worked around in FrameView::updateStyleAndLayoutIfNeededRecursive() by
+    // doing an extra style recalc and layout in case it's needed.
+    toElement(layoutObject()->node())->scheduleSVGFilterLayerUpdateHack();
+  }
+
+  layoutObject()->setShouldDoFullPaintInvalidation();
+}
+
 void PaintLayer::addLayerHitTestRects(LayerHitTestRects& rects) const {
   computeSelfHitTestRects(rects);
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling())
     child->addLayerHitTestRects(rects);
 }
 
 void PaintLayer::computeSelfHitTestRects(LayerHitTestRects& rects) const {
   if (!size().isEmpty()) {
     Vector<LayoutRect> rect;
 
@@ skipping 118 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif