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