[SVG] Handle repeat(n) event for svg animations

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 45 matching lines @@
     DEFINE_STATIC_LOCAL(SMILEventSender, sender, ("beginEvent"));
     return sender;
 }
 
 static SMILEventSender& smilRepeatEventSender()
 {
     DEFINE_STATIC_LOCAL(SMILEventSender, sender, ("repeatEvent"));
     return sender;
 }
 
+static SMILEventSender& smilRepeatNEventSender()
+{
+    DEFINE_STATIC_LOCAL(SMILEventSender, sender, ("repeatn"));
+    return sender;
+}
+
 // This is used for duration type time values that can't be negative.
 static const double invalidCachedTime = -1.;
 
 class ConditionEventListener : public EventListener {
 public:
     static PassRefPtr<ConditionEventListener> create(SVGSMILElement* animation, SVGSMILElement::Condition* condition)
     {
         return adoptRef(new ConditionEventListener(animation, condition));
     }
 
@@ skipping 32 matching lines @@
     return false;
 }
 
 void ConditionEventListener::handleEvent(ScriptExecutionContext*, Event* event)
 {
     if (!m_animation)
         return;
     m_animation->handleConditionEvent(event, m_condition);
 }
 
-SVGSMILElement::Condition::Condition(Type type, BeginOrEnd beginOrEnd, const String& baseID, const String& name, SMILTime offset, int repeats)
+SVGSMILElement::Condition::Condition(Type type, BeginOrEnd beginOrEnd, const String& baseID, const String& name, SMILTime offset)
     : m_type(type)
     , m_beginOrEnd(beginOrEnd)
     , m_baseID(baseID)
     , m_name(name)
     , m_offset(offset)
-    , m_repeats(repeats)
 {
 }
 
 SVGSMILElement::SVGSMILElement(const QualifiedName& tagName, Document& doc)
     : SVGElement(tagName, doc)
     , m_attributeName(anyQName())
     , m_targetElement(0)
     , m_conditionsConnected(false)
     , m_hasEndEventConditions(false)
     , m_isWaitingForFirstInterval(true)
@@ skipping 13 matching lines @@
 {
     resolveFirstInterval();
 }
 
 SVGSMILElement::~SVGSMILElement()
 {
     clearResourceReferences();
     smilEndEventSender().cancelEvent(this);
     smilBeginEventSender().cancelEvent(this);
     smilRepeatEventSender().cancelEvent(this);
+    smilRepeatNEventSender().cancelEvent(this);
     disconnectConditions();
     if (m_timeContainer && m_targetElement && hasValidAttributeName())
         m_timeContainer->unschedule(this, m_targetElement, m_attributeName);
 }
 
 void SVGSMILElement::clearResourceReferences()
 {
     document().accessSVGExtensions()->removeAllTargetReferencesForElement(this);
 }
 
@@ skipping 192 matching lines @@
 static void sortTimeList(Vector<SMILTimeWithOrigin>& timeList)
 {
     std::sort(timeList.begin(), timeList.end());
 }
 
 bool SVGSMILElement::parseCondition(const String& value, BeginOrEnd beginOrEnd)
 {
     String parseString = value.stripWhiteSpace();
 
     double sign = 1.;
-    bool ok;
     size_t pos = parseString.find('+');
     if (pos == notFound) {
         pos = parseString.find('-');
         if (pos != notFound)
             sign = -1.;
     }
     String conditionString;
     SMILTime offset = 0;
     if (pos == notFound)
         conditionString = parseString;
@@ skipping 14 matching lines @@
     if (pos == notFound)
         nameString = conditionString;
     else {
         baseID = conditionString.left(pos);
         nameString = conditionString.substring(pos + 1);
     }
     if (nameString.isEmpty())
         return false;
 
     Condition::Type type;
-    int repeats = -1;
-    if (nameString.startsWith("repeat(") && nameString.endsWith(')')) {
-        // FIXME: For repeat events we just need to add the data carrying TimeEvent class and
-        // fire the events at appropiate times.
-        repeats = nameString.substring(7, nameString.length() - 8).toUIntStrict(&ok);
-        if (!ok)
-            return false;
-        nameString = "repeat";
-        type = Condition::EventBase;
-    } else if (nameString == "begin" || nameString == "end") {
+    if (nameString == "begin" || nameString == "end") {
         if (baseID.isEmpty())
             return false;
         type = Condition::Syncbase;
     } else if (nameString.startsWith("accesskey(")) {
         // FIXME: accesskey() support.
         type = Condition::AccessKey;
     } else
         type = Condition::EventBase;
 
-    m_conditions.append(Condition(type, beginOrEnd, baseID, nameString, offset, repeats));
+    m_conditions.append(Condition(type, beginOrEnd, baseID, nameString, offset));
 
     if (type == Condition::EventBase && beginOrEnd == End)
         m_hasEndEventConditions = true;
 
     return true;
 }
 
 bool SVGSMILElement::isSMILElement(Node* node)
 {
     if (!node)
@@ skipping 683 matching lines @@
     if (this == resultElement && animationIsContributing)
         resetAnimatedType();
 
     if (animationIsContributing) {
         if (oldActiveState == Inactive) {
             smilBeginEventSender().dispatchEventSoon(this);
             startedActiveInterval();
         }
 
         if (repeat && repeat != m_lastRepeat)
-            smilRepeatEventSender().dispatchEventSoon(this);
+            dispatchRepeatEvents(repeat);
 
         updateAnimation(percent, repeat, resultElement);
         m_lastPercent = percent;
         m_lastRepeat = repeat;
     }
 
     if (oldActiveState == Active && m_activeState != Active) {
         smilEndEventSender().dispatchEventSoon(this);
         endedActiveInterval();
         if (m_activeState != Frozen && this == resultElement)
             clearAnimatedType(m_targetElement);
     }
 
     // Triggering all the pending events if the animation timeline is changed.
     if (seekToTime) {
         if (m_activeState == Inactive)
             smilBeginEventSender().dispatchEventSoon(this);
 
         if (repeat) {
-            for (unsigned repeatEventCount = 1; repeatEventCount < repeat; repeatEventCount++) {
-                smilRepeatEventSender().dispatchEventSoon(this);
-            }
+            for (unsigned repeatEventCount = 1; repeatEventCount < repeat; repeatEventCount++)
+                dispatchRepeatEvents(repeatEventCount);
             if (m_activeState == Inactive)
-                smilRepeatEventSender().dispatchEventSoon(this);
+                dispatchRepeatEvents(repeat);
         }
 
         if (m_activeState == Inactive || m_activeState == Frozen)
             smilEndEventSender().dispatchEventSoon(this);
     }
 
     m_nextProgressTime = calculateNextProgressTime(elapsed);
     return animationIsContributing;
 }
 
@@ skipping 62 matching lines @@
     SMILTime elapsed = this->elapsed();
     addBeginTime(elapsed, elapsed);
 }
 
 void SVGSMILElement::endedActiveInterval()
 {
     clearTimesWithDynamicOrigins(m_beginTimes);
     clearTimesWithDynamicOrigins(m_endTimes);
 }
 
+void SVGSMILElement::dispatchRepeatEvents(unsigned count)
+{
+    m_repeatEventCountList.append(count);
+    smilRepeatEventSender().dispatchEventSoon(this);
+    smilRepeatNEventSender().dispatchEventSoon(this);
+}
+
 void SVGSMILElement::dispatchPendingEvent(SMILEventSender* eventSender)
 {
-    ASSERT(eventSender == &smilEndEventSender() || eventSender == &smilBeginEventSender() || eventSender == &smilRepeatEventSender());
+    ASSERT(eventSender == &smilEndEventSender() || eventSender == &smilBeginEventSender() || eventSender == &smilRepeatEventSender() || eventSender == &smilRepeatNEventSender());
     const AtomicString& eventType = eventSender->eventType();
-    dispatchEvent(Event::create(eventType));
+    if (eventType == "repeatn") {
+        unsigned repeatEventCount = m_repeatEventCountList.first();
+        m_repeatEventCountList.remove(0);
+        dispatchEvent(Event::create(String("repeat(" + String::number(repeatEventCount) + ")")));
+    } else {
+        dispatchEvent(Event::create(eventType));
+    }
 }
 
 }