WIP Support var() references in registered custom property keyframes

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 273 matching lines @@
   const ElementAnimations* element_animations =
       animating_element ? animating_element->GetElementAnimations() : nullptr;
 
   bool is_animation_style_change =
       element_animations && element_animations->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 (is_animation_style_change) {
-    CalculateAnimationActiveInterpolations(update, animating_element);
+  if (isAnimationStyleChange) {
+    calculateAnimationActiveInterpolations(update, animatingElement);
     return;
   }
 #endif
 
   const CSSAnimationData* animation_data = style.Animations();
   const CSSAnimations* css_animations =
       element_animations ? &element_animations->CssAnimations() : nullptr;
   const Element* element_for_scoping =
       animating_element ? animating_element : &element;
 
@@ skipping 120 matching lines @@
     snapshot(new_animation.effect.Get());
 
   for (const auto& updated_animation : update.AnimationsWithUpdates())
     snapshot(updated_animation.effect.Get());
 
   for (const auto& new_transition : update.NewTransitions())
     snapshot(new_transition.value.effect.Get());
 }
 
 void CSSAnimations::MaybeApplyPendingUpdate(Element* element) {
-  previous_active_interpolations_for_animations_.Clear();
+  previous_active_interpolations_for_custom_animations_.Clear();
+  previous_active_interpolations_for_standard_animations_.Clear();
   if (pending_update_.IsEmpty())
     return;
 
-  previous_active_interpolations_for_animations_.Swap(
-      pending_update_.ActiveInterpolationsForAnimations());
+  previous_active_interpolations_for_custom_animations_.Swap(
+      pending_update_.ActiveInterpolationsForCustomAnimations());
+  previous_active_interpolations_for_standard_animations_.Swap(
+      pending_update_.ActiveInterpolationsForStandardAnimations());
 
   // 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 paused_index :
        pending_update_.AnimationIndicesWithPauseToggled()) {
     Animation& animation = *running_animations_[paused_index]->animation;
@@ skipping 175 matching lines @@
 
 void CSSAnimations::CalculateTransitionUpdateForProperty(
     TransitionUpdateState& state,
     const PropertyHandle& property,
     size_t transition_index) {
   state.listed_properties.insert(property);
 
   // 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.
-  if (state.update.ActiveInterpolationsForAnimations().Contains(property) ||
-      (state.animating_element->GetElementAnimations() &&
-       state.animating_element->GetElementAnimations()
-           ->CssAnimations()
-           .previous_active_interpolations_for_animations_.Contains(
-               property))) {
+  if (property.IsCSSCustomProperty()) {
+    if (state.update.ActiveInterpolationsForCustomAnimations().Contains(
+            property) ||
+        (state.animating_element->GetElementAnimations() &&
+         state.animating_element->GetElementAnimations()
+             ->CssAnimations()
+             .previous_active_interpolations_for_custom_animations_.Contains(
+                 property))) {
+      return;
+    }
+  } else if (state.update.ActiveInterpolationsForStandardAnimations().Contains(
+                 property) ||
+             (state.animating_element->GetElementAnimations() &&
+              state.animating_element->GetElementAnimations()
+                  ->CssAnimations()
+                  .previous_active_interpolations_for_standard_animations_
+                  .Contains(property))) {
     return;
   }
 
   RefPtr<AnimatableValue> to = nullptr;
   const RunningTransition* interrupted_transition = nullptr;
   if (state.active_transitions) {
     TransitionMap::const_iterator active_transition_iter =
         state.active_transitions->Find(property);
     if (active_transition_iter != state.active_transitions->end()) {
       const RunningTransition* running_transition =
@@ skipping 273 matching lines @@
   for (const auto& entry : transitions_) {
     entry.value.animation->cancel();
     entry.value.animation->Update(kTimingUpdateOnDemand);
   }
 
   running_animations_.Clear();
   transitions_.Clear();
   ClearPendingUpdate();
 }
 
+static bool IsCustomPropertyHandle(const PropertyHandle& property) {
+  return property.IsCSSCustomProperty();
+}
+
 // TODO(alancutter): CSS properties and presentation attributes may have
 // identical effects. By grouping them in the same set we introduce a bug where
 // arbitrary hash iteration will determine the order the apply in and thus which
 // one "wins". We should be more deliberate about the order of application in
 // the case of effect collisions.
 // Example: Both 'color' and 'svg-color' set the color on ComputedStyle but are
 // considered distinct properties in the ActiveInterpolationsMap.
-static bool IsStylePropertyHandle(const PropertyHandle& property_handle) {
-  return property_handle.IsCSSProperty() ||
-         property_handle.IsPresentationAttribute();
+static bool IsStandardPropertyHandle(const PropertyHandle& property) {
+  return (property.IsCSSProperty() && !property.IsCSSCustomProperty()) ||
+         property.IsPresentationAttribute();
 }
 
 void CSSAnimations::CalculateAnimationActiveInterpolations(
     CSSAnimationUpdate& update,
     const Element* animating_element) {
   ElementAnimations* element_animations =
       animating_element ? animating_element->GetElementAnimations() : nullptr;
   EffectStack* effect_stack =
       element_animations ? &element_animations->GetEffectStack() : nullptr;
 
   if (update.NewAnimations().IsEmpty() &&
       update.SuppressedAnimations().IsEmpty()) {
-    ActiveInterpolationsMap active_interpolations_for_animations(
+    ActiveInterpolationsMap active_interpolations_for_custom_animations(
         EffectStack::ActiveInterpolations(
             effect_stack, nullptr, nullptr,
-            KeyframeEffectReadOnly::kDefaultPriority, IsStylePropertyHandle));
-    update.AdoptActiveInterpolationsForAnimations(
-        active_interpolations_for_animations);
+            KeyframeEffectReadOnly::kDefaultPriority, IsCustomPropertyHandle));
+    update.AdoptActiveInterpolationsForCustomAnimations(
+        active_interpolations_for_custom_animations);
+    ActiveInterpolationsMap active_interpolations_for_standard_animations(
+        EffectStack::ActiveInterpolations(
+            effect_stack, nullptr, nullptr,
+            KeyframeEffectReadOnly::kDefaultPriority,
+            IsStandardPropertyHandle));
+    update.AdoptActiveInterpolationsForStandardAnimations(
+        active_interpolations_for_standard_animations);
     return;
   }
 
   HeapVector<Member<const InertEffect>> new_effects;
   for (const auto& new_animation : update.NewAnimations())
     new_effects.push_back(new_animation.effect);
 
   // Animations with updates use a temporary InertEffect for the current frame.
   for (const auto& updated_animation : update.AnimationsWithUpdates())
     new_effects.push_back(updated_animation.effect);
 
-  ActiveInterpolationsMap active_interpolations_for_animations(
+  ActiveInterpolationsMap active_interpolations_for_custom_animations(
       EffectStack::ActiveInterpolations(
           effect_stack, &new_effects, &update.SuppressedAnimations(),
-          KeyframeEffectReadOnly::kDefaultPriority, IsStylePropertyHandle));
-  update.AdoptActiveInterpolationsForAnimations(
-      active_interpolations_for_animations);
+          KeyframeEffectReadOnly::kDefaultPriority, IsCustomPropertyHandle));
+  update.AdoptActiveInterpolationsForCustomAnimations(
+      active_interpolations_for_custom_animations);
+  ActiveInterpolationsMap active_interpolations_for_standard_animations(
+      EffectStack::ActiveInterpolations(
+          effect_stack, &new_effects, &update.SuppressedAnimations(),
+          KeyframeEffectReadOnly::kDefaultPriority, IsStandardPropertyHandle));
+  update.AdoptActiveInterpolationsForStandardAnimations(
+      active_interpolations_for_standard_animations);
 }
 
-static bool IsCustomStylePropertyHandle(const PropertyHandle& property) {
-  return property.IsCSSCustomProperty();
-}
-
-static bool IsStandardStylePropertyHandle(const PropertyHandle& property) {
-  return IsStylePropertyHandle(property) && !property.IsCSSCustomProperty();
-}
-
-static EffectStack::PropertyHandleFilter StylePropertyFilter(
+static EffectStack::PropertyHandleFilter PropertyFilter(
     CSSAnimations::PropertyPass property_pass) {
   if (property_pass == CSSAnimations::PropertyPass::kCustom) {
-    return IsCustomStylePropertyHandle;
+    return IsCustomPropertyHandle;
   }
   DCHECK_EQ(property_pass, CSSAnimations::PropertyPass::kStandard);
-  return IsStandardStylePropertyHandle;
+  return IsStandardPropertyHandle;
 }
 
 void CSSAnimations::CalculateTransitionActiveInterpolations(
     CSSAnimationUpdate& update,
     PropertyPass property_pass,
     const Element* animating_element) {
   ElementAnimations* element_animations =
       animating_element ? animating_element->GetElementAnimations() : nullptr;
   EffectStack* effect_stack =
       element_animations ? &element_animations->GetEffectStack() : nullptr;
 
   ActiveInterpolationsMap active_interpolations_for_transitions;
   if (update.NewTransitions().IsEmpty() &&
       update.CancelledTransitions().IsEmpty()) {
     active_interpolations_for_transitions = EffectStack::ActiveInterpolations(
         effect_stack, nullptr, nullptr,
         KeyframeEffectReadOnly::kTransitionPriority,
-        StylePropertyFilter(property_pass));
+        PropertyFilter(property_pass));
   } else {
     HeapVector<Member<const InertEffect>> new_transitions;
     for (const auto& entry : update.NewTransitions())
       new_transitions.push_back(entry.value.effect.Get());
 
     HeapHashSet<Member<const Animation>> cancelled_animations;
     if (!update.CancelledTransitions().IsEmpty()) {
       DCHECK(element_animations);
       const TransitionMap& transition_map =
           element_animations->CssAnimations().transitions_;
       for (const PropertyHandle& property : update.CancelledTransitions()) {
         DCHECK(transition_map.Contains(property));
         cancelled_animations.insert(
             transition_map.at(property).animation.Get());
       }
     }
 
     active_interpolations_for_transitions = EffectStack::ActiveInterpolations(
         effect_stack, &new_transitions, &cancelled_animations,
         KeyframeEffectReadOnly::kTransitionPriority,
-        StylePropertyFilter(property_pass));
+        PropertyFilter(property_pass));
   }
 
+  const ActiveInterpolationsMap& animations =
+      property_pass == PropertyPass::kCustom
+          ? update.ActiveInterpolationsForCustomAnimations()
+          : update.ActiveInterpolationsForStandardAnimations();
   // Properties being animated by animations don't get values from transitions
   // applied.
-  if (!update.ActiveInterpolationsForAnimations().IsEmpty() &&
+  if (!animations.IsEmpty() &&
       !active_interpolations_for_transitions.IsEmpty()) {
-    for (const auto& entry : update.ActiveInterpolationsForAnimations())
+    for (const auto& entry : animations)
       active_interpolations_for_transitions.erase(entry.key);
   }
 
   if (property_pass == PropertyPass::kCustom) {
     update.AdoptActiveInterpolationsForCustomTransitions(
         active_interpolations_for_transitions);
   } else {
     DCHECK_EQ(property_pass, PropertyPass::kStandard);
     update.AdoptActiveInterpolationsForStandardTransitions(
         active_interpolations_for_transitions);
@@ skipping 10 matching lines @@
     double elapsed_time) {
   if (animation_target_->GetDocument().HasListenerType(listener_type)) {
     AnimationEvent* event =
         AnimationEvent::Create(event_name, name_, elapsed_time);
     event->SetTarget(GetEventTarget());
     GetDocument().EnqueueAnimationFrameEvent(event);
   }
 }
 
 bool CSSAnimations::AnimationEventDelegate::RequiresIterationEvents(
-    const AnimationEffectReadOnly& animation_node) {
+    const AnimationEffectReadOnly& animationNode) {
   return GetDocument().HasListenerType(Document::ANIMATIONITERATION_LISTENER);
 }
 
 void CSSAnimations::AnimationEventDelegate::OnEventCondition(
     const AnimationEffectReadOnly& animation_node) {
   const AnimationEffectReadOnly::Phase current_phase =
       animation_node.GetPhase();
   const double current_iteration = animation_node.CurrentIteration();
 
   if (previous_phase_ != current_phase &&
@@ skipping 110 matching lines @@
     case CSSPropertyTransitionDelay:
     case CSSPropertyTransitionDuration:
     case CSSPropertyTransitionProperty:
     case CSSPropertyTransitionTimingFunction:
       return true;
     default:
       return false;
   }
 }
 
-bool CSSAnimations::IsAffectedByKeyframesFromScope(
-    const Element& element,
-    const TreeScope& tree_scope) {
+bool CSSAnimations::IsAffectedByKeyframesFromScope(const Element& element,
+                                                   const TreeScope& treeScope) {
   // Animated elements are affected by @keyframes rules from the same scope
   // and from their shadow sub-trees if they are shadow hosts.
-  if (element.GetTreeScope() == tree_scope)
+  if (element.GetTreeScope() == treeScope)
     return true;
   if (!IsShadowHost(element))
     return false;
-  if (tree_scope.RootNode() == tree_scope.GetDocument())
+  if (treeScope.RootNode() == treeScope.GetDocument())
     return false;
-  return ToShadowRoot(tree_scope.RootNode()).host() == element;
-}
-
-bool CSSAnimations::IsCustomPropertyHandle(const PropertyHandle& property) {
-  return property.IsCSSProperty() &&
-         property.CssProperty() == CSSPropertyVariable;
+  return ToShadowRoot(treeScope.RootNode()).host() == element;
 }
 
 bool CSSAnimations::IsAnimatingCustomProperties(
-    const ElementAnimations* element_animations) {
-  return element_animations &&
-         element_animations->GetEffectStack().AffectsProperties(
+    const ElementAnimations* elementAnimations) {
+  return elementAnimations &&
+         elementAnimations->GetEffectStack().AffectsProperties(
              IsCustomPropertyHandle);
 }
 
 DEFINE_TRACE(CSSAnimations) {
   visitor->Trace(transitions_);
   visitor->Trace(pending_update_);
   visitor->Trace(running_animations_);
 }
 
 }  // namespace blink