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