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/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> {
+class CSSAnimationUpdate final {
+    STACK_ALLOCATED();
 public:
     class NewAnimation {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
         NewAnimation()
             : styleRuleVersion(0)
         {
         }
 
         NewAnimation(AtomicString name, PassRefPtrWillBeRawPtr<InertEffect> effect, Timing timing, PassRefPtrWillBeRawPtr<StyleRuleKeyframes> styleRule)
@@ skipping 86 matching lines @@
             visitor->trace(animation);
             visitor->trace(model);
             visitor->trace(snapshot);
         }
 
         RawPtrWillBeMember<Animation> animation;
         RawPtrWillBeMember<KeyframeEffectModelBase> model;
         CompositableStyleSnapshot snapshot;
     };
 
+    ~CSSAnimationUpdate()
+    {
+#if ENABLE(OILPAN)
+        // For performance reasons, explicitly clear HeapVectors and
+        // HeapHashMaps to avoid giving a pressure on Oilpan's GC.
+        m_newAnimations.clear();
+        m_suppressedAnimations.clear();
+        m_animationsWithUpdates.clear();
+        m_animationsWithStyleUpdates.clear();
+        m_newTransitions.clear();
+        m_activeInterpolationsForAnimations.clear();
+        m_activeInterpolationsForTransitions.clear();
+#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();
-
 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;
+
+    friend class PendingAnimationUpdate;
+};
+
+class PendingAnimationUpdate final {
+    DISALLOW_ALLOCATION();

[alancutter (OOO until 2018), 2015/08/19 02:46:30]

Can we make CSSAnimationUpdate DISALLOW_ALLOCATION instead of STACK_ALLOCATED
and avoid creating a new PendingAnimationUpdate class?

[haraken, 2015/08/19 05:46:08]

That is a great suggestion :) Done.

+    WTF_MAKE_NONCOPYABLE(PendingAnimationUpdate);
+public:
+    PendingAnimationUpdate()
+        : m_isEmpty(true)
+    {
+    }
+
+    void setPendingUpdate(const CSSAnimationUpdate& update)
+    {
+        ASSERT(m_isEmpty);
+        m_isEmpty = false;
+        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();
+    }
+
+    bool isEmpty() const { return m_isEmpty; }
+    const WillBeHeapVector<CSSAnimationUpdate::NewAnimation>& newAnimations() const { return m_newAnimations; }
+    const Vector<AtomicString>& cancelledAnimationNames() const { return m_cancelledAnimationNames; }
+    const Vector<AtomicString>& animationsWithPauseToggled() const { return m_animationsWithPauseToggled; }
+    const WillBeHeapVector<CSSAnimationUpdate::UpdatedAnimation>& animationsWithUpdates() const { return m_animationsWithUpdates; }
+    const WillBeHeapVector<CSSAnimationUpdate::UpdatedAnimationStyle>& animationsWithStyleUpdates() const { return m_animationsWithStyleUpdates; }
+    const CSSAnimationUpdate::NewTransitionMap& newTransitions() const { return m_newTransitions; }
+    const HashSet<CSSPropertyID>& cancelledTransitions() const { return m_cancelledTransitions; }
+    const HashSet<CSSPropertyID>& finishedTransitions() const { return m_finishedTransitions; }
+
+    const ActiveInterpolationMap& activeInterpolationsForAnimations() const { return m_activeInterpolationsForAnimations; }
+    const ActiveInterpolationMap& activeInterpolationsForTransitions() const { return m_activeInterpolationsForTransitions; }
+    ActiveInterpolationMap& activeInterpolationsForAnimations() { return m_activeInterpolationsForAnimations; }
+
+    DEFINE_INLINE_TRACE()
+    {
+#if ENABLE(OILPAN)

[alancutter (OOO until 2018), 2015/08/19 02:46:30]

Is it necessary to #if here?

[haraken, 2015/08/19 05:46:08]

Unfortunately yes. The current oilpan cannot handle vistor->trace(complicated
collections) in non-oilpan mode.

+        visitor->trace(m_newAnimations);
+        visitor->trace(m_animationsWithUpdates);
+        visitor->trace(m_animationsWithStyleUpdates);
+        visitor->trace(m_newTransitions);
+        visitor->trace(m_activeInterpolationsForAnimations);
+        visitor->trace(m_activeInterpolationsForTransitions);
+#endif
+    }
+
+    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();
+        m_isEmpty = true;
+    }
+
+private:
+    WillBeHeapVector<CSSAnimationUpdate::NewAnimation> m_newAnimations;
+    WillBeHeapVector<CSSAnimationUpdate::UpdatedAnimation> m_animationsWithUpdates;
+    WillBeHeapVector<CSSAnimationUpdate::UpdatedAnimationStyle> m_animationsWithStyleUpdates;
+    CSSAnimationUpdate::NewTransitionMap m_newTransitions;
+    ActiveInterpolationMap m_activeInterpolationsForAnimations;
+    ActiveInterpolationMap m_activeInterpolationsForTransitions;
+    Vector<AtomicString> m_cancelledAnimationNames;
+    Vector<AtomicString> m_animationsWithPauseToggled;
+    HashSet<CSSPropertyID> m_cancelledTransitions;
+    HashSet<CSSPropertyID> m_finishedTransitions;
+    bool m_isEmpty;
 };
 
 } // 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