Use an SVGElementProxy in ReferenceClipPathOperation

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 92 matching lines @@
   struct {
     IntSize size;
     void* pointer;
     LayoutRect rect;
   } previousPaintStatus;
 };
 
 static_assert(sizeof(PaintLayer) == sizeof(SameSizeAsPaintLayer),
               "PaintLayer should stay small");
 
+bool isReferenceClipPath(const ClipPathOperation* clipOperation) {
+  return clipOperation && clipOperation->type() == ClipPathOperation::REFERENCE;
+}
+
 }  // namespace
 
 using namespace HTMLNames;
 
 PaintLayerRareData::PaintLayerRareData()
     : enclosingPaginationLayer(nullptr),
       potentialCompositingReasonsFromStyle(CompositingReasonNone),
       compositingReasons(CompositingReasonNone),
       squashingDisallowedReasons(SquashingDisallowedReasonsNone),
       groupedMapping(nullptr) {}
@@ skipping 49 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);
-    m_rareData->filterInfo->clearLayer();
+  if (m_rareData && m_rareData->resourceInfo) {
+    const ComputedStyle& style = layoutObject()->styleRef();
+    if (style.hasFilter())
+      style.filter().removeClient(m_rareData->resourceInfo);
+    if (isReferenceClipPath(style.clipPath())) {
+      toReferenceClipPathOperation(style.clipPath())
+          ->removeClient(m_rareData->resourceInfo);
+    }
+    m_rareData->resourceInfo->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 2172 matching lines @@
   FloatPoint point(hitTestLocation.point());
 
   ClipPathOperation* clipPathOperation = layoutObject()->style()->clipPath();
   DCHECK(clipPathOperation);
   if (clipPathOperation->type() == ClipPathOperation::SHAPE) {
     ShapeClipPathOperation* clipPath =
         toShapeClipPathOperation(clipPathOperation);
     return !clipPath->path(FloatRect(referenceBox)).contains(point);
   }
   DCHECK_EQ(clipPathOperation->type(), ClipPathOperation::REFERENCE);
-  ReferenceClipPathOperation* referenceClipPathOperation =
-      toReferenceClipPathOperation(clipPathOperation);
-  Element* element = layoutObject()->document().getElementById(
-      referenceClipPathOperation->fragment());
+  Node* targetNode = layoutObject()->node();
+  if (!targetNode)
+    return false;
+  const ReferenceClipPathOperation& referenceClipPathOperation =
+      toReferenceClipPathOperation(*clipPathOperation);
+  SVGElement* element =
+      referenceClipPathOperation.findElement(targetNode->treeScope());
   if (!isSVGClipPathElement(element) || !element->layoutObject())
     return false;
   LayoutSVGResourceClipper* clipper = toLayoutSVGResourceClipper(
       toLayoutSVGResourceContainer(element->layoutObject()));
   // If the clipPath is using "userspace on use" units, then the origin of
   // the coordinate system is the top-left of the reference box, so adjust
   // the point accordingly.
   if (clipper->clipPathUnits() == SVGUnitTypes::kSvgUnitTypeUserspaceonuse)
     point.moveBy(-referenceBox.location());
   return !clipper->hitTestClipContent(FloatRect(referenceBox), point);
@@ skipping 247 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();
+  if (PaintLayerResourceInfo* resourceInfo = this->resourceInfo())
+    resourceInfo->invalidateFilterChain();
 }
 
 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 (PaintLayerResourceInfo* resourceInfo = this->resourceInfo())
+    resourceInfo->invalidateFilterChain();
 }
 
 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();
+  const bool hadResourceInfo = resourceInfo();
   if (newStyle.hasFilterInducingProperty())
-    newStyle.filter().addClient(&ensureFilterInfo());
-  if (hadFilterInfo && oldStyle)
-    oldStyle->filter().removeClient(filterInfo());
-  if (!newStyle.hasFilterInducingProperty()) {
-    removeFilterInfo();
+    newStyle.filter().addClient(&ensureResourceInfo());
+  if (hadResourceInfo && oldStyle)
+    oldStyle->filter().removeClient(resourceInfo());
+  if (PaintLayerResourceInfo* resourceInfo = this->resourceInfo())
+    resourceInfo->invalidateFilterChain();
+}
+
+void PaintLayer::updateClipPath(const ComputedStyle* oldStyle,
+                                const ComputedStyle& newStyle) {
+  ClipPathOperation* newClipOperation = newStyle.clipPath();
+  ClipPathOperation* oldClipOperation =
+      oldStyle ? oldStyle->clipPath() : nullptr;
+  if (!newClipOperation && !oldClipOperation)
     return;
+  const bool hadResourceInfo = resourceInfo();
+  if (isReferenceClipPath(newClipOperation)) {
+    toReferenceClipPathOperation(newClipOperation)
+        ->addClient(&ensureResourceInfo());
   }
-  if (PaintLayerFilterInfo* filterInfo = this->filterInfo())
-    filterInfo->invalidateFilterChain();
+  if (hadResourceInfo && isReferenceClipPath(oldClipOperation)) {
+    toReferenceClipPathOperation(oldClipOperation)
+        ->removeClient(resourceInfo());
+  }
 }
 
 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
@@ skipping 65 matching lines @@
     m_scrollableArea->updateAfterStyleChange(oldStyle);
 
   // Overlay scrollbars can make this layer self-painting so we need
   // to recompute the bit once scrollbars have been updated.
   updateSelfPaintingLayer();
 
   updateDescendantDependentFlags();
 
   updateTransform(oldStyle, layoutObject()->styleRef());
   updateFilters(oldStyle, layoutObject()->styleRef());
+  updateClipPath(oldStyle, layoutObject()->styleRef());
 
   setNeedsCompositingInputsUpdate();
 }
 
 bool PaintLayer::scrollsOverflow() const {
   if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea())
     return scrollableArea->scrollsOverflow();
 
   return false;
 }
@@ skipping 24 matching lines @@
 PaintLayer::createCompositorFilterOperationsForBackdropFilter(
     const ComputedStyle& style) {
   FloatRect zoomedReferenceBox;
   if (style.backdropFilter().hasReferenceFilter())
     zoomedReferenceBox = boxForFilter();
   FilterEffectBuilder builder(enclosingNode(), zoomedReferenceBox,
                               style.effectiveZoom());
   return builder.buildFilterOperations(style.backdropFilter());
 }
 
-PaintLayerFilterInfo& PaintLayer::ensureFilterInfo() {
+PaintLayerResourceInfo& PaintLayer::ensureResourceInfo() {
   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;
+  if (!rareData.resourceInfo)
+    rareData.resourceInfo = new PaintLayerResourceInfo(this);
+  return *rareData.resourceInfo;
 }
 
 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 {
   // TODO(chrishtr): ensure (and assert) that compositing is clean here.
   if (!paintsWithFilters())
     return nullptr;
-  PaintLayerFilterInfo* filterInfo = this->filterInfo();
-  DCHECK(filterInfo);
+  PaintLayerResourceInfo* resourceInfo = this->resourceInfo();
+  DCHECK(resourceInfo);
 
-  if (filterInfo->lastEffect())
-    return filterInfo->lastEffect();
+  if (resourceInfo->lastEffect())
+    return resourceInfo->lastEffect();
 
   const ComputedStyle& style = layoutObject()->styleRef();
   FloatRect zoomedReferenceBox;
   if (style.filter().hasReferenceFilter())
     zoomedReferenceBox = boxForFilter();
   FilterEffectBuilder builder(enclosingNode(), zoomedReferenceBox,
                               style.effectiveZoom());
-  filterInfo->setLastEffect(
+  resourceInfo->setLastEffect(
       builder.buildFilterEffect(addReflectionToFilterOperations(style)));
-  return filterInfo->lastEffect();
+  return resourceInfo->lastEffect();
 }
 
 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();
 
@@ skipping 150 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif