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