d14e439a1d62042c4bf268ca3f0acb72d094ab1d
[WebKit-https.git] / Source / WebCore / html / HTMLMediaElement.h
1 /*
2  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012 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 #if ENABLE(VIDEO)
30
31 #include "HTMLElement.h"
32 #include "ActiveDOMObject.h"
33 #include "GenericEventQueue.h"
34 #include "MediaCanStartListener.h"
35 #include "MediaControllerInterface.h"
36 #include "MediaPlayer.h"
37
38 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
39 #include "MediaPlayerProxy.h"
40 #endif
41
42 #if ENABLE(VIDEO_TRACK)
43 #include "PODIntervalTree.h"
44 #include "TextTrack.h"
45 #include "TextTrackCue.h"
46 #endif
47
48 namespace WebCore {
49
50 #if ENABLE(WEB_AUDIO)
51 class AudioSourceProvider;
52 class MediaElementAudioSourceNode;
53 #endif
54 class Event;
55 class HTMLSourceElement;
56 class HTMLTrackElement;
57 class MediaController;
58 class MediaControls;
59 class MediaError;
60 class KURL;
61 class TextTrackList;
62 class TimeRanges;
63 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
64 class Widget;
65 #endif
66 #if PLATFORM(MAC)
67 class DisplaySleepDisabler;
68 #endif
69
70 #if ENABLE(VIDEO_TRACK)
71 typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
72 typedef Vector<CueIntervalTree::IntervalType> CueList;
73 #endif
74
75 // FIXME: The inheritance from MediaPlayerClient here should be private inheritance.
76 // But it can't be until the Chromium WebMediaPlayerClientImpl class is fixed so it
77 // no longer depends on typecasting a MediaPlayerClient to an HTMLMediaElement.
78
79 class HTMLMediaElement : public HTMLElement, public MediaPlayerClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface
80 #if ENABLE(VIDEO_TRACK)
81     , private TextTrackClient
82 #endif
83 {
84 public:
85     MediaPlayer* player() const { return m_player.get(); }
86     
87     virtual bool isVideo() const = 0;
88     virtual bool hasVideo() const { return false; }
89     virtual bool hasAudio() const;
90
91     void rewind(float timeDelta);
92     void returnToRealtime();
93
94     // Eventually overloaded in HTMLVideoElement
95     virtual bool supportsFullscreen() const { return false; };
96
97     virtual bool supportsSave() const;
98     virtual bool supportsScanning() const;
99     
100     PlatformMedia platformMedia() const;
101 #if USE(ACCELERATED_COMPOSITING)
102     PlatformLayer* platformLayer() const;
103 #endif
104
105     enum LoadType {
106         MediaResource = 1 << 0,
107         TextTrackResource = 1 << 1
108     };
109     void scheduleLoad(LoadType);
110     
111     MediaPlayer::MovieLoadType movieLoadType() const;
112     
113     bool inActiveDocument() const { return m_inActiveDocument; }
114     
115 // DOM API
116 // error state
117     PassRefPtr<MediaError> error() const;
118
119 // network state
120     void setSrc(const String&);
121     const KURL& currentSrc() const { return m_currentSrc; }
122
123     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
124     NetworkState networkState() const;
125
126     String preload() const;    
127     void setPreload(const String&);
128
129     PassRefPtr<TimeRanges> buffered() const;
130     void load(ExceptionCode&);
131     String canPlayType(const String& mimeType) const;
132
133 // ready state
134     ReadyState readyState() const;
135     bool seeking() const;
136
137 // playback state
138     float currentTime() const;
139     void setCurrentTime(float, ExceptionCode&);
140     double initialTime() const;
141     float startTime() const;
142     float duration() const;
143     bool paused() const;
144     float defaultPlaybackRate() const;
145     void setDefaultPlaybackRate(float);
146     float playbackRate() const;
147     void setPlaybackRate(float);
148     void updatePlaybackRate();
149     bool webkitPreservesPitch() const;
150     void setWebkitPreservesPitch(bool);
151     PassRefPtr<TimeRanges> played();
152     PassRefPtr<TimeRanges> seekable() const;
153     bool ended() const;
154     bool autoplay() const;    
155     void setAutoplay(bool b);
156     bool loop() const;    
157     void setLoop(bool b);
158     void play();
159     void pause();
160
161 // captions
162     bool webkitHasClosedCaptions() const;
163     bool webkitClosedCaptionsVisible() const;
164     void setWebkitClosedCaptionsVisible(bool);
165
166 #if ENABLE(MEDIA_STATISTICS)
167 // Statistics
168     unsigned webkitAudioDecodedByteCount() const;
169     unsigned webkitVideoDecodedByteCount() const;
170 #endif
171
172 #if ENABLE(MEDIA_SOURCE)
173 //  Media Source.
174     const KURL& webkitMediaSourceURL() const { return m_mediaSourceURL; }
175     void webkitSourceAppend(PassRefPtr<Uint8Array> data, ExceptionCode&);
176     enum EndOfStreamStatus { EOS_NO_ERROR, EOS_NETWORK_ERR, EOS_DECODE_ERR };
177     void webkitSourceEndOfStream(unsigned short, ExceptionCode&);
178     enum SourceState { SOURCE_CLOSED, SOURCE_OPEN, SOURCE_ENDED };
179     SourceState webkitSourceState() const;
180     void setSourceState(SourceState);
181 #endif 
182
183 // controls
184     bool controls() const;
185     void setControls(bool);
186     float volume() const;
187     void setVolume(float, ExceptionCode&);
188     bool muted() const;
189     void setMuted(bool);
190
191     void togglePlayState();
192     void beginScrubbing();
193     void endScrubbing();
194     
195     bool canPlay() const;
196
197     float percentLoaded() const;
198
199 #if ENABLE(VIDEO_TRACK)
200     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
201     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
202     PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
203
204     TextTrackList* textTracks();
205     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
206
207     virtual void didAddTrack(HTMLTrackElement*);
208     virtual void willRemoveTrack(HTMLTrackElement*);
209
210     struct TrackGroup {
211         enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
212
213         TrackGroup(GroupKind kind)
214             : visibleTrack(0)
215             , defaultTrack(0)
216             , kind(kind)
217             , hasSrcLang(false)
218         {
219         }
220
221         Vector<HTMLTrackElement*> tracks;
222         HTMLTrackElement* visibleTrack;
223         HTMLTrackElement* defaultTrack;
224         GroupKind kind;
225         bool hasSrcLang;
226     };
227
228     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
229     void configureNewTextTracks();
230     void configureTextTrackGroup(const TrackGroup&) const;
231
232     bool userIsInterestedInThisTrackKind(String) const;
233     bool textTracksAreReady() const;
234     void configureTextTrackDisplay();
235
236     // TextTrackClient
237     virtual void textTrackReadyStateChanged(TextTrack*);
238     virtual void textTrackKindChanged(TextTrack*);
239     virtual void textTrackModeChanged(TextTrack*);
240     virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*);
241     virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*);
242     virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>);
243     virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>);
244 #endif
245
246 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
247     void allocateMediaPlayerIfNecessary();
248     void setNeedWidgetUpdate(bool needWidgetUpdate) { m_needWidgetUpdate = needWidgetUpdate; }
249     void deliverNotification(MediaPlayerProxyNotificationType notification);
250     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
251     void getPluginProxyParams(KURL& url, Vector<String>& names, Vector<String>& values);
252     void createMediaPlayerProxy();
253     void updateWidget(PluginCreationOption);
254 #endif
255
256     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
257     
258     bool isFullscreen() const;
259     void enterFullscreen();
260     void exitFullscreen();
261
262     bool hasClosedCaptions() const;
263     bool closedCaptionsVisible() const;
264     void setClosedCaptionsVisible(bool);
265
266     MediaControls* mediaControls();
267
268     void sourceWillBeRemoved(HTMLSourceElement*);
269     void sourceWasAdded(HTMLSourceElement*);
270
271     void privateBrowsingStateDidChange();
272
273     // Media cache management.
274     static void getSitesInMediaCache(Vector<String>&);
275     static void clearMediaCache();
276     static void clearMediaCacheForSite(const String&);
277
278     bool isPlaying() const { return m_playing; }
279
280     virtual bool hasPendingActivity() const;
281
282 #if ENABLE(WEB_AUDIO)
283     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
284     void setAudioSourceNode(MediaElementAudioSourceNode*);
285
286     AudioSourceProvider* audioSourceProvider();
287 #endif
288
289     enum InvalidURLAction { DoNothing, Complain };
290     bool isSafeToLoadURL(const KURL&, InvalidURLAction);
291
292     const String& mediaGroup() const;
293     void setMediaGroup(const String&);
294
295     MediaController* controller() const;
296     void setController(PassRefPtr<MediaController>);
297
298     virtual bool dispatchEvent(PassRefPtr<Event>);
299
300 protected:
301     HTMLMediaElement(const QualifiedName&, Document*, bool);
302     virtual ~HTMLMediaElement();
303
304     virtual void parseAttribute(Attribute*) OVERRIDE;
305     virtual void finishParsingChildren();
306     virtual bool isURLAttribute(Attribute*) const;
307     virtual void attach();
308
309     virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
310
311     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
312     DisplayMode displayMode() const { return m_displayMode; }
313     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
314     
315     virtual bool isMediaElement() const { return true; }
316
317     // Restrictions to change default behaviors.
318     enum BehaviorRestrictionFlags {
319         NoRestrictions = 0,
320         RequireUserGestureForLoadRestriction = 1 << 0,
321         RequireUserGestureForRateChangeRestriction = 1 << 1,
322         RequireUserGestureForFullscreenRestriction = 1 << 2,
323         RequirePageConsentToLoadMediaRestriction = 1 << 3,
324     };
325     typedef unsigned BehaviorRestrictions;
326     
327     bool userGestureRequiredForLoad() const { return m_restrictions & RequireUserGestureForLoadRestriction; }
328     bool userGestureRequiredForRateChange() const { return m_restrictions & RequireUserGestureForRateChangeRestriction; }
329     bool userGestureRequiredForFullscreen() const { return m_restrictions & RequireUserGestureForFullscreenRestriction; }
330     bool pageConsentRequiredForLoad() const { return m_restrictions & RequirePageConsentToLoadMediaRestriction; }
331     
332     void addBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions |= restriction; }
333     void removeBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions &= ~restriction; }
334     
335 private:
336     void createMediaPlayer();
337
338     virtual bool supportsFocus() const;
339     virtual bool isMouseFocusable() const;
340     virtual bool rendererIsNeeded(const NodeRenderingContext&);
341     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
342     virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const OVERRIDE;
343     virtual void insertedIntoDocument();
344     virtual void removedFromDocument();
345     virtual void didRecalcStyle(StyleChange);
346     
347     virtual void defaultEventHandler(Event*);
348
349     virtual void didBecomeFullscreenElement();
350     virtual void willStopBeingFullscreenElement();
351
352     // ActiveDOMObject functions.
353     virtual bool canSuspend() const;
354     virtual void suspend(ReasonForSuspension);
355     virtual void resume();
356     virtual void stop();
357     
358     virtual void mediaVolumeDidChange();
359
360     virtual void updateDisplayState() { }
361     
362     void setReadyState(MediaPlayer::ReadyState);
363     void setNetworkState(MediaPlayer::NetworkState);
364
365     virtual Document* mediaPlayerOwningDocument();
366     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*);
367     virtual void mediaPlayerReadyStateChanged(MediaPlayer*);
368     virtual void mediaPlayerTimeChanged(MediaPlayer*);
369     virtual void mediaPlayerVolumeChanged(MediaPlayer*);
370     virtual void mediaPlayerMuteChanged(MediaPlayer*);
371     virtual void mediaPlayerDurationChanged(MediaPlayer*);
372     virtual void mediaPlayerRateChanged(MediaPlayer*);
373     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*);
374     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*);
375     virtual void mediaPlayerResourceNotSupported(MediaPlayer*);
376     virtual void mediaPlayerRepaint(MediaPlayer*);
377     virtual void mediaPlayerSizeChanged(MediaPlayer*);
378 #if USE(ACCELERATED_COMPOSITING)
379     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*);
380     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*);
381 #endif
382     virtual void mediaPlayerEngineUpdated(MediaPlayer*);
383     
384     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*);
385     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*);
386
387 #if ENABLE(MEDIA_SOURCE)
388     virtual void mediaPlayerSourceOpened();
389     virtual String mediaPlayerSourceURL() const;
390 #endif
391
392     virtual String mediaPlayerReferrer() const OVERRIDE;
393     virtual String mediaPlayerUserAgent() const OVERRIDE;
394
395     void loadTimerFired(Timer<HTMLMediaElement>*);
396     void progressEventTimerFired(Timer<HTMLMediaElement>*);
397     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
398     void startPlaybackProgressTimer();
399     void startProgressEventTimer();
400     void stopPeriodicTimers();
401
402     void seek(float time, ExceptionCode&);
403     void finishSeek();
404     void checkIfSeekNeeded();
405     void addPlayedRange(float start, float end);
406     
407     void scheduleTimeupdateEvent(bool periodicEvent);
408     void scheduleEvent(const AtomicString& eventName);
409     
410     // loading
411     void selectMediaResource();
412     void loadResource(const KURL&, ContentType&);
413     void scheduleNextSourceChild();
414     void loadNextSourceChild();
415     void userCancelledLoad();
416     bool havePotentialSourceChild();
417     void noneSupported();
418     void mediaEngineError(PassRefPtr<MediaError> err);
419     void cancelPendingEventsAndCallbacks();
420     void waitForSourceChange();
421     void prepareToPlay();
422
423     KURL selectNextSourceChild(ContentType*, InvalidURLAction);
424     void mediaLoadingFailed(MediaPlayer::NetworkState);
425
426 #if ENABLE(VIDEO_TRACK)
427     void updateActiveTextTrackCues(float);
428     bool userIsInterestedInThisLanguage(const String&) const;
429     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
430
431     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0; }
432     void beginIgnoringTrackDisplayUpdateRequests() { ++m_ignoreTrackDisplayUpdate; }
433     void endIgnoringTrackDisplayUpdateRequests() { ASSERT(m_ignoreTrackDisplayUpdate); --m_ignoreTrackDisplayUpdate; }
434 #endif
435
436     // These "internal" functions do not check user gesture restrictions.
437     void loadInternal();
438     void playInternal();
439     void pauseInternal();
440
441     void prepareForLoad();
442     void allowVideoRendering();
443
444     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
445     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
446     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
447
448     void updateVolume();
449     void updatePlayState();
450     bool potentiallyPlaying() const;
451     bool endedPlayback() const;
452     bool stoppedDueToErrors() const;
453     bool pausedForUserInteraction() const;
454     bool couldPlayIfEnoughData() const;
455
456     float minTimeSeekable() const;
457     float maxTimeSeekable() const;
458
459     // Pauses playback without changing any states or generating events
460     void setPausedInternal(bool);
461
462     void setPlaybackRateInternal(float);
463
464     virtual void mediaCanStart();
465
466     void setShouldDelayLoadEvent(bool);
467     void invalidateCachedTime();
468     void refreshCachedTime() const;
469
470     bool hasMediaControls();
471     bool createMediaControls();
472     void configureMediaControls();
473
474     void prepareMediaFragmentURI();
475     void applyMediaFragmentURI();
476
477     virtual void* preDispatchEventHandler(Event*);
478
479     void changeNetworkStateFromLoadingToIdle();
480
481     void removeBehaviorsRestrictionsAfterFirstUserGesture();
482
483 #if ENABLE(MICRODATA)
484     virtual String itemValueText() const;
485     virtual void setItemValueText(const String&, ExceptionCode&);
486 #endif
487
488     void updateMediaController();
489     bool isBlocked() const;
490     bool isBlockedOnMediaController() const;
491     bool hasCurrentSrc() const { return !m_currentSrc.isEmpty(); }
492     bool isLiveStream() const { return movieLoadType() == MediaPlayer::LiveStream; }
493     bool isAutoplaying() const { return m_autoplaying; }
494
495 #if PLATFORM(MAC)
496     void updateDisableSleep();
497     bool shouldDisableSleep() const;
498 #endif
499
500     Timer<HTMLMediaElement> m_loadTimer;
501     Timer<HTMLMediaElement> m_progressEventTimer;
502     Timer<HTMLMediaElement> m_playbackProgressTimer;
503     RefPtr<TimeRanges> m_playedTimeRanges;
504     GenericEventQueue m_asyncEventQueue;
505
506     float m_playbackRate;
507     float m_defaultPlaybackRate;
508     bool m_webkitPreservesPitch;
509     NetworkState m_networkState;
510     ReadyState m_readyState;
511     ReadyState m_readyStateMaximum;
512     KURL m_currentSrc;
513
514     RefPtr<MediaError> m_error;
515
516     float m_volume;
517     float m_lastSeekTime;
518     
519     unsigned m_previousProgress;
520     double m_previousProgressTime;
521
522     // The last time a timeupdate event was sent (wall clock).
523     double m_lastTimeUpdateEventWallTime;
524
525     // The last time a timeupdate event was sent in movie time.
526     float m_lastTimeUpdateEventMovieTime;
527     
528     // Loading state.
529     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
530     LoadState m_loadState;
531     HTMLSourceElement* m_currentSourceNode;
532     Node* m_nextChildNodeToConsider;
533     Node* sourceChildEndOfListValue() { return static_cast<Node*>(this); }
534
535     OwnPtr<MediaPlayer> m_player;
536 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
537     RefPtr<Widget> m_proxyWidget;
538 #endif
539
540     BehaviorRestrictions m_restrictions;
541     
542     MediaPlayer::Preload m_preload;
543
544     DisplayMode m_displayMode;
545
546     // Counter incremented while processing a callback from the media player, so we can avoid
547     // calling the media engine recursively.
548     int m_processingMediaPlayerCallback;
549
550 #if ENABLE(MEDIA_SOURCE)
551     KURL m_mediaSourceURL;
552     SourceState m_sourceState;
553 #endif
554
555     mutable float m_cachedTime;
556     mutable double m_cachedTimeWallClockUpdateTime;
557     mutable double m_minimumWallClockTimeToCacheMediaTime;
558
559     double m_fragmentStartTime;
560     double m_fragmentEndTime;
561
562     typedef unsigned PendingLoadFlags;
563     PendingLoadFlags m_pendingLoadFlags;
564
565     bool m_playing : 1;
566     bool m_isWaitingUntilMediaCanStart : 1;
567     bool m_shouldDelayLoadEvent : 1;
568     bool m_haveFiredLoadedData : 1;
569     bool m_inActiveDocument : 1;
570     bool m_autoplaying : 1;
571     bool m_muted : 1;
572     bool m_paused : 1;
573     bool m_seeking : 1;
574
575     // data has not been loaded since sending a "stalled" event
576     bool m_sentStalledEvent : 1;
577
578     // time has not changed since sending an "ended" event
579     bool m_sentEndEvent : 1;
580
581     bool m_pausedInternal : 1;
582
583     // Not all media engines provide enough information about a file to be able to
584     // support progress events so setting m_sendProgressEvents disables them 
585     bool m_sendProgressEvents : 1;
586
587     bool m_isFullscreen : 1;
588     bool m_closedCaptionsVisible : 1;
589
590 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
591     bool m_needWidgetUpdate : 1;
592 #endif
593
594     bool m_dispatchingCanPlayEvent : 1;
595     bool m_loadInitiatedByUserGesture : 1;
596     bool m_completelyLoaded : 1;
597     bool m_havePreparedToPlay : 1;
598     bool m_parsingInProgress : 1;
599
600 #if ENABLE(VIDEO_TRACK)
601     bool m_tracksAreReady : 1;
602     bool m_haveVisibleTextTrack : 1;
603     float m_lastTextTrackUpdateTime;
604
605     RefPtr<TextTrackList> m_textTracks;
606     Vector<RefPtr<TextTrack> > m_textTracksWhenResourceSelectionBegan;
607
608     CueIntervalTree m_cueTree;
609
610     CueList m_currentlyActiveCues;
611     int m_ignoreTrackDisplayUpdate;
612 #endif
613
614 #if ENABLE(WEB_AUDIO)
615     // This is a weak reference, since m_audioSourceNode holds a reference to us.
616     // The value is set just after the MediaElementAudioSourceNode is created.
617     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
618     MediaElementAudioSourceNode* m_audioSourceNode;
619 #endif
620
621     String m_mediaGroup;
622     friend class MediaController;
623     RefPtr<MediaController> m_mediaController;
624
625 #if PLATFORM(MAC)
626     OwnPtr<DisplaySleepDisabler> m_sleepDisabler;
627 #endif
628 };
629
630 #if ENABLE(VIDEO_TRACK)
631 #ifndef NDEBUG
632 // Template specializations required by PodIntervalTree in debug mode.
633 template <>
634 struct ValueToString<double> {
635     static String string(const double value)
636     {
637         return String::number(value);
638     }
639 };
640
641 template <>
642 struct ValueToString<TextTrackCue*> {
643     static String string(TextTrackCue* const& cue)
644     {
645         return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), cue->text().utf8().data());
646     }
647 };
648 #endif
649 #endif
650
651 } //namespace
652
653 #endif
654 #endif