Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/html/HTMLMediaElement.h

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 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 48 matching lines @@
 class TextTrackContainer;
 class TextTrackList;
 class TimeRanges;
 class URLRegistry;
 class VideoTrackList;
 class WebAudioSourceProvider;
 class WebInbandTextTrack;
 class WebLayer;
 class WebRemotePlaybackClient;
 
-class CORE_EXPORT HTMLMediaElement : public HTMLElement, public WillBeHeapSupplementable<HTMLMediaElement>, public ActiveScriptWrappable, public ActiveDOMObject, private WebMediaPlayerClient {
+class CORE_EXPORT HTMLMediaElement : public HTMLElement, public HeapSupplementable<HTMLMediaElement>, public ActiveScriptWrappable, public ActiveDOMObject, private WebMediaPlayerClient {
     DEFINE_WRAPPERTYPEINFO();
-    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(HTMLMediaElement);
-    WILL_BE_USING_PRE_FINALIZER(HTMLMediaElement, dispose);
+    USING_GARBAGE_COLLECTED_MIXIN(HTMLMediaElement);
+    USING_PRE_FINALIZER(HTMLMediaElement, dispose);
 public:
     static WebMimeRegistry::SupportsType supportsType(const ContentType&);
 
     enum class RecordMetricsBehavior {
         DoNotRecord,
         DoRecord
     };
 
     static void setMediaStreamRegistry(URLRegistry*);
     static bool isMediaStreamURL(const String& url);
@@ skipping 158 matching lines @@
 
     AudioSourceProvider& getAudioSourceProvider() { return m_audioSourceProvider; }
 
     enum InvalidURLAction { DoNothing, Complain };
     bool isSafeToLoadURL(const KURL&, InvalidURLAction);
 
     // Checks to see if current media data is CORS-same-origin as the
     // specified origin.
     bool isMediaDataCORSSameOrigin(SecurityOrigin*) const;
 
-    void scheduleEvent(PassRefPtrWillBeRawPtr<Event>);
+    void scheduleEvent(RawPtr<Event>);
     void scheduleTimeupdateEvent(bool periodicEvent);
 
     // Returns the "effective media volume" value as specified in the HTML5 spec.
     double effectiveMediaVolume() const;
 
     // Predicates also used when dispatching wrapper creation (cf. [SpecialWrapFor] IDL attribute usage.)
     virtual bool isHTMLAudioElement() const { return false; }
     virtual bool isHTMLVideoElement() const { return false; }
 
     // Temporary callback for crbug.com/487345,402044
@@ skipping 200 matching lines @@
     void resolvePlayPromises();
     // TODO(mlamouri): this is used for cancellable tasks because we can't pass
     // parameters.
     void rejectPlayPromises();
     void rejectPlayPromises(ExceptionCode, const String&);
 
     UnthrottledTimer<HTMLMediaElement> m_loadTimer;
     UnthrottledTimer<HTMLMediaElement> m_progressEventTimer;
     UnthrottledTimer<HTMLMediaElement> m_playbackProgressTimer;
     UnthrottledTimer<HTMLMediaElement> m_audioTracksTimer;
-    PersistentWillBeMember<TimeRanges> m_playedTimeRanges;
-    OwnPtrWillBeMember<GenericEventQueue> m_asyncEventQueue;
+    Member<TimeRanges> m_playedTimeRanges;
+    Member<GenericEventQueue> m_asyncEventQueue;
 
     double m_playbackRate;
     double m_defaultPlaybackRate;
     NetworkState m_networkState;
     ReadyState m_readyState;
     ReadyState m_readyStateMaximum;
     KURL m_currentSrc;
 
-    PersistentWillBeMember<MediaError> m_error;
+    Member<MediaError> m_error;
 
     double m_volume;
     double m_lastSeekTime;
 
     double m_previousProgressTime;
 
     // Cached duration to suppress duplicate events if duration unchanged.
     double m_duration;
 
     // The last time a timeupdate event was sent (wall clock).
     double m_lastTimeUpdateEventWallTime;
 
     // The last time a timeupdate event was sent in movie time.
     double m_lastTimeUpdateEventMovieTime;
 
     // The default playback start position.
     double m_defaultPlaybackStartPosition;
 
     // Loading state.
     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
     LoadState m_loadState;
-    RefPtrWillBeMember<HTMLSourceElement> m_currentSourceNode;
-    RefPtrWillBeMember<Node> m_nextChildNodeToConsider;
+    Member<HTMLSourceElement> m_currentSourceNode;
+    Member<Node> m_nextChildNodeToConsider;
 
     // "Deferred loading" state (for preload=none).
     enum DeferredLoadState {
         // The load is not deferred.
         NotDeferred,
         // The load is deferred, and waiting for the task to set the
         // delaying-the-load-event flag (to false).
         WaitingForStopDelayingLoadEventTask,
         // The load is the deferred, and waiting for a triggering event.
         WaitingForTrigger,
         // The load is deferred, and waiting for the task to set the
         // delaying-the-load-event flag, after which the load will be executed.
         ExecuteOnStopDelayingLoadEventTask
     };
     DeferredLoadState m_deferredLoadState;
     Timer<HTMLMediaElement> m_deferredLoadTimer;
 
     OwnPtr<WebMediaPlayer> m_webMediaPlayer;
     WebLayer* m_webLayer;
 
     DisplayMode m_displayMode;
 
-    RefPtrWillBeMember<HTMLMediaSource> m_mediaSource;
+    Member<HTMLMediaSource> m_mediaSource;
 
     // Cached time value. Only valid when ready state is HAVE_METADATA or
     // higher, otherwise the current time is assumed to be zero.
     mutable double m_cachedTime;
 
     double m_fragmentEndTime;
 
     typedef unsigned PendingActionFlags;
     PendingActionFlags m_pendingActionFlags;
 
@@ skipping 17 matching lines @@
 
     bool m_ignorePreloadNone : 1;
     bool m_tracksAreReady : 1;
     bool m_processingPreferenceChange : 1;
     bool m_remoteRoutesAvailable : 1;
     bool m_playingRemotely : 1;
     bool m_isFinalizing : 1;
     // Whether this element is in overlay fullscreen mode.
     bool m_inOverlayFullscreenVideo : 1;
 
-    PersistentWillBeMember<AudioTrackList> m_audioTracks;
-    PersistentWillBeMember<VideoTrackList> m_videoTracks;
-    PersistentWillBeMember<TextTrackList> m_textTracks;
-    PersistentHeapVectorWillBeHeapVector<Member<TextTrack>> m_textTracksWhenResourceSelectionBegan;
+    Member<AudioTrackList> m_audioTracks;
+    Member<VideoTrackList> m_videoTracks;
+    Member<TextTrackList> m_textTracks;
+    HeapVector<Member<TextTrack>> m_textTracksWhenResourceSelectionBegan;
 
-    OwnPtrWillBeMember<CueTimeline> m_cueTimeline;
+    Member<CueTimeline> m_cueTimeline;
 
-    PersistentHeapVectorWillBeHeapVector<Member<ScriptPromiseResolver>> m_playResolvers;
+    HeapVector<Member<ScriptPromiseResolver>> m_playResolvers;
     OwnPtr<CancellableTaskFactory> m_playPromiseResolveTask;
     OwnPtr<CancellableTaskFactory> m_playPromiseRejectTask;
     ExceptionCode m_playPromiseErrorCode;
 
     // This is a weak reference, since m_audioSourceNode holds a reference to us.
     // FIXME: Oilpan: Consider making this a strongly traced pointer with oilpan where strong cycles are not a problem.
     GC_PLUGIN_IGNORE("http://crbug.com/404577")
-    RawPtrWillBeWeakMember<AudioSourceProviderClient> m_audioSourceNode;
+    WeakMember<AudioSourceProviderClient> m_audioSourceNode;
 
     // AudioClientImpl wraps an AudioSourceProviderClient.
     // When the audio format is known, Chromium calls setFormat().
     class AudioClientImpl final : public GarbageCollectedFinalized<AudioClientImpl>, public WebAudioSourceProviderClient {
     public:
         explicit AudioClientImpl(AudioSourceProviderClient* client)
             : m_client(client)
         {
         }
 
@@ skipping 24 matching lines @@
         void wrap(WebAudioSourceProvider*);
 
         // AudioSourceProvider
         void setClient(AudioSourceProviderClient*) override;
         void provideInput(AudioBus*, size_t framesToProcess) override;
 
         DECLARE_TRACE();
 
     private:
         WebAudioSourceProvider* m_webAudioSourceProvider;
-        PersistentWillBeMember<AudioClientImpl> m_client;
+        Member<AudioClientImpl> m_client;
         Mutex provideInputLock;
     };
 
     AudioSourceProviderImpl m_audioSourceProvider;
 
     class AutoplayHelperClientImpl;
 
     friend class Internals;
     friend class TrackDisplayUpdateScope;
     friend class AutoplayExperimentHelper;
     friend class MediaControlsTest;
 
-    OwnPtrWillBeMember<AutoplayExperimentHelper::Client> m_autoplayHelperClient;
-    OwnPtrWillBeMember<AutoplayExperimentHelper> m_autoplayHelper;
+    Member<AutoplayExperimentHelper::Client> m_autoplayHelperClient;
+    Member<AutoplayExperimentHelper> m_autoplayHelper;
 
     WebRemotePlaybackClient* m_remotePlaybackClient;
 
     static URLRegistry* s_mediaStreamRegistry;
 };
 
 inline bool isHTMLMediaElement(const HTMLElement& element)
 {
     return isHTMLAudioElement(element) || isHTMLVideoElement(element);
 }
 
 DEFINE_HTMLELEMENT_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
 
 } // namespace blink
 
 #endif // HTMLMediaElement_h