Oilpan: Unship oilpan from temporary animation objects

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"
@@ skipping 77 matching lines @@
         Member<InertEffect> effect;
         Timing specifiedTiming;
         RefPtrWillBeMember<StyleRuleKeyframes> styleRule;
         unsigned styleRuleVersion;
     };
 
     class UpdatedAnimationStyle {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
         struct CompositableStyleSnapshot {
-            DISALLOW_ALLOCATION();

[sof, 2015/09/02 13:02:12]

Won't do any harm to keep?

-
         public:
-            RefPtrWillBeMember<AnimatableValue> opacity;
-            RefPtrWillBeMember<AnimatableValue> transform;
-            RefPtrWillBeMember<AnimatableValue> webkitFilter;
-            RefPtrWillBeMember<AnimatableValue> backdropFilter;
-
-            DEFINE_INLINE_TRACE()
-            {
-                visitor->trace(opacity);
-                visitor->trace(transform);
-                visitor->trace(webkitFilter);
-                visitor->trace(backdropFilter);
-            }
+            RefPtr<AnimatableValue> opacity;
+            RefPtr<AnimatableValue> transform;
+            RefPtr<AnimatableValue> webkitFilter;
+            RefPtr<AnimatableValue> backdropFilter;
         };
 
         UpdatedAnimationStyle()
         {
         }
 
         UpdatedAnimationStyle(Animation* animation, KeyframeEffectModelBase* model, const UpdatedAnimationStyle::CompositableStyleSnapshot& snapshot)
             : animation(animation)
             , model(model)
             , snapshot(snapshot)
         {
         }
 
         DEFINE_INLINE_TRACE()
         {
             visitor->trace(animation);
             visitor->trace(model);
-            visitor->trace(snapshot);
         }
 
         Member<Animation> animation;
         Member<KeyframeEffectModelBase> model;
         CompositableStyleSnapshot snapshot;
     };
 
     CSSAnimationUpdate()
     {
     }
@@ skipping 93 matching lines @@
     const HeapHashSet<Member<const Animation>>& suppressedAnimations() const { return m_suppressedAnimations; }
     const Vector<AtomicString>& animationsWithPauseToggled() const { return m_animationsWithPauseToggled; }
     const HeapVector<UpdatedAnimation>& animationsWithUpdates() const { return m_animationsWithUpdates; }
     const HeapVector<UpdatedAnimationStyle>& animationsWithStyleUpdates() const { return m_animationsWithStyleUpdates; }
 
     struct NewTransition {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
         DEFINE_INLINE_TRACE()
         {
-            visitor->trace(from);
-            visitor->trace(to);
             visitor->trace(effect);
         }
 
         CSSPropertyID id;
-        RawPtrWillBeMember<const AnimatableValue> from;
-        RawPtrWillBeMember<const AnimatableValue> to;
+        const AnimatableValue* from;
+        const AnimatableValue* to;
         Member<InertEffect> effect;
     };
     using NewTransitionMap = HeapHashMap<CSSPropertyID, NewTransition>;
     const NewTransitionMap& newTransitions() const { return m_newTransitions; }
     const HashSet<CSSPropertyID>& cancelledTransitions() const { return m_cancelledTransitions; }
     const HashSet<CSSPropertyID>& finishedTransitions() const { return m_finishedTransitions; }
 
     void adoptActiveInterpolationsForAnimations(ActiveInterpolationMap& newMap) { newMap.swap(m_activeInterpolationsForAnimations); }
     void adoptActiveInterpolationsForTransitions(ActiveInterpolationMap& newMap) { newMap.swap(m_activeInterpolationsForTransitions); }
     const ActiveInterpolationMap& activeInterpolationsForAnimations() const { return m_activeInterpolationsForAnimations; }
@@ skipping 11 matching lines @@
             && m_newTransitions.isEmpty()
             && m_cancelledTransitions.isEmpty()
             && m_finishedTransitions.isEmpty()
             && m_activeInterpolationsForAnimations.isEmpty()
             && m_activeInterpolationsForTransitions.isEmpty();
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_newTransitions);
-#if ENABLE(OILPAN)
-        visitor->trace(m_activeInterpolationsForAnimations);
-        visitor->trace(m_activeInterpolationsForTransitions);
-#endif
         visitor->trace(m_newAnimations);
         visitor->trace(m_suppressedAnimations);
         visitor->trace(m_animationsWithUpdates);
         visitor->trace(m_animationsWithStyleUpdates);
     }
 
 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<NewAnimation> m_newAnimations;
     Vector<AtomicString> m_cancelledAnimationNames;
     HeapHashSet<Member<const Animation>> m_suppressedAnimations;
     Vector<AtomicString> m_animationsWithPauseToggled;
     HeapVector<UpdatedAnimation> m_animationsWithUpdates;
     HeapVector<UpdatedAnimationStyle> m_animationsWithStyleUpdates;
 
     NewTransitionMap m_newTransitions;
     HashSet<CSSPropertyID> m_cancelledTransitions;
     HashSet<CSSPropertyID> m_finishedTransitions;
 
     ActiveInterpolationMap m_activeInterpolationsForAnimations;
     ActiveInterpolationMap m_activeInterpolationsForTransitions;
+
+    friend class PendingAnimationUpdate;
 };
 
 } // 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