Apply custom property animations

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 184 matching lines @@
   void matchUARules(ElementRuleCollector&);
   void matchScopedRules(const Element&, ElementRuleCollector&);
   void matchAuthorRules(const Element&, ElementRuleCollector&);
   void matchAuthorRulesV0(const Element&, ElementRuleCollector&);
   void matchAllRules(StyleResolverState&,
                      ElementRuleCollector&,
                      bool includeSMILProperties);
   void collectTreeBoundaryCrossingRulesV0CascadeOrder(const Element&,
                                                       ElementRuleCollector&);
 
-  void applyMatchedProperties(StyleResolverState&, const MatchResult&);
-  bool applyAnimatedProperties(StyleResolverState&,
-                               const Element* animatingElement);
-  void applyCallbackSelectors(StyleResolverState&);
+  struct CacheSuccess {
+    STACK_ALLOCATED();
+    bool isInheritedCacheHit;
+    bool isNonInheritedCacheHit;
+    unsigned cacheHash;
+    Member<const CachedMatchedProperties> cachedMatchedProperties;
+
+    CacheSuccess(bool isInheritedCacheHit,
+                 bool isNonInheritedCacheHit,
+                 unsigned cacheHash,
+                 const CachedMatchedProperties* cachedMatchedProperties)
+        : isInheritedCacheHit(isInheritedCacheHit),
+          isNonInheritedCacheHit(isNonInheritedCacheHit),
+          cacheHash(cacheHash),
+          cachedMatchedProperties(cachedMatchedProperties) {}
+
+    bool isFullCacheHit() const {
+      return isInheritedCacheHit && isNonInheritedCacheHit;
+    }
+    bool shouldApplyInheritedOnly() const {
+      return isNonInheritedCacheHit && !isInheritedCacheHit;
+    }
+    void setFailed() {
+      isInheritedCacheHit = false;
+      isNonInheritedCacheHit = false;
+    }
+  };
 
   // These flags indicate whether an apply pass for a given CSSPropertyPriority
   // and isImportant is required.
   class NeedsApplyPass {
    public:
     bool get(CSSPropertyPriority priority, bool isImportant) const {
       return m_flags[getIndex(priority, isImportant)];
     }
     void set(CSSPropertyPriority priority, bool isImportant) {
       m_flags[getIndex(priority, isImportant)] = true;
     }
 
    private:
     static size_t getIndex(CSSPropertyPriority priority, bool isImportant) {
       DCHECK(priority >= 0 && priority < PropertyPriorityCount);
       return priority * 2 + isImportant;
     }
     bool m_flags[PropertyPriorityCount * 2] = {0};
   };
 
   enum ShouldUpdateNeedsApplyPass {
     CheckNeedsApplyPass = false,
     UpdateNeedsApplyPass = true,
   };
 
+  void applyMatchedPropertiesAndCustomPropertyAnimations(
+      StyleResolverState&,
+      const MatchResult&,
+      const Element* animatingElement);
+  CacheSuccess applyMatchedCache(StyleResolverState&, const MatchResult&);
+  void applyCustomProperties(StyleResolverState&,
+                             const MatchResult&,
+                             bool applyAnimations,
+                             const CacheSuccess&,
+                             NeedsApplyPass&);
+  void applyMatchedAnimationProperties(StyleResolverState&,
+                                       const MatchResult&,
+                                       const CacheSuccess&,
+                                       NeedsApplyPass&);
+  void applyMatchedStandardProperties(StyleResolverState&,
+                                      const MatchResult&,
+                                      const CacheSuccess&,
+                                      NeedsApplyPass&);
+  void calculateAnimationUpdate(StyleResolverState&,
+                                const Element* animatingElement);
+  bool applyAnimatedStandardProperties(StyleResolverState&, const Element*);
+
+  void applyCallbackSelectors(StyleResolverState&);
+
   template <CSSPropertyPriority priority, ShouldUpdateNeedsApplyPass>
   void applyMatchedProperties(StyleResolverState&,
                               const MatchedPropertiesRange&,
                               bool important,
                               bool inheritedOnly,
                               NeedsApplyPass&);
   template <CSSPropertyPriority priority, ShouldUpdateNeedsApplyPass>
   void applyProperties(StyleResolverState&,
                        const StylePropertySet* properties,
                        bool isImportant,
@@ skipping 39 matching lines @@
   bool m_printMediaType = false;
 
   unsigned m_styleSharingDepth = 0;
   HeapVector<Member<StyleSharingList>, styleSharingMaxDepth>
       m_styleSharingLists;
 };
 
 }  // namespace blink
 
 #endif  // StyleResolver_h