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