WIP Support var() references in registered custom property keyframes

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  * All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 45 matching lines @@
 enum StyleSharingBehavior {
   kAllowStyleSharing,
   kDisallowStyleSharing,
 };
 
 enum RuleMatchingBehavior { kMatchAllRules, kMatchAllRulesExcludingSMIL };
 
 const unsigned kStyleSharingListSize = 15;
 const unsigned kStyleSharingMaxDepth = 32;
 using StyleSharingList = HeapDeque<Member<Element>, kStyleSharingListSize>;
-using ActiveInterpolationsMap =
-    HashMap<PropertyHandle, Vector<RefPtr<Interpolation>, 1>>;
+using ActiveInterpolations = Vector<RefPtr<Interpolation>, 1>;
+using ActiveInterpolationsMap = HashMap<PropertyHandle, ActiveInterpolations>;
 
 // This class selects a ComputedStyle for a given element based on a collection
 // of stylesheets.
 class CORE_EXPORT StyleResolver final
     : public GarbageCollectedFinalized<StyleResolver> {
   WTF_MAKE_NONCOPYABLE(StyleResolver);
 
  public:
   static StyleResolver* Create(Document& document) {
     return new StyleResolver(document);
@@ skipping 134 matching lines @@
     void SetFailed() {
       is_inherited_cache_hit = false;
       is_non_inherited_cache_hit = false;
     }
   };
 
   // These flags indicate whether an apply pass for a given CSSPropertyPriority
   // and isImportant is required.
   class NeedsApplyPass {
    public:
-    bool Get(CSSPropertyPriority priority, bool is_important) const {
-      return flags_[GetIndex(priority, is_important)];
+    bool Get(CSSPropertyPriority priority, bool isImportant) const {
+      return flags_[GetIndex(priority, isImportant)];
     }
     void Set(CSSPropertyPriority priority, bool is_important) {
       flags_[GetIndex(priority, is_important)] = true;
     }
 
    private:
     static size_t GetIndex(CSSPropertyPriority priority, bool is_important) {
       DCHECK(priority >= 0 && priority < kPropertyPriorityCount);
       return priority * 2 + is_important;
     }
@@ skipping 19 matching lines @@
   void ApplyMatchedAnimationProperties(StyleResolverState&,
                                        const MatchResult&,
                                        const CacheSuccess&,
                                        NeedsApplyPass&);
   void ApplyMatchedStandardProperties(StyleResolverState&,
                                       const MatchResult&,
                                       const CacheSuccess&,
                                       NeedsApplyPass&);
   void CalculateAnimationUpdate(StyleResolverState&,
                                 const Element* animating_element);
+  void ApplyAnimatedCustomProperties(StyleResolverState&);
+  void ApplyAnimatedCustomProperty(StyleResolverState&, const PropertyHandle&);
   bool ApplyAnimatedStandardProperties(StyleResolverState&, const Element*);
 
   void ApplyCallbackSelectors(StyleResolverState&);
 
   template <CSSPropertyPriority priority, ShouldUpdateNeedsApplyPass>
   void ApplyMatchedProperties(StyleResolverState&,
                               const MatchedPropertiesRange&,
                               bool important,
                               bool inherited_only,
                               NeedsApplyPass&);
   template <CSSPropertyPriority priority, ShouldUpdateNeedsApplyPass>
   void ApplyProperties(StyleResolverState&,
                        const StylePropertySet* properties,
                        bool is_important,
                        bool inherited_only,
                        NeedsApplyPass&,
                        PropertyWhitelistType = kPropertyWhitelistNone);
   template <CSSPropertyPriority priority>
-  void ApplyAnimatedProperties(StyleResolverState&,
-                               const ActiveInterpolationsMap&);
+  void ApplyAnimatedStandardProperties(StyleResolverState&,
+                                       const ActiveInterpolationsMap&);
   template <CSSPropertyPriority priority>
   void ApplyAllProperty(StyleResolverState&,
                         const CSSValue&,
                         bool inherited_only,
                         PropertyWhitelistType);
   template <CSSPropertyPriority priority, ShouldUpdateNeedsApplyPass>
   void ApplyPropertiesForApplyAtRule(StyleResolverState&,
                                      const CSSValue&,
                                      bool is_important,
                                      NeedsApplyPass&,
                                      PropertyWhitelistType);
 
   bool PseudoStyleForElementInternal(Element&,
                                      const PseudoStyleRequest&,
-                                     const ComputedStyle* parent_style,
+                                     const ComputedStyle* parentStyle,
                                      StyleResolverState&);
   bool HasAuthorBackground(const StyleResolverState&);
   bool HasAuthorBorder(const StyleResolverState&);
 
   PseudoElement* CreatePseudoElement(Element* parent, PseudoId);
 
   Document& GetDocument() const { return *document_; }
 
   bool WasViewportResized() const { return was_viewport_resized_; }
 
   static ComputedStyle* style_not_yet_available_;
 
   MatchedPropertiesCache matched_properties_cache_;
   Member<Document> document_;
   SelectorFilter selector_filter_;
 
   Member<StyleRuleUsageTracker> tracker_;
 
   bool print_media_type_ = false;
   bool was_viewport_resized_ = false;
 
   unsigned style_sharing_depth_ = 0;
   HeapVector<Member<StyleSharingList>, kStyleSharingMaxDepth>
       style_sharing_lists_;
 };
 
 }  // namespace blink
 
 #endif  // StyleResolver_h