Reflow comments in core/animation and subdirs

third_party/WebKit/Source/core/animation/css/CSSAnimations.cpp

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 250 matching lines @@
 
 void CSSAnimations::calculateCompositorAnimationUpdate(
     CSSAnimationUpdate& update,
     const Element* animatingElement,
     Element& element,
     const ComputedStyle& style,
     const ComputedStyle* parentStyle) {
   ElementAnimations* elementAnimations =
       animatingElement ? animatingElement->elementAnimations() : nullptr;
 
-  // We only update compositor animations in response to changes in the base style.
+  // We only update compositor animations in response to changes in the base
+  // style.
   if (!elementAnimations || elementAnimations->isAnimationStyleChange())
     return;
 
   if (!animatingElement->layoutObject() ||
       !animatingElement->layoutObject()->style())
     return;
 
   const ComputedStyle& oldStyle = *animatingElement->layoutObject()->style();
   if (!oldStyle.shouldCompositeForCurrentAnimations())
     return;
@@ skipping 30 matching lines @@
                                              const ComputedStyle& style,
                                              ComputedStyle* parentStyle,
                                              StyleResolver* resolver) {
   const ElementAnimations* elementAnimations =
       animatingElement ? animatingElement->elementAnimations() : nullptr;
 
   bool isAnimationStyleChange =
       elementAnimations && elementAnimations->isAnimationStyleChange();
 
 #if !DCHECK_IS_ON()
-  // If we're in an animation style change, no animations can have started, been cancelled or changed play state.
-  // When DCHECK is enabled, we verify this optimization.
+  // If we're in an animation style change, no animations can have started, been
+  // cancelled or changed play state. When DCHECK is enabled, we verify this
+  // optimization.
   if (isAnimationStyleChange)
     return;
 #endif
 
   const CSSAnimationData* animationData = style.animations();
   const CSSAnimations* cssAnimations =
       elementAnimations ? &elementAnimations->cssAnimations() : nullptr;
   const Element* elementForScoping =
       animatingElement ? animatingElement : &element;
 
@@ skipping 123 matching lines @@
 }
 
 void CSSAnimations::maybeApplyPendingUpdate(Element* element) {
   m_previousActiveInterpolationsForAnimations.clear();
   if (m_pendingUpdate.isEmpty())
     return;
 
   m_previousActiveInterpolationsForAnimations.swap(
       m_pendingUpdate.activeInterpolationsForAnimations());
 
-  // FIXME: cancelling, pausing, unpausing animations all query compositingState, which is not necessarily up to date here
+  // FIXME: cancelling, pausing, unpausing animations all query
+  // compositingState, which is not necessarily up to date here
   // since we call this from recalc style.
   // https://code.google.com/p/chromium/issues/detail?id=339847
   DisableCompositingQueryAsserts disabler;
 
   for (size_t pausedIndex :
        m_pendingUpdate.animationIndicesWithPauseToggled()) {
     Animation& animation = *m_runningAnimations[pausedIndex]->animation;
     if (animation.paused())
       animation.unpause();
     else
@@ skipping 198 matching lines @@
   Timing timing = transitionData.convertToTiming(transitionIndex);
   if (timing.startDelay + timing.iterationDuration <= 0)
     return;
 
   AnimatableValue* reversingAdjustedStartValue = from.get();
   double reversingShorteningFactor = 1;
   if (interruptedTransition) {
     const double interruptedProgress =
         interruptedTransition->animation->effect()->progress();
     if (!std::isnan(interruptedProgress)) {
-      // const_cast because we need to take a ref later when passing to startTransition.
+      // const_cast because we need to take a ref later when passing to
+      // startTransition.
       reversingAdjustedStartValue =
           const_cast<AnimatableValue*>(interruptedTransition->to);
       reversingShorteningFactor =
           clampTo((interruptedProgress *
                    interruptedTransition->reversingShorteningFactor) +
                       (1 - interruptedTransition->reversingShorteningFactor),
                   0.0, 1.0);
       timing.iterationDuration *= reversingShorteningFactor;
       if (timing.startDelay < 0) {
         timing.startDelay *= reversingShorteningFactor;
@@ skipping 49 matching lines @@
       animatingElement->document().wasPrinting())
     return;
 
   ElementAnimations* elementAnimations = animatingElement->elementAnimations();
   const TransitionMap* activeTransitions =
       elementAnimations ? &elementAnimations->cssAnimations().m_transitions
                         : nullptr;
   const CSSTransitionData* transitionData = style.transitions();
 
 #if DCHECK_IS_ON()
-  // In debug builds we verify that it would have been safe to avoid populating and testing listedProperties if the style recalc is due to animation.
+  // In debug builds we verify that it would have been safe to avoid populating
+  // and testing listedProperties if the style recalc is due to animation.
   const bool animationStyleRecalc = false;
 #else
-  // In release builds we avoid the cost of checking for new and interrupted transitions if the style recalc is due to animation.
+  // In release builds we avoid the cost of checking for new and interrupted
+  // transitions if the style recalc is due to animation.
   const bool animationStyleRecalc =
       elementAnimations && elementAnimations->isAnimationStyleChange();
 #endif
 
   std::bitset<numCSSProperties> listedProperties;
   bool anyTransitionHadTransitionAll = false;
   const LayoutObject* layoutObject = animatingElement->layoutObject();
   if (!animationStyleRecalc && style.display() != EDisplay::None &&
       layoutObject && layoutObject->style() && transitionData) {
     const ComputedStyle& oldStyle = *layoutObject->style();
 
     for (size_t i = 0; i < transitionData->propertyList().size(); ++i) {
       const CSSTransitionData::TransitionProperty& transitionProperty =
           transitionData->propertyList()[i];
       if (transitionProperty.propertyType !=
           CSSTransitionData::TransitionKnownProperty)
         continue;
 
       CSSPropertyID property =
           resolveCSSPropertyID(transitionProperty.unresolvedProperty);
       bool animateAll = property == CSSPropertyAll;
       if (animateAll)
         anyTransitionHadTransitionAll = true;
       const StylePropertyShorthand& propertyList =
           animateAll ? CSSAnimations::propertiesForTransitionAll()
                      : shorthandForProperty(property);
-      // If not a shorthand we only execute one iteration of this loop, and refer to the property directly.
+      // If not a shorthand we only execute one iteration of this loop, and
+      // refer to the property directly.
       for (unsigned j = 0; !j || j < propertyList.length(); ++j) {
         CSSPropertyID id =
             propertyList.length() ? propertyList.properties()[j] : property;
         DCHECK_GE(id, firstCSSProperty);
 
         if (!animateAll) {
           if (CSSPropertyMetadata::isInterpolableProperty(id))
             listedProperties.set(id - firstCSSProperty);
           else
             continue;
         }
 
-        // FIXME: We should transition if an !important property changes even when an animation is running,
-        // but this is a bit hard to do with the current applyMatchedProperties system.
+        // FIXME: We should transition if an !important property changes even
+        // when an animation is running, but this is a bit hard to do with the
+        // current applyMatchedProperties system.
         PropertyHandle property = PropertyHandle(id);
         if (!update.activeInterpolationsForAnimations().contains(property) &&
             (!elementAnimations ||
              !elementAnimations->cssAnimations()
                   .m_previousActiveInterpolationsForAnimations.contains(
                       property))) {
           calculateTransitionUpdateForProperty(id, *transitionData, i, oldStyle,
                                                style, activeTransitions, update,
                                                animatingElement);
         }
       }
     }
   }
 
   if (activeTransitions) {
     for (const auto& entry : *activeTransitions) {
       CSSPropertyID id = entry.key;
       if (!anyTransitionHadTransitionAll && !animationStyleRecalc &&
           !listedProperties.test(id - firstCSSProperty)) {
-        // TODO: Figure out why this fails on Chrome OS login page. crbug.com/365507
-        // DCHECK(animation.playStateInternal() == Animation::Finished || !(elementAnimations && elementAnimations->isAnimationStyleChange()));
+        // TODO(crbug.com/365507): Figure out why this fails on Chrome OS login
+        // page.
+        // DCHECK(animation.playStateInternal() == Animation::Finished ||
+        //       !(elementAnimations &&
+        //         elementAnimations->isAnimationStyleChange()));
         update.cancelTransition(id);
       } else if (entry.value.animation->finishedInternal()) {
         update.finishTransition(id);
       }
     }
   }
 }
 
 void CSSAnimations::cancel() {
   for (const auto& runningAnimation : m_runningAnimations) {
@@ skipping 31 matching lines @@
                                              KeyframeEffect::DefaultPriority,
                                              isStylePropertyHandle));
     update.adoptActiveInterpolationsForAnimations(
         activeInterpolationsForAnimations);
     return;
   }
 
   HeapVector<Member<const InertEffect>> newEffects;
   for (const auto& newAnimation : update.newAnimations())
     newEffects.append(newAnimation.effect);
+
+  // Animations with updates use a temporary InertEffect for the current frame.
   for (const auto& updatedAnimation : update.animationsWithUpdates())
-    newEffects.append(
-        updatedAnimation
-            .effect);  // Animations with updates use a temporary InertEffect for the current frame.
+    newEffects.append(updatedAnimation.effect);
 
   ActiveInterpolationsMap activeInterpolationsForAnimations(
       AnimationStack::activeInterpolations(
           animationStack, &newEffects, &update.suppressedAnimations(),
           KeyframeEffect::DefaultPriority, isStylePropertyHandle));
   update.adoptActiveInterpolationsForAnimations(
       activeInterpolationsForAnimations);
 }
 
 void CSSAnimations::calculateTransitionActiveInterpolations(
@@ skipping 24 matching lines @@
         DCHECK(transitionMap.contains(id));
         cancelledAnimations.add(transitionMap.get(id).animation.get());
       }
     }
 
     activeInterpolationsForTransitions = AnimationStack::activeInterpolations(
         animationStack, &newTransitions, &cancelledAnimations,
         KeyframeEffect::TransitionPriority, isStylePropertyHandle);
   }
 
-  // Properties being animated by animations don't get values from transitions applied.
+  // Properties being animated by animations don't get values from transitions
+  // applied.
   if (!update.activeInterpolationsForAnimations().isEmpty() &&
       !activeInterpolationsForTransitions.isEmpty()) {
     for (const auto& entry : update.activeInterpolationsForAnimations())
       activeInterpolationsForTransitions.remove(entry.key);
   }
   update.adoptActiveInterpolationsForTransitions(
       activeInterpolationsForTransitions);
 }
 
 EventTarget* CSSAnimations::AnimationEventDelegate::eventTarget() const {
@@ skipping 91 matching lines @@
   visitor->trace(m_transitionTarget);
   AnimationEffectReadOnly::EventDelegate::trace(visitor);
 }
 
 const StylePropertyShorthand& CSSAnimations::propertiesForTransitionAll() {
   DEFINE_STATIC_LOCAL(Vector<CSSPropertyID>, properties, ());
   DEFINE_STATIC_LOCAL(StylePropertyShorthand, propertyShorthand, ());
   if (properties.isEmpty()) {
     for (int i = firstCSSProperty; i < lastCSSProperty; ++i) {
       CSSPropertyID id = convertToCSSPropertyID(i);
-      // Avoid creating overlapping transitions with perspective-origin and transition-origin.
+      // Avoid creating overlapping transitions with perspective-origin and
+      // transition-origin.
       if (id == CSSPropertyWebkitPerspectiveOriginX ||
           id == CSSPropertyWebkitPerspectiveOriginY ||
           id == CSSPropertyWebkitTransformOriginX ||
           id == CSSPropertyWebkitTransformOriginY ||
           id == CSSPropertyWebkitTransformOriginZ)
         continue;
       if (CSSPropertyMetadata::isInterpolableProperty(id))
         properties.append(id);
     }
     propertyShorthand = StylePropertyShorthand(
         CSSPropertyInvalid, properties.begin(), properties.size());
   }
   return propertyShorthand;
 }
 
-// Properties that affect animations are not allowed to be affected by animations.
-// http://w3c.github.io/web-animations/#not-animatable-section
+// Properties that affect animations are not allowed to be affected by
+// animations. http://w3c.github.io/web-animations/#not-animatable-section
 bool CSSAnimations::isAnimatableProperty(CSSPropertyID property) {
   switch (property) {
     case CSSPropertyAnimation:
     case CSSPropertyAnimationDelay:
     case CSSPropertyAnimationDirection:
     case CSSPropertyAnimationDuration:
     case CSSPropertyAnimationFillMode:
     case CSSPropertyAnimationIterationCount:
     case CSSPropertyAnimationName:
     case CSSPropertyAnimationPlayState:
@@ skipping 23 matching lines @@
   return toShadowRoot(treeScope.rootNode()).host() == element;
 }
 
 DEFINE_TRACE(CSSAnimations) {
   visitor->trace(m_transitions);
   visitor->trace(m_pendingUpdate);
   visitor->trace(m_runningAnimations);
 }
 
 }  // namespace blink