Make CSSAnimationUpdate stack-allocated

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/AnimationStack.h"
+#include "core/animation/InertEffect.h"
 #include "core/animation/Interpolation.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/animation/css/CSSPropertyEquality.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/layout/LayoutObject.h"
 #include "wtf/Allocator.h"
 #include "wtf/HashMap.h"
 #include "wtf/Vector.h"
 #include "wtf/text/AtomicString.h"
 
 namespace blink {
 
 class Animation;
-class InertEffect;
 
 // This class stores the CSS Animations/Transitions information we use during a style recalc.
 // This includes updates to animations/transitions as well as the Interpolations to be applied.
-class CSSAnimationUpdate final : public NoBaseWillBeGarbageCollectedFinalized<CSSAnimationUpdate> {
-    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(CSSAnimationUpdate);
+class CSSAnimationUpdate final {
+    DISALLOW_ALLOCATION();
     WTF_MAKE_NONCOPYABLE(CSSAnimationUpdate);
 public:
-    CSSAnimationUpdate() { }
-
     class NewAnimation {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
         NewAnimation()
             : styleRuleVersion(0)
         {
         }
 
         NewAnimation(AtomicString name, PassRefPtrWillBeRawPtr<InertEffect> effect, Timing timing, PassRefPtrWillBeRawPtr<StyleRuleKeyframes> styleRule)
             : name(name)
@@ skipping 85 matching lines @@
             visitor->trace(animation);
             visitor->trace(model);
             visitor->trace(snapshot);
         }
 
         RawPtrWillBeMember<Animation> animation;
         RawPtrWillBeMember<KeyframeEffectModelBase> model;
         CompositableStyleSnapshot snapshot;
     };
 
+    CSSAnimationUpdate()
+#if ENABLE(ASSERT)
+        : m_isCleared(true)
+#endif
+    {
+    }
+
+    ~CSSAnimationUpdate()
+    {
+#if ENABLE(OILPAN)
+        // For performance reasons, explicitly clear HeapVectors and
+        // HeapHashMaps to avoid giving a pressure on Oilpan's GC.
+        clear();
+#endif
+    }
+
+    void copy(const CSSAnimationUpdate& update)
+    {
+#if ENABLE(ASSERT)
+        ASSERT(m_isCleared);
+        m_isCleared = false;
+#endif

[alancutter (OOO until 2018), 2015/08/20 02:06:58]

I'm not sure it's worthwhile adding 4 ifdefs for a relatively minor assertion. I
think it's fine to just assert on isEmpty() instead.

[haraken, 2015/08/20 03:01:25]

Done.

+        m_newAnimations = update.newAnimations();
+        m_animationsWithUpdates = update.animationsWithUpdates();
+        m_animationsWithStyleUpdates = update.animationsWithStyleUpdates();
+        m_newTransitions = update.newTransitions();
+        m_activeInterpolationsForAnimations = update.activeInterpolationsForAnimations();
+        m_activeInterpolationsForTransitions = update.activeInterpolationsForTransitions();
+        m_cancelledAnimationNames = update.cancelledAnimationNames();
+        m_animationsWithPauseToggled = update.animationsWithPauseToggled();
+        m_cancelledTransitions = update.cancelledTransitions();
+        m_finishedTransitions = update.finishedTransitions();
+    }
+
+    void clear()
+    {
+        m_newAnimations.clear();
+        m_animationsWithUpdates.clear();
+        m_animationsWithStyleUpdates.clear();
+        m_newTransitions.clear();
+        m_activeInterpolationsForAnimations.clear();
+        m_activeInterpolationsForTransitions.clear();
+        m_cancelledAnimationNames.clear();
+        m_animationsWithPauseToggled.clear();
+        m_cancelledTransitions.clear();
+        m_finishedTransitions.clear();
+#if ENABLE(ASSERT)
+        m_isCleared = true;
+#endif
+    }
+
     void startAnimation(const AtomicString& animationName, PassRefPtrWillBeRawPtr<InertEffect> effect, const Timing& timing, PassRefPtrWillBeRawPtr<StyleRuleKeyframes> styleRule)
     {
         effect->setName(animationName);
         m_newAnimations.append(NewAnimation(animationName, effect, timing, styleRule));
     }
     // Returns whether animation has been suppressed and should be filtered during style application.
     bool isSuppressedAnimation(const Animation* animation) const { return m_suppressedAnimations.contains(animation); }
     void cancelAnimation(const AtomicString& name, Animation& animation)
     {
         m_cancelledAnimationNames.append(name);
@@ skipping 80 matching lines @@
             && m_animationsWithPauseToggled.isEmpty()
             && m_animationsWithUpdates.isEmpty()
             && m_animationsWithStyleUpdates.isEmpty()
             && m_newTransitions.isEmpty()
             && m_cancelledTransitions.isEmpty()
             && m_finishedTransitions.isEmpty()
             && m_activeInterpolationsForAnimations.isEmpty()
             && m_activeInterpolationsForTransitions.isEmpty();
     }
 
-    DECLARE_TRACE();
+    DEFINE_INLINE_TRACE()
+    {
+#if ENABLE(OILPAN)
+        visitor->trace(m_newTransitions);
+        visitor->trace(m_activeInterpolationsForAnimations);
+        visitor->trace(m_activeInterpolationsForTransitions);
+        visitor->trace(m_newAnimations);
+        visitor->trace(m_suppressedAnimations);
+        visitor->trace(m_animationsWithUpdates);
+        visitor->trace(m_animationsWithStyleUpdates);
+#endif
+    }
 
 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.
     WillBeHeapVector<NewAnimation> m_newAnimations;
     Vector<AtomicString> m_cancelledAnimationNames;
     WillBeHeapHashSet<RawPtrWillBeMember<const Animation>> m_suppressedAnimations;
     Vector<AtomicString> m_animationsWithPauseToggled;
     WillBeHeapVector<UpdatedAnimation> m_animationsWithUpdates;
     WillBeHeapVector<UpdatedAnimationStyle> m_animationsWithStyleUpdates;
 
     NewTransitionMap m_newTransitions;
     HashSet<CSSPropertyID> m_cancelledTransitions;
     HashSet<CSSPropertyID> m_finishedTransitions;
 
     ActiveInterpolationMap m_activeInterpolationsForAnimations;
     ActiveInterpolationMap m_activeInterpolationsForTransitions;
+
+#if ENABLE(ASSERT)
+    bool m_isCleared;
+#endif
 };
 
 } // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::CSSAnimationUpdate::NewAnimation);
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::CSSAnimationUpdate::UpdatedAnimation);
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::CSSAnimationUpdate::UpdatedAnimationStyle);
 
 #endif