Use IdTargetObserver in SVGSMILElement

third_party/WebKit/Source/core/svg/animation/SVGSMILElement.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/svg/animation/SVGSMILElement.h"
 
+#include <algorithm>
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "core/XLinkNames.h"
 #include "core/dom/Document.h"
+#include "core/dom/IdTargetObserver.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
 #include "core/events/EventListener.h"
 #include "core/svg/SVGSVGElement.h"
-#include "core/svg/SVGTreeScopeResources.h"
 #include "core/svg/SVGURIReference.h"
 #include "core/svg/animation/SMILTimeContainer.h"
 #include "platform/heap/Handle.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
-#include <algorithm>
 
 namespace blink {
 
 class RepeatEvent final : public Event {
  public:
   static RepeatEvent* create(const AtomicString& type, int repeat) {
     return new RepeatEvent(type, false, false, repeat);
   }
 
   ~RepeatEvent() override {}
@@ skipping 85 matching lines @@
       m_beginOrEnd(beginOrEnd),
       m_baseID(baseID),
       m_name(name),
       m_offset(offset),
       m_repeat(repeat) {}
 
 SVGSMILElement::Condition::~Condition() = default;
 
 DEFINE_TRACE(SVGSMILElement::Condition) {
   visitor->trace(m_baseElement);
+  visitor->trace(m_baseIdObserver);
   visitor->trace(m_eventListener);
 }
 
 void SVGSMILElement::Condition::connectSyncBase(SVGSMILElement& timedElement) {
   DCHECK(!m_baseID.isEmpty());
   DCHECK_EQ(m_type, Syncbase);
   Element* element = timedElement.treeScope().getElementById(m_baseID);
   if (!element || !isSVGSMILElement(*element)) {
     m_baseElement = nullptr;
     return;
   }
   m_baseElement = toSVGSMILElement(element);
   toSVGSMILElement(*element).addSyncBaseDependent(timedElement);
 }
 
 void SVGSMILElement::Condition::disconnectSyncBase(
     SVGSMILElement& timedElement) {
   DCHECK_EQ(m_type, Syncbase);
   if (!m_baseElement)
     return;
   toSVGSMILElement(*m_baseElement).removeSyncBaseDependent(timedElement);
   m_baseElement = nullptr;
 }
 
-SVGElement* SVGSMILElement::Condition::lookupEventBase(
-    SVGSMILElement& timedElement) const {
-  Element* eventBase = m_baseID.isEmpty()
-                           ? timedElement.targetElement()
-                           : timedElement.treeScope().getElementById(m_baseID);
-  if (!eventBase || !eventBase->isSVGElement())
-    return nullptr;
-  return toSVGElement(eventBase);
-}
-
 void SVGSMILElement::Condition::connectEventBase(SVGSMILElement& timedElement) {
   DCHECK_EQ(m_type, EventBase);
   DCHECK(!m_baseElement);
-  SVGElement* eventBase = lookupEventBase(timedElement);
-  if (!eventBase) {
-    if (m_baseID.isEmpty())
-      return;
-    SVGTreeScopeResources& treeScopeResources =
-        timedElement.treeScope().ensureSVGTreeScopedResources();
-    if (!treeScopeResources.isElementPendingResource(timedElement, m_baseID))
-      treeScopeResources.addPendingResource(m_baseID, timedElement);
+  Element* target;
+  if (m_baseID.isEmpty()) {
+    target = timedElement.targetElement();
+  } else {
+    target = SVGURIReference::observeTarget(
+        m_baseIdObserver, timedElement.treeScope(), m_baseID,
+        WTF::bind(&SVGSMILElement::buildPendingResource,
+                  wrapWeakPersistent(&timedElement)));
+  }
+  if (!target || !target->isSVGElement())
     return;
-  }
   DCHECK(!m_eventListener);
   m_eventListener = ConditionEventListener::create(&timedElement, this);
-  m_baseElement = eventBase;
+  m_baseElement = toSVGElement(target);
   m_baseElement->addEventListener(m_name, m_eventListener, false);
   timedElement.addReferenceTo(m_baseElement);
 }
 
 void SVGSMILElement::Condition::disconnectEventBase(
     SVGSMILElement& timedElement) {
   DCHECK_EQ(m_type, EventBase);
+  SVGURIReference::unobserveTarget(m_baseIdObserver);
   if (!m_eventListener)
     return;
   m_baseElement->removeEventListener(m_name, m_eventListener, false);
   m_baseElement = nullptr;
   m_eventListener->disconnectAnimation();
   m_eventListener = nullptr;
 }
 
 SVGSMILElement::SVGSMILElement(const QualifiedName& tagName, Document& doc)
     : SVGElement(tagName, doc),
@@ skipping 15 matching lines @@
       m_cachedRepeatDur(invalidCachedTime),
       m_cachedRepeatCount(invalidCachedTime),
       m_cachedMin(invalidCachedTime),
       m_cachedMax(invalidCachedTime) {
   resolveFirstInterval();
 }
 
 SVGSMILElement::~SVGSMILElement() {}
 
 void SVGSMILElement::clearResourceAndEventBaseReferences() {
+  SVGURIReference::unobserveTarget(m_targetIdObserver);
   removeAllOutgoingReferences();
 }
 
 void SVGSMILElement::clearConditions() {
   disconnectSyncBaseConditions();
   disconnectEventBaseConditions();
   m_conditions.clear();
 }
 
 void SVGSMILElement::buildPendingResource() {
   clearResourceAndEventBaseReferences();
+  disconnectEventBaseConditions();
 
   if (!isConnected()) {
     // Reset the target element if we are no longer in the document.
     setTargetElement(nullptr);
     return;
   }
 
-  AtomicString id;
   const AtomicString& href = SVGURIReference::legacyHrefString(*this);
   Element* target;
-  if (href.isEmpty())
-    target = parentNode() && parentNode()->isElementNode()
-                 ? toElement(parentNode())
-                 : nullptr;
-  else
-    target =
-        SVGURIReference::targetElementFromIRIString(href, treeScope(), &id);
+  if (href.isEmpty()) {
+    target = parentElement();
+  } else {
+    target = SVGURIReference::observeTarget(m_targetIdObserver, *this, href);
+  }
   SVGElement* svgTarget =
       target && target->isSVGElement() ? toSVGElement(target) : nullptr;
 
   if (svgTarget && !svgTarget->isConnected())
     svgTarget = nullptr;
 
   if (svgTarget != targetElement())
     setTargetElement(svgTarget);
 
-  if (!svgTarget) {
-    // Do not register as pending if we are already pending this resource.
-    if (treeScope().ensureSVGTreeScopedResources().isElementPendingResource(
-            *this, id))
-      return;
-    if (!id.isEmpty()) {
-      treeScope().ensureSVGTreeScopedResources().addPendingResource(id, *this);
-      DCHECK(hasPendingResources());
-    }
-  } else {
+  if (svgTarget) {
     // Register us with the target in the dependencies map. Any change of
     // hrefElement that leads to relayout/repainting now informs us, so we can
     // react to it.
     addReferenceTo(svgTarget);
   }
   connectEventBaseConditions();
 }
 
 static inline void clearTimesWithDynamicOrigins(
     Vector<SMILTimeWithOrigin>& timeList) {
@@ skipping 985 matching lines @@
     return;
 
   DCHECK(m_timeContainer);
   DCHECK(m_targetElement);
   m_timeContainer->unschedule(this, m_targetElement, m_attributeName);
   m_isScheduled = false;
 }
 
 DEFINE_TRACE(SVGSMILElement) {
   visitor->trace(m_targetElement);
+  visitor->trace(m_targetIdObserver);
   visitor->trace(m_timeContainer);
   visitor->trace(m_conditions);
   visitor->trace(m_syncBaseDependents);
   SVGElement::trace(visitor);
   SVGTests::trace(visitor);
 }
 
 }  // namespace blink