WIP Support var() references in registered custom property keyframes

third_party/WebKit/Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
@@ skipping 1114 matching lines @@
   if (rules_to_include & kUAAndUserCSSRules)
     MatchUARules(collector);
 
   if (rules_to_include & kAuthorCSSRules) {
     collector.SetSameOriginOnly(!(rules_to_include & kCrossOriginCSSRules));
     collector.SetIncludeEmptyRules(rules_to_include & kEmptyCSSRules);
     MatchAuthorRules(element, collector);
   }
 }
 
+void StyleResolver::ApplyAnimatedCustomProperties(StyleResolverState& state) {
+  if (!state.IsAnimatingCustomProperties()) {
+    return;
+  }
+  CSSAnimationUpdate& update = state.AnimationUpdate();
+  HashSet<PropertyHandle>& pending = state.AnimationPendingCustomProperties();
+  DCHECK(pending.IsEmpty());
+  for (const auto& interpolations :
+       {update.ActiveInterpolationsForCustomAnimations(),
+        update.ActiveInterpolationsForCustomTransitions()}) {
+    for (const auto& entry : interpolations) {
+      pending.insert(entry.key);
+    }
+  }
+  while (!pending.IsEmpty()) {
+    PropertyHandle property = *pending.begin();
+    CSSVariableResolver variable_resolver(state);
+    ApplyAnimatedCustomProperty(state, variable_resolver, property);
+    DCHECK_EQ(pending.find(property), pending.end());
+  }
+}
+
+static const ActiveInterpolations& ActiveInterpolationsForCustomProperty(
+    const StyleResolverState& state,
+    const PropertyHandle& property) {
+  const ActiveInterpolationsMap& animations_map =
+      state.AnimationUpdate().ActiveInterpolationsForCustomAnimations();
+  const auto& animation = animations_map.find(property);
+  if (animation != animations_map.end()) {
+    return animation->value;
+  }
+  const ActiveInterpolationsMap& transitions_map =
+      state.AnimationUpdate().ActiveInterpolationsForCustomTransitions();
+  const auto& transition = transitions_map.find(property);
+  DCHECK_NE(transition, transitions_map.end());
+  return transition->value;
+}
+
+void StyleResolver::ApplyAnimatedCustomProperty(
+    StyleResolverState& state,
+    CSSVariableResolver& variable_resolver,
+    const PropertyHandle& property) {
+  DCHECK(property.IsCSSCustomProperty());
+  const ActiveInterpolations& interpolations =
+      ActiveInterpolationsForCustomProperty(state, property);
+  const Interpolation& interpolation = *interpolations.front();
+  if (interpolation.IsInvalidatableInterpolation()) {
+    CSSInterpolationTypesMap map(state.GetDocument().GetPropertyRegistry());
+    CSSInterpolationEnvironment environment(map, state, &variable_resolver);
+    InvalidatableInterpolation::ApplyStack(interpolations, environment);
+  } else {
+    ToTransitionInterpolation(interpolation).Apply(state);
+  }
+  state.AnimationPendingCustomProperties().erase(property);
+}
+
 bool StyleResolver::ApplyAnimatedStandardProperties(
     StyleResolverState& state,
     const Element* animating_element) {
   Element* element = state.GetElement();
   DCHECK(element);
 
   // The animating element may be this element, or its pseudo element. It is
   // null when calculating the style for a potential pseudo element that has
   // yet to be created.
   DCHECK(animating_element == element || !animating_element ||
@@ skipping 18 matching lines @@
       *element, state.AnimationUpdate(), *state.Style(), state.ParentStyle());
 
   if (state.AnimationUpdate().IsEmpty())
     return false;
 
   if (state.Style()->InsideLink() != EInsideLink::kNotInsideLink) {
     DCHECK(state.ApplyPropertyToRegularStyle());
     state.SetApplyPropertyToVisitedLinkStyle(true);
   }
 
-  const ActiveInterpolationsMap&
-      active_interpolations_map_for_standard_animations =
-          state.AnimationUpdate().ActiveInterpolationsForStandardAnimations();
-  const ActiveInterpolationsMap&
-      active_interpolations_map_for_standard_transitions =
-          state.AnimationUpdate().ActiveInterpolationsForStandardTransitions();
-  // TODO(crbug.com/644148): Apply animations on custom properties.
-  ApplyAnimatedProperties<kHighPropertyPriority>(
-      state, active_interpolations_map_for_standard_animations);
-  ApplyAnimatedProperties<kHighPropertyPriority>(
-      state, active_interpolations_map_for_standard_transitions);
+  const ActiveInterpolationsMap& animations_map =
+      state.AnimationUpdate().ActiveInterpolationsForStandardAnimations();
+  const ActiveInterpolationsMap& transitions_map =
+      state.AnimationUpdate().ActiveInterpolationsForStandardTransitions();
+  ApplyAnimatedStandardProperties<kHighPropertyPriority>(state, animations_map);
+  ApplyAnimatedStandardProperties<kHighPropertyPriority>(state,
+                                                         transitions_map);
 
   UpdateFont(state);
 
-  ApplyAnimatedProperties<kLowPropertyPriority>(
-      state, active_interpolations_map_for_standard_animations);
-  ApplyAnimatedProperties<kLowPropertyPriority>(
-      state, active_interpolations_map_for_standard_transitions);
+  ApplyAnimatedStandardProperties<kLowPropertyPriority>(state, animations_map);
+  ApplyAnimatedStandardProperties<kLowPropertyPriority>(state, transitions_map);
 
   // Start loading resources used by animations.
   LoadPendingResources(state);
 
   DCHECK(!state.GetFontBuilder().FontDirty());
 
   state.SetApplyPropertyToVisitedLinkStyle(false);
 
   return true;
 }
@@ skipping 12 matching lines @@
             resolver->KeyframeStylesForAnimation(animation_name.Impl()))
       return keyframes_rule;
   }
 
   for (auto& resolver : resolvers)
     resolver->SetHasUnresolvedKeyframesRule();
   return nullptr;
 }
 
 template <CSSPropertyPriority priority>
-void StyleResolver::ApplyAnimatedProperties(
+void StyleResolver::ApplyAnimatedStandardProperties(
     StyleResolverState& state,
     const ActiveInterpolationsMap& active_interpolations_map) {
+  static_assert(
+      priority != kResolveVariables,
+      "Use applyAnimatedCustomProperty() for custom property animations");
   // TODO(alancutter): Don't apply presentation attribute animations here,
   // they should instead apply in
   // SVGElement::CollectStyleForPresentationAttribute().
   for (const auto& entry : active_interpolations_map) {
     CSSPropertyID property = entry.key.IsCSSProperty()
                                  ? entry.key.CssProperty()
                                  : entry.key.PresentationAttribute();
-    DCHECK_EQ(entry.key.IsCSSCustomProperty(), priority == kResolveVariables);
     if (!CSSPropertyPriorityData<priority>::PropertyHasPriority(property))
       continue;
     const Interpolation& interpolation = *entry.value.front();
     if (interpolation.IsInvalidatableInterpolation()) {
       CSSInterpolationTypesMap map(state.GetDocument().GetPropertyRegistry());
       CSSInterpolationEnvironment environment(map, state);
       InvalidatableInterpolation::ApplyStack(entry.value, environment);
     } else if (interpolation.IsTransitionInterpolation()) {
       ToTransitionInterpolation(interpolation).Apply(state);
     } else {
@@ skipping 501 matching lines @@
 
   // TODO(leviw): We need the proper bit for tracking whether we need to do
   // this work.
   ApplyMatchedProperties<kResolveVariables, kUpdateNeedsApplyPass>(
       state, match_result.AuthorRules(), false, apply_inherited_only,
       needs_apply_pass);
   ApplyMatchedProperties<kResolveVariables, kCheckNeedsApplyPass>(
       state, match_result.AuthorRules(), true, apply_inherited_only,
       needs_apply_pass);
   if (apply_animations == kIncludeAnimations) {
-    ApplyAnimatedProperties<kResolveVariables>(
-        state,
-        state.AnimationUpdate().ActiveInterpolationsForCustomAnimations());
-    ApplyAnimatedProperties<kResolveVariables>(
-        state,
-        state.AnimationUpdate().ActiveInterpolationsForCustomTransitions());
+    ApplyAnimatedCustomProperties(state);
   }
   // TODO(leviw): stop recalculating every time
   CSSVariableResolver(state).ResolveVariableDefinitions();
 
   if (RuntimeEnabledFeatures::cssApplyAtRulesEnabled()) {
     if (CacheCustomPropertiesForApplyAtRules(state,
                                              match_result.AuthorRules())) {
       ApplyMatchedProperties<kResolveVariables, kUpdateNeedsApplyPass>(
           state, match_result.AuthorRules(), false, apply_inherited_only,
           needs_apply_pass);
       ApplyMatchedProperties<kResolveVariables, kCheckNeedsApplyPass>(
           state, match_result.AuthorRules(), true, apply_inherited_only,
           needs_apply_pass);
       if (apply_animations == kIncludeAnimations) {
-        ApplyAnimatedProperties<kResolveVariables>(
-            state,
-            state.AnimationUpdate().ActiveInterpolationsForCustomAnimations());
-        ApplyAnimatedProperties<kResolveVariables>(
-            state,
-            state.AnimationUpdate().ActiveInterpolationsForCustomTransitions());
+        ApplyAnimatedCustomProperties(state);
       }
       CSSVariableResolver(state).ResolveVariableDefinitions();
     }
   }
 }
 
 void StyleResolver::ApplyMatchedAnimationProperties(
     StyleResolverState& state,
     const MatchResult& match_result,
     const CacheSuccess& cache_success,
@@ skipping 229 matching lines @@
 
 DEFINE_TRACE(StyleResolver) {
   visitor->Trace(matched_properties_cache_);
   visitor->Trace(selector_filter_);
   visitor->Trace(style_sharing_lists_);
   visitor->Trace(document_);
   visitor->Trace(tracker_);
 }
 
 }  // namespace blink