Remove tons of OILPAN.

sky/engine/core/animation/css/CSSAnimations.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 71 matching lines @@
         newTransition.to = to;
         newTransition.animation = animation;
         m_newTransitions.set(id, newTransition);
     }
     bool isCancelledTransition(CSSPropertyID id) const { return m_cancelledTransitions.contains(id); }
     void cancelTransition(CSSPropertyID id) { m_cancelledTransitions.add(id); }
 
     struct NewAnimation {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
-        void trace(Visitor* visitor)
-        {
-            visitor->trace(animation);
-        }
-
         AtomicString name;
         RefPtr<InertAnimation> animation;
     };
     const Vector<NewAnimation>& newAnimations() const { return m_newAnimations; }
     const Vector<AtomicString>& cancelledAnimationNames() const { return m_cancelledAnimationNames; }
     const HashSet<RawPtr<const AnimationPlayer> >& cancelledAnimationAnimationPlayers() const { return m_cancelledAnimationPlayers; }
     const Vector<AtomicString>& animationsWithPauseToggled() const { return m_animationsWithPauseToggled; }
 
     struct NewTransition {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
-        void trace(Visitor* visitor)
-        {
-            visitor->trace(from);
-            visitor->trace(to);
-            visitor->trace(animation);
-        }
-
         CSSPropertyID id;
         CSSPropertyID eventId;
         RawPtr<const AnimatableValue> from;
         RawPtr<const AnimatableValue> to;
         RefPtr<InertAnimation> animation;
     };
     typedef HashMap<CSSPropertyID, NewTransition> NewTransitionMap;
     const NewTransitionMap& newTransitions() const { return m_newTransitions; }
     const HashSet<CSSPropertyID>& cancelledTransitions() const { return m_cancelledTransitions; }
 
     void adoptActiveInterpolationsForAnimations(HashMap<CSSPropertyID, RefPtr<Interpolation> >& newMap) { newMap.swap(m_activeInterpolationsForAnimations); }
     void adoptActiveInterpolationsForTransitions(HashMap<CSSPropertyID, RefPtr<Interpolation> >& newMap) { newMap.swap(m_activeInterpolationsForTransitions); }
     const HashMap<CSSPropertyID, RefPtr<Interpolation> >& activeInterpolationsForAnimations() const { return m_activeInterpolationsForAnimations; }
     const HashMap<CSSPropertyID, RefPtr<Interpolation> >& activeInterpolationsForTransitions() const { return m_activeInterpolationsForTransitions; }
     HashMap<CSSPropertyID, RefPtr<Interpolation> >& activeInterpolationsForAnimations() { return m_activeInterpolationsForAnimations; }
 
     bool isEmpty() const
     {
         return m_newAnimations.isEmpty()
             && m_cancelledAnimationNames.isEmpty()
             && m_cancelledAnimationPlayers.isEmpty()
             && m_animationsWithPauseToggled.isEmpty()
             && m_newTransitions.isEmpty()
             && m_cancelledTransitions.isEmpty()
             && m_activeInterpolationsForAnimations.isEmpty()
             && m_activeInterpolationsForTransitions.isEmpty();
     }
 
-    void trace(Visitor*);
-
 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.
     Vector<NewAnimation> m_newAnimations;
     Vector<AtomicString> m_cancelledAnimationNames;
     HashSet<RawPtr<const AnimationPlayer> > m_cancelledAnimationPlayers;
     Vector<AtomicString> m_animationsWithPauseToggled;
 
@@ skipping 18 matching lines @@
     static const StylePropertyShorthand& animatableProperties();
     static bool isAllowedAnimation(CSSPropertyID);
     // FIXME: We should change the Element* to a const Element*
     static PassOwnPtr<CSSAnimationUpdate> calculateUpdate(Element*, const Element& parentElement, const RenderStyle&, RenderStyle* parentStyle, StyleResolver*);
 
     void setPendingUpdate(PassOwnPtr<CSSAnimationUpdate> update) { m_pendingUpdate = update; }
     void maybeApplyPendingUpdate(Element*);
     bool isEmpty() const { return m_animations.isEmpty() && m_transitions.isEmpty() && !m_pendingUpdate; }
     void cancel();
 
-    void trace(Visitor*);
-
 private:
     struct RunningTransition {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
-        void trace(Visitor* visitor)
-        {
-            visitor->trace(from);
-            visitor->trace(to);
-            visitor->trace(player);
-        }
-
         RefPtr<AnimationPlayer> player;
         RawPtr<const AnimatableValue> from;
         RawPtr<const AnimatableValue> to;
     };
 
     typedef HashMap<AtomicString, RefPtr<AnimationPlayer> > AnimationMap;
     AnimationMap m_animations;
 
     typedef HashMap<CSSPropertyID, RunningTransition> TransitionMap;
     TransitionMap m_transitions;
@@ skipping 12 matching lines @@
     class AnimationEventDelegate final : public AnimationNode::EventDelegate {
     public:
         AnimationEventDelegate(Element* target, const AtomicString& name)
             : m_target(target)
             , m_name(name)
             , m_previousPhase(AnimationNode::PhaseNone)
             , m_previousIteration(nullValue())
         {
         }
         virtual void onEventCondition(const AnimationNode*) override;
-        virtual void trace(Visitor*) override;
 
     private:
         void maybeDispatch(Document::ListenerType, const AtomicString& eventName, double elapsedTime);
         RawPtr<Element> m_target;
         const AtomicString m_name;
         AnimationNode::Phase m_previousPhase;
         double m_previousIteration;
     };
 
     class TransitionEventDelegate final : public AnimationNode::EventDelegate {
     public:
         TransitionEventDelegate(Element* target, CSSPropertyID property)
             : m_target(target)
             , m_property(property)
             , m_previousPhase(AnimationNode::PhaseNone)
         {
         }
         virtual void onEventCondition(const AnimationNode*) override;
-        virtual void trace(Visitor*) override;
 
     private:
         RawPtr<Element> m_target;
         const CSSPropertyID m_property;
         AnimationNode::Phase m_previousPhase;
     };
 };
 
 } // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::CSSAnimationUpdate::NewAnimation);
 
 #endif