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 288 matching lines @@
     // Inline style is immutable as long as there is no CSSOM wrapper.
     bool is_inline_style_cacheable = !element.InlineStyle()->IsMutable();
     collector.AddElementStyleProperties(element.InlineStyle(),
                                         is_inline_style_cacheable);
   }
 
   collector.FinishAddingAuthorRulesForTreeScope();
 }
 
 static bool ShouldCheckScope(const Element& element,
-                             const Node& scoping_node,
-                             bool is_inner_tree_scope) {
-  if (is_inner_tree_scope &&
-      element.GetTreeScope() != scoping_node.GetTreeScope()) {
+                             const Node& scopingNode,
+                             bool isInnerTreeScope) {
+  if (isInnerTreeScope &&
+      element.GetTreeScope() != scopingNode.GetTreeScope()) {
     // Check if |element| may be affected by a ::content rule in |scopingNode|'s
     // style.  If |element| is a descendant of a shadow host which is ancestral
     // to |scopingNode|, the |element| should be included for rule collection.
     // Skip otherwise.
-    const TreeScope* scope = &scoping_node.GetTreeScope();
+    const TreeScope* scope = &scopingNode.GetTreeScope();
     while (scope && scope->ParentTreeScope() != &element.GetTreeScope())
       scope = scope->ParentTreeScope();
     Element* shadow_host =
         scope ? scope->RootNode().OwnerShadowHost() : nullptr;
     return shadow_host && element.IsDescendantOf(shadow_host);
   }
 
   // When |element| can be distributed to |scopingNode| via <shadow>, ::content
   // rule can match, thus the case should be included.
-  if (!is_inner_tree_scope &&
-      scoping_node.ParentOrShadowHostNode() ==
+  if (!isInnerTreeScope &&
+      scopingNode.ParentOrShadowHostNode() ==
           element.GetTreeScope().RootNode().ParentOrShadowHostNode())
     return true;
 
   // Obviously cases when ancestor scope has /deep/ or ::shadow rule should be
   // included.  Skip otherwise.
-  return scoping_node.GetTreeScope()
+  return scopingNode.GetTreeScope()
       .GetScopedStyleResolver()
       ->HasDeepOrShadowSelector();
 }
 
 void StyleResolver::MatchScopedRules(const Element& element,
                                      ElementRuleCollector& collector) {
   // Match rules from treeScopes in the reverse tree-of-trees order, since the
   // cascading order for normal rules is such that when comparing rules from
   // different shadow trees, the rule from the tree which comes first in the
   // tree-of-trees order wins. From other treeScopes than the element's own
@@ skipping 551 matching lines @@
   PseudoElement* pseudo = CreatePseudoElement(&parent, pseudo_id);
 
   SetAnimationUpdateIfNeeded(state, *pseudo);
   if (ElementAnimations* element_animations = pseudo->GetElementAnimations())
     element_animations->CssAnimations().MaybeApplyPendingUpdate(pseudo);
   return pseudo;
 }
 
 bool StyleResolver::PseudoStyleForElementInternal(
     Element& element,
-    const PseudoStyleRequest& pseudo_style_request,
-    const ComputedStyle* parent_style,
+    const PseudoStyleRequest& pseudoStyleRequest,
+    const ComputedStyle* parentStyle,
     StyleResolverState& state) {
   DCHECK(GetDocument().GetFrame());
   DCHECK(GetDocument().GetSettings());
-  DCHECK(pseudo_style_request.pseudo_id != kPseudoIdFirstLineInherited);
+  DCHECK(pseudoStyleRequest.pseudo_id != kPseudoIdFirstLineInherited);
   DCHECK(state.ParentStyle());
 
   SelectorFilterParentScope::EnsureParentStackIsPushed();
 
   Element* pseudo_element =
-      element.GetPseudoElement(pseudo_style_request.pseudo_id);
+      element.GetPseudoElement(pseudoStyleRequest.pseudo_id);
 
   const ComputedStyle* base_computed_style =
       CalculateBaseComputedStyle(state, pseudo_element);
 
   if (base_computed_style) {
     state.SetStyle(ComputedStyle::Clone(*base_computed_style));
-  } else if (pseudo_style_request.AllowsInheritance(state.ParentStyle())) {
+  } else if (pseudoStyleRequest.AllowsInheritance(state.ParentStyle())) {
     RefPtr<ComputedStyle> style = ComputedStyle::Create();
     style->InheritFrom(*state.ParentStyle());
     state.SetStyle(std::move(style));
   } else {
     state.SetStyle(InitialStyleForElement());
     state.SetParentStyle(ComputedStyle::Clone(*state.Style()));
   }
 
-  state.Style()->SetStyleType(pseudo_style_request.pseudo_id);
+  state.Style()->SetStyleType(pseudoStyleRequest.pseudo_id);
 
   // Since we don't use pseudo-elements in any of our quirk/print
   // user agent rules, don't waste time walking those rules.
 
   if (!base_computed_style) {
     // Check UA, user and author rules.
     ElementRuleCollector collector(state.ElementContext(), selector_filter_,
                                    state.Style());
-    collector.SetPseudoStyleRequest(pseudo_style_request);
+    collector.SetPseudoStyleRequest(pseudoStyleRequest);
 
     MatchUARules(collector);
     MatchAuthorRules(*state.GetElement(), collector);
     collector.FinishAddingAuthorRulesForTreeScope();
 
     if (tracker_)
       AddMatchedRulesToTracker(collector);
 
     if (!collector.MatchedResult().HasMatchedProperties())
       return false;
@@ skipping 172 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;
+  }
+  HashSet<PropertyHandle>& pending =
+      state.CustomPropertiesPendingAnimationApplication();
+  pending.Clear();
+  for (const auto& interpolations_map :
+       {state.AnimationUpdate().ActiveInterpolationsForCustomAnimations(),
+        state.AnimationUpdate().ActiveInterpolationsForCustomTransitions()}) {
+    for (const auto& entry : interpolations_map) {
+      pending.insert(entry.key);
+    }
+  }
+  while (!pending.IsEmpty()) {
+    ApplyAnimatedCustomProperty(state, pending.TakeAny());
+  }
+}
+
+static const ActiveInterpolations& ActiveInterpolationsForCustomProperty(
+    const StyleResolverState& state,
+    const PropertyHandle& property) {
+  const ActiveInterpolationsMap& animations_map =
+      state.AnimationUpdate().ActiveInterpolationsForCustomAnimations();
+  const auto& find_result = animations_map.Find(property);
+  if (find_result != animations_map.end()) {
+    return find_result->value;
+  }
+  return state.AnimationUpdate()
+      .ActiveInterpolationsForCustomAnimations()
+      .Find(property)
+      ->value;
+}
+
+void StyleResolver::ApplyAnimatedCustomProperty(
+    StyleResolverState& state,
+    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());
+    InterpolationEnvironment environment(map, state);
+    InvalidatableInterpolation::ApplyStack(interpolations, environment);
+  } else {
+    ToTransitionInterpolation(interpolation).Apply(state);
+  }
+}
+
 bool StyleResolver::ApplyAnimatedStandardProperties(
     StyleResolverState& state,
-    const Element* animating_element) {
+    const Element* animatingElement) {
   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 ||
-         animating_element->ParentOrShadowHostElement() == element);
+  DCHECK(animatingElement == element || !animatingElement ||
+         animatingElement->ParentOrShadowHostElement() == element);
 
   if (state.Style()->Animations() ||
-      (animating_element && animating_element->HasAnimations())) {
+      (animatingElement && animatingElement->HasAnimations())) {
     if (!state.IsAnimationInterpolationMapReady())
-      CalculateAnimationUpdate(state, animating_element);
+      CalculateAnimationUpdate(state, animatingElement);
   } else if (!state.Style()->Transitions()) {
     return false;
   }
 
   CSSAnimations::CalculateCompositorAnimationUpdate(
-      state.AnimationUpdate(), animating_element, *element, *state.Style(),
+      state.AnimationUpdate(), animatingElement, *element, *state.Style(),
       state.ParentStyle(), WasViewportResized());
   CSSAnimations::CalculateTransitionUpdate(
       state.AnimationUpdate(), CSSAnimations::PropertyPass::kStandard,
-      animating_element, *state.Style());
+      animatingElement, *state.Style());
 
   CSSAnimations::SnapshotCompositorKeyframes(
       *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_transitions =
-          state.AnimationUpdate().ActiveInterpolationsForStandardTransitions();
-  // TODO(crbug.com/644148): Apply animations on custom properties.
-  ApplyAnimatedProperties<kHighPropertyPriority>(
-      state, active_interpolations_map_for_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_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();
     if (!CSSPropertyPriorityData<priority>::PropertyHasPriority(property))
       continue;
     const Interpolation& interpolation = *entry.value.front();
@@ skipping 198 matching lines @@
       !settings->GetTextTrackFontStyle().IsEmpty() ||
       !settings->GetTextTrackFontVariant().IsEmpty() ||
       !settings->GetTextTrackTextColor().IsEmpty() ||
       !settings->GetTextTrackTextShadow().IsEmpty() ||
       !settings->GetTextTrackTextSize().IsEmpty())
     return true;
   return false;
 }
 
 static inline bool IsPropertyInWhitelist(
-    PropertyWhitelistType property_whitelist_type,
+    PropertyWhitelistType propertyWhitelistType,
     CSSPropertyID property,
     const Document& document) {
-  if (property_whitelist_type == kPropertyWhitelistNone)
+  if (propertyWhitelistType == kPropertyWhitelistNone)
     return true;  // Early bail for the by far most common case.
 
-  if (property_whitelist_type == kPropertyWhitelistFirstLetter)
+  if (propertyWhitelistType == kPropertyWhitelistFirstLetter)
     return IsValidFirstLetterStyleProperty(property);
 
-  if (property_whitelist_type == kPropertyWhitelistCue)
+  if (propertyWhitelistType == kPropertyWhitelistCue)
     return IsValidCueStyleProperty(property) &&
            !ShouldIgnoreTextTrackAuthorStyle(document);
 
   NOTREACHED();
   return true;
 }
 
 // This method expands the 'all' shorthand property to longhand properties
 // and applies the expanded longhand properties.
 template <CSSPropertyPriority priority>
@@ skipping 280 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());
-    ApplyAnimatedProperties<kResolveVariables>(
-        state,
-        state.AnimationUpdate().ActiveInterpolationsForCustomTransitions());
+    ApplyAnimatedCustomProperties(state);
   }
   // 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());
-        ApplyAnimatedProperties<kResolveVariables>(
-            state,
-            state.AnimationUpdate().ActiveInterpolationsForCustomTransitions());
+        ApplyAnimatedCustomProperties(state);
       }
       CSSVariableResolver::ResolveVariableDefinitions(state);
     }
   }
 }
 
 void StyleResolver::ApplyMatchedAnimationProperties(
     StyleResolverState& state,
     const MatchResult& match_result,
     const CacheSuccess& cache_success,
@@ skipping 21 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 178 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