Removing blink::prefix

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 55 matching lines @@
 class VideoTrackList;
 
 // FIXME: The inheritance from MediaPlayerClient here should be private inheritance.
 // But it can't be until the Chromium WebMediaPlayerClientImpl class is fixed so it
 // no longer depends on typecasting a MediaPlayerClient to an HTMLMediaElement.
 
 class CORE_EXPORT HTMLMediaElement : public HTMLElement, public WillBeHeapSupplementable<HTMLMediaElement>, public MediaPlayerClient, public ActiveDOMObject {
     DEFINE_WRAPPERTYPEINFO();
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(HTMLMediaElement);
 public:
-    static blink::WebMimeRegistry::SupportsType supportsType(const ContentType&, const String& keySystem = String());
+    static WebMimeRegistry::SupportsType supportsType(const ContentType&, const String& keySystem = String());
 
     static void setMediaStreamRegistry(URLRegistry*);
     static bool isMediaStreamURL(const String& url);
 
     DECLARE_VIRTUAL_TRACE();
 #if ENABLE(WEB_AUDIO)
     void clearWeakMembers(Visitor*);
 #endif
-    blink::WebMediaPlayer* webMediaPlayer() const { return m_player ? m_player->webMediaPlayer() : 0; }
+    WebMediaPlayer* webMediaPlayer() const { return m_player ? m_player->webMediaPlayer() : 0; }
 
     virtual bool hasVideo() const { return false; }
     bool hasAudio() const;
 
     bool supportsSave() const;
 
-    blink::WebLayer* platformLayer() const;
+    WebLayer* platformLayer() const;
 
     enum DelayedActionType {
         LoadMediaResource = 1 << 0,
         LoadTextTrackResource = 1 << 1,
         TextTrackChangesNotification = 1 << 2
     };
     void scheduleDelayedAction(DelayedActionType);
 
     bool hasRemoteRoutes() const { return m_remoteRoutesAvailable; }
     bool isPlayingRemotely() const { return m_playingRemotely; }
@@ skipping 59 matching lines @@
 
     // play/pause toggling that uses the media controller if present. togglePlayStateWillPlay() is
     // true if togglePlayState() will call play() or unpause() on the media element or controller.
     bool togglePlayStateWillPlay() const;
     void togglePlayState();
 
     AudioTrackList& audioTracks();
     void audioTrackChanged();
 
     VideoTrackList& videoTracks();
-    void selectedVideoTrackChanged(blink::WebMediaPlayer::TrackId*);
+    void selectedVideoTrackChanged(WebMediaPlayer::TrackId*);
 
     PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, ExceptionState&);
 
     TextTrackList* textTracks();
     CueTimeline& cueTimeline();
 
     void addTextTrack(TextTrack*);
     void removeTextTrack(TextTrack*);
     void textTracksChanged();
     void notifyMediaPlayerOfTextTrackChanges();
 
     // Implements the "forget the media element's media-resource-specific tracks" algorithm in the HTML5 spec.
     void forgetResourceSpecificTracks();
 
     void didAddTrackElement(HTMLTrackElement*);
     void didRemoveTrackElement(HTMLTrackElement*);
 
-    blink::WebMediaPlayer::TrackId addAudioTrack(const String& id, blink::WebMediaPlayerClient::AudioTrackKind, const AtomicString& label, const AtomicString& language, bool enabled);
-    void removeAudioTrack(blink::WebMediaPlayer::TrackId);
-    blink::WebMediaPlayer::TrackId addVideoTrack(const String& id, blink::WebMediaPlayerClient::VideoTrackKind, const AtomicString& label, const AtomicString& language, bool selected);
-    void removeVideoTrack(blink::WebMediaPlayer::TrackId);
+    WebMediaPlayer::TrackId addAudioTrack(const String& id, WebMediaPlayerClient::AudioTrackKind, const AtomicString& label, const AtomicString& language, bool enabled);
+    void removeAudioTrack(WebMediaPlayer::TrackId);
+    WebMediaPlayer::TrackId addVideoTrack(const String& id, WebMediaPlayerClient::VideoTrackKind, const AtomicString& label, const AtomicString& language, bool selected);
+    void removeVideoTrack(WebMediaPlayer::TrackId);
 
-    virtual void mediaPlayerDidAddTextTrack(blink::WebInbandTextTrack*) override final;
-    virtual void mediaPlayerDidRemoveTextTrack(blink::WebInbandTextTrack*) override final;
+    virtual void mediaPlayerDidAddTextTrack(WebInbandTextTrack*) override final;
+    virtual void mediaPlayerDidRemoveTextTrack(WebInbandTextTrack*) override final;
     // FIXME: Remove this when WebMediaPlayerClientImpl::loadInternal does not depend on it.
     virtual KURL mediaPlayerPosterURL() override { return KURL(); }
 
     void honorUserPreferencesForAutomaticTextTrackSelection();
 
     bool textTracksAreReady() const;
     enum VisibilityChangeAssumption {
         AssumeNoVisibleChange,
         AssumeVisibleChange
     };
@@ skipping 112 matching lines @@
     virtual void willStopBeingFullscreenElement() override final;
     virtual bool isInteractiveContent() const override final;
     virtual void defaultEventHandler(Event*) override final;
 
     // ActiveDOMObject functions.
     virtual void stop() override final;
 
     virtual void updateDisplayState() { }
 
     void setReadyState(ReadyState);
-    void setNetworkState(blink::WebMediaPlayer::NetworkState);
+    void setNetworkState(WebMediaPlayer::NetworkState);
 
     virtual void mediaPlayerNetworkStateChanged() override final;
     virtual void mediaPlayerReadyStateChanged() override final;
     virtual void mediaPlayerTimeChanged() override final;
     virtual void mediaPlayerDurationChanged() override final;
     virtual void mediaPlayerPlaybackStateChanged() override final;
     virtual void mediaPlayerRequestFullscreen() override final;
     virtual void mediaPlayerRequestSeek(double) override final;
     virtual void mediaPlayerRepaint() override final;
     virtual void mediaPlayerSizeChanged() override final;
-    virtual void mediaPlayerSetWebLayer(blink::WebLayer*) override final;
-    virtual void mediaPlayerMediaSourceOpened(blink::WebMediaSource*) override final;
+    virtual void mediaPlayerSetWebLayer(WebLayer*) override final;
+    virtual void mediaPlayerMediaSourceOpened(WebMediaSource*) override final;
 
     void loadTimerFired(Timer<HTMLMediaElement>*);
     void progressEventTimerFired(Timer<HTMLMediaElement>*);
     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
     void startPlaybackProgressTimer();
     void startProgressEventTimer();
     void stopPeriodicTimers();
 
     void seek(double time);
     void finishSeek();
     void checkIfSeekNeeded();
     void addPlayedRange(double start, double end);
 
     void scheduleEvent(const AtomicString& eventName); // FIXME: Rename to scheduleNamedEvent for clarity.
 
     // loading
     void prepareForLoad();
     void loadInternal();
     void selectMediaResource();
     void loadResource(const KURL&, ContentType&, const String& keySystem);
     void startPlayerLoad();
     void setPlayerPreload();
-    blink::WebMediaPlayer::LoadType loadType() const;
+    WebMediaPlayer::LoadType loadType() const;
     void scheduleNextSourceChild();
     void loadNextSourceChild();
     void userCancelledLoad();
     void clearMediaPlayer(int flags);
     void clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
     bool havePotentialSourceChild();
     void noneSupported();
     void mediaEngineError(PassRefPtrWillBeRawPtr<MediaError>);
     void cancelPendingEventsAndCallbacks();
     void waitForSourceChange();
     void prepareToPlay();
 
     KURL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
 
-    void mediaLoadingFailed(blink::WebMediaPlayer::NetworkState);
+    void mediaLoadingFailed(WebMediaPlayer::NetworkState);
 
     // deferred loading (preload=none)
     bool loadIsDeferred() const;
     void deferLoad();
     void cancelDeferredLoad();
     void startDeferredLoad();
     void executeDeferredLoad();
     void deferredLoadTimerFired(Timer<HTMLMediaElement>*);
 
     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
@@ skipping 32 matching lines @@
 
     void changeNetworkStateFromLoadingToIdle();
 
     const AtomicString& mediaGroup() const;
     void setMediaGroup(const AtomicString&);
     void updateMediaController();
     bool isBlocked() const;
     bool isBlockedOnMediaController() const;
     bool isAutoplaying() const { return m_autoplaying; }
 
-    blink::WebMediaPlayer::CORSMode corsMode() const;
+    WebMediaPlayer::CORSMode corsMode() const;
 
     // Returns the "direction of playback" value as specified in the HTML5 spec.
     enum DirectionOfPlayback { Backward, Forward };
     DirectionOfPlayback directionOfPlayback() const;
 
     // Returns the "effective playback rate" value as specified in the HTML5 spec.
     double effectivePlaybackRate() const;
 
     // Creates placeholder AudioTrack and/or VideoTrack objects when WebMemediaPlayer objects
     // advertise they have audio and/or video, but don't explicitly signal them via
@@ skipping 56 matching lines @@
         // 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<MediaPlayer> m_player;
-    blink::WebLayer* m_webLayer;
+    WebLayer* m_webLayer;
 
     MediaPlayer::Preload m_preload;
 
     DisplayMode m_displayMode;
 
     RefPtrWillBeMember<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;
@@ skipping 63 matching lines @@
 inline bool isHTMLMediaElement(const HTMLElement& element)
 {
     return isHTMLAudioElement(element) || isHTMLVideoElement(element);
 }
 
 DEFINE_HTMLELEMENT_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
 
 } // namespace blink
 
 #endif // HTMLMediaElement_h