reflow comments in core/svg/

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 199 matching lines @@
   if (!svgTarget) {
     // Do not register as pending if we are already pending this resource.
     if (document().accessSVGExtensions().isElementPendingResource(this, id))
       return;
 
     if (!id.isEmpty()) {
       document().accessSVGExtensions().addPendingResource(id, this);
       ASSERT(hasPendingResources());
     }
   } else {
-    // Register us with the target in the dependencies map. Any change of hrefElement
-    // that leads to relayout/repainting now informs us, so we can react to it.
+    // Register us with the target in the dependencies map. Any change of
+    // hrefElement that leads to relayout/repainting now informs us, so we can
+    // react to it.
     addReferenceTo(svgTarget);
   }
   connectEventBaseConditions();
 }
 
 static inline QualifiedName constructQualifiedName(
     const SVGElement* svgElement,
     const AtomicString& attributeName) {
   ASSERT(svgElement);
   if (attributeName.isEmpty())
@@ skipping 56 matching lines @@
   setAttributeName(constructQualifiedName(
       this, fastGetAttribute(SVGNames::attributeNameAttr)));
   SVGSVGElement* owner = ownerSVGElement();
   if (!owner)
     return InsertionDone;
 
   m_timeContainer = owner->timeContainer();
   ASSERT(m_timeContainer);
   m_timeContainer->setDocumentOrderIndexesDirty();
 
-  // "If no attribute is present, the default begin value (an offset-value of 0) must be evaluated."
+  // "If no attribute is present, the default begin value (an offset-value of 0)
+  // must be evaluated."
   if (!fastHasAttribute(SVGNames::beginAttr))
     m_beginTimes.append(SMILTimeWithOrigin());
 
   if (m_isWaitingForFirstInterval)
     resolveFirstInterval();
 
   if (m_timeContainer)
     m_timeContainer->notifyIntervalsChanged();
 
   buildPendingResource();
@@ skipping 215 matching lines @@
     m_cachedRepeatCount = invalidCachedTime;
   } else if (attrName == SVGNames::minAttr) {
     m_cachedMin = invalidCachedTime;
   } else if (attrName == SVGNames::maxAttr) {
     m_cachedMax = invalidCachedTime;
   } else if (attrName == SVGNames::attributeNameAttr) {
     setAttributeName(constructQualifiedName(
         this, fastGetAttribute(SVGNames::attributeNameAttr)));
   } else if (attrName.matches(SVGNames::hrefAttr) ||
              attrName.matches(XLinkNames::hrefAttr)) {
-    // TODO(fs): Could be smarter here when 'href' is specified and 'xlink:href' is changed.
+    // TODO(fs): Could be smarter here when 'href' is specified and 'xlink:href'
+    // is changed.
     SVGElement::InvalidationGuard invalidationGuard(this);
     buildPendingResource();
     if (m_targetElement)
       clearAnimatedType();
   } else if (attrName == SVGNames::beginAttr || attrName == SVGNames::endAttr) {
     if (isConnected()) {
       connectEventBaseConditions();
       if (attrName == SVGNames::beginAttr)
         beginListChanged(elapsed());
       else if (attrName == SVGNames::endAttr)
@@ skipping 109 matching lines @@
 
 void SVGSMILElement::setTargetElement(SVGElement* target) {
   unscheduleIfScheduled();
 
   if (m_targetElement) {
     // Clear values that may depend on the previous target.
     clearAnimatedType();
     disconnectSyncBaseConditions();
   }
 
-  // If the animation state is not Inactive, always reset to a clear state before leaving the old target element.
+  // If the animation state is not Inactive, always reset to a clear state
+  // before leaving the old target element.
   if (m_activeState != Inactive)
     endedActiveInterval();
 
   m_targetElement = target;
   schedule();
 }
 
 SMILTime SVGSMILElement::elapsed() const {
   return m_timeContainer ? m_timeContainer->elapsed() : 0;
 }
@@ skipping 113 matching lines @@
 
   const SMILTimeWithOrigin dummyTimeWithOrigin(
       minimumTime, SMILTimeWithOrigin::ParserOrigin);
   const SMILTimeWithOrigin* result = std::lower_bound(
       list.begin(), list.end(), dummyTimeWithOrigin, compareTimes);
   int indexOfResult = result - list.begin();
   if (indexOfResult == sizeOfList)
     return SMILTime::unresolved();
   const SMILTime& currentTime = list[indexOfResult].time();
 
-  // The special value "indefinite" does not yield an instance time in the begin list.
+  // The special value "indefinite" does not yield an instance time in the begin
+  // list.
   if (currentTime.isIndefinite() && beginOrEnd == Begin)
     return SMILTime::unresolved();
 
   if (currentTime > minimumTime)
     return currentTime;
 
   ASSERT(currentTime == minimumTime);
   if (equalsMinimumOK)
     return currentTime;
 
@@ skipping 194 matching lines @@
     if (resolveNextInterval() && elapsed >= m_interval.begin)
       return DidRestartInterval;
   }
   return DidNotRestartInterval;
 }
 
 void SVGSMILElement::seekToIntervalCorrespondingToTime(SMILTime elapsed) {
   ASSERT(!m_isWaitingForFirstInterval);
   ASSERT(elapsed >= m_interval.begin);
 
-  // Manually seek from interval to interval, just as if the animation would run regulary.
+  // Manually seek from interval to interval, just as if the animation would run
+  // regulary.
   while (true) {
-    // Figure out the next value in the begin time list after the current interval begin.
+    // Figure out the next value in the begin time list after the current
+    // interval begin.
     SMILTime nextBegin = findInstanceTime(Begin, m_interval.begin, false);
 
-    // If the 'nextBegin' time is unresolved (eg. just one defined interval), we're done seeking.
+    // If the 'nextBegin' time is unresolved (eg. just one defined interval),
+    // we're done seeking.
     if (nextBegin.isUnresolved())
       return;
 
-    // If the 'nextBegin' time is larger than or equal to the current interval end time, we're done seeking.
-    // If the 'elapsed' time is smaller than the next begin interval time, we're done seeking.
+    // If the 'nextBegin' time is larger than or equal to the current interval
+    // end time, we're done seeking.  If the 'elapsed' time is smaller than the
+    // next begin interval time, we're done seeking.
     if (nextBegin < m_interval.end && elapsed >= nextBegin) {
-      // End current interval, and start a new interval from the 'nextBegin' time.
+      // End current interval, and start a new interval from the 'nextBegin'
+      // time.
       m_interval.end = nextBegin;
       if (!resolveNextInterval())
         break;
       continue;
     }
 
-    // If the desired 'elapsed' time is past the current interval, advance to the next.
+    // If the desired 'elapsed' time is past the current interval, advance to
+    // the next.
     if (elapsed >= m_interval.end) {
       if (!resolveNextInterval())
         break;
       continue;
     }
 
     return;
   }
 }
 
@@ skipping 28 matching lines @@
       return 1.0f;
     return clampTo<float>(percent);
   }
   repeat = static_cast<unsigned>(activeTime.value() / simpleDuration.value());
   SMILTime simpleTime = fmod(activeTime.value(), simpleDuration.value());
   return clampTo<float>(simpleTime.value() / simpleDuration.value());
 }
 
 SMILTime SVGSMILElement::calculateNextProgressTime(SMILTime elapsed) const {
   if (m_activeState == Active) {
-    // If duration is indefinite the value does not actually change over time. Same is true for <set>.
+    // If duration is indefinite the value does not actually change over time.
+    // Same is true for <set>.
     SMILTime simpleDuration = this->simpleDuration();
     if (simpleDuration.isIndefinite() || isSVGSetElement(*this)) {
       SMILTime repeatingDurationEnd = m_interval.begin + repeatingDuration();
-      // We are supposed to do freeze semantics when repeating ends, even if the element is still active.
+      // We are supposed to do freeze semantics when repeating ends, even if the
+      // element is still active.
       // Take care that we get a timer callback at that point.
       if (elapsed < repeatingDurationEnd &&
           repeatingDurationEnd < m_interval.end &&
           repeatingDurationEnd.isFinite())
         return repeatingDurationEnd;
       return m_interval.end;
     }
     return elapsed + 0.025;
   }
   return m_interval.begin >= elapsed ? m_interval.begin
                                      : SMILTime::unresolved();
 }
 
 SVGSMILElement::ActiveState SVGSMILElement::determineActiveState(
     SMILTime elapsed) const {
   if (elapsed >= m_interval.begin && elapsed < m_interval.end)
     return Active;
 
   return fill() == FillFreeze ? Frozen : Inactive;
 }
 
 bool SVGSMILElement::isContributing(SMILTime elapsed) const {
-  // Animation does not contribute during the active time if it is past its repeating duration and has fill=remove.
+  // Animation does not contribute during the active time if it is past its
+  // repeating duration and has fill=remove.
   return (m_activeState == Active &&
           (fill() == FillFreeze ||
            elapsed <= m_interval.begin + repeatingDuration())) ||
          m_activeState == Frozen;
 }
 
 bool SVGSMILElement::progress(SMILTime elapsed, bool seekToTime) {
   ASSERT(m_timeContainer);
   ASSERT(m_isWaitingForFirstInterval || m_interval.begin.isFinite());
 
@@ skipping 13 matching lines @@
     return m_activeState == Frozen;
   }
 
   m_previousIntervalBegin = m_interval.begin;
 
   if (m_isWaitingForFirstInterval) {
     m_isWaitingForFirstInterval = false;
     resolveFirstInterval();
   }
 
-  // This call may obtain a new interval -- never call calculateAnimationPercentAndRepeat() before!
+  // This call may obtain a new interval -- never call
+  // calculateAnimationPercentAndRepeat() before!
   if (seekToTime) {
     seekToIntervalCorrespondingToTime(elapsed);
     if (elapsed < m_interval.begin) {
       // elapsed is not within an interval.
       m_nextProgressTime = m_interval.begin;
       return false;
     }
   }
 
   unsigned repeat = 0;
@@ skipping 39 matching lines @@
     if (m_activeState == Inactive || m_activeState == Frozen)
       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:
-  // |notifyDependentsIntervalChanged| -> |createInstanceTimesFromSyncbase| -> |add{Begin,End}Time| -> |{begin,end}TimeChanged| -> |notifyDependentsIntervalChanged|
+  // |loopBreaker| is used to avoid infinite recursions which may be caused by:
+  // |notifyDependentsIntervalChanged| -> |createInstanceTimesFromSyncbase| ->
+  // |add{Begin,End}Time| -> |{begin,end}TimeChanged| ->
+  // |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.add(this).isNewEntry)
     return;
 
   for (SVGSMILElement* element : m_syncBaseDependents)
     element->createInstanceTimesFromSyncbase(this);
 
   loopBreaker.remove(this);
 }
 
 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.
+  // 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();
     if (condition->getType() == Condition::Syncbase &&
         condition->syncBase() == syncBase) {
       ASSERT(condition->name() == "begin" || condition->name() == "end");
-      // No nested time containers in SVG, no need for crazy time space conversions. Phew!
+      // 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;
@@ skipping 98 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