Split transitions update storage between custom and standard properties

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 88 matching lines @@
 
   ~CSSAnimationUpdate() {}
 
   void copy(const CSSAnimationUpdate& update) {
     DCHECK(isEmpty());
     m_newAnimations = update.newAnimations();
     m_animationsWithUpdates = update.animationsWithUpdates();
     m_newTransitions = update.newTransitions();
     m_activeInterpolationsForAnimations =
         update.activeInterpolationsForAnimations();
-    m_activeInterpolationsForTransitions =
-        update.activeInterpolationsForTransitions();
+    m_activeInterpolationsForCustomTransitions =
+        update.activeInterpolationsForCustomTransitions();
+    m_activeInterpolationsForStandardTransitions =
+        update.activeInterpolationsForStandardTransitions();
     m_cancelledAnimationIndices = update.cancelledAnimationIndices();
     m_animationIndicesWithPauseToggled =
         update.animationIndicesWithPauseToggled();
     m_cancelledTransitions = update.cancelledTransitions();
     m_finishedTransitions = update.finishedTransitions();
     m_updatedCompositorKeyframes = update.updatedCompositorKeyframes();
   }
 
   void clear() {
     m_newAnimations.clear();
     m_animationsWithUpdates.clear();
     m_newTransitions.clear();
     m_activeInterpolationsForAnimations.clear();
-    m_activeInterpolationsForTransitions.clear();
+    m_activeInterpolationsForCustomTransitions.clear();
+    m_activeInterpolationsForStandardTransitions.clear();
     m_cancelledAnimationIndices.clear();
     m_animationIndicesWithPauseToggled.clear();
     m_cancelledTransitions.clear();
     m_finishedTransitions.clear();
     m_updatedCompositorKeyframes.clear();
   }
 
   void startAnimation(const AtomicString& animationName,
                       size_t nameIndex,
                       const InertEffect& effect,
@@ skipping 89 matching lines @@
   const HashSet<PropertyHandle>& cancelledTransitions() const {
     return m_cancelledTransitions;
   }
   const HashSet<PropertyHandle>& finishedTransitions() const {
     return m_finishedTransitions;
   }
 
   void adoptActiveInterpolationsForAnimations(ActiveInterpolationsMap& newMap) {
     newMap.swap(m_activeInterpolationsForAnimations);
   }
-  void adoptActiveInterpolationsForTransitions(
+  void adoptActiveInterpolationsForCustomTransitions(
       ActiveInterpolationsMap& newMap) {
-    newMap.swap(m_activeInterpolationsForTransitions);
+    newMap.swap(m_activeInterpolationsForCustomTransitions);
+  }
+  void adoptActiveInterpolationsForStandardTransitions(
+      ActiveInterpolationsMap& newMap) {
+    newMap.swap(m_activeInterpolationsForStandardTransitions);
   }
   const ActiveInterpolationsMap& activeInterpolationsForAnimations() const {
     return m_activeInterpolationsForAnimations;
   }
-  const ActiveInterpolationsMap& activeInterpolationsForTransitions() const {
-    return m_activeInterpolationsForTransitions;
+  const ActiveInterpolationsMap& activeInterpolationsForCustomTransitions()
+      const {
+    return m_activeInterpolationsForCustomTransitions;
+  }
+  const ActiveInterpolationsMap& activeInterpolationsForStandardTransitions()
+      const {
+    return m_activeInterpolationsForStandardTransitions;
   }
   ActiveInterpolationsMap& activeInterpolationsForAnimations() {
     return m_activeInterpolationsForAnimations;
   }
 
   bool isEmpty() const {
     return m_newAnimations.isEmpty() && m_cancelledAnimationIndices.isEmpty() &&
            m_suppressedAnimations.isEmpty() &&
            m_animationIndicesWithPauseToggled.isEmpty() &&
            m_animationsWithUpdates.isEmpty() && m_newTransitions.isEmpty() &&
            m_cancelledTransitions.isEmpty() &&
            m_finishedTransitions.isEmpty() &&
            m_activeInterpolationsForAnimations.isEmpty() &&
-           m_activeInterpolationsForTransitions.isEmpty() &&
+           m_activeInterpolationsForCustomTransitions.isEmpty() &&
+           m_activeInterpolationsForStandardTransitions.isEmpty() &&
            m_updatedCompositorKeyframes.isEmpty();
   }
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_newTransitions);
     visitor->trace(m_newAnimations);
     visitor->trace(m_suppressedAnimations);
     visitor->trace(m_animationsWithUpdates);
     visitor->trace(m_updatedCompositorKeyframes);
   }
 
  private:
   // Order is significant since it defines the order in which new animations
   // will be started. Note that there may be multiple animations present
   // 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<PropertyHandle> m_cancelledTransitions;
   HashSet<PropertyHandle> m_finishedTransitions;
 
   ActiveInterpolationsMap m_activeInterpolationsForAnimations;
-  ActiveInterpolationsMap m_activeInterpolationsForTransitions;
+  ActiveInterpolationsMap m_activeInterpolationsForCustomTransitions;
+  ActiveInterpolationsMap m_activeInterpolationsForStandardTransitions;
 
   friend class PendingAnimationUpdate;
 };
 
 }  // namespace blink
 
 #endif