Tidy up event-/syncbase registration 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
@@ skipping 106 matching lines @@
            m_condition == conditionEventListener->m_condition;
   return false;
 }
 
 void ConditionEventListener::handleEvent(ExecutionContext*, Event* event) {
   if (!m_animation)
     return;
   m_animation->handleConditionEvent(event, m_condition);
 }
 
-void SVGSMILElement::Condition::setEventListener(
-    ConditionEventListener* eventListener) {
-  m_eventListener = eventListener;
-}
-
 SVGSMILElement::Condition::Condition(Type type,
                                      BeginOrEnd beginOrEnd,
-                                     const String& baseID,
-                                     const String& name,
+                                     const AtomicString& baseID,
+                                     const AtomicString& name,
                                      SMILTime offset,
                                      int repeat)
     : m_type(type),
       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_syncBase);
+  visitor->trace(m_eventListener);
+}
+
+void SVGSMILElement::Condition::connectSyncBase(SVGSMILElement& timedElement) {
+  DCHECK(!m_baseID.isEmpty());
+  Element* element = timedElement.treeScope().getElementById(m_baseID);
+  if (!element || !isSVGSMILElement(*element)) {
+    m_syncBase = nullptr;
+    return;
+  }
+  m_syncBase = toSVGSMILElement(element);
+  m_syncBase->addSyncBaseDependent(timedElement);
+}
+
+void SVGSMILElement::Condition::disconnectSyncBase(
+    SVGSMILElement& timedElement) {
+  if (!m_syncBase)
+    return;
+  m_syncBase->removeSyncBaseDependent(timedElement);
+  m_syncBase = 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(!m_syncBase);
+  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);
+    return;
+  }
+  DCHECK(!m_eventListener);
+  m_eventListener = ConditionEventListener::create(&timedElement, this);
+  eventBase->addEventListener(m_name, m_eventListener, false);
+  timedElement.addReferenceTo(eventBase);
+}
+
+void SVGSMILElement::Condition::disconnectEventBase(
+    SVGSMILElement& timedElement) {
+  DCHECK(!m_syncBase);
+  if (!m_eventListener)
+    return;
+  // Note: It's a memory optimization to try to remove our condition event
+  // listener, but it's not guaranteed to work, since we have no guarantee that
+  // we will be able to find our condition's original eventBase. So, we also
+  // have to disconnect ourselves from our condition event listener, in case it
+  // later fires.
+  if (SVGElement* eventBase = lookupEventBase(timedElement))
+    eventBase->removeEventListener(m_name, m_eventListener, false);
+  m_eventListener->disconnectAnimation();
+  m_eventListener = nullptr;
+}
+
 SVGSMILElement::SVGSMILElement(const QualifiedName& tagName, Document& doc)
     : SVGElement(tagName, doc),
       SVGTests(this),
       m_attributeName(anyQName()),
       m_targetElement(nullptr),
       m_syncBaseConditionsConnected(false),
       m_hasEndEventConditions(false),
       m_isWaitingForFirstInterval(true),
       m_isScheduled(false),
       m_interval(SMILInterval(SMILTime::unresolved(), SMILTime::unresolved())),
@@ skipping 251 matching lines @@
     type = Condition::Syncbase;
   } else if (nameString.startsWith("accesskey(")) {
     // FIXME: accesskey() support.
     type = Condition::AccessKey;
   } else {
     UseCounter::count(&document(), UseCounter::SVGSMILBeginOrEndEventValue);
     type = Condition::EventBase;
   }
 
   m_conditions.push_back(
-      Condition::create(type, beginOrEnd, baseID, nameString, offset, repeat));
+      Condition::create(type, beginOrEnd, AtomicString(baseID),
+                        AtomicString(nameString), offset, repeat));
 
   if (type == Condition::EventBase && beginOrEnd == End)
     m_hasEndEventConditions = true;
 
   return true;
 }
 
 void SVGSMILElement::parseBeginOrEnd(const String& parseString,
                                      BeginOrEnd beginOrEnd) {
   Vector<SMILTimeWithOrigin>& timeList =
@@ skipping 82 matching lines @@
         endListChanged(elapsed());
     }
   } else {
     SVGElement::svgAttributeChanged(attrName);
     return;
   }
 
   animationAttributeChanged();
 }
 
-inline SVGElement* SVGSMILElement::eventBaseFor(const Condition& condition) {
-  Element* eventBase =
-      condition.baseID().isEmpty()
-          ? targetElement()
-          : treeScope().getElementById(AtomicString(condition.baseID()));
-  if (eventBase && eventBase->isSVGElement())
-    return toSVGElement(eventBase);
-  return nullptr;
-}
-
 void SVGSMILElement::connectSyncBaseConditions() {
   if (m_syncBaseConditionsConnected)
     disconnectSyncBaseConditions();
   m_syncBaseConditionsConnected = true;
-  for (unsigned n = 0; n < m_conditions.size(); ++n) {
-    Condition* condition = m_conditions[n].get();
-    if (condition->getType() == Condition::Syncbase) {
-      ASSERT(!condition->baseID().isEmpty());
-      Element* element =
-          treeScope().getElementById(AtomicString(condition->baseID()));
-      if (!element || !isSVGSMILElement(*element)) {
-        condition->setSyncBase(0);
-        continue;
-      }
-      SVGSMILElement* svgSMILElement = toSVGSMILElement(element);
-      condition->setSyncBase(svgSMILElement);
-      svgSMILElement->addSyncBaseDependent(this);
-    }
+  for (Condition* condition : m_conditions) {
+    if (condition->getType() == Condition::Syncbase)
+      condition->connectSyncBase(*this);
   }
 }
 
 void SVGSMILElement::disconnectSyncBaseConditions() {
   if (!m_syncBaseConditionsConnected)
     return;
   m_syncBaseConditionsConnected = false;
-  for (unsigned n = 0; n < m_conditions.size(); ++n) {
-    Condition* condition = m_conditions[n].get();
-    if (condition->getType() == Condition::Syncbase) {
-      if (condition->syncBase())
-        condition->syncBase()->removeSyncBaseDependent(this);
-      condition->setSyncBase(0);
-    }
+  for (Condition* condition : m_conditions) {
+    if (condition->getType() == Condition::Syncbase)
+      condition->disconnectSyncBase(*this);
   }
 }
 
 void SVGSMILElement::connectEventBaseConditions() {
   disconnectEventBaseConditions();
-  for (unsigned n = 0; n < m_conditions.size(); ++n) {
-    Condition* condition = m_conditions[n].get();
-    if (condition->getType() == Condition::EventBase) {
-      ASSERT(!condition->syncBase());
-      SVGElement* eventBase = eventBaseFor(*condition);
-      if (!eventBase) {
-        if (!condition->baseID().isEmpty() &&
-            !treeScope()
-                 .ensureSVGTreeScopedResources()
-                 .isElementPendingResource(*this,
-                                           AtomicString(condition->baseID()))) {
-          treeScope().ensureSVGTreeScopedResources().addPendingResource(
-              AtomicString(condition->baseID()), *this);
-        }
-        continue;
-      }
-      ASSERT(!condition->eventListener());
-      condition->setEventListener(
-          ConditionEventListener::create(this, condition));
-      eventBase->addEventListener(AtomicString(condition->name()),
-                                  condition->eventListener(), false);
-      addReferenceTo(eventBase);
-    }
+  for (Condition* condition : m_conditions) {
+    if (condition->getType() == Condition::EventBase)
+      condition->connectEventBase(*this);
   }
 }
 
 void SVGSMILElement::disconnectEventBaseConditions() {
-  for (unsigned n = 0; n < m_conditions.size(); ++n) {
-    Condition* condition = m_conditions[n].get();
-    if (condition->getType() == Condition::EventBase) {
-      ASSERT(!condition->syncBase());
-      if (!condition->eventListener())
-        continue;
-      // Note: It's a memory optimization to try to remove our condition
-      // event listener, but it's not guaranteed to work, since we have
-      // no guarantee that eventBaseFor() will be able to find our condition's
-      // original eventBase. So, we also have to disconnect ourselves from
-      // our condition event listener, in case it later fires.
-      SVGElement* eventBase = eventBaseFor(*condition);
-      if (eventBase)
-        eventBase->removeEventListener(AtomicString(condition->name()),
-                                       condition->eventListener(), false);
-      condition->eventListener()->disconnectAnimation();
-      condition->setEventListener(nullptr);
-    }
+  for (Condition* condition : m_conditions) {
+    if (condition->getType() == Condition::EventBase)
+      condition->disconnectEventBase(*this);
   }
 }
 
 void SVGSMILElement::setTargetElement(SVGElement* target) {
   unscheduleIfScheduled();
 
   if (m_targetElement) {
     // Clear values that may depend on the previous target.
     clearAnimatedType();
     disconnectSyncBaseConditions();
@@ skipping 555 matching lines @@
   // |notifyDependentsIntervalChanged|
   //
   // As the set here records SVGSMILElements on the stack, it is acceptable to
   // use a HashSet of untraced heap references -- any conservative GC which
   // strikes before unwinding will find these elements on the stack.
   DEFINE_STATIC_LOCAL(HashSet<UntracedMember<SVGSMILElement>>, loopBreaker, ());
   if (!loopBreaker.insert(this).isNewEntry)
     return;
 
   for (SVGSMILElement* element : m_syncBaseDependents)
-    element->createInstanceTimesFromSyncbase(this);
+    element->createInstanceTimesFromSyncbase(*this);
 
   loopBreaker.erase(this);
 }
 
-void SVGSMILElement::createInstanceTimesFromSyncbase(SVGSMILElement* syncBase) {
+void SVGSMILElement::createInstanceTimesFromSyncbase(SVGSMILElement& syncBase) {
   // FIXME: To be really correct, this should handle updating exising interval
   // by changing the associated times instead of creating new ones.
-  for (unsigned n = 0; n < m_conditions.size(); ++n) {
-    Condition* condition = m_conditions[n].get();
+  for (Condition* condition : m_conditions) {
     if (condition->getType() == Condition::Syncbase &&
-        condition->syncBase() == syncBase) {
+        condition->syncBaseEquals(syncBase)) {
       ASSERT(condition->name() == "begin" || condition->name() == "end");
       // No nested time containers in SVG, no need for crazy time space
       // conversions. Phew!
       SMILTime time = 0;
       if (condition->name() == "begin")
-        time = syncBase->m_interval.begin + condition->offset();
+        time = syncBase.m_interval.begin + condition->offset();
       else
-        time = syncBase->m_interval.end + condition->offset();
+        time = syncBase.m_interval.end + condition->offset();
       if (!time.isFinite())
         continue;
       SMILTime elapsed = this->elapsed();
       if (elapsed.isUnresolved())
         continue;
       if (condition->getBeginOrEnd() == Begin)
         addBeginTime(elapsed, time);
       else
         addEndTime(elapsed, time);
     }
   }
 }
 
-void SVGSMILElement::addSyncBaseDependent(SVGSMILElement* animation) {
-  m_syncBaseDependents.insert(animation);
+void SVGSMILElement::addSyncBaseDependent(SVGSMILElement& animation) {
+  m_syncBaseDependents.insert(&animation);
   if (m_interval.begin.isFinite())
-    animation->createInstanceTimesFromSyncbase(this);
+    animation.createInstanceTimesFromSyncbase(*this);
 }
 
-void SVGSMILElement::removeSyncBaseDependent(SVGSMILElement* animation) {
-  m_syncBaseDependents.erase(animation);
+void SVGSMILElement::removeSyncBaseDependent(SVGSMILElement& animation) {
+  m_syncBaseDependents.erase(&animation);
 }
 
 void SVGSMILElement::handleConditionEvent(Event* event, Condition* condition) {
   if (event->type() == "repeatn" &&
       toRepeatEvent(event)->repeat() != condition->repeat())
     return;
 
   SMILTime elapsed = this->elapsed();
   if (elapsed.isUnresolved())
     return;
@@ skipping 58 matching lines @@
 void SVGSMILElement::unscheduleIfScheduled() {
   if (!m_isScheduled)
     return;
 
   DCHECK(m_timeContainer);
   DCHECK(m_targetElement);
   m_timeContainer->unschedule(this, m_targetElement, m_attributeName);
   m_isScheduled = false;
 }
 
-SVGSMILElement::Condition::~Condition() {}
-
-DEFINE_TRACE(SVGSMILElement::Condition) {
-  visitor->trace(m_syncBase);
-  visitor->trace(m_eventListener);
-}
-
 DEFINE_TRACE(SVGSMILElement) {
   visitor->trace(m_targetElement);
   visitor->trace(m_timeContainer);
   visitor->trace(m_conditions);
   visitor->trace(m_syncBaseDependents);
   SVGElement::trace(visitor);
   SVGTests::trace(visitor);
 }
 
 }  // namespace blink