Revert of Apply custom property animation

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 192 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&);
 
-  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;
-    }
-  };
+  void applyMatchedProperties(StyleResolverState&, const MatchResult&);
+  bool applyAnimatedProperties(StyleResolverState&,
+                               const Element* animatingElement);
+  void applyCallbackSelectors(StyleResolverState&);
 
   // 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 44 matching lines @@
   bool m_printMediaType;
 
   unsigned m_styleSharingDepth;
   HeapVector<Member<StyleSharingList>, styleSharingMaxDepth>
       m_styleSharingLists;
 };
 
 }  // namespace blink
 
 #endif  // StyleResolver_h