Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/svg/animation/SVGSMILElement.h

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 27 matching lines @@
 
 class ConditionEventListener;
 class SMILTimeContainer;
 class SVGSMILElement;
 
 template<typename T> class EventSender;
 using SMILEventSender = EventSender<SVGSMILElement>;
 
 // This class implements SMIL interval timing model as needed for SVG animation.
 class CORE_EXPORT SVGSMILElement : public SVGElement, public SVGTests {
-    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(SVGSMILElement);
+    USING_GARBAGE_COLLECTED_MIXIN(SVGSMILElement);
 public:
     SVGSMILElement(const QualifiedName&, Document&);
     ~SVGSMILElement() override;
 
     void parseAttribute(const QualifiedName&, const AtomicString&, const AtomicString&) override;
     void svgAttributeChanged(const QualifiedName&) override;
     InsertionNotificationRequest insertedInto(ContainerNode*) override;
     void removedFrom(ContainerNode*) override;
 
     virtual bool hasValidAttributeType() = 0;
@@ skipping 109 matching lines @@
         DidNotRestartInterval,
         DidRestartInterval
     };
 
     RestartedInterval maybeRestartInterval(SMILTime elapsed);
     void beginListChanged(SMILTime eventTime);
     void endListChanged(SMILTime eventTime);
 
     // This represents conditions on elements begin or end list that need to be resolved on runtime
     // for example <animate begin="otherElement.begin + 8s; button.click" ... />
-    class Condition : public NoBaseWillBeGarbageCollectedFinalized<Condition> {
+    class Condition : public GarbageCollectedFinalized<Condition> {
     public:
         enum Type {
             EventBase,
             Syncbase,
             AccessKey
         };
 
         Condition(Type, BeginOrEnd, const String& baseID, const String& name, SMILTime offset, int repeat = -1);
-        static PassOwnPtrWillBeRawPtr<Condition> create(Type type, BeginOrEnd beginOrEnd, const String& baseID, const String& name, SMILTime offset, int repeat = -1)
+        static RawPtr<Condition> create(Type type, BeginOrEnd beginOrEnd, const String& baseID, const String& name, SMILTime offset, int repeat = -1)
         {
-            return adoptPtrWillBeNoop(new Condition(type, beginOrEnd, baseID, name, offset, repeat));
+            return new Condition(type, beginOrEnd, baseID, name, offset, repeat);
         }
         ~Condition();
         DECLARE_TRACE();
 
         Type getType() const { return m_type; }
         BeginOrEnd getBeginOrEnd() const { return m_beginOrEnd; }
         String baseID() const { return m_baseID; }
         String name() const { return m_name; }
         SMILTime offset() const { return m_offset; }
         int repeat() const { return m_repeat; }
         SVGSMILElement* syncBase() const { return m_syncBase.get(); }
         void setSyncBase(SVGSMILElement* element) { m_syncBase = element; }
         ConditionEventListener* eventListener() const { return m_eventListener.get(); }
-        void setEventListener(PassRefPtrWillBeRawPtr<ConditionEventListener>);
+        void setEventListener(RawPtr<ConditionEventListener>);
 
     private:
         Type m_type;
         BeginOrEnd m_beginOrEnd;
         String m_baseID;
         String m_name;
         SMILTime m_offset;
         int m_repeat;
-        RefPtrWillBeMember<SVGSMILElement> m_syncBase;
-        RefPtrWillBeMember<ConditionEventListener> m_eventListener;
+        Member<SVGSMILElement> m_syncBase;
+        Member<ConditionEventListener> m_eventListener;
     };
     bool parseCondition(const String&, BeginOrEnd beginOrEnd);
     void parseBeginOrEnd(const String&, BeginOrEnd beginOrEnd);
     SVGElement* eventBaseFor(const Condition&);
 
     void disconnectSyncBaseConditions();
     void disconnectEventBaseConditions();
 
     // Event base timing
     void handleConditionEvent(Event*, Condition*);
 
     void notifyDependentsIntervalChanged();
     void createInstanceTimesFromSyncbase(SVGSMILElement* syncbase);
     void addSyncBaseDependent(SVGSMILElement*);
     void removeSyncBaseDependent(SVGSMILElement*);
 
     enum ActiveState {
         Inactive,
         Active,
         Frozen
     };
 
     QualifiedName m_attributeName;
 
     ActiveState determineActiveState(SMILTime elapsed) const;
     float calculateAnimationPercentAndRepeat(SMILTime elapsed, unsigned& repeat) const;
     SMILTime calculateNextProgressTime(SMILTime elapsed) const;
 
-    RawPtrWillBeMember<SVGElement> m_targetElement;
+    Member<SVGElement> m_targetElement;
 
-    WillBeHeapVector<OwnPtrWillBeMember<Condition>> m_conditions;
+    HeapVector<Member<Condition>> m_conditions;
     bool m_syncBaseConditionsConnected;
     bool m_hasEndEventConditions;
 
     bool m_isWaitingForFirstInterval;
     bool m_isScheduled;
 
-    using TimeDependentSet = WillBeHeapHashSet<RawPtrWillBeMember<SVGSMILElement>>;
+    using TimeDependentSet = HeapHashSet<Member<SVGSMILElement>>;
     TimeDependentSet m_syncBaseDependents;
 
     // Instance time lists
     Vector<SMILTimeWithOrigin> m_beginTimes;
     Vector<SMILTimeWithOrigin> m_endTimes;
 
     // This is the upcoming or current interval
     SMILInterval m_interval;
 
     SMILTime m_previousIntervalBegin;
 
     ActiveState m_activeState;
     float m_lastPercent;
     unsigned m_lastRepeat;
 
     SMILTime m_nextProgressTime;
 
-    RefPtrWillBeMember<SMILTimeContainer> m_timeContainer;
+    Member<SMILTimeContainer> m_timeContainer;
     unsigned m_documentOrderIndex;
 
     Vector<unsigned> m_repeatEventCountList;
 
     mutable SMILTime m_cachedDur;
     mutable SMILTime m_cachedRepeatDur;
     mutable SMILTime m_cachedRepeatCount;
     mutable SMILTime m_cachedMin;
     mutable SMILTime m_cachedMax;
 
     friend class ConditionEventListener;
 };
 
 inline bool isSVGSMILElement(const SVGElement& element)
 {
     return element.hasTagName(SVGNames::setTag) || element.hasTagName(SVGNames::animateTag) || element.hasTagName(SVGNames::animateMotionTag)
         || element.hasTagName(SVGNames::animateTransformTag) || element.hasTagName((SVGNames::discardTag));
 }
 
 DEFINE_SVGELEMENT_TYPE_CASTS_WITH_FUNCTION(SVGSMILElement);
 
 } // namespace blink
 
 #endif // SVGSMILElement_h