Apply custom property animations

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 213 matching lines @@
 
 bool CSSAnimations::isTransitionAnimationForInspector(
     const Animation& animation) const {
   for (const auto& it : m_transitions) {
     if (it.value.animation->sequenceNumber() == animation.sequenceNumber())
       return true;
   }
   return false;
 }
 
-void CSSAnimations::calculateUpdate(const Element* animatingElement,
-                                    Element& element,
-                                    const ComputedStyle& style,
-                                    ComputedStyle* parentStyle,
-                                    CSSAnimationUpdate& animationUpdate,
-                                    StyleResolver* resolver) {
+void CSSAnimations::calculateCompositorAndTransitionUpdate(
+    const Element* animatingElement,
+    Element& element,
+    const ComputedStyle& style,
+    ComputedStyle* parentStyle,
+    CSSAnimationUpdate& animationUpdate) {
   calculateCompositorAnimationUpdate(animationUpdate, animatingElement, element,
                                      style, parentStyle);
-  calculateAnimationUpdate(animationUpdate, animatingElement, element, style,
-                           parentStyle, resolver);
-  calculateAnimationActiveInterpolations(animationUpdate, animatingElement);
   calculateTransitionUpdate(animationUpdate, animatingElement, style);
-  calculateTransitionActiveInterpolations(animationUpdate, animatingElement);
 }
 
 static const KeyframeEffectModelBase* getKeyframeEffectModelBase(
     const AnimationEffectReadOnly* effect) {
   if (!effect)
     return nullptr;
   const EffectModel* model = nullptr;
   if (effect->isKeyframeEffectReadOnly())
     model = toKeyframeEffectReadOnly(effect)->model();
   else if (effect->isInertEffect())
@@ skipping 56 matching lines @@
                                              Element& element,
                                              const ComputedStyle& style,
                                              ComputedStyle* parentStyle,
                                              StyleResolver* resolver) {
   const ElementAnimations* elementAnimations =
       animatingElement ? animatingElement->elementAnimations() : nullptr;
 
   bool isAnimationStyleChange =
       elementAnimations && elementAnimations->isAnimationStyleChange();
 
+  bool checkAnimationProperties = true;
 #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 (isAnimationStyleChange)
-    return;
+    checkAnimationProperties = false;

[Timothy Loh, 2016/12/01 03:41:48]

maybe just calculateAnimationActiveInterpolations+return here to keep the diff
smaller :/

 #endif
 
-  const CSSAnimationData* animationData = style.animations();
-  const CSSAnimations* cssAnimations =
-      elementAnimations ? &elementAnimations->cssAnimations() : nullptr;
-  const Element* elementForScoping =
-      animatingElement ? animatingElement : &element;
+  if (checkAnimationProperties) {
+    // All mutations to "update" in this block must be accompanied by a DCHECK
+    // for !isAnimationStyleChange.
+    const CSSAnimationData* animationData = style.animations();
+    const CSSAnimations* cssAnimations =
+        elementAnimations ? &elementAnimations->cssAnimations() : nullptr;
+    const Element* elementForScoping =
+        animatingElement ? animatingElement : &element;
 
-  Vector<bool> cancelRunningAnimationFlags(
-      cssAnimations ? cssAnimations->m_runningAnimations.size() : 0);
-  for (bool& flag : cancelRunningAnimationFlags)
-    flag = true;
+    Vector<bool> cancelRunningAnimationFlags(
+        cssAnimations ? cssAnimations->m_runningAnimations.size() : 0);
+    for (bool& flag : cancelRunningAnimationFlags)
+      flag = true;
 
-  if (animationData && style.display() != EDisplay::None) {
-    const Vector<AtomicString>& nameList = animationData->nameList();
-    for (size_t i = 0; i < nameList.size(); ++i) {
-      AtomicString name = nameList[i];
-      if (name == CSSAnimationData::initialName())
-        continue;
+    if (animationData && style.display() != EDisplay::None) {
+      const Vector<AtomicString>& nameList = animationData->nameList();
+      for (size_t i = 0; i < nameList.size(); ++i) {
+        AtomicString name = nameList[i];
+        if (name == CSSAnimationData::initialName())
+          continue;
 
-      // Find n where this is the nth occurence of this animation name.
-      size_t nameIndex = 0;
-      for (size_t j = 0; j < i; j++) {
-        if (nameList[j] == name)
-          nameIndex++;
-      }
+        // Find n where this is the nth occurence of this animation name.
+        size_t nameIndex = 0;
+        for (size_t j = 0; j < i; j++) {
+          if (nameList[j] == name)
+            nameIndex++;
+        }
 
-      const bool isPaused =
-          CSSTimingData::getRepeated(animationData->playStateList(), i) ==
-          AnimPlayStatePaused;
+        const bool isPaused =
+            CSSTimingData::getRepeated(animationData->playStateList(), i) ==
+            AnimPlayStatePaused;
 
-      Timing timing = animationData->convertToTiming(i);
-      Timing specifiedTiming = timing;
-      RefPtr<TimingFunction> keyframeTimingFunction = timing.timingFunction;
-      timing.timingFunction = Timing::defaults().timingFunction;
+        Timing timing = animationData->convertToTiming(i);
+        Timing specifiedTiming = timing;
+        RefPtr<TimingFunction> keyframeTimingFunction = timing.timingFunction;
+        timing.timingFunction = Timing::defaults().timingFunction;
 
-      StyleRuleKeyframes* keyframesRule =
-          resolver->findKeyframesRule(elementForScoping, name);
-      if (!keyframesRule)
-        continue;  // Cancel the animation if there's no style rule for it.
+        StyleRuleKeyframes* keyframesRule =
+            resolver->findKeyframesRule(elementForScoping, name);
+        if (!keyframesRule)
+          continue;  // Cancel the animation if there's no style rule for it.
 
-      const RunningAnimation* existingAnimation = nullptr;
-      size_t existingAnimationIndex = 0;
+        const RunningAnimation* existingAnimation = nullptr;
+        size_t existingAnimationIndex = 0;
 
-      if (cssAnimations) {
-        for (size_t i = 0; i < cssAnimations->m_runningAnimations.size(); i++) {
-          const RunningAnimation& runningAnimation =
-              *cssAnimations->m_runningAnimations[i];
-          if (runningAnimation.name == name &&
-              runningAnimation.nameIndex == nameIndex) {
-            existingAnimation = &runningAnimation;
-            existingAnimationIndex = i;
-            break;
+        if (cssAnimations) {
+          for (size_t i = 0; i < cssAnimations->m_runningAnimations.size();
+               i++) {
+            const RunningAnimation& runningAnimation =
+                *cssAnimations->m_runningAnimations[i];
+            if (runningAnimation.name == name &&
+                runningAnimation.nameIndex == nameIndex) {
+              existingAnimation = &runningAnimation;
+              existingAnimationIndex = i;
+              break;
+            }
           }
         }
-      }
 
-      if (existingAnimation) {
-        cancelRunningAnimationFlags[existingAnimationIndex] = false;
+        if (existingAnimation) {
+          cancelRunningAnimationFlags[existingAnimationIndex] = false;
 
-        Animation* animation = existingAnimation->animation.get();
+          Animation* animation = existingAnimation->animation.get();
 
-        if (keyframesRule != existingAnimation->styleRule ||
-            keyframesRule->version() != existingAnimation->styleRuleVersion ||
-            existingAnimation->specifiedTiming != specifiedTiming) {
+          if (keyframesRule != existingAnimation->styleRule ||
+              keyframesRule->version() != existingAnimation->styleRuleVersion ||
+              existingAnimation->specifiedTiming != specifiedTiming) {
+            DCHECK(!isAnimationStyleChange);
+            update.updateAnimation(
+                existingAnimationIndex, animation,
+                *InertEffect::create(
+                    createKeyframeEffectModel(
+                        resolver, animatingElement, element, &style,
+                        parentStyle, name, keyframeTimingFunction.get(), i),
+                    timing, isPaused,
+                    animation->unlimitedCurrentTimeInternal()),
+                specifiedTiming, keyframesRule);
+          }
+
+          if (isPaused != animation->paused()) {
+            DCHECK(!isAnimationStyleChange);
+            update.toggleAnimationIndexPaused(existingAnimationIndex);
+          }
+        } else {
           DCHECK(!isAnimationStyleChange);
-          update.updateAnimation(
-              existingAnimationIndex, animation,
+          update.startAnimation(
+              name, nameIndex,
               *InertEffect::create(
                   createKeyframeEffectModel(resolver, animatingElement, element,
                                             &style, parentStyle, name,
                                             keyframeTimingFunction.get(), i),
-                  timing, isPaused, animation->unlimitedCurrentTimeInternal()),
+                  timing, isPaused, 0),
               specifiedTiming, keyframesRule);
         }
+      }
+    }
 
-        if (isPaused != animation->paused()) {
-          DCHECK(!isAnimationStyleChange);
-          update.toggleAnimationIndexPaused(existingAnimationIndex);
-        }
-      } else {
-        DCHECK(!isAnimationStyleChange);
-        update.startAnimation(
-            name, nameIndex,
-            *InertEffect::create(
-                createKeyframeEffectModel(resolver, animatingElement, element,
-                                          &style, parentStyle, name,
-                                          keyframeTimingFunction.get(), i),
-                timing, isPaused, 0),
-            specifiedTiming, keyframesRule);
+    for (size_t i = 0; i < cancelRunningAnimationFlags.size(); i++) {
+      if (cancelRunningAnimationFlags[i]) {
+        DCHECK(cssAnimations && !isAnimationStyleChange);
+        update.cancelAnimation(
+            i, *cssAnimations->m_runningAnimations[i]->animation);
       }
     }
   }
 
-  for (size_t i = 0; i < cancelRunningAnimationFlags.size(); i++) {
-    if (cancelRunningAnimationFlags[i]) {
-      DCHECK(cssAnimations && !isAnimationStyleChange);
-      update.cancelAnimation(i,
-                             *cssAnimations->m_runningAnimations[i]->animation);
-    }
-  }
+  calculateAnimationActiveInterpolations(update, animatingElement);
 }
 
 void CSSAnimations::snapshotCompositorKeyframes(
     Element& element,
     CSSAnimationUpdate& update,
     const ComputedStyle& style,
     const ComputedStyle* parentStyle) {
   const auto& snapshot = [&element, &style,
                           parentStyle](const AnimationEffectReadOnly* effect) {
     const KeyframeEffectModelBase* keyframeEffect =
@@ skipping 379 matching lines @@
     for (const auto& entry : *activeTransitions) {
       CSSPropertyID id = entry.key;
       if (!anyTransitionHadTransitionAll && !animationStyleRecalc &&
           !listedProperties.test(id - firstCSSProperty)) {
         update.cancelTransition(id);
       } else if (entry.value.animation->finishedInternal()) {
         update.finishTransition(id);
       }
     }
   }
+  calculateTransitionActiveInterpolations(update, animatingElement);
 }
 
 void CSSAnimations::cancel() {
   for (const auto& runningAnimation : m_runningAnimations) {
     runningAnimation->animation->cancel();
     runningAnimation->animation->update(TimingUpdateOnDemand);
   }
 
   for (const auto& entry : m_transitions) {
     entry.value.animation->cancel();
@@ skipping 248 matching lines @@
   // and from their shadow sub-trees if they are shadow hosts.
   if (element.treeScope() == treeScope)
     return true;
   if (!isShadowHost(element))
     return false;
   if (treeScope.rootNode() == treeScope.document())
     return false;
   return toShadowRoot(treeScope.rootNode()).host() == element;
 }
 
+bool CSSAnimations::isCustomPropertyHandle(const PropertyHandle& property) {
+  return property.isCSSProperty() &&
+         property.cssProperty() == CSSPropertyVariable;
+}
+
+bool CSSAnimations::isAnimatingCustomProperties(
+    const ElementAnimations* elementAnimations) {
+  return elementAnimations &&
+         elementAnimations->effectStack().affectsProperties(
+             isCustomPropertyHandle);
+}
+
 DEFINE_TRACE(CSSAnimations) {
   visitor->trace(m_transitions);
   visitor->trace(m_pendingUpdate);
   visitor->trace(m_runningAnimations);
 }
 
 }  // namespace blink