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