[SVG] Avoid unnecessarily populating hashmap for repeat(n) event

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 27 matching lines @@
 #include "core/svg/SVGURIReference.h"
 #include "core/svg/animation/SMILTimeContainer.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 
 using namespace std;
 
 namespace WebCore {
 
+class RepeatEvent : public Event {
+public:
+    static PassRefPtr<RepeatEvent> create(const AtomicString& type, int repeat)
+    {
+        return adoptRef(new RepeatEvent(type, false, false, repeat));
+    }
+
+    ~RepeatEvent() { }
+
+    int repeat() const { return m_repeat; }
+protected:
+    RepeatEvent(const AtomicString& type, bool canBubble, bool cancelable, int repeat = -1)
+        : Event(type, canBubble, cancelable)
+        , m_repeat(repeat)
+    {
+    }
+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, ("endEvent"));
     return sender;
 }
 
 static SMILEventSender& smilBeginEventSender()
 {
     DEFINE_STATIC_LOCAL(SMILEventSender, sender, ("beginEvent"));
     return sender;
@@ skipping 56 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)
+SVGSMILElement::Condition::Condition(Type type, BeginOrEnd beginOrEnd, const String& baseID, const String& name, SMILTime offset, int repeat)
     : m_type(type)
     , m_beginOrEnd(beginOrEnd)
     , m_baseID(baseID)
     , m_name(name)
     , m_offset(offset)
+    , m_repeat(repeat)
 {
 }
 
 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 226 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;
-    if (nameString == "begin" || nameString == "end") {
+    int repeat = -1;
+    if (nameString.startsWith("repeat(") && nameString.endsWith(')')) {
+        repeat = nameString.substring(7, nameString.length() - 8).toUIntStrict(&ok);
+        if (!ok)
+            return false;
+        nameString = "repeatn";
+        type = Condition::EventBase;
+    } else 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));
+    m_conditions.append(Condition(type, beginOrEnd, baseID, nameString, offset, repeat));
 
     if (type == Condition::EventBase && beginOrEnd == End)
         m_hasEndEventConditions = true;
 
     return true;
 }
 
 bool SVGSMILElement::isSMILElement(Node* node)
 {
     if (!node)
@@ skipping 773 matching lines @@
     m_timeDependents.add(animation);
     if (m_intervalBegin.isFinite())
         animation->createInstanceTimesFromSyncbase(this, NewInterval);
 }
 
 void SVGSMILElement::removeTimeDependent(SVGSMILElement* animation)
 {
     m_timeDependents.remove(animation);
 }
 
-void SVGSMILElement::handleConditionEvent(Event*, Condition* condition)
+void SVGSMILElement::handleConditionEvent(Event* event, Condition* condition)
 {
+    if (event->type() == "repeatn" && toRepeatEvent(event)->repeat() != condition->m_repeat)
+        return;
+
     SMILTime elapsed = this->elapsed();
     if (condition->m_beginOrEnd == Begin)
         addBeginTime(elapsed, elapsed + condition->m_offset);
     else
         addEndTime(elapsed, elapsed + condition->m_offset);
 }
 
 void SVGSMILElement::beginByLinkActivation()
 {
     SMILTime elapsed = this->elapsed();
@@ skipping 13 matching lines @@
     smilRepeatNEventSender().dispatchEventSoon(this);
 }
 
 void SVGSMILElement::dispatchPendingEvent(SMILEventSender* eventSender)
 {
     ASSERT(eventSender == &smilEndEventSender() || eventSender == &smilBeginEventSender() || eventSender == &smilRepeatEventSender() || eventSender == &smilRepeatNEventSender());
     const AtomicString& eventType = eventSender->eventType();
     if (eventType == "repeatn") {
         unsigned repeatEventCount = m_repeatEventCountList.first();
         m_repeatEventCountList.remove(0);
-        dispatchEvent(Event::create(String("repeat(" + String::number(repeatEventCount) + ")")));
+        dispatchEvent(RepeatEvent::create(eventType, repeatEventCount));
     } else {
         dispatchEvent(Event::create(eventType));
     }
 }
 
 }