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 60 matching lines @@
   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 (isAnimationStyleChange)
+  if (isAnimationStyleChange) {
+    calculateAnimationActiveInterpolations(update, animatingElement);
     return;
+  }
 #endif
 
   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);
@@ skipping 81 matching lines @@
     }
   }
 
   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