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