Split active animation interpolation storage between standard and custom properties

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 415 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 177 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();
+}
+
+static void AdoptActiveAnimationInterpolations(
+    EffectStack* effect_stack,
+    CSSAnimationUpdate& update,
+    const HeapVector<Member<const InertEffect>>* new_animations,
+    const HeapHashSet<Member<const Animation>>* suppressed_animations) {
+  ActiveInterpolationsMap custom_interpolations(
+      EffectStack::ActiveInterpolations(
+          effect_stack, new_animations, suppressed_animations,
+          KeyframeEffectReadOnly::kDefaultPriority, IsCustomPropertyHandle));
+  update.AdoptActiveInterpolationsForCustomAnimations(custom_interpolations);
+
+  ActiveInterpolationsMap standard_interpolations(
+      EffectStack::ActiveInterpolations(
+          effect_stack, new_animations, suppressed_animations,
+          KeyframeEffectReadOnly::kDefaultPriority, IsStandardPropertyHandle));
+  update.AdoptActiveInterpolationsForStandardAnimations(
+      standard_interpolations);
 }
 
 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(
-        EffectStack::ActiveInterpolations(
-            effect_stack, nullptr, nullptr,
-            KeyframeEffectReadOnly::kDefaultPriority, IsStylePropertyHandle));
-    update.AdoptActiveInterpolationsForAnimations(
-        active_interpolations_for_animations);
+    AdoptActiveAnimationInterpolations(effect_stack, update, nullptr, nullptr);
     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(
-      EffectStack::ActiveInterpolations(
-          effect_stack, &new_effects, &update.SuppressedAnimations(),
-          KeyframeEffectReadOnly::kDefaultPriority, IsStylePropertyHandle));
-  update.AdoptActiveInterpolationsForAnimations(
-      active_interpolations_for_animations);
+  AdoptActiveAnimationInterpolations(effect_stack, update, &new_effects,
+                                     &update.SuppressedAnimations());
 }
 
-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 155 matching lines @@
   // and from their shadow sub-trees if they are shadow hosts.
   if (element.GetTreeScope() == tree_scope)
     return true;
   if (!IsShadowHost(element))
     return false;
   if (tree_scope.RootNode() == tree_scope.GetDocument())
     return false;
   return ToShadowRoot(tree_scope.RootNode()).host() == element;
 }
 
-bool CSSAnimations::IsCustomPropertyHandle(const PropertyHandle& property) {
-  return property.IsCSSProperty() &&
-         property.CssProperty() == CSSPropertyVariable;
-}
-
 bool CSSAnimations::IsAnimatingCustomProperties(
     const ElementAnimations* element_animations) {
   return element_animations &&
          element_animations->GetEffectStack().AffectsProperties(
              IsCustomPropertyHandle);
 }
 
 DEFINE_TRACE(CSSAnimations) {
   visitor->Trace(transitions_);
   visitor->Trace(pending_update_);
   visitor->Trace(running_animations_);
 }
 
 }  // namespace blink