Tidy up instance time handling 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 103 matching lines @@
   if (const ConditionEventListener* conditionEventListener =
           ConditionEventListener::cast(&listener))
     return m_animation == conditionEventListener->m_animation &&
            m_condition == conditionEventListener->m_condition;
   return false;
 }
 
 void ConditionEventListener::handleEvent(ExecutionContext*, Event* event) {
   if (!m_animation)
     return;
-  m_animation->handleConditionEvent(event, m_condition);
+  if (event->type() == "repeatn" &&
+      toRepeatEvent(event)->repeat() != m_condition->repeat())
+    return;
+  m_animation->addInstanceTime(m_condition->getBeginOrEnd(),
+                               m_animation->elapsed() + m_condition->offset());
 }
 
 SVGSMILElement::Condition::Condition(Type type,
                                      BeginOrEnd beginOrEnd,
                                      const AtomicString& baseID,
                                      const AtomicString& name,
                                      SMILTime offset,
                                      int repeat)
     : m_type(type),
       m_beginOrEnd(beginOrEnd),
@@ skipping 578 matching lines @@
     return m_cachedMin;
   const AtomicString& value = fastGetAttribute(SVGNames::minAttr);
   SMILTime result = parseClockValue(value);
   return m_cachedMin = (result.isUnresolved() || result < 0) ? 0 : result;
 }
 
 SMILTime SVGSMILElement::simpleDuration() const {
   return std::min(dur(), SMILTime::indefinite());
 }
 
-void SVGSMILElement::addBeginTime(SMILTime eventTime,
-                                  SMILTime beginTime,
-                                  SMILTimeWithOrigin::Origin origin) {
-  m_beginTimes.push_back(SMILTimeWithOrigin(beginTime, origin));
-  sortTimeList(m_beginTimes);
-  beginListChanged(eventTime);
-}
-
-void SVGSMILElement::addEndTime(SMILTime eventTime,
-                                SMILTime endTime,
-                                SMILTimeWithOrigin::Origin origin) {
-  m_endTimes.push_back(SMILTimeWithOrigin(endTime, origin));
-  sortTimeList(m_endTimes);
-  endListChanged(eventTime);
+void SVGSMILElement::addInstanceTime(BeginOrEnd beginOrEnd,
+                                     SMILTime time,
+                                     SMILTimeWithOrigin::Origin origin) {
+  SMILTime elapsed = this->elapsed();
+  if (elapsed.isUnresolved())
+    return;
+  Vector<SMILTimeWithOrigin>& list =
+      beginOrEnd == Begin ? m_beginTimes : m_endTimes;
+  list.push_back(SMILTimeWithOrigin(time, origin));
+  sortTimeList(list);
+  if (beginOrEnd == Begin)
+    beginListChanged(elapsed);
+  else
+    endListChanged(elapsed);
 }
 
 inline bool compareTimes(const SMILTimeWithOrigin& left,
                          const SMILTimeWithOrigin& right) {
   return left.time() < right.time();
 }
 
 SMILTime SVGSMILElement::findInstanceTime(BeginOrEnd beginOrEnd,
                                           SMILTime minimumTime,
                                           bool equalsMinimumOK) const {
@@ skipping 456 matching lines @@
       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();
       else
         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);
+      addInstanceTime(condition->getBeginOrEnd(), time);
     }
   }
 }
 
 void SVGSMILElement::addSyncBaseDependent(SVGSMILElement& animation) {
   m_syncBaseDependents.insert(&animation);
   if (m_interval.begin.isFinite())
     animation.createInstanceTimesFromSyncbase(*this);
 }
 
 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;
-  if (condition->getBeginOrEnd() == Begin)
-    addBeginTime(elapsed, elapsed + condition->offset());
-  else
-    addEndTime(elapsed, elapsed + condition->offset());
-}
-
 void SVGSMILElement::beginByLinkActivation() {
-  SMILTime elapsed = this->elapsed();
-  if (elapsed.isUnresolved())
-    return;
-  addBeginTime(elapsed, elapsed);
+  addInstanceTime(Begin, elapsed());
 }
 
 void SVGSMILElement::endedActiveInterval() {
   clearTimesWithDynamicOrigins(m_beginTimes);
   clearTimesWithDynamicOrigins(m_endTimes);
 }
 
 void SVGSMILElement::scheduleRepeatEvents(unsigned count) {
   m_repeatEventCountList.push_back(count);
   scheduleEvent(EventTypeNames::repeatEvent);
@@ skipping 47 matching lines @@
 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