Split active animation interpolation storage between standard and custom properties

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 1153 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_animations =
-      state.AnimationUpdate().ActiveInterpolationsForAnimations();
+  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_animations);
+      state, active_interpolations_map_for_standard_animations);
   ApplyAnimatedProperties<kHighPropertyPriority>(
       state, active_interpolations_map_for_standard_transitions);
 
   UpdateFont(state);
 
   ApplyAnimatedProperties<kLowPropertyPriority>(
-      state, active_interpolations_map_for_animations);
+      state, active_interpolations_map_for_standard_animations);
   ApplyAnimatedProperties<kLowPropertyPriority>(
       state, active_interpolations_map_for_standard_transitions);
 
   // Start loading resources used by animations.
   LoadPendingResources(state);
 
   DCHECK(!state.GetFontBuilder().FontDirty());
 
   state.SetApplyPropertyToVisitedLinkStyle(false);
 
@@ skipping 24 matching lines @@
 void StyleResolver::ApplyAnimatedProperties(
     StyleResolverState& state,
     const ActiveInterpolationsMap& active_interpolations_map) {
   // 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 502 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().ActiveInterpolationsForAnimations());
+        state,
+        state.AnimationUpdate().ActiveInterpolationsForCustomAnimations());
     ApplyAnimatedProperties<kResolveVariables>(
         state,
         state.AnimationUpdate().ActiveInterpolationsForCustomTransitions());
   }
   // TODO(leviw): stop recalculating every time
   CSSVariableResolver::ResolveVariableDefinitions(state);
 
   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().ActiveInterpolationsForAnimations());
+            state,
+            state.AnimationUpdate().ActiveInterpolationsForCustomAnimations());
         ApplyAnimatedProperties<kResolveVariables>(
             state,
             state.AnimationUpdate().ActiveInterpolationsForCustomTransitions());
       }
       CSSVariableResolver::ResolveVariableDefinitions(state);
     }
   }
 }
 
 void StyleResolver::ApplyMatchedAnimationProperties(
@@ skipping 24 matching lines @@
   CSSAnimations::CalculateTransitionUpdate(state.AnimationUpdate(),
                                            CSSAnimations::PropertyPass::kCustom,
                                            animating_element, *state.Style());
 
   state.SetIsAnimationInterpolationMapReady();
 
   if (state.IsAnimatingCustomProperties()) {
     return;
   }
   if (!state.AnimationUpdate()
+           .ActiveInterpolationsForCustomAnimations()
+           .IsEmpty() ||
+      !state.AnimationUpdate()
            .ActiveInterpolationsForCustomTransitions()
            .IsEmpty()) {
     state.SetIsAnimatingCustomProperties(true);
-    return;
-  }
-  for (const auto& property_handle :
-       state.AnimationUpdate().ActiveInterpolationsForAnimations().Keys()) {
-    if (CSSAnimations::IsCustomPropertyHandle(property_handle)) {
-      state.SetIsAnimatingCustomProperties(true);
-      return;
-    }
   }
 }
 
 void StyleResolver::ApplyMatchedStandardProperties(
     StyleResolverState& state,
     const MatchResult& match_result,
     const CacheSuccess& cache_success,
     NeedsApplyPass& needs_apply_pass) {
   INCREMENT_STYLE_STATS_COUNTER(GetDocument().GetStyleEngine(),
                                 matched_property_apply, 1);
@@ skipping 182 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