Use PropertyHandle instead of CSSPropertyID to identify CSS Transitions

third_party/WebKit/Source/core/animation/css/CSSAnimationUpdate.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CSSAnimationUpdate_h
 #define CSSAnimationUpdate_h
 
 #include "core/animation/EffectStack.h"
 #include "core/animation/InertEffect.h"
 #include "core/animation/Interpolation.h"
@@ skipping 144 matching lines @@
                        const Timing& specifiedTiming,
                        StyleRuleKeyframes* styleRule) {
     m_animationsWithUpdates.push_back(UpdatedCSSAnimation(
         index, animation, effect, specifiedTiming, styleRule));
     m_suppressedAnimations.insert(animation);
   }
   void updateCompositorKeyframes(Animation* animation) {
     m_updatedCompositorKeyframes.push_back(animation);
   }
 
-  void startTransition(CSSPropertyID id,
+  void startTransition(const PropertyHandle& property,
                        RefPtr<AnimatableValue> from,
                        RefPtr<AnimatableValue> to,
                        PassRefPtr<AnimatableValue> reversingAdjustedStartValue,
                        double reversingShorteningFactor,
                        const InertEffect& effect) {
     NewTransition newTransition;
-    newTransition.id = id;
+    newTransition.property = property;
     newTransition.from = std::move(from);
     newTransition.to = std::move(to);
     newTransition.reversingAdjustedStartValue = reversingAdjustedStartValue;
     newTransition.reversingShorteningFactor = reversingShorteningFactor;
     newTransition.effect = &effect;
-    m_newTransitions.set(id, newTransition);
+    m_newTransitions.set(property, newTransition);
   }
-  bool isCancelledTransition(CSSPropertyID id) const {
-    return m_cancelledTransitions.contains(id);
+  bool isCancelledTransition(const PropertyHandle& property) const {
+    return m_cancelledTransitions.contains(property);
   }
-  void cancelTransition(CSSPropertyID id) { m_cancelledTransitions.insert(id); }
-  void finishTransition(CSSPropertyID id) { m_finishedTransitions.insert(id); }
+  void cancelTransition(const PropertyHandle& property) {
+    m_cancelledTransitions.insert(property);
+  }
+  void finishTransition(const PropertyHandle& property) {
+    m_finishedTransitions.insert(property);
+  }
 
   const HeapVector<NewCSSAnimation>& newAnimations() const {
     return m_newAnimations;
   }
   const Vector<size_t>& cancelledAnimationIndices() const {
     return m_cancelledAnimationIndices;
   }
   const HeapHashSet<Member<const Animation>>& suppressedAnimations() const {
     return m_suppressedAnimations;
   }
   const Vector<size_t>& animationIndicesWithPauseToggled() const {
     return m_animationIndicesWithPauseToggled;
   }
   const HeapVector<UpdatedCSSAnimation>& animationsWithUpdates() const {
     return m_animationsWithUpdates;
   }
   const HeapVector<Member<Animation>>& updatedCompositorKeyframes() const {
     return m_updatedCompositorKeyframes;
   }
 
   struct NewTransition {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
    public:
     DEFINE_INLINE_TRACE() { visitor->trace(effect); }
 
-    CSSPropertyID id;
+    PropertyHandle property = HashTraits<blink::PropertyHandle>::emptyValue();
     RefPtr<AnimatableValue> from;
     RefPtr<AnimatableValue> to;
     RefPtr<AnimatableValue> reversingAdjustedStartValue;
     double reversingShorteningFactor;
     Member<const InertEffect> effect;
   };
-  using NewTransitionMap = HeapHashMap<CSSPropertyID, NewTransition>;
+  using NewTransitionMap = HeapHashMap<PropertyHandle, NewTransition>;
   const NewTransitionMap& newTransitions() const { return m_newTransitions; }
-  const HashSet<CSSPropertyID>& cancelledTransitions() const {
+  const HashSet<PropertyHandle>& cancelledTransitions() const {
     return m_cancelledTransitions;
   }
-  const HashSet<CSSPropertyID>& finishedTransitions() const {
+  const HashSet<PropertyHandle>& finishedTransitions() const {
     return m_finishedTransitions;
   }
 
   void adoptActiveInterpolationsForAnimations(ActiveInterpolationsMap& newMap) {
     newMap.swap(m_activeInterpolationsForAnimations);
   }
   void adoptActiveInterpolationsForTransitions(
       ActiveInterpolationsMap& newMap) {
     newMap.swap(m_activeInterpolationsForTransitions);
   }
@@ skipping 33 matching lines @@
   // with the same name, due to the way in which we split up animations with
   // incomplete keyframes.
   HeapVector<NewCSSAnimation> m_newAnimations;
   Vector<size_t> m_cancelledAnimationIndices;
   HeapHashSet<Member<const Animation>> m_suppressedAnimations;
   Vector<size_t> m_animationIndicesWithPauseToggled;
   HeapVector<UpdatedCSSAnimation> m_animationsWithUpdates;
   HeapVector<Member<Animation>> m_updatedCompositorKeyframes;
 
   NewTransitionMap m_newTransitions;
-  HashSet<CSSPropertyID> m_cancelledTransitions;
-  HashSet<CSSPropertyID> m_finishedTransitions;
+  HashSet<PropertyHandle> m_cancelledTransitions;
+  HashSet<PropertyHandle> m_finishedTransitions;
 
   ActiveInterpolationsMap m_activeInterpolationsForAnimations;
   ActiveInterpolationsMap m_activeInterpolationsForTransitions;
 
   friend class PendingAnimationUpdate;
 };
 
 }  // namespace blink
 
 #endif