#include "core/dom/ActiveDOMObject.h"
#include "core/events/GenericEventQueue.h"
#include "core/html/HTMLElement.h"
-#include "core/html/MediaControllerInterface.h"
#include "core/html/track/TextTrack.h"
#include "core/html/track/TextTrackCue.h"
#include "core/html/track/vtt/VTTCue.h"
#include "platform/PODIntervalTree.h"
+#include "platform/Supplementable.h"
#include "platform/graphics/media/MediaPlayer.h"
+#include "public/platform/WebMediaPlayerClient.h"
#include "public/platform/WebMimeRegistry.h"
namespace blink {
-class WebContentDecryptionModule;
class WebInbandTextTrack;
class WebLayer;
}
-namespace WebCore {
+namespace blink {
#if ENABLE(WEB_AUDIO)
class AudioSourceProvider;
-class MediaElementAudioSourceNode;
+class AudioSourceProviderClient;
#endif
+class AudioTrackList;
class ContentType;
class Event;
class ExceptionState;
class MediaController;
class MediaControls;
class MediaError;
-class MediaKeys;
class HTMLMediaSource;
class TextTrackList;
class TimeRanges;
+class URLRegistry;
+class VideoTrackList;
typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
typedef CueIntervalTree::IntervalType CueInterval;
// 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 HTMLMediaElement : public HTMLElement, public MediaPlayerClient, public ActiveDOMObject, public MediaControllerInterface
- , private TextTrackClient
-{
+class 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());
- MediaPlayer* player() const { return m_player.get(); }
+ static void setMediaStreamRegistry(URLRegistry*);
+ static bool isMediaStreamURL(const String& url);
+
+ virtual void trace(Visitor*) override;
+#if ENABLE(WEB_AUDIO)
+ void clearWeakMembers(Visitor*);
+#endif
+ blink::WebMediaPlayer* webMediaPlayer() const { return m_player ? m_player->webMediaPlayer() : 0; }
- virtual bool isVideo() const = 0;
- virtual bool hasVideo() const OVERRIDE { return false; }
- virtual bool hasAudio() const OVERRIDE FINAL;
+ virtual bool hasVideo() const { return false; }
+ bool hasAudio() const;
bool supportsSave() const;
bool isActive() const { return m_active; }
+ bool hasRemoteRoutes() const { return m_remoteRoutesAvailable; }
+ bool isPlayingRemotely() const { return m_playingRemotely; }
+
// error state
- PassRefPtr<MediaError> error() const;
+ PassRefPtrWillBeRawPtr<MediaError> error() const;
// network state
void setSrc(const AtomicString&);
String preload() const;
void setPreload(const AtomicString&);
- virtual PassRefPtr<TimeRanges> buffered() const OVERRIDE FINAL;
+ PassRefPtrWillBeRawPtr<TimeRanges> buffered() const;
void load();
String canPlayType(const String& mimeType, const String& keySystem = String()) const;
// ready state
- virtual ReadyState readyState() const OVERRIDE FINAL;
+ enum ReadyState { HAVE_NOTHING, HAVE_METADATA, HAVE_CURRENT_DATA, HAVE_FUTURE_DATA, HAVE_ENOUGH_DATA };
+ ReadyState readyState() const;
bool seeking() const;
// playback state
- virtual double currentTime() const OVERRIDE FINAL;
- virtual void setCurrentTime(double, ExceptionState&) OVERRIDE FINAL;
- virtual double duration() const OVERRIDE FINAL;
- virtual bool paused() const OVERRIDE FINAL;
- virtual double defaultPlaybackRate() const OVERRIDE FINAL;
- virtual void setDefaultPlaybackRate(double) OVERRIDE FINAL;
- virtual double playbackRate() const OVERRIDE FINAL;
- virtual void setPlaybackRate(double) OVERRIDE FINAL;
+ double currentTime() const;
+ void setCurrentTime(double, ExceptionState&);
+ double duration() const;
+ bool paused() const;
+ double defaultPlaybackRate() const;
+ void setDefaultPlaybackRate(double);
+ double playbackRate() const;
+ void setPlaybackRate(double);
void updatePlaybackRate();
- virtual PassRefPtr<TimeRanges> played() OVERRIDE FINAL;
- virtual PassRefPtr<TimeRanges> seekable() const OVERRIDE FINAL;
+ PassRefPtrWillBeRawPtr<TimeRanges> played();
+ PassRefPtrWillBeRawPtr<TimeRanges> seekable() const;
bool ended() const;
bool autoplay() const;
bool loop() const;
- void setLoop(bool b);
- virtual void play() OVERRIDE FINAL;
- virtual void pause() OVERRIDE FINAL;
+ void setLoop(bool);
+ void play();
+ void pause();
+ void requestRemotePlayback();
+ void requestRemotePlaybackControl();
// statistics
unsigned webkitAudioDecodedByteCount() const;
// media source extensions
void closeMediaSource();
- void durationChanged(double duration);
-
- // encrypted media extensions (v0.1b)
- void webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionState&);
- void webkitGenerateKeyRequest(const String& keySystem, ExceptionState&);
- void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionState&);
- void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionState&);
- void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionState&);
-
- DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
- DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
- DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
- DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitneedkey);
-
- // encrypted media extensions (WD)
- MediaKeys* mediaKeys() const { return m_mediaKeys.get(); }
- void setMediaKeys(MediaKeys*, ExceptionState&);
- DEFINE_ATTRIBUTE_EVENT_LISTENER(needkey);
+ void durationChanged(double duration, bool requestSeek);
// controls
- bool controls() const;
- void setControls(bool);
- virtual double volume() const OVERRIDE FINAL;
- virtual void setVolume(double, ExceptionState&) OVERRIDE FINAL;
- virtual bool muted() const OVERRIDE FINAL;
- virtual void setMuted(bool) OVERRIDE FINAL;
-
+ bool shouldShowControls() const;
+ double volume() const;
+ void setVolume(double, ExceptionState&);
+ bool muted() const;
+ void setMuted(bool);
+
+ // 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();
- virtual void beginScrubbing() OVERRIDE FINAL;
- virtual void endScrubbing() OVERRIDE FINAL;
- virtual bool canPlay() const OVERRIDE FINAL;
+ AudioTrackList& audioTracks();
+ void audioTrackChanged();
- double percentLoaded() const;
+ VideoTrackList& videoTracks();
+ void selectedVideoTrackChanged(blink::WebMediaPlayer::TrackId*);
- PassRefPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, ExceptionState&);
- PassRefPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, ExceptionState& exceptionState) { return addTextTrack(kind, label, emptyAtom, exceptionState); }
- PassRefPtr<TextTrack> addTextTrack(const AtomicString& kind, ExceptionState& exceptionState) { return addTextTrack(kind, emptyAtom, emptyAtom, exceptionState); }
+ PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, ExceptionState&);
+ PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, ExceptionState& exceptionState) { return addTextTrack(kind, label, emptyAtom, exceptionState); }
+ PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, ExceptionState& exceptionState) { return addTextTrack(kind, emptyAtom, emptyAtom, exceptionState); }
TextTrackList* textTracks();
CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
- void addTrack(TextTrack*);
- void removeTrack(TextTrack*);
- void removeAllInbandTracks();
- void closeCaptionTracksChanged();
+ void addTextTrack(TextTrack*);
+ void removeTextTrack(TextTrack*);
+ void textTracksChanged();
void notifyMediaPlayerOfTextTrackChanges();
- void didAddTrack(HTMLTrackElement*);
- void didRemoveTrack(HTMLTrackElement*);
+ // 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);
- virtual void mediaPlayerDidAddTrack(blink::WebInbandTextTrack*) OVERRIDE FINAL;
- virtual void mediaPlayerDidRemoveTrack(blink::WebInbandTextTrack*) OVERRIDE FINAL;
+ virtual void mediaPlayerDidAddTextTrack(blink::WebInbandTextTrack*) override final;
+ virtual void mediaPlayerDidRemoveTextTrack(blink::WebInbandTextTrack*) override final;
+ // FIXME: Remove this when WebMediaPlayerClientImpl::loadInternal does not depend on it.
+ virtual KURL mediaPlayerPosterURL() override { return KURL(); }
- struct TrackGroup {
+ class TrackGroup {
+ STACK_ALLOCATED();
+ public:
enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
- TrackGroup(GroupKind kind)
- : visibleTrack(0)
- , defaultTrack(0)
+ explicit TrackGroup(GroupKind kind)
+ : visibleTrack(nullptr)
+ , defaultTrack(nullptr)
, kind(kind)
, hasSrcLang(false)
{
}
- Vector<RefPtr<TextTrack> > tracks;
- RefPtr<TextTrack> visibleTrack;
- RefPtr<TextTrack> defaultTrack;
+ WillBeHeapVector<RefPtrWillBeMember<TextTrack>> tracks;
+ RefPtrWillBeMember<TextTrack> visibleTrack;
+ RefPtrWillBeMember<TextTrack> defaultTrack;
GroupKind kind;
bool hasSrcLang;
};
void updateTextTrackDisplay();
void textTrackReadyStateChanged(TextTrack*);
- // TextTrackClient
- virtual void textTrackKindChanged(TextTrack*) OVERRIDE FINAL;
- virtual void textTrackModeChanged(TextTrack*) OVERRIDE FINAL;
- virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*) OVERRIDE FINAL;
- virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*) OVERRIDE FINAL;
- virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>) OVERRIDE FINAL;
- virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>) OVERRIDE FINAL;
+ void textTrackKindChanged(TextTrack*);
+ void textTrackModeChanged(TextTrack*);
+ void textTrackAddCues(TextTrack*, const TextTrackCueList*);
+ void textTrackRemoveCues(TextTrack*, const TextTrackCueList*);
+ void textTrackAddCue(TextTrack*, PassRefPtrWillBeRawPtr<TextTrackCue>);
+ void textTrackRemoveCue(TextTrack*, PassRefPtrWillBeRawPtr<TextTrackCue>);
// EventTarget function.
// Both Node (via HTMLElement) and ActiveDOMObject define this method, which
// causes an ambiguity error at compile time. This class's constructor
// ensures that both implementations return document, so return the result
// of one of them here.
- virtual ExecutionContext* executionContext() const OVERRIDE FINAL { return HTMLElement::executionContext(); }
+ using HTMLElement::executionContext;
- bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
+ bool hasSingleSecurityOrigin() const { return !m_player || (webMediaPlayer() && webMediaPlayer()->hasSingleSecurityOrigin()); }
- virtual bool isFullscreen() const OVERRIDE FINAL;
- virtual void enterFullscreen() OVERRIDE FINAL;
+ bool isFullscreen() const;
+ void enterFullscreen();
void exitFullscreen();
- virtual bool hasClosedCaptions() const OVERRIDE FINAL;
- virtual bool closedCaptionsVisible() const OVERRIDE FINAL;
- virtual void setClosedCaptionsVisible(bool) OVERRIDE FINAL;
+ bool hasClosedCaptions() const;
+ bool closedCaptionsVisible() const;
+ void setClosedCaptionsVisible(bool);
+
+ void remoteRouteAvailabilityChanged(bool);
+ void connectedToRemoteDevice();
+ void disconnectedFromRemoteDevice();
MediaControls* mediaControls() const;
void sourceWasRemoved(HTMLSourceElement*);
void sourceWasAdded(HTMLSourceElement*);
- bool isPlaying() const { return m_playing; }
-
// ActiveDOMObject functions.
- virtual bool hasPendingActivity() const OVERRIDE FINAL;
- virtual void contextDestroyed() OVERRIDE FINAL;
+ virtual bool hasPendingActivity() const override final;
+ virtual void contextDestroyed() override final;
#if ENABLE(WEB_AUDIO)
- MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
- void setAudioSourceNode(MediaElementAudioSourceNode*);
+ AudioSourceProviderClient* audioSourceNode() { return m_audioSourceNode; }
+ void setAudioSourceNode(AudioSourceProviderClient*);
AudioSourceProvider* audioSourceProvider();
#endif
bool isSafeToLoadURL(const KURL&, InvalidURLAction);
MediaController* controller() const;
- void setController(PassRefPtr<MediaController>); // Resets the MediaGroup and sets the MediaController.
+ void setController(PassRefPtrWillBeRawPtr<MediaController>); // Resets the MediaGroup and sets the MediaController.
-protected:
- HTMLMediaElement(const QualifiedName&, Document&, bool);
- virtual ~HTMLMediaElement();
+ void scheduleEvent(PassRefPtrWillBeRawPtr<Event>);
- virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
- virtual void finishParsingChildren() OVERRIDE FINAL;
- virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
- virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
+ // Returns the "effective media volume" value as specified in the HTML5 spec.
+ double effectiveMediaVolume() const;
- virtual void didMoveToNewDocument(Document& oldDocument) OVERRIDE;
+#if ENABLE(OILPAN)
+ bool isFinalizing() const { return m_isFinalizing; }
- enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
- DisplayMode displayMode() const { return m_displayMode; }
- virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
+ // Oilpan: finalization of the media element is observable from its
+ // attached MediaSource; it entering a closed state.
+ //
+ // Express that by having the MediaSource keep a weak reference
+ // to the media element and signal that it wants to be notified
+ // of destruction if it survives a GC, but the media element
+ // doesn't.
+ void setCloseMediaSourceWhenFinalizing();
+#endif
+
+ // Predicates also used when dispatching wrapper creation (cf. [SpecialWrapFor] IDL attribute usage.)
+ virtual bool isHTMLAudioElement() const { return false; }
+ virtual bool isHTMLVideoElement() const { return false; }
- virtual bool isMediaElement() const OVERRIDE FINAL { return true; }
+protected:
+ HTMLMediaElement(const QualifiedName&, Document&);
+ virtual ~HTMLMediaElement();
- void setControllerInternal(PassRefPtr<MediaController>);
+ virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
+ virtual void finishParsingChildren() override final;
+ virtual bool isURLAttribute(const Attribute&) const override;
+ virtual void attach(const AttachContext& = AttachContext()) override;
- // Restrictions to change default behaviors.
- enum BehaviorRestrictionFlags {
- NoRestrictions = 0,
- RequireUserGestureForLoadRestriction = 1 << 0,
- RequireUserGestureForRateChangeRestriction = 1 << 1,
- RequireUserGestureForFullscreenRestriction = 1 << 2,
- RequirePageConsentToLoadMediaRestriction = 1 << 3,
- };
- typedef unsigned BehaviorRestrictions;
+ virtual void didMoveToNewDocument(Document& oldDocument) override;
- bool userGestureRequiredForLoad() const { return m_restrictions & RequireUserGestureForLoadRestriction; }
- bool userGestureRequiredForRateChange() const { return m_restrictions & RequireUserGestureForRateChangeRestriction; }
- bool userGestureRequiredForFullscreen() const { return m_restrictions & RequireUserGestureForFullscreenRestriction; }
- bool pageConsentRequiredForLoad() const { return m_restrictions & RequirePageConsentToLoadMediaRestriction; }
+ enum DisplayMode { Unknown, Poster, PosterWaitingForVideo, Video };
+ DisplayMode displayMode() const { return m_displayMode; }
+ virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
- void addBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions |= restriction; }
- void removeBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions &= ~restriction; }
+ void setControllerInternal(PassRefPtrWillBeRawPtr<MediaController>);
bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0; }
void beginIgnoringTrackDisplayUpdateRequests();
private:
void createMediaPlayer();
- virtual bool alwaysCreateUserAgentShadowRoot() const OVERRIDE FINAL { return true; }
- virtual bool areAuthorShadowsAllowed() const OVERRIDE FINAL { return false; }
+ virtual bool alwaysCreateUserAgentShadowRoot() const override final { return true; }
+ virtual bool areAuthorShadowsAllowed() const override final { return false; }
- virtual bool hasCustomFocusLogic() const OVERRIDE FINAL;
- virtual bool supportsFocus() const OVERRIDE FINAL;
- virtual bool isMouseFocusable() const OVERRIDE FINAL;
- virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
- virtual RenderObject* createRenderer(RenderStyle*) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE FINAL;
- virtual void removedFrom(ContainerNode*) OVERRIDE FINAL;
- virtual void didRecalcStyle(StyleRecalcChange) OVERRIDE FINAL;
+ virtual bool supportsFocus() const override final;
+ virtual bool isMouseFocusable() const override final;
+ virtual bool rendererIsNeeded(const RenderStyle&) override;
+ virtual RenderObject* createRenderer(RenderStyle*) override;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) override final;
+ virtual void didNotifySubtreeInsertionsToDocument() override;
+ virtual void removedFrom(ContainerNode*) override final;
+ virtual void didRecalcStyle(StyleRecalcChange) override final;
- virtual void didBecomeFullscreenElement() OVERRIDE FINAL;
- virtual void willStopBeingFullscreenElement() OVERRIDE FINAL;
- virtual bool isInteractiveContent() const OVERRIDE FINAL;
+ virtual void didBecomeFullscreenElement() override final;
+ 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 stop() override final;
virtual void updateDisplayState() { }
- void setReadyState(MediaPlayer::ReadyState);
- void setNetworkState(MediaPlayer::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 mediaPlayerKeyAdded(const String& keySystem, const String& sessionId) OVERRIDE FINAL;
- virtual void mediaPlayerKeyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) OVERRIDE FINAL;
- virtual void mediaPlayerKeyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const KURL& defaultURL) OVERRIDE FINAL;
- virtual bool mediaPlayerKeyNeeded(const String& contentType, const unsigned char* initData, unsigned initDataLength) OVERRIDE FINAL;
-
- virtual CORSMode mediaPlayerCORSMode() const OVERRIDE FINAL;
-
- virtual void mediaPlayerSetWebLayer(blink::WebLayer*) OVERRIDE FINAL;
- virtual void mediaPlayerSetOpaque(bool) OVERRIDE FINAL;
- virtual void mediaPlayerMediaSourceOpened(blink::WebMediaSource*) OVERRIDE FINAL;
+ void setReadyState(ReadyState);
+ void setNetworkState(blink::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;
void loadTimerFired(Timer<HTMLMediaElement>*);
void progressEventTimerFired(Timer<HTMLMediaElement>*);
void startProgressEventTimer();
void stopPeriodicTimers();
- void seek(double time, ExceptionState&);
+ void seek(double time);
void finishSeek();
void checkIfSeekNeeded();
void addPlayedRange(double start, double end);
void scheduleTimeupdateEvent(bool periodicEvent);
- void scheduleEvent(const AtomicString& eventName);
+ 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;
void scheduleNextSourceChild();
void loadNextSourceChild();
void userCancelledLoad();
void clearMediaPlayer(int flags);
- void clearMediaPlayerAndAudioSourceProviderClient();
+ void clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
bool havePotentialSourceChild();
void noneSupported();
- void mediaEngineError(PassRefPtr<MediaError> err);
+ void mediaEngineError(PassRefPtrWillBeRawPtr<MediaError>);
void cancelPendingEventsAndCallbacks();
void waitForSourceChange();
void prepareToPlay();
KURL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
- void mediaLoadingFailed(MediaPlayer::NetworkState);
+ void mediaLoadingFailed(blink::WebMediaPlayer::NetworkState);
+
+ // deferred loading (preload=none)
+ bool loadIsDeferred() const;
+ void deferLoad();
+ void cancelDeferredLoad();
+ void startDeferredLoad();
+ void executeDeferredLoad();
+ void deferredLoadTimerFired(Timer<HTMLMediaElement>*);
void updateActiveTextTrackCues(double);
HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
void markCaptionAndSubtitleTracksAsUnconfigured();
- // These "internal" functions do not check user gesture restrictions.
- void loadInternal();
+ // This does not check user gesture restrictions.
void playInternal();
- void pauseInternal();
- void prepareForLoad();
+ void gesturelessInitialPlayHalted();
+ void autoplayMediaEncountered();
void allowVideoRendering();
void updateVolume();
bool potentiallyPlaying() const;
bool endedPlayback() const;
bool stoppedDueToErrors() const;
- bool pausedForUserInteraction() const;
bool couldPlayIfEnoughData() const;
- // Pauses playback without changing any states or generating events
- void setPausedInternal(bool);
-
- void setPlaybackRateInternal(double);
-
void setShouldDelayLoadEvent(bool);
void invalidateCachedTime();
void refreshCachedTime() const;
bool createMediaControls();
void configureMediaControls();
- void prepareMediaFragmentURI();
- void applyMediaFragmentURI();
-
- virtual void* preDispatchEventHandler(Event*) OVERRIDE FINAL;
+ virtual void* preDispatchEventHandler(Event*) override final;
void changeNetworkStateFromLoadingToIdle();
- void removeBehaviorsRestrictionsAfterFirstUserGesture();
-
const AtomicString& mediaGroup() const;
void setMediaGroup(const AtomicString&);
void updateMediaController();
bool isBlocked() const;
bool isBlockedOnMediaController() const;
- virtual bool hasCurrentSrc() const OVERRIDE FINAL { return !m_currentSrc.isEmpty(); }
bool isAutoplaying() const { return m_autoplaying; }
- // Currently we have both EME v0.1b and EME WD implemented in media element.
- // But we do not want to support both at the same time. The one used first
- // will be supported. Use |m_emeMode| to track this selection.
- // FIXME: Remove EmeMode once EME v0.1b support is removed. See crbug.com/249976.
- enum EmeMode { EmeModeNotSelected, EmeModePrefixed, EmeModeUnprefixed };
+ blink::WebMediaPlayer::CORSMode corsMode() const;
+
+ // Returns the "direction of playback" value as specified in the HTML5 spec.
+ enum DirectionOfPlayback { Backward, Forward };
+ DirectionOfPlayback directionOfPlayback() const;
- // check (and set if necessary) the encrypted media extensions (EME) mode
- // (v0.1b or WD). Returns whether the mode is allowed and successfully set.
- bool setEmeMode(EmeMode, ExceptionState&);
+ // Returns the "effective playback rate" value as specified in the HTML5 spec.
+ double effectivePlaybackRate() const;
- blink::WebContentDecryptionModule* contentDecryptionModule();
- void setMediaKeysInternal(MediaKeys*);
+ // Creates placeholder AudioTrack and/or VideoTrack objects when WebMemediaPlayer objects
+ // advertise they have audio and/or video, but don't explicitly signal them via
+ // addAudioTrack() and addVideoTrack().
+ // FIXME: Remove this once all WebMediaPlayer implementations properly report their track info.
+ void createPlaceholderTracksIfNecessary();
+
+ // Sets the selected/enabled tracks if they aren't set before we initially
+ // transition to HAVE_METADATA.
+ void selectInitialTracksIfNecessary();
+
+ void audioTracksTimerFired(Timer<HTMLMediaElement>*);
Timer<HTMLMediaElement> m_loadTimer;
Timer<HTMLMediaElement> m_progressEventTimer;
Timer<HTMLMediaElement> m_playbackProgressTimer;
- RefPtr<TimeRanges> m_playedTimeRanges;
- OwnPtr<GenericEventQueue> m_asyncEventQueue;
+ Timer<HTMLMediaElement> m_audioTracksTimer;
+ RefPtrWillBeMember<TimeRanges> m_playedTimeRanges;
+ OwnPtrWillBeMember<GenericEventQueue> m_asyncEventQueue;
double m_playbackRate;
double m_defaultPlaybackRate;
ReadyState m_readyStateMaximum;
KURL m_currentSrc;
- RefPtr<MediaError> m_error;
+ RefPtrWillBeMember<MediaError> m_error;
double m_volume;
double m_lastSeekTime;
// 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;
- RefPtr<HTMLSourceElement> m_currentSourceNode;
- RefPtr<Node> m_nextChildNodeToConsider;
+ RefPtrWillBeMember<HTMLSourceElement> m_currentSourceNode;
+ RefPtrWillBeMember<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<MediaPlayer> m_player;
blink::WebLayer* m_webLayer;
- bool m_opaque;
-
- BehaviorRestrictions m_restrictions;
MediaPlayer::Preload m_preload;
DisplayMode m_displayMode;
- RefPtr<HTMLMediaSource> m_mediaSource;
+ 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;
- mutable double m_cachedTimeWallClockUpdateTime;
- mutable double m_minimumWallClockTimeToCacheMediaTime;
- double m_fragmentStartTime;
double m_fragmentEndTime;
typedef unsigned PendingActionFlags;
PendingActionFlags m_pendingActionFlags;
// FIXME: MediaElement has way too many state bits.
+ bool m_userGestureRequiredForPlay : 1;
bool m_playing : 1;
bool m_shouldDelayLoadEvent : 1;
bool m_haveFiredLoadedData : 1;
// time has not changed since sending an "ended" event
bool m_sentEndEvent : 1;
- bool m_pausedInternal : 1;
-
bool m_closedCaptionsVisible : 1;
- bool m_loadInitiatedByUserGesture : 1;
bool m_completelyLoaded : 1;
bool m_havePreparedToPlay : 1;
- bool m_parsingInProgress : 1;
+ bool m_delayingLoadForPreloadNone : 1;
bool m_tracksAreReady : 1;
bool m_haveVisibleTextTrack : 1;
bool m_processingPreferenceChange : 1;
+ bool m_remoteRoutesAvailable : 1;
+ bool m_playingRemotely : 1;
+#if ENABLE(OILPAN)
+ bool m_isFinalizing : 1;
+ bool m_closeMediaSourceWhenFinalizing : 1;
+#endif
double m_lastTextTrackUpdateTime;
+ bool m_initialPlayWithoutUserGestures : 1;
+ bool m_autoplayMediaCounted : 1;
- RefPtr<TextTrackList> m_textTracks;
- Vector<RefPtr<TextTrack> > m_textTracksWhenResourceSelectionBegan;
+ RefPtrWillBeMember<AudioTrackList> m_audioTracks;
+ RefPtrWillBeMember<VideoTrackList> m_videoTracks;
+ RefPtrWillBeMember<TextTrackList> m_textTracks;
+ WillBeHeapVector<RefPtrWillBeMember<TextTrack>> m_textTracksWhenResourceSelectionBegan;
CueIntervalTree m_cueTree;
#if ENABLE(WEB_AUDIO)
// This is a weak reference, since m_audioSourceNode holds a reference to us.
- // The value is set just after the MediaElementAudioSourceNode is created.
- // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
- MediaElementAudioSourceNode* m_audioSourceNode;
+ // 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;
#endif
friend class MediaController;
- RefPtr<MediaController> m_mediaController;
+ RefPtrWillBeMember<MediaController> m_mediaController;
+ friend class Internals;
friend class TrackDisplayUpdateScope;
- EmeMode m_emeMode;
-
- RefPtr<MediaKeys> m_mediaKeys;
+ static URLRegistry* s_mediaStreamRegistry;
};
#ifndef NDEBUG
};
#endif
-inline bool isHTMLMediaElement(const Node& node)
+inline bool isHTMLMediaElement(const HTMLElement& element)
{
- return node.isElementNode() && toElement(node).isMediaElement();
+ return isHTMLAudioElement(element) || isHTMLVideoElement(element);
}
-DEFINE_NODE_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
+DEFINE_HTMLELEMENT_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
-} //namespace
+} // namespace blink
-#endif
+#endif // HTMLMediaElement_h
projects / platform / framework / web / crosswalk.git / blobdiff