• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25 
26 #ifndef HTMLMediaElement_h
27 #define HTMLMediaElement_h
28 
29 #include "core/dom/ActiveDOMObject.h"
30 #include "core/events/GenericEventQueue.h"
31 #include "core/html/HTMLElement.h"
32 #include "core/html/track/TextTrack.h"
33 #include "core/html/track/TextTrackCue.h"
34 #include "core/html/track/vtt/VTTCue.h"
35 #include "platform/PODIntervalTree.h"
36 #include "platform/Supplementable.h"
37 #include "platform/graphics/media/MediaPlayer.h"
38 #include "public/platform/WebMediaPlayerClient.h"
39 #include "public/platform/WebMimeRegistry.h"
40 
41 namespace blink {
42 class WebContentDecryptionModule;
43 class WebInbandTextTrack;
44 class WebLayer;
45 }
46 
47 namespace blink {
48 
49 #if ENABLE(WEB_AUDIO)
50 class AudioSourceProvider;
51 class AudioSourceProviderClient;
52 #endif
53 class AudioTrackList;
54 class ContentType;
55 class Event;
56 class ExceptionState;
57 class HTMLSourceElement;
58 class HTMLTrackElement;
59 class KURL;
60 class MediaController;
61 class MediaControls;
62 class MediaError;
63 class HTMLMediaSource;
64 class TextTrackList;
65 class TimeRanges;
66 class URLRegistry;
67 class VideoTrackList;
68 
69 typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
70 typedef CueIntervalTree::IntervalType CueInterval;
71 typedef Vector<CueInterval> CueList;
72 
73 // FIXME: The inheritance from MediaPlayerClient here should be private inheritance.
74 // But it can't be until the Chromium WebMediaPlayerClientImpl class is fixed so it
75 // no longer depends on typecasting a MediaPlayerClient to an HTMLMediaElement.
76 
77 class HTMLMediaElement : public HTMLElement, public WillBeHeapSupplementable<HTMLMediaElement>, public MediaPlayerClient, public ActiveDOMObject {
78     DEFINE_WRAPPERTYPEINFO();
79     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(HTMLMediaElement);
80 public:
81     static blink::WebMimeRegistry::SupportsType supportsType(const ContentType&, const String& keySystem = String());
82 
83     static void setMediaStreamRegistry(URLRegistry*);
84     static bool isMediaStreamURL(const String& url);
85 
86     virtual void trace(Visitor*) OVERRIDE;
87 #if ENABLE(WEB_AUDIO)
88     void clearWeakMembers(Visitor*);
89 #endif
webMediaPlayer()90     blink::WebMediaPlayer* webMediaPlayer() const { return m_player ? m_player->webMediaPlayer() : 0; }
91 
hasVideo()92     virtual bool hasVideo() const { return false; }
93     bool hasAudio() const;
94 
95     bool supportsSave() const;
96 
97     blink::WebLayer* platformLayer() const;
98 
99     enum DelayedActionType {
100         LoadMediaResource = 1 << 0,
101         LoadTextTrackResource = 1 << 1,
102         TextTrackChangesNotification = 1 << 2
103     };
104     void scheduleDelayedAction(DelayedActionType);
105 
isActive()106     bool isActive() const { return m_active; }
107 
hasRemoteRoutes()108     bool hasRemoteRoutes() const { return m_remoteRoutesAvailable; }
isPlayingRemotely()109     bool isPlayingRemotely() const { return m_playingRemotely; }
110 
111     // error state
112     PassRefPtrWillBeRawPtr<MediaError> error() const;
113 
114     // network state
115     void setSrc(const AtomicString&);
currentSrc()116     const KURL& currentSrc() const { return m_currentSrc; }
117 
118     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
119     NetworkState networkState() const;
120 
121     String preload() const;
122     void setPreload(const AtomicString&);
123 
124     PassRefPtrWillBeRawPtr<TimeRanges> buffered() const;
125     void load();
126     String canPlayType(const String& mimeType, const String& keySystem = String()) const;
127 
128     // ready state
129     enum ReadyState { HAVE_NOTHING, HAVE_METADATA, HAVE_CURRENT_DATA, HAVE_FUTURE_DATA, HAVE_ENOUGH_DATA };
130     ReadyState readyState() const;
131     bool seeking() const;
132 
133     // playback state
134     double currentTime() const;
135     void setCurrentTime(double, ExceptionState&);
136     double duration() const;
137     bool paused() const;
138     double defaultPlaybackRate() const;
139     void setDefaultPlaybackRate(double);
140     double playbackRate() const;
141     void setPlaybackRate(double);
142     void updatePlaybackRate();
143     PassRefPtrWillBeRawPtr<TimeRanges> played();
144     PassRefPtrWillBeRawPtr<TimeRanges> seekable() const;
145     bool ended() const;
146     bool autoplay() const;
147     bool loop() const;
148     void setLoop(bool);
149     void play();
150     void pause();
151     void requestRemotePlayback();
152     void requestRemotePlaybackControl();
153 
154     // statistics
155     unsigned webkitAudioDecodedByteCount() const;
156     unsigned webkitVideoDecodedByteCount() const;
157 
158     // media source extensions
159     void closeMediaSource();
160     void durationChanged(double duration, bool requestSeek);
161 
162     // controls
163     bool shouldShowControls() const;
164     double volume() const;
165     void setVolume(double, ExceptionState&);
166     bool muted() const;
167     void setMuted(bool);
168 
169     // play/pause toggling that uses the media controller if present. togglePlayStateWillPlay() is
170     // true if togglePlayState() will call play() or unpause() on the media element or controller.
171     bool togglePlayStateWillPlay() const;
172     void togglePlayState();
173 
174     AudioTrackList& audioTracks();
175     void audioTrackChanged();
176 
177     VideoTrackList& videoTracks();
178     void selectedVideoTrackChanged(blink::WebMediaPlayer::TrackId*);
179 
180     PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, ExceptionState&);
addTextTrack(const AtomicString & kind,const AtomicString & label,ExceptionState & exceptionState)181     PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, ExceptionState& exceptionState) { return addTextTrack(kind, label, emptyAtom, exceptionState); }
addTextTrack(const AtomicString & kind,ExceptionState & exceptionState)182     PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, ExceptionState& exceptionState) { return addTextTrack(kind, emptyAtom, emptyAtom, exceptionState); }
183 
184     TextTrackList* textTracks();
currentlyActiveCues()185     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
186 
187     void addTextTrack(TextTrack*);
188     void removeTextTrack(TextTrack*);
189     void textTracksChanged();
190     void notifyMediaPlayerOfTextTrackChanges();
191 
192     // Implements the "forget the media element's media-resource-specific tracks" algorithm in the HTML5 spec.
193     void forgetResourceSpecificTracks();
194 
195     void didAddTrackElement(HTMLTrackElement*);
196     void didRemoveTrackElement(HTMLTrackElement*);
197 
198     blink::WebMediaPlayer::TrackId addAudioTrack(const String& id, blink::WebMediaPlayerClient::AudioTrackKind, const AtomicString& label, const AtomicString& language, bool enabled);
199     void removeAudioTrack(blink::WebMediaPlayer::TrackId);
200     blink::WebMediaPlayer::TrackId addVideoTrack(const String& id, blink::WebMediaPlayerClient::VideoTrackKind, const AtomicString& label, const AtomicString& language, bool selected);
201     void removeVideoTrack(blink::WebMediaPlayer::TrackId);
202 
203     virtual void mediaPlayerDidAddTextTrack(blink::WebInbandTextTrack*) OVERRIDE FINAL;
204     virtual void mediaPlayerDidRemoveTextTrack(blink::WebInbandTextTrack*) OVERRIDE FINAL;
205     // FIXME: Remove this when WebMediaPlayerClientImpl::loadInternal does not depend on it.
mediaPlayerPosterURL()206     virtual KURL mediaPlayerPosterURL() OVERRIDE { return KURL(); }
207 
208     class TrackGroup {
209         STACK_ALLOCATED();
210     public:
211         enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
212 
TrackGroup(GroupKind kind)213         explicit TrackGroup(GroupKind kind)
214             : visibleTrack(nullptr)
215             , defaultTrack(nullptr)
216             , kind(kind)
217             , hasSrcLang(false)
218         {
219         }
220 
221         WillBeHeapVector<RefPtrWillBeMember<TextTrack> > tracks;
222         RefPtrWillBeMember<TextTrack> visibleTrack;
223         RefPtrWillBeMember<TextTrack> defaultTrack;
224         GroupKind kind;
225         bool hasSrcLang;
226     };
227 
228     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
229     void configureTextTracks();
230     void configureTextTrackGroup(const TrackGroup&);
231 
232     bool textTracksAreReady() const;
233     enum VisibilityChangeAssumption {
234         AssumeNoVisibleChange,
235         AssumeVisibleChange
236     };
237     void configureTextTrackDisplay(VisibilityChangeAssumption);
238     void updateTextTrackDisplay();
239     void textTrackReadyStateChanged(TextTrack*);
240 
241     void textTrackKindChanged(TextTrack*);
242     void textTrackModeChanged(TextTrack*);
243     void textTrackAddCues(TextTrack*, const TextTrackCueList*);
244     void textTrackRemoveCues(TextTrack*, const TextTrackCueList*);
245     void textTrackAddCue(TextTrack*, PassRefPtrWillBeRawPtr<TextTrackCue>);
246     void textTrackRemoveCue(TextTrack*, PassRefPtrWillBeRawPtr<TextTrackCue>);
247 
248     // EventTarget function.
249     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
250     // causes an ambiguity error at compile time. This class's constructor
251     // ensures that both implementations return document, so return the result
252     // of one of them here.
253     using HTMLElement::executionContext;
254 
hasSingleSecurityOrigin()255     bool hasSingleSecurityOrigin() const { return !m_player || (webMediaPlayer() && webMediaPlayer()->hasSingleSecurityOrigin()); }
256 
257     bool isFullscreen() const;
258     void enterFullscreen();
259     void exitFullscreen();
260 
261     bool hasClosedCaptions() const;
262     bool closedCaptionsVisible() const;
263     void setClosedCaptionsVisible(bool);
264 
265     void remoteRouteAvailabilityChanged(bool);
266     void connectedToRemoteDevice();
267     void disconnectedFromRemoteDevice();
268 
269     MediaControls* mediaControls() const;
270 
271     void sourceWasRemoved(HTMLSourceElement*);
272     void sourceWasAdded(HTMLSourceElement*);
273 
274     // ActiveDOMObject functions.
275     virtual bool hasPendingActivity() const OVERRIDE FINAL;
276     virtual void contextDestroyed() OVERRIDE FINAL;
277 
278 #if ENABLE(WEB_AUDIO)
audioSourceNode()279     AudioSourceProviderClient* audioSourceNode() { return m_audioSourceNode; }
280     void setAudioSourceNode(AudioSourceProviderClient*);
281 
282     AudioSourceProvider* audioSourceProvider();
283 #endif
284 
285     enum InvalidURLAction { DoNothing, Complain };
286     bool isSafeToLoadURL(const KURL&, InvalidURLAction);
287 
288     MediaController* controller() const;
289     void setController(PassRefPtrWillBeRawPtr<MediaController>); // Resets the MediaGroup and sets the MediaController.
290 
291     void scheduleEvent(PassRefPtrWillBeRawPtr<Event>);
292 
293     // Returns the "effective media volume" value as specified in the HTML5 spec.
294     double effectiveMediaVolume() const;
295 
296 #if ENABLE(OILPAN)
isFinalizing()297     bool isFinalizing() const { return m_isFinalizing; }
298 
299     // Oilpan: finalization of the media element is observable from its
300     // attached MediaSource; it entering a closed state.
301     //
302     // Express that by having the MediaSource keep a weak reference
303     // to the media element and signal that it wants to be notified
304     // of destruction if it survives a GC, but the media element
305     // doesn't.
306     void setCloseMediaSourceWhenFinalizing();
307 #endif
308 
309     // Predicates also used when dispatching wrapper creation (cf. [SpecialWrapFor] IDL attribute usage.)
isHTMLAudioElement()310     virtual bool isHTMLAudioElement() const { return false; }
isHTMLVideoElement()311     virtual bool isHTMLVideoElement() const { return false; }
312 
313 protected:
314     HTMLMediaElement(const QualifiedName&, Document&);
315     virtual ~HTMLMediaElement();
316 
317     virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
318     virtual void finishParsingChildren() OVERRIDE FINAL;
319     virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
320     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
321 
322     virtual void didMoveToNewDocument(Document& oldDocument) OVERRIDE;
323 
324     enum DisplayMode { Unknown, Poster, PosterWaitingForVideo, Video };
displayMode()325     DisplayMode displayMode() const { return m_displayMode; }
setDisplayMode(DisplayMode mode)326     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
327 
328     void setControllerInternal(PassRefPtrWillBeRawPtr<MediaController>);
329 
ignoreTrackDisplayUpdateRequests()330     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0; }
331     void beginIgnoringTrackDisplayUpdateRequests();
332     void endIgnoringTrackDisplayUpdateRequests();
333 
334 private:
335     void createMediaPlayer();
336 
alwaysCreateUserAgentShadowRoot()337     virtual bool alwaysCreateUserAgentShadowRoot() const OVERRIDE FINAL { return true; }
areAuthorShadowsAllowed()338     virtual bool areAuthorShadowsAllowed() const OVERRIDE FINAL { return false; }
339 
340     virtual bool supportsFocus() const OVERRIDE FINAL;
341     virtual bool isMouseFocusable() const OVERRIDE FINAL;
342     virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
343     virtual RenderObject* createRenderer(RenderStyle*) OVERRIDE;
344     virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE FINAL;
345     virtual void didNotifySubtreeInsertionsToDocument() OVERRIDE;
346     virtual void removedFrom(ContainerNode*) OVERRIDE FINAL;
347     virtual void didRecalcStyle(StyleRecalcChange) OVERRIDE FINAL;
348 
349     virtual void didBecomeFullscreenElement() OVERRIDE FINAL;
350     virtual void willStopBeingFullscreenElement() OVERRIDE FINAL;
351     virtual bool isInteractiveContent() const OVERRIDE FINAL;
352     virtual void defaultEventHandler(Event*) OVERRIDE FINAL;
353 
354     // ActiveDOMObject functions.
355     virtual void stop() OVERRIDE FINAL;
356 
updateDisplayState()357     virtual void updateDisplayState() { }
358 
359     void setReadyState(ReadyState);
360     void setNetworkState(blink::WebMediaPlayer::NetworkState);
361 
362     virtual void mediaPlayerNetworkStateChanged() OVERRIDE FINAL;
363     virtual void mediaPlayerReadyStateChanged() OVERRIDE FINAL;
364     virtual void mediaPlayerTimeChanged() OVERRIDE FINAL;
365     virtual void mediaPlayerDurationChanged() OVERRIDE FINAL;
366     virtual void mediaPlayerPlaybackStateChanged() OVERRIDE FINAL;
367     virtual void mediaPlayerRequestFullscreen() OVERRIDE FINAL;
368     virtual void mediaPlayerRequestSeek(double) OVERRIDE FINAL;
369     virtual void mediaPlayerRepaint() OVERRIDE FINAL;
370     virtual void mediaPlayerSizeChanged() OVERRIDE FINAL;
371     virtual void mediaPlayerSetWebLayer(blink::WebLayer*) OVERRIDE FINAL;
372     virtual void mediaPlayerMediaSourceOpened(blink::WebMediaSource*) OVERRIDE FINAL;
373 
374     void loadTimerFired(Timer<HTMLMediaElement>*);
375     void progressEventTimerFired(Timer<HTMLMediaElement>*);
376     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
377     void startPlaybackProgressTimer();
378     void startProgressEventTimer();
379     void stopPeriodicTimers();
380 
381     void seek(double time);
382     void finishSeek();
383     void checkIfSeekNeeded();
384     void addPlayedRange(double start, double end);
385 
386     void scheduleTimeupdateEvent(bool periodicEvent);
387     void scheduleEvent(const AtomicString& eventName); // FIXME: Rename to scheduleNamedEvent for clarity.
388 
389     // loading
390     void prepareForLoad();
391     void loadInternal();
392     void selectMediaResource();
393     void loadResource(const KURL&, ContentType&, const String& keySystem);
394     void startPlayerLoad();
395     void setPlayerPreload();
396     blink::WebMediaPlayer::LoadType loadType() const;
397     void scheduleNextSourceChild();
398     void loadNextSourceChild();
399     void userCancelledLoad();
400     void clearMediaPlayer(int flags);
401     void clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
402     bool havePotentialSourceChild();
403     void noneSupported();
404     void mediaEngineError(PassRefPtrWillBeRawPtr<MediaError>);
405     void cancelPendingEventsAndCallbacks();
406     void waitForSourceChange();
407     void prepareToPlay();
408 
409     KURL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
410 
411     void mediaLoadingFailed(blink::WebMediaPlayer::NetworkState);
412 
413     // deferred loading (preload=none)
414     bool loadIsDeferred() const;
415     void deferLoad();
416     void cancelDeferredLoad();
417     void startDeferredLoad();
418     void executeDeferredLoad();
419     void deferredLoadTimerFired(Timer<HTMLMediaElement>*);
420 
421     void updateActiveTextTrackCues(double);
422     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
423 
424     void markCaptionAndSubtitleTracksAsUnconfigured();
425 
426     // This does not check user gesture restrictions.
427     void playInternal();
428 
429     void allowVideoRendering();
430 
431     void updateVolume();
432     void updatePlayState();
433     bool potentiallyPlaying() const;
434     bool endedPlayback() const;
435     bool stoppedDueToErrors() const;
436     bool couldPlayIfEnoughData() const;
437 
438     void setShouldDelayLoadEvent(bool);
439     void invalidateCachedTime();
440     void refreshCachedTime() const;
441 
442     bool hasMediaControls() const;
443     bool createMediaControls();
444     void configureMediaControls();
445 
446     virtual void* preDispatchEventHandler(Event*) OVERRIDE FINAL;
447 
448     void changeNetworkStateFromLoadingToIdle();
449 
450     const AtomicString& mediaGroup() const;
451     void setMediaGroup(const AtomicString&);
452     void updateMediaController();
453     bool isBlocked() const;
454     bool isBlockedOnMediaController() const;
isAutoplaying()455     bool isAutoplaying() const { return m_autoplaying; }
456 
457     blink::WebMediaPlayer::CORSMode corsMode() const;
458 
459     // Returns the "direction of playback" value as specified in the HTML5 spec.
460     enum DirectionOfPlayback { Backward, Forward };
461     DirectionOfPlayback directionOfPlayback() const;
462 
463     // Returns the "effective playback rate" value as specified in the HTML5 spec.
464     double effectivePlaybackRate() const;
465 
466     // Creates placeholder AudioTrack and/or VideoTrack objects when WebMemediaPlayer objects
467     // advertise they have audio and/or video, but don't explicitly signal them via
468     // addAudioTrack() and addVideoTrack().
469     // FIXME: Remove this once all WebMediaPlayer implementations properly report their track info.
470     void createPlaceholderTracksIfNecessary();
471 
472     // Sets the selected/enabled tracks if they aren't set before we initially
473     // transition to HAVE_METADATA.
474     void selectInitialTracksIfNecessary();
475 
476     void audioTracksTimerFired(Timer<HTMLMediaElement>*);
477 
478     Timer<HTMLMediaElement> m_loadTimer;
479     Timer<HTMLMediaElement> m_progressEventTimer;
480     Timer<HTMLMediaElement> m_playbackProgressTimer;
481     Timer<HTMLMediaElement> m_audioTracksTimer;
482     RefPtrWillBeMember<TimeRanges> m_playedTimeRanges;
483     OwnPtrWillBeMember<GenericEventQueue> m_asyncEventQueue;
484 
485     double m_playbackRate;
486     double m_defaultPlaybackRate;
487     NetworkState m_networkState;
488     ReadyState m_readyState;
489     ReadyState m_readyStateMaximum;
490     KURL m_currentSrc;
491 
492     RefPtrWillBeMember<MediaError> m_error;
493 
494     double m_volume;
495     double m_lastSeekTime;
496 
497     double m_previousProgressTime;
498 
499     // Cached duration to suppress duplicate events if duration unchanged.
500     double m_duration;
501 
502     // The last time a timeupdate event was sent (wall clock).
503     double m_lastTimeUpdateEventWallTime;
504 
505     // The last time a timeupdate event was sent in movie time.
506     double m_lastTimeUpdateEventMovieTime;
507 
508     // The default playback start position.
509     double m_defaultPlaybackStartPosition;
510 
511     // Loading state.
512     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
513     LoadState m_loadState;
514     RefPtrWillBeMember<HTMLSourceElement> m_currentSourceNode;
515     RefPtrWillBeMember<Node> m_nextChildNodeToConsider;
516 
517     // "Deferred loading" state (for preload=none).
518     enum DeferredLoadState {
519         // The load is not deferred.
520         NotDeferred,
521         // The load is deferred, and waiting for the task to set the
522         // delaying-the-load-event flag (to false).
523         WaitingForStopDelayingLoadEventTask,
524         // The load is the deferred, and waiting for a triggering event.
525         WaitingForTrigger,
526         // The load is deferred, and waiting for the task to set the
527         // delaying-the-load-event flag, after which the load will be executed.
528         ExecuteOnStopDelayingLoadEventTask
529     };
530     DeferredLoadState m_deferredLoadState;
531     Timer<HTMLMediaElement> m_deferredLoadTimer;
532 
533     OwnPtr<MediaPlayer> m_player;
534     blink::WebLayer* m_webLayer;
535 
536     MediaPlayer::Preload m_preload;
537 
538     DisplayMode m_displayMode;
539 
540     RefPtrWillBeMember<HTMLMediaSource> m_mediaSource;
541 
542     // Cached time value. Only valid when ready state is HAVE_METADATA or
543     // higher, otherwise the current time is assumed to be zero.
544     mutable double m_cachedTime;
545 
546     double m_fragmentEndTime;
547 
548     typedef unsigned PendingActionFlags;
549     PendingActionFlags m_pendingActionFlags;
550 
551     // FIXME: MediaElement has way too many state bits.
552     bool m_userGestureRequiredForPlay : 1;
553     bool m_playing : 1;
554     bool m_shouldDelayLoadEvent : 1;
555     bool m_haveFiredLoadedData : 1;
556     bool m_active : 1;
557     bool m_autoplaying : 1;
558     bool m_muted : 1;
559     bool m_paused : 1;
560     bool m_seeking : 1;
561 
562     // data has not been loaded since sending a "stalled" event
563     bool m_sentStalledEvent : 1;
564 
565     // time has not changed since sending an "ended" event
566     bool m_sentEndEvent : 1;
567 
568     bool m_closedCaptionsVisible : 1;
569 
570     bool m_completelyLoaded : 1;
571     bool m_havePreparedToPlay : 1;
572     bool m_delayingLoadForPreloadNone : 1;
573 
574     bool m_tracksAreReady : 1;
575     bool m_haveVisibleTextTrack : 1;
576     bool m_processingPreferenceChange : 1;
577     bool m_remoteRoutesAvailable : 1;
578     bool m_playingRemotely : 1;
579 #if ENABLE(OILPAN)
580     bool m_isFinalizing : 1;
581     bool m_closeMediaSourceWhenFinalizing : 1;
582 #endif
583     double m_lastTextTrackUpdateTime;
584 
585     RefPtrWillBeMember<AudioTrackList> m_audioTracks;
586     RefPtrWillBeMember<VideoTrackList> m_videoTracks;
587     RefPtrWillBeMember<TextTrackList> m_textTracks;
588     WillBeHeapVector<RefPtrWillBeMember<TextTrack> > m_textTracksWhenResourceSelectionBegan;
589 
590     CueIntervalTree m_cueTree;
591 
592     CueList m_currentlyActiveCues;
593     int m_ignoreTrackDisplayUpdate;
594 
595 #if ENABLE(WEB_AUDIO)
596     // This is a weak reference, since m_audioSourceNode holds a reference to us.
597     // FIXME: Oilpan: Consider making this a strongly traced pointer with oilpan where strong cycles are not a problem.
598     GC_PLUGIN_IGNORE("http://crbug.com/404577")
599     RawPtrWillBeWeakMember<AudioSourceProviderClient> m_audioSourceNode;
600 #endif
601 
602     friend class MediaController;
603     RefPtrWillBeMember<MediaController> m_mediaController;
604 
605     friend class Internals;
606     friend class TrackDisplayUpdateScope;
607 
608     static URLRegistry* s_mediaStreamRegistry;
609 };
610 
611 #ifndef NDEBUG
612 // Template specializations required by PodIntervalTree in debug mode.
613 template <>
614 struct ValueToString<double> {
615     static String string(const double value)
616     {
617         return String::number(value);
618     }
619 };
620 
621 template <>
622 struct ValueToString<TextTrackCue*> {
623     static String string(TextTrackCue* const& cue)
624     {
625         return cue->toString();
626     }
627 };
628 #endif
629 
630 inline bool isHTMLMediaElement(const HTMLElement& element)
631 {
632     return isHTMLAudioElement(element) || isHTMLVideoElement(element);
633 }
634 
635 DEFINE_HTMLELEMENT_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
636 
637 } // namespace blink
638 
639 #endif // HTMLMediaElement_h
640