reflow comments in core/svg/

third_party/WebKit/Source/core/svg/animation/SMILTimeContainer.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 110 matching lines @@
 }
 
 bool SMILTimeContainer::hasPendingSynchronization() const {
   return m_frameSchedulingState == SynchronizeAnimations &&
          m_wakeupTimer.isActive() && !m_wakeupTimer.nextFireInterval();
 }
 
 void SMILTimeContainer::notifyIntervalsChanged() {
   if (!isStarted())
     return;
-  // Schedule updateAnimations() to be called asynchronously so multiple intervals
-  // can change with updateAnimations() only called once at the end.
+  // Schedule updateAnimations() to be called asynchronously so multiple
+  // intervals can change with updateAnimations() only called once at the end.
   if (hasPendingSynchronization())
     return;
   cancelAnimationFrame();
   scheduleWakeUp(0, SynchronizeAnimations);
 }
 
 double SMILTimeContainer::elapsed() const {
   if (!isStarted())
     return 0;
 
@@ skipping 23 matching lines @@
 
 void SMILTimeContainer::start() {
   RELEASE_ASSERT(!isStarted());
 
   if (!document().isActive())
     return;
 
   if (!handleAnimationPolicy(RestartOnceTimerIfNotPaused))
     return;
 
-  // Sample the document timeline to get a time reference for the "presentation time".
+  // Sample the document timeline to get a time reference for the "presentation
+  // time".
   synchronizeToDocumentTimeline();
   m_started = true;
 
   // If the "presentation time" is non-zero, the timeline was modified via
-  // setElapsed() before the document began.
-  // In this case pass on 'seekToTime=true' to updateAnimations() to issue a seek.
+  // setElapsed() before the document began.  In this case pass on
+  // 'seekToTime=true' to updateAnimations() to issue a seek.
   SMILTime earliestFireTime =
       updateAnimations(m_presentationTime, m_presentationTime ? true : false);
   if (!canScheduleFrame(earliestFireTime))
     return;
   // If the timeline is running, and there are pending animation updates,
   // always perform the first update after the timeline was started using
   // the wake-up mechanism.
   double delayTime = earliestFireTime.value() - m_presentationTime;
   scheduleWakeUp(std::max(initialFrameDelay, delayTime), SynchronizeAnimations);
 }
@@ skipping 159 matching lines @@
   for (SVGSMILElement& element :
        Traversal<SVGSMILElement>::descendantsOf(ownerSVGElement()))
     element.setDocumentOrderIndex(timingElementCount++);
   m_documentOrderIndexesDirty = false;
 }
 
 struct PriorityCompare {
   PriorityCompare(double elapsed) : m_elapsed(elapsed) {}
   bool operator()(const Member<SVGSMILElement>& a,
                   const Member<SVGSMILElement>& b) {
-    // FIXME: This should also consider possible timing relations between the elements.
+    // FIXME: This should also consider possible timing relations between the
+    // elements.
     SMILTime aBegin = a->intervalBegin();
     SMILTime bBegin = b->intervalBegin();
     // Frozen elements need to be prioritized based on their previous interval.
     aBegin = a->isFrozen() && m_elapsed < aBegin ? a->previousIntervalBegin()
                                                  : aBegin;
     bBegin = b->isFrozen() && m_elapsed < bBegin ? b->previousIntervalBegin()
                                                  : bBegin;
     if (aBegin == bBegin)
       return a->documentOrderIndex() < b->documentOrderIndex();
     return aBegin < bBegin;
@@ skipping 45 matching lines @@
     return;
   double delayTime = earliestFireTime.value() - elapsed;
   scheduleAnimationFrame(delayTime);
 }
 
 SMILTime SMILTimeContainer::updateAnimations(double elapsed, bool seekToTime) {
   ASSERT(document().isActive());
   SMILTime earliestFireTime = SMILTime::unresolved();
 
 #if ENABLE(ASSERT)
-  // This boolean will catch any attempts to schedule/unschedule scheduledAnimations during this critical section.
-  // Similarly, any elements removed will unschedule themselves, so this will catch modification of animationsToApply.
+  // This boolean will catch any attempts to schedule/unschedule
+  // scheduledAnimations during this critical section.  Similarly, any elements
+  // removed will unschedule themselves, so this will catch modification of
+  // animationsToApply.
   m_preventScheduledAnimationsChanges = true;
 #endif
 
   if (m_documentOrderIndexesDirty)
     updateDocumentOrderIndexes();
 
   HeapHashSet<ElementAttributePair> invalidKeys;
   using AnimationsVector = HeapVector<Member<SVGSMILElement>>;
   AnimationsVector animationsToApply;
   AnimationsVector scheduledAnimationsInSameGroup;
   for (const auto& entry : m_scheduledAnimations) {
     if (!entry.key.first || entry.value->isEmpty()) {
       invalidKeys.add(entry.key);
       continue;
     }
 
-    // Sort according to priority. Elements with later begin time have higher priority.
-    // In case of a tie, document order decides.
-    // FIXME: This should also consider timing relationships between the elements. Dependents
-    // have higher priority.
+    // Sort according to priority. Elements with later begin time have higher
+    // priority.  In case of a tie, document order decides.
+    // FIXME: This should also consider timing relationships between the
+    // elements. Dependents have higher priority.
     copyToVector(*entry.value, scheduledAnimationsInSameGroup);
     std::sort(scheduledAnimationsInSameGroup.begin(),
               scheduledAnimationsInSameGroup.end(), PriorityCompare(elapsed));
 
     AnimationsVector sandwich;
     for (const auto& itAnimation : scheduledAnimationsInSameGroup) {
       SVGSMILElement* animation = itAnimation.get();
       ASSERT(animation->timeContainer() == this);
       ASSERT(animation->targetElement());
       ASSERT(animation->hasValidAttributeName());
       ASSERT(animation->hasValidAttributeType());
 
-      // This will calculate the contribution from the animation and update timing.
+      // This will calculate the contribution from the animation and update
+      // timing.
       if (animation->progress(elapsed, seekToTime)) {
         sandwich.append(animation);
       } else {
         animation->clearAnimatedType();
       }
 
       SMILTime nextFireTime = animation->nextProgressTime();
       if (nextFireTime.isFinite())
         earliestFireTime = std::min(nextFireTime, earliestFireTime);
     }
@@ skipping 57 matching lines @@
 void SMILTimeContainer::advanceFrameForTesting() {
   setElapsed(elapsed() + initialFrameDelay);
 }
 
 DEFINE_TRACE(SMILTimeContainer) {
   visitor->trace(m_scheduledAnimations);
   visitor->trace(m_ownerSVGElement);
 }
 
 }  // namespace blink