76c24cbab7f0fcc6c28fa820b387d7bc1aff0780
[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 trackWasAdded(HTMLTrackElement*);
208     virtual void trackWasRemoved(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 void attributeChanged(Attribute*) OVERRIDE;
341     virtual bool rendererIsNeeded(const NodeRenderingContext&);
342     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
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     void loadTimerFired(Timer<HTMLMediaElement>*);
393     void progressEventTimerFired(Timer<HTMLMediaElement>*);
394     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
395     void startPlaybackProgressTimer();
396     void startProgressEventTimer();
397     void stopPeriodicTimers();
398
399     void seek(float time, ExceptionCode&);
400     void finishSeek();
401     void checkIfSeekNeeded();
402     void addPlayedRange(float start, float end);
403     
404     void scheduleTimeupdateEvent(bool periodicEvent);
405     void scheduleEvent(const AtomicString& eventName);
406     
407     // loading
408     void selectMediaResource();
409     void loadResource(const KURL&, ContentType&);
410     void scheduleNextSourceChild();
411     void loadNextSourceChild();
412     void userCancelledLoad();
413     bool havePotentialSourceChild();
414     void noneSupported();
415     void mediaEngineError(PassRefPtr<MediaError> err);
416     void cancelPendingEventsAndCallbacks();
417     void waitForSourceChange();
418     void prepareToPlay();
419
420     KURL selectNextSourceChild(ContentType*, InvalidURLAction);
421     void mediaLoadingFailed(MediaPlayer::NetworkState);
422
423 #if ENABLE(VIDEO_TRACK)
424     void updateActiveTextTrackCues(float);
425     bool userIsInterestedInThisLanguage(const String&) const;
426     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
427
428     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0; }
429     void beginIgnoringTrackDisplayUpdateRequests() { ++m_ignoreTrackDisplayUpdate; }
430     void endIgnoringTrackDisplayUpdateRequests() { ASSERT(m_ignoreTrackDisplayUpdate); --m_ignoreTrackDisplayUpdate; }
431 #endif
432
433     // These "internal" functions do not check user gesture restrictions.
434     void loadInternal();
435     void playInternal();
436     void pauseInternal();
437
438     void prepareForLoad();
439     void allowVideoRendering();
440
441     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
442     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
443     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
444
445     void updateVolume();
446     void updatePlayState();
447     bool potentiallyPlaying() const;
448     bool endedPlayback() const;
449     bool stoppedDueToErrors() const;
450     bool pausedForUserInteraction() const;
451     bool couldPlayIfEnoughData() const;
452
453     float minTimeSeekable() const;
454     float maxTimeSeekable() const;
455
456     // Pauses playback without changing any states or generating events
457     void setPausedInternal(bool);
458
459     void setPlaybackRateInternal(float);
460
461     virtual void mediaCanStart();
462
463     void setShouldDelayLoadEvent(bool);
464     void invalidateCachedTime();
465     void refreshCachedTime() const;
466
467     bool hasMediaControls();
468     bool createMediaControls();
469     void configureMediaControls();
470
471     void prepareMediaFragmentURI();
472     void applyMediaFragmentURI();
473
474     virtual void* preDispatchEventHandler(Event*);
475
476     void changeNetworkStateFromLoadingToIdle();
477
478 #if ENABLE(MICRODATA)
479     virtual String itemValueText() const;
480     virtual void setItemValueText(const String&, ExceptionCode&);
481 #endif
482
483     void updateMediaController();
484     bool isBlocked() const;
485     bool isBlockedOnMediaController() const;
486     bool hasCurrentSrc() const { return !m_currentSrc.isEmpty(); }
487     bool isLiveStream() const { return movieLoadType() == MediaPlayer::LiveStream; }
488     bool isAutoplaying() const { return m_autoplaying; }
489
490 #if PLATFORM(MAC)
491     void updateDisableSleep();
492     bool shouldDisableSleep() const;
493 #endif
494
495     Timer<HTMLMediaElement> m_loadTimer;
496     Timer<HTMLMediaElement> m_progressEventTimer;
497     Timer<HTMLMediaElement> m_playbackProgressTimer;
498     RefPtr<TimeRanges> m_playedTimeRanges;
499     GenericEventQueue m_asyncEventQueue;
500
501     float m_playbackRate;
502     float m_defaultPlaybackRate;
503     bool m_webkitPreservesPitch;
504     NetworkState m_networkState;
505     ReadyState m_readyState;
506     ReadyState m_readyStateMaximum;
507     KURL m_currentSrc;
508
509     RefPtr<MediaError> m_error;
510
511     float m_volume;
512     float m_lastSeekTime;
513     
514     unsigned m_previousProgress;
515     double m_previousProgressTime;
516
517     // The last time a timeupdate event was sent (wall clock).
518     double m_lastTimeUpdateEventWallTime;
519
520     // The last time a timeupdate event was sent in movie time.
521     float m_lastTimeUpdateEventMovieTime;
522     
523     // Loading state.
524     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
525     LoadState m_loadState;
526     HTMLSourceElement* m_currentSourceNode;
527     Node* m_nextChildNodeToConsider;
528     Node* sourceChildEndOfListValue() { return static_cast<Node*>(this); }
529
530     OwnPtr<MediaPlayer> m_player;
531 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
532     RefPtr<Widget> m_proxyWidget;
533 #endif
534
535     BehaviorRestrictions m_restrictions;
536     
537     MediaPlayer::Preload m_preload;
538
539     DisplayMode m_displayMode;
540
541     // Counter incremented while processing a callback from the media player, so we can avoid
542     // calling the media engine recursively.
543     int m_processingMediaPlayerCallback;
544
545 #if ENABLE(MEDIA_SOURCE)
546     KURL m_mediaSourceURL;
547     SourceState m_sourceState;
548 #endif
549
550     mutable float m_cachedTime;
551     mutable double m_cachedTimeWallClockUpdateTime;
552     mutable double m_minimumWallClockTimeToCacheMediaTime;
553
554     double m_fragmentStartTime;
555     double m_fragmentEndTime;
556
557     typedef unsigned PendingLoadFlags;
558     PendingLoadFlags m_pendingLoadFlags;
559
560     bool m_playing : 1;
561     bool m_isWaitingUntilMediaCanStart : 1;
562     bool m_shouldDelayLoadEvent : 1;
563     bool m_haveFiredLoadedData : 1;
564     bool m_inActiveDocument : 1;
565     bool m_autoplaying : 1;
566     bool m_muted : 1;
567     bool m_paused : 1;
568     bool m_seeking : 1;
569
570     // data has not been loaded since sending a "stalled" event
571     bool m_sentStalledEvent : 1;
572
573     // time has not changed since sending an "ended" event
574     bool m_sentEndEvent : 1;
575
576     bool m_pausedInternal : 1;
577
578     // Not all media engines provide enough information about a file to be able to
579     // support progress events so setting m_sendProgressEvents disables them 
580     bool m_sendProgressEvents : 1;
581
582     bool m_isFullscreen : 1;
583     bool m_closedCaptionsVisible : 1;
584
585 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
586     bool m_needWidgetUpdate : 1;
587 #endif
588
589     bool m_dispatchingCanPlayEvent : 1;
590     bool m_loadInitiatedByUserGesture : 1;
591     bool m_completelyLoaded : 1;
592     bool m_havePreparedToPlay : 1;
593     bool m_parsingInProgress : 1;
594
595 #if ENABLE(VIDEO_TRACK)
596     bool m_tracksAreReady : 1;
597     bool m_haveVisibleTextTrack : 1;
598
599     RefPtr<TextTrackList> m_textTracks;
600     Vector<RefPtr<TextTrack> > m_textTracksWhenResourceSelectionBegan;
601     CueIntervalTree m_cueTree;
602     CueList m_currentlyActiveCues;
603     int m_ignoreTrackDisplayUpdate;
604 #endif
605
606 #if ENABLE(WEB_AUDIO)
607     // This is a weak reference, since m_audioSourceNode holds a reference to us.
608     // The value is set just after the MediaElementAudioSourceNode is created.
609     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
610     MediaElementAudioSourceNode* m_audioSourceNode;
611 #endif
612
613     String m_mediaGroup;
614     friend class MediaController;
615     RefPtr<MediaController> m_mediaController;
616
617 #if PLATFORM(MAC)
618     OwnPtr<DisplaySleepDisabler> m_sleepDisabler;
619 #endif
620 };
621
622 #if ENABLE(VIDEO_TRACK)
623 #ifndef NDEBUG
624 // Template specializations required by PodIntervalTree in debug mode.
625 template <>
626 struct ValueToString<double> {
627     static String string(const double value)
628     {
629         return String::number(value);
630     }
631 };
632
633 template <>
634 struct ValueToString<TextTrackCue*> {
635     static String string(TextTrackCue* const& cue)
636     {
637         return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), cue->text().utf8().data());
638     }
639 };
640 #endif
641 #endif
642
643 } //namespace
644
645 #endif
646 #endif