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