Make resource lookup more uniform in SVGResources::buildResources

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

 /*
  * Copyright (C) Research In Motion Limited 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
  * 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/SVGResources.h"
 
+#include <memory>
 #include "core/SVGNames.h"
 #include "core/layout/svg/LayoutSVGResourceClipper.h"
 #include "core/layout/svg/LayoutSVGResourceFilter.h"
 #include "core/layout/svg/LayoutSVGResourceMarker.h"
 #include "core/layout/svg/LayoutSVGResourceMasker.h"
 #include "core/layout/svg/LayoutSVGResourcePaintServer.h"
 #include "core/style/ComputedStyle.h"
 #include "core/svg/SVGGradientElement.h"
 #include "core/svg/SVGPatternElement.h"
+#include "core/svg/SVGTreeScopeResources.h"
 #include "core/svg/SVGURIReference.h"
 #include "wtf/PtrUtil.h"
-#include <memory>
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 using namespace SVGNames;
 
 SVGResources::SVGResources() : m_linkedResource(nullptr) {}
@@ skipping 82 matching lines @@
     case SVG_PAINTTYPE_URI_CURRENTCOLOR:
     case SVG_PAINTTYPE_URI_RGBCOLOR:
     case SVG_PAINTTYPE_URI:
       return true;
     default:
       break;
   }
   return false;
 }
 
-static inline LayoutSVGResourcePaintServer* paintingResourceFromSVGPaint(
-    TreeScope& treeScope,
-    const String& paintUri,
-    AtomicString& id) {
-  id = SVGURIReference::fragmentIdentifierFromIRIString(paintUri, treeScope);
-  LayoutSVGResourceContainer* container =
-      treeScope.ensureSVGTreeScopedResources().resourceById(id);
-  if (!container || !container->isSVGPaintServer())
-    return nullptr;
-  return toLayoutSVGResourcePaintServer(container);
+namespace {
+
+template <typename ContainerType>
+bool isResourceOfType(LayoutSVGResourceContainer* container) {
+  return container->resourceType() == ContainerType::s_resourceType;
+}
+
+template <>
+bool isResourceOfType<LayoutSVGResourcePaintServer>(

[pdr., 2017/03/24 16:46:34]

The LayoutSVGResourcePaintServer and LayoutSVGResourceContainer templates were
pretty confusing to me but I don't see a better way to do this. Is there any way
to reel those special cases in?

[fs, 2017/03/24 19:26:54]

We should (be able to) get rid of the latter by removing the "linked resource"
from SVGResources (this would make it entirely a "style" thingy.) The latter is
more difficult, and I don't have a direct plan ATM, although I suspect it might
erode eventually as we migrate away from storing LayoutSVGResource<foo>
pointers.

+    LayoutSVGResourceContainer* container) {
+  return container->isSVGPaintServer();
+}
+
+template <>
+bool isResourceOfType<LayoutSVGResourceContainer>(
+    LayoutSVGResourceContainer* container) {
+  return true;
+}
+
+template <typename ContainerType>
+ContainerType* attachToResource(SVGTreeScopeResources& treeScopeResources,
+                                const AtomicString& id,
+                                SVGElement& element) {
+  if (LayoutSVGResourceContainer* container =
+          treeScopeResources.resourceById(id)) {
+    if (isResourceOfType<ContainerType>(container))
+      return static_cast<ContainerType*>(container);
+  }
+  treeScopeResources.addPendingResource(id, element);
+  return nullptr;
+}
 }
 
 bool SVGResources::hasResourceData() const {
   return m_clipperFilterMaskerData || m_markerData || m_fillStrokeData ||
          m_linkedResource;
 }
 
 static inline SVGResources& ensureResources(
     std::unique_ptr<SVGResources>& resources) {
   if (!resources)
@@ skipping 24 matching lines @@
 
   std::unique_ptr<SVGResources> resources;
   if (clipperFilterMaskerTags().contains(tagName)) {
     if (computedStyle.clipPath() && !object->isSVGRoot()) {
       ClipPathOperation* clipPathOperation = computedStyle.clipPath();
       if (clipPathOperation->type() == ClipPathOperation::REFERENCE) {
         const ReferenceClipPathOperation& clipPathReference =
             toReferenceClipPathOperation(*clipPathOperation);
         AtomicString id = SVGURIReference::fragmentIdentifierFromIRIString(
             clipPathReference.url(), treeScope);
-        if (!ensureResources(resources).setClipper(
-                getLayoutSVGResourceById<LayoutSVGResourceClipper>(
-                    treeScopeResources, id)))
-          treeScopeResources.addPendingResource(id, element);
+        ensureResources(resources).setClipper(
+            attachToResource<LayoutSVGResourceClipper>(treeScopeResources, id,
+                                                       element));
       }
     }
 
     if (computedStyle.hasFilter() && !object->isSVGRoot()) {
       const FilterOperations& filterOperations = computedStyle.filter();
       if (filterOperations.size() == 1) {
         const FilterOperation& filterOperation = *filterOperations.at(0);
         if (filterOperation.type() == FilterOperation::REFERENCE) {
           const auto& referenceFilterOperation =
               toReferenceFilterOperation(filterOperation);
           AtomicString id = SVGURIReference::fragmentIdentifierFromIRIString(
               referenceFilterOperation.url(), treeScope);
-          if (!ensureResources(resources).setFilter(
-                  getLayoutSVGResourceById<LayoutSVGResourceFilter>(
-                      treeScopeResources, id)))
-            treeScopeResources.addPendingResource(id, element);
+          ensureResources(resources).setFilter(
+              attachToResource<LayoutSVGResourceFilter>(treeScopeResources, id,
+                                                        element));
         }
       }
     }
 
     if (style.hasMasker()) {
-      AtomicString id = style.maskerResource();
-      if (!ensureResources(resources).setMasker(
-              getLayoutSVGResourceById<LayoutSVGResourceMasker>(
-                  treeScopeResources, id)))
-        treeScopeResources.addPendingResource(id, element);
+      ensureResources(resources).setMasker(
+          attachToResource<LayoutSVGResourceMasker>(
+              treeScopeResources, style.maskerResource(), element));
     }
   }
 
   if (style.hasMarkers() && supportsMarkers(element)) {
-    const AtomicString& markerStartId = style.markerStartResource();
-    if (!ensureResources(resources).setMarkerStart(
-            getLayoutSVGResourceById<LayoutSVGResourceMarker>(
-                treeScopeResources, markerStartId)))
-      treeScopeResources.addPendingResource(markerStartId, element);
-
-    const AtomicString& markerMidId = style.markerMidResource();
-    if (!ensureResources(resources).setMarkerMid(
-            getLayoutSVGResourceById<LayoutSVGResourceMarker>(
-                treeScopeResources, markerMidId)))
-      treeScopeResources.addPendingResource(markerMidId, element);
-
-    const AtomicString& markerEndId = style.markerEndResource();
-    if (!ensureResources(resources).setMarkerEnd(
-            getLayoutSVGResourceById<LayoutSVGResourceMarker>(
-                treeScopeResources, markerEndId)))
-      treeScopeResources.addPendingResource(markerEndId, element);
+    ensureResources(resources).setMarkerStart(
+        attachToResource<LayoutSVGResourceMarker>(
+            treeScopeResources, style.markerStartResource(), element));
+    ensureResources(resources).setMarkerMid(
+        attachToResource<LayoutSVGResourceMarker>(
+            treeScopeResources, style.markerMidResource(), element));
+    ensureResources(resources).setMarkerEnd(
+        attachToResource<LayoutSVGResourceMarker>(
+            treeScopeResources, style.markerEndResource(), element));
   }
 
   if (fillAndStrokeTags().contains(tagName)) {
     if (style.hasFill() && svgPaintTypeHasURL(style.fillPaintType())) {
-      AtomicString id;
-      LayoutSVGResourcePaintServer* resource =
-          paintingResourceFromSVGPaint(treeScope, style.fillPaintUri(), id);
-      if (!ensureResources(resources).setFill(resource))
-        treeScopeResources.addPendingResource(id, element);
+      AtomicString id = SVGURIReference::fragmentIdentifierFromIRIString(
+          style.fillPaintUri(), treeScope);
+      ensureResources(resources).setFill(
+          attachToResource<LayoutSVGResourcePaintServer>(treeScopeResources, id,
+                                                         element));
     }
 
     if (style.hasStroke() && svgPaintTypeHasURL(style.strokePaintType())) {
-      AtomicString id;
-      LayoutSVGResourcePaintServer* resource =
-          paintingResourceFromSVGPaint(treeScope, style.strokePaintUri(), id);
-      if (!ensureResources(resources).setStroke(resource))
-        treeScopeResources.addPendingResource(id, element);
+      AtomicString id = SVGURIReference::fragmentIdentifierFromIRIString(
+          style.strokePaintUri(), treeScope);
+      ensureResources(resources).setStroke(
+          attachToResource<LayoutSVGResourcePaintServer>(treeScopeResources, id,
+                                                         element));
     }
   }
 
   if (chainableResourceTags().contains(tagName)) {
     AtomicString id = targetReferenceFromResource(element);
-    if (!ensureResources(resources).setLinkedResource(
-            treeScopeResources.resourceById(id)))
-      treeScopeResources.addPendingResource(id, element);
+    ensureResources(resources).setLinkedResource(
+        attachToResource<LayoutSVGResourceContainer>(treeScopeResources, id,
+                                                     element));
   }
 
   return (!resources || !resources->hasResourceData()) ? nullptr
                                                        : std::move(resources);
 }
 
 void SVGResources::layoutIfNeeded() {
   if (m_clipperFilterMaskerData) {
     if (LayoutSVGResourceClipper* clipper = m_clipperFilterMaskerData->clipper)
       clipper->layoutIfNeeded();
@@ skipping 163 matching lines @@
   }
 
   if (m_fillStrokeData) {
     if (m_fillStrokeData->fill)
       set.insert(m_fillStrokeData->fill);
     if (m_fillStrokeData->stroke)
       set.insert(m_fillStrokeData->stroke);
   }
 }
 
-bool SVGResources::setClipper(LayoutSVGResourceClipper* clipper) {
+void SVGResources::setClipper(LayoutSVGResourceClipper* clipper) {
   if (!clipper)
-    return false;
+    return;
 
   ASSERT(clipper->resourceType() == ClipperResourceType);
 
   if (!m_clipperFilterMaskerData)
     m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
 
   m_clipperFilterMaskerData->clipper = clipper;
-  return true;
 }
 
 void SVGResources::resetClipper() {
   ASSERT(m_clipperFilterMaskerData);
   ASSERT(m_clipperFilterMaskerData->clipper);
   m_clipperFilterMaskerData->clipper = nullptr;
 }
 
-bool SVGResources::setFilter(LayoutSVGResourceFilter* filter) {
+void SVGResources::setFilter(LayoutSVGResourceFilter* filter) {
   if (!filter)
-    return false;
+    return;
 
   ASSERT(filter->resourceType() == FilterResourceType);
 
   if (!m_clipperFilterMaskerData)
     m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
 
   m_clipperFilterMaskerData->filter = filter;
-  return true;
 }
 
 void SVGResources::resetFilter() {
   ASSERT(m_clipperFilterMaskerData);
   ASSERT(m_clipperFilterMaskerData->filter);
   m_clipperFilterMaskerData->filter = nullptr;
 }
 
-bool SVGResources::setMarkerStart(LayoutSVGResourceMarker* markerStart) {
+void SVGResources::setMarkerStart(LayoutSVGResourceMarker* markerStart) {
   if (!markerStart)
-    return false;
+    return;
 
   ASSERT(markerStart->resourceType() == MarkerResourceType);
 
   if (!m_markerData)
     m_markerData = MarkerData::create();
 
   m_markerData->markerStart = markerStart;
-  return true;
 }
 
 void SVGResources::resetMarkerStart() {
   ASSERT(m_markerData);
   ASSERT(m_markerData->markerStart);
   m_markerData->markerStart = nullptr;
 }
 
-bool SVGResources::setMarkerMid(LayoutSVGResourceMarker* markerMid) {
+void SVGResources::setMarkerMid(LayoutSVGResourceMarker* markerMid) {
   if (!markerMid)
-    return false;
+    return;
 
   ASSERT(markerMid->resourceType() == MarkerResourceType);
 
   if (!m_markerData)
     m_markerData = MarkerData::create();
 
   m_markerData->markerMid = markerMid;
-  return true;
 }
 
 void SVGResources::resetMarkerMid() {
   ASSERT(m_markerData);
   ASSERT(m_markerData->markerMid);
   m_markerData->markerMid = nullptr;
 }
 
-bool SVGResources::setMarkerEnd(LayoutSVGResourceMarker* markerEnd) {
+void SVGResources::setMarkerEnd(LayoutSVGResourceMarker* markerEnd) {
   if (!markerEnd)
-    return false;
+    return;
 
   ASSERT(markerEnd->resourceType() == MarkerResourceType);
 
   if (!m_markerData)
     m_markerData = MarkerData::create();
 
   m_markerData->markerEnd = markerEnd;
-  return true;
 }
 
 void SVGResources::resetMarkerEnd() {
   ASSERT(m_markerData);
   ASSERT(m_markerData->markerEnd);
   m_markerData->markerEnd = nullptr;
 }
 
-bool SVGResources::setMasker(LayoutSVGResourceMasker* masker) {
+void SVGResources::setMasker(LayoutSVGResourceMasker* masker) {
   if (!masker)
-    return false;
+    return;
 
   ASSERT(masker->resourceType() == MaskerResourceType);
 
   if (!m_clipperFilterMaskerData)
     m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
 
   m_clipperFilterMaskerData->masker = masker;
-  return true;
 }
 
 void SVGResources::resetMasker() {
   ASSERT(m_clipperFilterMaskerData);
   ASSERT(m_clipperFilterMaskerData->masker);
   m_clipperFilterMaskerData->masker = nullptr;
 }
 
-bool SVGResources::setFill(LayoutSVGResourcePaintServer* fill) {
+void SVGResources::setFill(LayoutSVGResourcePaintServer* fill) {
   if (!fill)
-    return false;
+    return;
 
   if (!m_fillStrokeData)
     m_fillStrokeData = FillStrokeData::create();
 
   m_fillStrokeData->fill = fill;
-  return true;
 }
 
 void SVGResources::resetFill() {
   ASSERT(m_fillStrokeData);
   ASSERT(m_fillStrokeData->fill);
   m_fillStrokeData->fill = nullptr;
 }
 
-bool SVGResources::setStroke(LayoutSVGResourcePaintServer* stroke) {
+void SVGResources::setStroke(LayoutSVGResourcePaintServer* stroke) {
   if (!stroke)
-    return false;
+    return;
 
   if (!m_fillStrokeData)
     m_fillStrokeData = FillStrokeData::create();
 
   m_fillStrokeData->stroke = stroke;
-  return true;
 }
 
 void SVGResources::resetStroke() {
   ASSERT(m_fillStrokeData);
   ASSERT(m_fillStrokeData->stroke);
   m_fillStrokeData->stroke = nullptr;
 }
 
-bool SVGResources::setLinkedResource(
+void SVGResources::setLinkedResource(
     LayoutSVGResourceContainer* linkedResource) {
   if (!linkedResource)
-    return false;
+    return;
 
   m_linkedResource = linkedResource;
-  return true;
 }
 
 void SVGResources::resetLinkedResource() {
   ASSERT(m_linkedResource);
   m_linkedResource = nullptr;
 }
 
 #ifndef NDEBUG
 void SVGResources::dump(const LayoutObject* object) {
   ASSERT(object);
@@ skipping 38 matching lines @@
               stroke->element());
   }
 
   if (m_linkedResource)
     fprintf(stderr, " |-> xlink:href : %p (node=%p)\n", m_linkedResource,
             m_linkedResource->element());
 }
 #endif
 
 }  // namespace blink