Unify predicates for elements "contributing" to a <clipPath>

third_party/WebKit/Source/core/layout/svg/LayoutSVGResourceClipper.cpp

 /*
  * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  * Copyright (C) 2011 Dirk Schulze <krit@webkit.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/layout/svg/LayoutSVGResourceClipper.h"
 
-#include "core/SVGNames.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/paint/PaintInfo.h"
 #include "core/svg/SVGGeometryElement.h"
 #include "core/svg/SVGUseElement.h"
-#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/SkPictureBuilder.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 
 namespace blink {
 
+namespace {
+
+bool requiresMask(const SVGElement& childElement) {
+  // TODO(fs): This needs to special-case <use> in a way similar to
+  // contributesToClip. (crbug.com/604677)
+  LayoutObject* layoutObject = childElement.layoutObject();
+  DCHECK(layoutObject);
+  // Only basic shapes or paths are supported for direct clipping. We need to
+  // fallback to masking for texts.
+  if (layoutObject->isSVGText())
+    return true;
+  // Current shape in clip-path gets clipped too. Fallback to masking.
+  return layoutObject->styleRef().clipPath();
+}
+
+bool contributesToClip(const SVGGraphicsElement& element) {
+  const LayoutObject* layoutObject = element.layoutObject();
+  if (!layoutObject)
+    return false;
+  const ComputedStyle& style = layoutObject->styleRef();
+  if (style.display() == EDisplay::None ||
+      style.visibility() != EVisibility::Visible)
+    return false;
+  // Only shapes, paths and texts are allowed for clipping.
+  return layoutObject->isSVGShape() || layoutObject->isSVGText();
+}
+
+bool contributesToClip(const SVGElement& element) {
+  // <use> within <clipPath> have a restricted content model.
+  // (https://drafts.fxtf.org/css-masking-1/#ClipPathElement)
+  if (isSVGUseElement(element)) {
+    const LayoutObject* useLayoutObject = element.layoutObject();
+    if (!useLayoutObject ||
+        useLayoutObject->styleRef().display() == EDisplay::None)
+      return false;
+    const SVGGraphicsElement* clippingElement =
+        toSVGUseElement(element).visibleTargetGraphicsElementForClipping();
+    if (!clippingElement)
+      return false;
+    return contributesToClip(*clippingElement);
+  }
+  if (!element.isSVGGraphicsElement())
+    return false;
+  return contributesToClip(toSVGGraphicsElement(element));
+}
+
+void pathFromElement(const SVGElement& element, Path& clipPath) {
+  if (isSVGGeometryElement(element))
+    toSVGGeometryElement(element).toClipPath(clipPath);
+  else if (isSVGUseElement(element))
+    toSVGUseElement(element).toClipPath(clipPath);
+}
+
+}  // namespace
+
 LayoutSVGResourceClipper::LayoutSVGResourceClipper(SVGClipPathElement* node)
     : LayoutSVGResourceContainer(node), m_inClipExpansion(false) {}
 
 LayoutSVGResourceClipper::~LayoutSVGResourceClipper() {}
 
 void LayoutSVGResourceClipper::removeAllClientsFromCache(
     bool markForInvalidation) {
   m_clipContentPath.clear();
   m_clipContentPicture.reset();
   m_localClipBounds = FloatRect();
@@ skipping 16 matching lines @@
 
   // If the current clip-path gets clipped itself, we have to fallback to
   // masking.
   if (styleRef().clipPath())
     return false;
 
   unsigned opCount = 0;
   bool usingBuilder = false;
   SkOpBuilder clipPathBuilder;
 
-  for (SVGElement* childElement = Traversal<SVGElement>::firstChild(*element());
-       childElement;
-       childElement = Traversal<SVGElement>::nextSibling(*childElement)) {
-    LayoutObject* childLayoutObject = childElement->layoutObject();
-    if (!childLayoutObject)
-      continue;
-    // Only shapes or paths are supported for direct clipping. We need to
-    // fallback to masking for texts.
-    if (childLayoutObject->isSVGText()) {
-      m_clipContentPath.clear();
-      return false;
-    }
-    if (!childElement->isSVGGraphicsElement())
+  for (const SVGElement& childElement :
+       Traversal<SVGElement>::childrenOf(*element())) {
+    if (!contributesToClip(childElement))
       continue;
 
-    const ComputedStyle* style = childLayoutObject->style();
-    if (!style || style->display() == EDisplay::None ||
-        (style->visibility() != EVisibility::Visible &&
-         !isSVGUseElement(*childElement)))
-      continue;
-
-    // Current shape in clip-path gets clipped too. Fallback to masking.
-    if (style->clipPath()) {
+    if (requiresMask(childElement)) {
       m_clipContentPath.clear();
       return false;
     }
 
     // First clip shape.
     if (m_clipContentPath.isEmpty()) {
-      if (isSVGGeometryElement(childElement))
-        toSVGGeometryElement(childElement)->toClipPath(m_clipContentPath);
-      else if (isSVGUseElement(childElement))
-        toSVGUseElement(childElement)->toClipPath(m_clipContentPath);
-
+      pathFromElement(childElement, m_clipContentPath);
       continue;
     }
 
     // Multiple shapes require PathOps. In some degenerate cases PathOps can
     // exhibit quadratic behavior, so we cap the number of ops to a reasonable
     // count.
     const unsigned kMaxOps = 42;
     if (++opCount > kMaxOps) {
       m_clipContentPath.clear();
       return false;
     }
 
     // Second clip shape => start using the builder.
     if (!usingBuilder) {
       clipPathBuilder.add(m_clipContentPath.getSkPath(), kUnion_SkPathOp);
       usingBuilder = true;
     }
 
     Path subPath;
-    if (isSVGGeometryElement(childElement))
-      toSVGGeometryElement(childElement)->toClipPath(subPath);
-    else if (isSVGUseElement(childElement))
-      toSVGUseElement(childElement)->toClipPath(subPath);
+    pathFromElement(childElement, subPath);
 
     clipPathBuilder.add(subPath.getSkPath(), kUnion_SkPathOp);
   }
 
   if (usingBuilder) {
     SkPath resolvedPath;
     clipPathBuilder.resolve(&resolvedPath);
     m_clipContentPath = resolvedPath;
   }
 
@@ skipping 28 matching lines @@
   if (m_clipContentPicture)
     return m_clipContentPicture;
 
   // Using strokeBoundingBox (instead of visualRectInLocalSVGCoordinates) to
   // avoid the intersection with local clips/mask, which may yield incorrect
   // results when mixing objectBoundingBox and userSpaceOnUse units
   // (http://crbug.com/294900).
   FloatRect bounds = strokeBoundingBox();
 
   SkPictureBuilder pictureBuilder(bounds, nullptr, nullptr);
+  // Switch to a paint behavior where all children of this <clipPath> will be
+  // laid out using special constraints:
+  // - fill-opacity/stroke-opacity/opacity set to 1
+  // - masker/filter not applied when laying out the children
+  // - fill is set to the initial fill paint server (solid, black)
+  // - stroke is set to the initial stroke paint server (none)
+  PaintInfo info(pictureBuilder.context(), LayoutRect::infiniteIntRect(),
+                 PaintPhaseForeground, GlobalPaintNormalPhase,
+                 PaintLayerPaintingRenderingClipPathAsMask);
 
-  for (SVGElement* childElement = Traversal<SVGElement>::firstChild(*element());
-       childElement;
-       childElement = Traversal<SVGElement>::nextSibling(*childElement)) {
-    LayoutObject* layoutObject = childElement->layoutObject();
-    if (!layoutObject)
+  for (const SVGElement& childElement :
+       Traversal<SVGElement>::childrenOf(*element())) {
+    if (!contributesToClip(childElement))
       continue;
-
-    const ComputedStyle* style = layoutObject->style();
-    if (!style || style->display() == EDisplay::None ||
-        (style->visibility() != EVisibility::Visible &&
-         !isSVGUseElement(*childElement)))
-      continue;
-
-    bool isUseElement = isSVGUseElement(*childElement);
-    if (isUseElement) {
-      const SVGGraphicsElement* clippingElement =
-          toSVGUseElement(*childElement)
-              .visibleTargetGraphicsElementForClipping();
-      if (!clippingElement)
-        continue;
-
-      layoutObject = clippingElement->layoutObject();
-      if (!layoutObject)
-        continue;
-    }
-
-    // Only shapes, paths and texts are allowed for clipping.
-    if (!layoutObject->isSVGShape() && !layoutObject->isSVGText())
-      continue;
-
-    if (isUseElement)
-      layoutObject = childElement->layoutObject();
-
-    // Switch to a paint behavior where all children of this <clipPath> will be
-    // laid out using special constraints:
-    // - fill-opacity/stroke-opacity/opacity set to 1
-    // - masker/filter not applied when laying out the children
-    // - fill is set to the initial fill paint server (solid, black)
-    // - stroke is set to the initial stroke paint server (none)
-    PaintInfo info(pictureBuilder.context(), LayoutRect::infiniteIntRect(),
-                   PaintPhaseForeground, GlobalPaintNormalPhase,
-                   PaintLayerPaintingRenderingClipPathAsMask);
+    // Use the LayoutObject of the direct child even if it is a <use>. In that
+    // case, we will paint the targeted element indirectly.
+    const LayoutObject* layoutObject = childElement.layoutObject();
     layoutObject->paint(info, IntPoint());
   }
 
   m_clipContentPicture = pictureBuilder.endRecording();
   return m_clipContentPicture;
 }
 
 void LayoutSVGResourceClipper::calculateLocalClipBounds() {
   // This is a rough heuristic to appraise the clip size and doesn't consider
   // clip on clip.
-  for (SVGElement* childElement = Traversal<SVGElement>::firstChild(*element());
-       childElement;
-       childElement = Traversal<SVGElement>::nextSibling(*childElement)) {
-    LayoutObject* layoutObject = childElement->layoutObject();
-    if (!layoutObject)
+  for (const SVGElement& childElement :
+       Traversal<SVGElement>::childrenOf(*element())) {
+    if (!contributesToClip(childElement))
       continue;
-    if (!layoutObject->isSVGShape() && !layoutObject->isSVGText() &&
-        !isSVGUseElement(*childElement))
-      continue;
-    const ComputedStyle* style = layoutObject->style();
-    if (!style || style->display() == EDisplay::None ||
-        (style->visibility() != EVisibility::Visible &&
-         !isSVGUseElement(*childElement)))
-      continue;
-    if (isSVGUseElement(*childElement) &&
-        !toSVGUseElement(*childElement)
-             .visibleTargetGraphicsElementForClipping())
-      continue;
-
+    const LayoutObject* layoutObject = childElement.layoutObject();
     m_localClipBounds.unite(layoutObject->localToSVGParentTransform().mapRect(
         layoutObject->visualRectInLocalSVGCoordinates()));
   }
 }
 
 bool LayoutSVGResourceClipper::hitTestClipContent(
     const FloatRect& objectBoundingBox,
     const FloatPoint& nodeAtPoint) {
   FloatPoint point = nodeAtPoint;
   if (!SVGLayoutSupport::pointInClippingArea(*this, point))
     return false;
 
   if (clipPathUnits() == SVGUnitTypes::kSvgUnitTypeObjectboundingbox) {
     AffineTransform transform;
     transform.translate(objectBoundingBox.x(), objectBoundingBox.y());
     transform.scaleNonUniform(objectBoundingBox.width(),
                               objectBoundingBox.height());
     point = transform.inverse().mapPoint(point);
   }
 
   AffineTransform animatedLocalTransform =
       toSVGClipPathElement(element())->calculateTransform(
           SVGElement::IncludeMotionTransform);
   if (!animatedLocalTransform.isInvertible())
     return false;
 
   point = animatedLocalTransform.inverse().mapPoint(point);
 
-  for (SVGElement* childElement = Traversal<SVGElement>::firstChild(*element());
-       childElement;
-       childElement = Traversal<SVGElement>::nextSibling(*childElement)) {
-    LayoutObject* layoutObject = childElement->layoutObject();
-    if (!layoutObject)
-      continue;
-    if (!layoutObject->isSVGShape() && !layoutObject->isSVGText() &&
-        !isSVGUseElement(*childElement))
+  for (const SVGElement& childElement :
+       Traversal<SVGElement>::childrenOf(*element())) {
+    if (!contributesToClip(childElement))
       continue;
     IntPoint hitPoint;
     HitTestResult result(HitTestRequest::SVGClipContent, hitPoint);
+    LayoutObject* layoutObject = childElement.layoutObject();
     if (layoutObject->nodeAtFloatPoint(result, point, HitTestForeground))
       return true;
   }
-
   return false;
 }
 
 FloatRect LayoutSVGResourceClipper::resourceBoundingBox(
     const FloatRect& referenceBox) {
   // The resource has not been layouted yet. Return the reference box.
   if (selfNeedsLayout())
     return referenceBox;
 
   if (m_localClipBounds.isEmpty())
     calculateLocalClipBounds();
 
   AffineTransform transform =
       toSVGClipPathElement(element())->calculateTransform(
           SVGElement::IncludeMotionTransform);
   if (clipPathUnits() == SVGUnitTypes::kSvgUnitTypeObjectboundingbox) {
     transform.translate(referenceBox.x(), referenceBox.y());
     transform.scaleNonUniform(referenceBox.width(), referenceBox.height());
   }
   return transform.mapRect(m_localClipBounds);
 }
 
 }  // namespace blink