Remove EventSender from 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 11 matching lines @@
  * (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 "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "core/XLinkNames.h"
 #include "core/dom/Document.h"
+#include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
 #include "core/events/EventListener.h"
-#include "core/events/EventSender.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGSVGElement.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>
 
@@ skipping 25 matching lines @@
 private:
     int m_repeat;
 };
 
 inline RepeatEvent* toRepeatEvent(Event* event)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!event || event->type() == "repeatn");
     return static_cast<RepeatEvent*>(event);
 }
 
-static SMILEventSender& smilEndEventSender()
-{
-    DEFINE_STATIC_LOCAL(SMILEventSender, sender, (SMILEventSender::create(EventTypeNames::endEvent)));
-    return sender;
-}
-
-static SMILEventSender& smilBeginEventSender()
-{
-    DEFINE_STATIC_LOCAL(SMILEventSender, sender, (SMILEventSender::create(EventTypeNames::beginEvent)));
-    return sender;
-}
-
-static SMILEventSender& smilRepeatEventSender()
-{
-    DEFINE_STATIC_LOCAL(SMILEventSender, sender, (SMILEventSender::create(EventTypeNames::repeatEvent)));
-    return sender;
-}
-
-static SMILEventSender& smilRepeatNEventSender()
-{
-    DEFINE_STATIC_LOCAL(SMILEventSender, sender, (SMILEventSender::create(AtomicString("repeatn"))));
-    return sender;
-}
-
 // This is used for duration type time values that can't be negative.
 static const double invalidCachedTime = -1.;
 
 class ConditionEventListener final : public EventListener {
 public:
     static ConditionEventListener* create(SVGSMILElement* animation, SVGSMILElement::Condition* condition)
     {
         return new ConditionEventListener(animation, condition);
     }
 
@@ skipping 1049 matching lines @@
     unsigned repeat = 0;
     float percent = calculateAnimationPercentAndRepeat(elapsed, repeat);
     RestartedInterval restartedInterval = maybeRestartInterval(elapsed);
 
     ActiveState oldActiveState = m_activeState;
     m_activeState = determineActiveState(elapsed);
     bool animationIsContributing = isContributing(elapsed);
 
     if (animationIsContributing) {
         if (oldActiveState == Inactive || restartedInterval == DidRestartInterval) {
-            smilBeginEventSender().dispatchEventSoon(this);
+            scheduleEvent(EventTypeNames::beginEvent);
             startedActiveInterval();
         }
 
         if (repeat && repeat != m_lastRepeat)
-            dispatchRepeatEvents(repeat);
+            scheduleRepeatEvents(repeat);
 
         m_lastPercent = percent;
         m_lastRepeat = repeat;
     }
 
     if ((oldActiveState == Active && m_activeState != Active) || restartedInterval == DidRestartInterval) {
-        smilEndEventSender().dispatchEventSoon(this);
+        scheduleEvent(EventTypeNames::endEvent);
         endedActiveInterval();
     }
 
     // Triggering all the pending events if the animation timeline is changed.
     if (seekToTime) {
         if (m_activeState == Inactive)
-            smilBeginEventSender().dispatchEventSoon(this);
+            scheduleEvent(EventTypeNames::beginEvent);
 
         if (repeat) {
             for (unsigned repeatEventCount = 1; repeatEventCount < repeat; repeatEventCount++)
-                dispatchRepeatEvents(repeatEventCount);
+                scheduleRepeatEvents(repeatEventCount);
             if (m_activeState == Inactive)
-                dispatchRepeatEvents(repeat);
+                scheduleRepeatEvents(repeat);
         }
 
         if (m_activeState == Inactive || m_activeState == Frozen)
-            smilEndEventSender().dispatchEventSoon(this);
+            scheduleEvent(EventTypeNames::endEvent);
     }
 
     m_nextProgressTime = calculateNextProgressTime(elapsed);
     return animationIsContributing;
 }
 
 void SVGSMILElement::notifyDependentsIntervalChanged()
 {
     ASSERT(m_interval.begin.isFinite());
     // |loopBreaker| is used to avoid infinite recursions which may be caused from:
@@ skipping 72 matching lines @@
         return;
     addBeginTime(elapsed, elapsed);
 }
 
 void SVGSMILElement::endedActiveInterval()
 {
     clearTimesWithDynamicOrigins(m_beginTimes);
     clearTimesWithDynamicOrigins(m_endTimes);
 }
 
-void SVGSMILElement::dispatchRepeatEvents(unsigned count)
+void SVGSMILElement::scheduleRepeatEvents(unsigned count)
 {
     m_repeatEventCountList.append(count);
-    smilRepeatEventSender().dispatchEventSoon(this);
-    smilRepeatNEventSender().dispatchEventSoon(this);
+    scheduleEvent(EventTypeNames::repeatEvent);
+    scheduleEvent(AtomicString("repeatn"));
 }
 
-void SVGSMILElement::dispatchPendingEvent(SMILEventSender* eventSender)
+void SVGSMILElement::scheduleEvent(const AtomicString& eventType)
 {
-    ASSERT(eventSender == &smilEndEventSender() || eventSender == &smilBeginEventSender() || eventSender == &smilRepeatEventSender() || eventSender == &smilRepeatNEventSender());
-    const AtomicString& eventType = eventSender->eventType();
+    TaskRunnerHelper::get(TaskType::DOMManipulation, &document())->postTask(BLINK_FROM_HERE, WTF::bind(&SVGSMILElement::dispatchPendingEvent, wrapPersistent(this), eventType));
+}
+
+void SVGSMILElement::dispatchPendingEvent(const AtomicString& eventType)
+{
+    DCHECK(eventType == EventTypeNames::endEvent || eventType == EventTypeNames::beginEvent || eventType == EventTypeNames::repeatEvent || eventType == "repeatn");
     if (eventType == "repeatn") {
         unsigned repeatEventCount = m_repeatEventCountList.first();
         m_repeatEventCountList.remove(0);
         dispatchEvent(RepeatEvent::create(eventType, repeatEventCount));
     } else {
         dispatchEvent(Event::create(eventType));
     }
 }
 
 void SVGSMILElement::schedule()
@@ skipping 32 matching lines @@
 {
     visitor->trace(m_targetElement);
     visitor->trace(m_timeContainer);
     visitor->trace(m_conditions);
     visitor->trace(m_syncBaseDependents);
     SVGElement::trace(visitor);
     SVGTests::trace(visitor);
 }
 
 } // namespace blink