Unprefix -webkit-clip-path

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

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 352 matching lines @@
 }
 
 bool SVGLayoutSupport::hasFilterResource(const LayoutObject& object)
 {
     SVGResources* resources = SVGResourcesCache::cachedResourcesForLayoutObject(&object);
     return resources && resources->filter();
 }
 
 bool SVGLayoutSupport::pointInClippingArea(const LayoutObject& object, const FloatPoint& point)
 {
-    // We just take clippers into account to determine if a point is on the node. The Specification may
-    // change later and we also need to check maskers.
+    ClipPathOperation* clipPathOperation = object.styleRef().clipPath();
+    if (!clipPathOperation)
+        return true;
+    if (clipPathOperation->type() == ClipPathOperation::SHAPE) {

[chrishtr, 2016/09/09 02:04:46]

Why this new code to support SHAPE? Is this to implement
the additional feature mentioned in the CL description?
if so, why add a new feature while unprefixing?

[fs, 2016/09/09 08:28:10]

No, this is actually what falls out by starting to use ClipPathOperation
(ComputedStyle::clipPath). This was broken before because we didn't consider
'-webkit-clip-path' here although we painted it. Considering it's literally only
four additional lines (and two would be needed to avoid supporting it) it felt a
bit silly to leave it out. In contrast, the painting side of things (this is
hit-testing code) are nicely shareable, so just constitutes plugging in
ClipPathClipper, for a net reduction in code. No such luck for hit-testing
though...

[fs, 2016/09/09 08:31:35]

I should probably mention that "Support for nesting a <clipPath> with a
<basic-shape>..." as mentioned in the description is also one of those things
that are trivially supported by sharing code - although technically landing that
separately essentially mean that paint and hit-test code-paths have to diverge
in some way. (Or be very ugly/require additional code.)

[fs, 2016/09/09 16:26:42]

I've split out <basic-shape> support for 'clip-path' to
https://codereview.chromium.org/2322343003 - I'll update this CL to be based on
that as soon as I've shuttled home.

[fs, 2016/09/09 20:12:16]

Done.

+        ShapeClipPathOperation& clipPath = toShapeClipPathOperation(*clipPathOperation);
+        return clipPath.path(object.objectBoundingBox()).contains(point);
+    }
+    DCHECK_EQ(clipPathOperation->type(), ClipPathOperation::REFERENCE);
     SVGResources* resources = SVGResourcesCache::cachedResourcesForLayoutObject(&object);
-    if (!resources)
+    if (!resources || !resources->clipper())
         return true;
-
-    if (LayoutSVGResourceClipper* clipper = resources->clipper())
-        return clipper->hitTestClipContent(object.objectBoundingBox(), point);
-
-    return true;
+    return resources->clipper()->hitTestClipContent(object.objectBoundingBox(), point);
 }
 
 bool SVGLayoutSupport::transformToUserSpaceAndCheckClipping(const LayoutObject& object, const AffineTransform& localTransform, const FloatPoint& pointInParent, FloatPoint& localPoint)
 {
     if (!localTransform.isInvertible())
         return false;
     localPoint = localTransform.inverse().mapPoint(pointInParent);
     return pointInClippingArea(object, localPoint);
 }
 
@@ skipping 35 matching lines @@
     ASSERT(object->isText());
     // <br> is marked as text, but is not handled by the SVG layout code-path.
     return object->isSVGInlineText() && !toLayoutSVGInlineText(object)->hasEmptyText();
 }
 
 bool SVGLayoutSupport::willIsolateBlendingDescendantsForStyle(const ComputedStyle& style)
 {
     const SVGComputedStyle& svgStyle = style.svgStyle();
 
     return style.hasIsolation() || style.opacity() < 1 || style.hasBlendMode()
-        || style.hasFilter() || svgStyle.hasMasker() || svgStyle.hasClipper();
+        || style.hasFilter() || svgStyle.hasMasker() || style.clipPath();
 }
 
 bool SVGLayoutSupport::willIsolateBlendingDescendantsForObject(const LayoutObject* object)
 {
     if (object->isSVGHiddenContainer())
         return false;
     if (!object->isSVGRoot() && !object->isSVGContainer())
         return false;
     return willIsolateBlendingDescendantsForStyle(object->styleRef());
 }
@@ skipping 125 matching lines @@
 
     return closestText;
 }
 
 LayoutObject* SVGLayoutSupport::findClosestLayoutSVGText(LayoutObject* layoutObject, const FloatPoint& point)
 {
     return searchTreeForFindClosestLayoutSVGText(layoutObject, point).candidateLayoutObject;
 }
 
 } // namespace blink