372e0ff1193df831172bca17172a8caabef6a05a
[WebKit-https.git] / Source / WebCore / html / HTMLMediaElement.h
1 /*
2  * Copyright (C) 2007-2015 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 "GenericTaskQueue.h"
34 #include "HTMLMediaElementEnums.h"
35 #include "JSDOMPromise.h"
36 #include "MediaCanStartListener.h"
37 #include "MediaControllerInterface.h"
38 #include "MediaElementSession.h"
39 #include "MediaProducer.h"
40 #include "PageThrottler.h"
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 "VTTCue.h"
49 #include "VideoTrack.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 DOMError;
63 class DisplaySleepDisabler;
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 MediaPlayer;
73 class TimeRanges;
74 #if ENABLE(ENCRYPTED_MEDIA_V2)
75 class MediaKeys;
76 #endif
77 #if ENABLE(MEDIA_SESSION)
78 class MediaSession;
79 #endif
80 #if ENABLE(MEDIA_SOURCE)
81 class MediaSource;
82 class SourceBuffer;
83 class VideoPlaybackQuality;
84 #endif
85
86 #if ENABLE(VIDEO_TRACK)
87 class AudioTrackList;
88 class AudioTrackPrivate;
89 class InbandTextTrackPrivate;
90 class TextTrackList;
91 class VideoTrackList;
92 class VideoTrackPrivate;
93
94 typedef PODIntervalTree<MediaTime, TextTrackCue*> CueIntervalTree;
95 typedef CueIntervalTree::IntervalType CueInterval;
96 typedef Vector<CueInterval> CueList;
97 #endif
98
99 #if ENABLE(MEDIA_STREAM)
100 class MediaStream;
101 class ScriptExecutionContext;
102 #endif
103
104 class HTMLMediaElement
105     : public HTMLElement
106     , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface , public PlatformMediaSessionClient, private MediaProducer
107 #if ENABLE(VIDEO_TRACK)
108     , private AudioTrackClient
109     , private TextTrackClient
110     , private VideoTrackClient
111 #endif
112 {
113 public:
114     MediaPlayer* player() const { return m_player.get(); }
115
116     virtual bool isVideo() const { return false; }
117     bool hasVideo() const override { return false; }
118     bool hasAudio() const override;
119
120     static HashSet<HTMLMediaElement*>& allMediaElements();
121
122     void rewind(double timeDelta);
123     WEBCORE_EXPORT void returnToRealtime() override;
124
125     // Eventually overloaded in HTMLVideoElement
126     bool supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenMode) const override { return false; };
127
128     bool supportsScanning() const override;
129
130     bool canSaveMediaData() const;
131
132     bool doesHaveAttribute(const AtomicString&, AtomicString* value = nullptr) const override;
133
134     WEBCORE_EXPORT PlatformMedia platformMedia() const;
135     PlatformLayer* platformLayer() const;
136 #if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
137     void setVideoFullscreenLayer(PlatformLayer*);
138     PlatformLayer* videoFullscreenLayer() const { return m_videoFullscreenLayer.get(); }
139     void setVideoFullscreenFrame(FloatRect);
140     void setVideoFullscreenGravity(MediaPlayerEnums::VideoGravity);
141     MediaPlayerEnums::VideoGravity videoFullscreenGravity() const { return m_videoFullscreenGravity; }
142 #endif
143
144     using HTMLMediaElementEnums::DelayedActionType;
145     void scheduleDelayedAction(DelayedActionType);
146     void scheduleResolvePendingPlayPromises();
147     void rejectPendingPlayPromises(DOMError&);
148     void resolvePendingPlayPromises();
149     void scheduleNotifyAboutPlaying();
150     void notifyAboutPlaying();
151     
152     MediaPlayerEnums::MovieLoadType movieLoadType() const;
153     
154     bool inActiveDocument() const { return m_inActiveDocument; }
155
156     const Document* hostingDocument() const override { return &document(); }
157
158 // DOM API
159 // error state
160     MediaError* error() const;
161
162     void setSrc(const String&);
163     const URL& currentSrc() const { return m_currentSrc; }
164
165 #if ENABLE(MEDIA_STREAM)
166     MediaStream* srcObject() const { return m_mediaStreamSrcObject.get(); }
167     void setSrcObject(ScriptExecutionContext&, MediaStream*);
168 #endif
169
170 // network state
171     using HTMLMediaElementEnums::NetworkState;
172     NetworkState networkState() const;
173
174     String preload() const;    
175     void setPreload(const String&);
176
177     Ref<TimeRanges> buffered() const override;
178     void load();
179     String canPlayType(const String& mimeType, const String& keySystem = String(), const URL& = URL()) const;
180
181 // ready state
182     using HTMLMediaElementEnums::ReadyState;
183     ReadyState readyState() const override;
184     bool seeking() const;
185
186 // playback state
187     WEBCORE_EXPORT double currentTime() const override;
188     void setCurrentTime(double) override;
189     virtual void setCurrentTime(double, ExceptionCode&);
190     virtual double getStartDate() const;
191     WEBCORE_EXPORT double duration() const override;
192     WEBCORE_EXPORT bool paused() const override;
193     double defaultPlaybackRate() const override;
194     void setDefaultPlaybackRate(double) override;
195     WEBCORE_EXPORT double playbackRate() const override;
196     void setPlaybackRate(double) override;
197
198 // MediaTime versions of playback state
199     MediaTime currentMediaTime() const;
200     void setCurrentTime(const MediaTime&);
201     MediaTime durationMediaTime() const;
202     void fastSeek(const MediaTime&);
203
204     void updatePlaybackRate();
205     bool webkitPreservesPitch() const;
206     void setWebkitPreservesPitch(bool);
207     Ref<TimeRanges> played() override;
208     Ref<TimeRanges> seekable() const override;
209     WEBCORE_EXPORT bool ended() const;
210     bool autoplay() const;
211     bool isAutoplaying() const { return m_autoplaying; }
212     bool loop() const;
213     void setLoop(bool b);
214
215     typedef DOMPromise<std::nullptr_t> PlayPromise;
216     void play(PlayPromise&&);
217
218     WEBCORE_EXPORT void play() override;
219     WEBCORE_EXPORT void pause() override;
220     void setShouldBufferData(bool) override;
221     void fastSeek(double);
222     double minFastReverseRate() const;
223     double maxFastForwardRate() const;
224
225     void purgeBufferedDataIfPossible();
226
227 // captions
228     bool webkitHasClosedCaptions() const;
229     bool webkitClosedCaptionsVisible() const;
230     void setWebkitClosedCaptionsVisible(bool);
231
232     bool elementIsHidden() const override { return m_elementIsHidden; }
233
234 #if ENABLE(MEDIA_STATISTICS)
235 // Statistics
236     unsigned webkitAudioDecodedByteCount() const;
237     unsigned webkitVideoDecodedByteCount() const;
238 #endif
239
240 #if ENABLE(MEDIA_SOURCE)
241 //  Media Source.
242     void closeMediaSource();
243     void incrementDroppedFrameCount() { ++m_droppedVideoFrames; }
244     size_t maximumSourceBufferSize(const SourceBuffer&) const;
245 #endif
246
247 #if ENABLE(ENCRYPTED_MEDIA)
248     void webkitGenerateKeyRequest(const String& keySystem, const RefPtr<Uint8Array>& initData, ExceptionCode&);
249     void webkitAddKey(const String& keySystem, Uint8Array& key, const RefPtr<Uint8Array>& initData, const String& sessionId, ExceptionCode&);
250     void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
251 #endif
252
253 #if ENABLE(ENCRYPTED_MEDIA_V2)
254     MediaKeys* keys() const { return m_mediaKeys.get(); }
255     void setMediaKeys(MediaKeys*);
256
257     void keyAdded();
258 #endif
259
260 // controls
261     bool controls() const;
262     void setControls(bool);
263     WEBCORE_EXPORT double volume() const override;
264     void setVolume(double, ExceptionCode&) override;
265     WEBCORE_EXPORT bool muted() const override;
266     WEBCORE_EXPORT void setMuted(bool) override;
267
268     WEBCORE_EXPORT void togglePlayState();
269     WEBCORE_EXPORT void beginScrubbing() override;
270     WEBCORE_EXPORT void endScrubbing() override;
271
272     void beginScanning(ScanDirection) override;
273     void endScanning() override;
274     double nextScanRate();
275
276     WEBCORE_EXPORT bool canPlay() const override;
277
278     double percentLoaded() const;
279
280 #if ENABLE(VIDEO_TRACK)
281     RefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
282
283     AudioTrackList& audioTracks();
284     TextTrackList& textTracks();
285     VideoTrackList& videoTracks();
286
287     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
288
289     void addAudioTrack(Ref<AudioTrack>&&);
290     void addTextTrack(Ref<TextTrack>&&);
291     void addVideoTrack(Ref<VideoTrack>&&);
292     void removeAudioTrack(AudioTrack&);
293     void removeTextTrack(TextTrack&, bool scheduleEvent = true);
294     void removeVideoTrack(VideoTrack&);
295     void forgetResourceSpecificTracks();
296     void closeCaptionTracksChanged();
297     void notifyMediaPlayerOfTextTrackChanges();
298
299     virtual void didAddTextTrack(HTMLTrackElement*);
300     virtual void didRemoveTextTrack(HTMLTrackElement*);
301
302     void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
303     void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
304     void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
305     void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
306     void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
307     void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
308
309 #if ENABLE(AVF_CAPTIONS)
310     Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() override;
311 #endif
312
313     struct TrackGroup;
314     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
315     void configureTextTracks();
316     void configureTextTrackGroup(const TrackGroup&);
317
318     void setSelectedTextTrack(TextTrack*);
319
320     bool textTracksAreReady() const;
321     using HTMLMediaElementEnums::TextTrackVisibilityCheckType;
322     void configureTextTrackDisplay(TextTrackVisibilityCheckType checkType = CheckTextTrackVisibility);
323     void updateTextTrackDisplay();
324
325     // AudioTrackClient
326     void audioTrackEnabledChanged(AudioTrack*) override;
327
328     // TextTrackClient
329     virtual void textTrackReadyStateChanged(TextTrack*);
330     void textTrackKindChanged(TextTrack*) override;
331     void textTrackModeChanged(TextTrack*) override;
332     void textTrackAddCues(TextTrack*, const TextTrackCueList*) override;
333     void textTrackRemoveCues(TextTrack*, const TextTrackCueList*) override;
334     void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
335     void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
336
337     // VideoTrackClient
338     void videoTrackSelectedChanged(VideoTrack*) override;
339
340     bool requiresTextTrackRepresentation() const;
341     void setTextTrackRepresentation(TextTrackRepresentation*);
342     void syncTextTrackBounds();
343 #endif
344
345 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
346     void webkitShowPlaybackTargetPicker();
347     bool addEventListener(const AtomicString& eventType, RefPtr<EventListener>&&, bool useCapture) override;
348     bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture) override;
349
350     void wirelessRoutesAvailableDidChange() override;
351     bool canPlayToWirelessPlaybackTarget() const override;
352     bool isPlayingToWirelessPlaybackTarget() const override;
353     void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&) override;
354     void setShouldPlayToPlaybackTarget(bool) override;
355 #endif
356     bool webkitCurrentPlaybackTargetIsWireless() const;
357
358     // EventTarget function.
359     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
360     // causes an ambiguity error at compile time. This class's constructor
361     // ensures that both implementations return document, so return the result
362     // of one of them here.
363     using HTMLElement::scriptExecutionContext;
364
365     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
366     
367     WEBCORE_EXPORT bool isFullscreen() const override;
368     bool isStandardFullscreen() const;
369     void toggleStandardFullscreenState();
370
371     using MediaPlayerEnums::VideoFullscreenMode;
372     VideoFullscreenMode fullscreenMode() const { return m_videoFullscreenMode; }
373     virtual void fullscreenModeChanged(VideoFullscreenMode mode) { m_videoFullscreenMode = mode; }
374
375     void enterFullscreen(VideoFullscreenMode);
376     void enterFullscreen() override;
377     WEBCORE_EXPORT void exitFullscreen();
378
379     bool hasClosedCaptions() const override;
380     bool closedCaptionsVisible() const override;
381     void setClosedCaptionsVisible(bool) override;
382
383     MediaControls* mediaControls() const;
384
385     void sourceWasRemoved(HTMLSourceElement*);
386     void sourceWasAdded(HTMLSourceElement*);
387
388     void privateBrowsingStateDidChange() override;
389
390     // Media cache management.
391     WEBCORE_EXPORT static void setMediaCacheDirectory(const String&);
392     WEBCORE_EXPORT static const String& mediaCacheDirectory();
393     WEBCORE_EXPORT static HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String&);
394     WEBCORE_EXPORT static void clearMediaCache(const String&, std::chrono::system_clock::time_point modifiedSince = { });
395     WEBCORE_EXPORT static void clearMediaCacheForOrigins(const String&, const HashSet<RefPtr<SecurityOrigin>>&);
396     static void resetMediaEngines();
397
398     bool isPlaying() const { return m_playing; }
399
400     bool hasPendingActivity() const override;
401
402 #if ENABLE(WEB_AUDIO)
403     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
404     void setAudioSourceNode(MediaElementAudioSourceNode*);
405
406     AudioSourceProvider* audioSourceProvider();
407 #endif
408
409     using HTMLMediaElementEnums::InvalidURLAction;
410     bool isSafeToLoadURL(const URL&, InvalidURLAction);
411
412     const String& mediaGroup() const;
413     void setMediaGroup(const String&);
414
415     MediaController* controller() const;
416     void setController(PassRefPtr<MediaController>);
417
418     void enteredOrExitedFullscreen() { configureMediaControls(); }
419
420     unsigned long long fileSize() const;
421
422     void mediaLoadingFailed(MediaPlayerEnums::NetworkState);
423     void mediaLoadingFailedFatally(MediaPlayerEnums::NetworkState);
424
425 #if ENABLE(MEDIA_SESSION)
426     WEBCORE_EXPORT double playerVolume() const;
427
428     const String& kind() const { return m_kind; }
429     void setKind(const String& kind) { m_kind = kind; }
430
431     MediaSession* session() const;
432     void setSession(MediaSession*);
433
434     void setShouldDuck(bool);
435
436     static HTMLMediaElement* elementWithID(uint64_t);
437     uint64_t elementID() const { return m_elementID; }
438 #endif
439
440 #if ENABLE(MEDIA_SOURCE)
441     RefPtr<VideoPlaybackQuality> getVideoPlaybackQuality();
442 #endif
443
444     MediaPlayerEnums::Preload preloadValue() const { return m_preload; }
445     MediaElementSession& mediaSession() const { return *m_mediaSession; }
446
447 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
448     void pageScaleFactorChanged();
449     WEBCORE_EXPORT String getCurrentMediaControlsStatus();
450 #endif
451
452     MediaControlsHost* mediaControlsHost() { return m_mediaControlsHost.get(); }
453
454     bool isDisablingSleep() const { return m_sleepDisabler.get(); }
455
456     double maxBufferedTime() const;
457
458     MediaProducer::MediaStateFlags mediaState() const override;
459
460     void layoutSizeChanged();
461     void visibilityDidChange();
462
463     void allowsMediaDocumentInlinePlaybackChanged();
464     void updateShouldPlay();
465
466 protected:
467     HTMLMediaElement(const QualifiedName&, Document&, bool);
468     virtual ~HTMLMediaElement();
469
470     void parseAttribute(const QualifiedName&, const AtomicString&) override;
471     void finishParsingChildren() override;
472     bool isURLAttribute(const Attribute&) const override;
473     void willAttachRenderers() override;
474     void didAttachRenderers() override;
475     void willDetachRenderers() override;
476     void didDetachRenderers() override;
477
478     void didMoveToNewDocument(Document* oldDocument) override;
479
480     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
481     DisplayMode displayMode() const { return m_displayMode; }
482     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
483     
484     bool isMediaElement() const final { return true; }
485
486 #if ENABLE(VIDEO_TRACK)
487     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
488     void beginIgnoringTrackDisplayUpdateRequests();
489     void endIgnoringTrackDisplayUpdateRequests();
490 #endif
491
492     RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
493
494 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
495     bool mediaControlsDependOnPageScaleFactor() const { return m_mediaControlsDependOnPageScaleFactor; }
496     void setMediaControlsDependOnPageScaleFactor(bool);
497     void updateMediaControlsAfterPresentationModeChange();
498 #endif
499
500     void scheduleEvent(const AtomicString& eventName);
501
502 private:
503     void createMediaPlayer();
504
505     bool alwaysCreateUserAgentShadowRoot() const override { return true; }
506
507     // FIXME: Shadow DOM spec says we should be able to create shadow root on audio and video elements
508     bool canHaveUserAgentShadowRoot() const final { return true; }
509
510     bool supportsFocus() const override;
511     bool isMouseFocusable() const override;
512     bool rendererIsNeeded(const RenderStyle&) override;
513     bool childShouldCreateRenderer(const Node&) const override;
514     InsertionNotificationRequest insertedInto(ContainerNode&) override;
515     void removedFrom(ContainerNode&) override;
516     void didRecalcStyle(Style::Change) override;
517
518     void willBecomeFullscreenElement() override;
519     void didBecomeFullscreenElement() override;
520     void willStopBeingFullscreenElement() override;
521
522     // ActiveDOMObject API.
523     const char* activeDOMObjectName() const override;
524     bool canSuspendForDocumentSuspension() const override;
525     void suspend(ReasonForSuspension) override;
526     void resume() override;
527     void stop() override;
528     void stopWithoutDestroyingMediaPlayer();
529     void contextDestroyed() override;
530     
531     void mediaVolumeDidChange() override;
532
533     void visibilityStateChanged() override;
534
535     virtual void updateDisplayState() { }
536     
537     void setReadyState(MediaPlayerEnums::ReadyState);
538     void setNetworkState(MediaPlayerEnums::NetworkState);
539
540     double effectivePlaybackRate() const;
541     double requestedPlaybackRate() const;
542
543     void mediaPlayerNetworkStateChanged(MediaPlayer*) override;
544     void mediaPlayerReadyStateChanged(MediaPlayer*) override;
545     void mediaPlayerTimeChanged(MediaPlayer*) override;
546     void mediaPlayerVolumeChanged(MediaPlayer*) override;
547     void mediaPlayerMuteChanged(MediaPlayer*) override;
548     void mediaPlayerDurationChanged(MediaPlayer*) override;
549     void mediaPlayerRateChanged(MediaPlayer*) override;
550     void mediaPlayerPlaybackStateChanged(MediaPlayer*) override;
551     void mediaPlayerSawUnsupportedTracks(MediaPlayer*) override;
552     void mediaPlayerResourceNotSupported(MediaPlayer*) override;
553     void mediaPlayerRepaint(MediaPlayer*) override;
554     void mediaPlayerSizeChanged(MediaPlayer*) override;
555     bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) override;
556     void mediaPlayerRenderingModeChanged(MediaPlayer*) override;
557     void mediaPlayerEngineUpdated(MediaPlayer*) override;
558     void mediaEngineWasUpdated();
559
560     void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) override;
561     void mediaPlayerCharacteristicChanged(MediaPlayer*) override;
562
563 #if ENABLE(ENCRYPTED_MEDIA)
564     void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) override;
565     void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) override;
566     void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL) override;
567     bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) override;
568 #endif
569
570 #if ENABLE(ENCRYPTED_MEDIA_V2)
571     RefPtr<ArrayBuffer> mediaPlayerCachedKeyForKeyId(const String& keyId) const override;
572     bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) override;
573     String mediaPlayerMediaKeysStorageDirectory() const override;
574 #endif
575     
576 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
577     void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) override;
578     void enqueuePlaybackTargetAvailabilityChangedEvent();
579
580     using EventTarget::dispatchEvent;
581     bool dispatchEvent(Event&) override;
582 #endif
583
584 #if ENABLE(MEDIA_SESSION)
585     void setSessionInternal(MediaSession&);
586 #endif
587
588     String mediaPlayerReferrer() const override;
589     String mediaPlayerUserAgent() const override;
590
591     bool mediaPlayerNeedsSiteSpecificHacks() const override;
592     String mediaPlayerDocumentHost() const override;
593
594     void mediaPlayerEnterFullscreen() override;
595     void mediaPlayerExitFullscreen() override;
596     bool mediaPlayerIsFullscreen() const override;
597     bool mediaPlayerIsFullscreenPermitted() const override;
598     bool mediaPlayerIsVideo() const override;
599     LayoutRect mediaPlayerContentBoxRect() const override;
600     float mediaPlayerContentsScale() const override;
601     void mediaPlayerSetSize(const IntSize&) override;
602     void mediaPlayerPause() override;
603     void mediaPlayerPlay() override;
604     bool mediaPlayerPlatformVolumeConfigurationRequired() const override;
605     bool mediaPlayerIsPaused() const override;
606     bool mediaPlayerIsLooping() const override;
607     CachedResourceLoader* mediaPlayerCachedResourceLoader() override;
608     RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() override;
609     bool mediaPlayerShouldUsePersistentCache() const override;
610     const String& mediaPlayerMediaCacheDirectory() const override;
611
612 #if PLATFORM(WIN) && USE(AVFOUNDATION)
613     GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const override;
614 #endif
615
616     bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) override;
617     void mediaPlayerHandlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType command) override { didReceiveRemoteControlCommand(command); }
618     String mediaPlayerSourceApplicationIdentifier() const override;
619     Vector<String> mediaPlayerPreferredAudioCharacteristics() const override;
620
621 #if PLATFORM(IOS)
622     String mediaPlayerNetworkInterfaceName() const override;
623     bool mediaPlayerGetRawCookies(const URL&, Vector<Cookie>&) const override;
624 #endif
625
626     bool mediaPlayerIsInMediaDocument() const final;
627     void mediaPlayerEngineFailedToLoad() const final;
628
629     double mediaPlayerRequestedPlaybackRate() const final;
630     VideoFullscreenMode mediaPlayerFullscreenMode() const final { return fullscreenMode(); }
631
632 #if USE(GSTREAMER)
633     void requestInstallMissingPlugins(const String& details, const String& description, MediaPlayerRequestInstallMissingPluginsCallback&) final;
634 #endif
635
636     void pendingActionTimerFired();
637     void progressEventTimerFired();
638     void playbackProgressTimerFired();
639     void scanTimerFired();
640     void seekTask();
641     void startPlaybackProgressTimer();
642     void startProgressEventTimer();
643     void stopPeriodicTimers();
644
645     void seek(const MediaTime&);
646     void seekInternal(const MediaTime&);
647     void seekWithTolerance(const MediaTime&, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance, bool fromDOM);
648     void finishSeek();
649     void clearSeeking();
650     void addPlayedRange(const MediaTime& start, const MediaTime& end);
651     
652     void scheduleTimeupdateEvent(bool periodicEvent);
653     virtual void scheduleResizeEvent() { }
654     virtual void scheduleResizeEventIfSizeChanged() { }
655
656     // loading
657     void selectMediaResource();
658     void loadResource(const URL&, ContentType&, const String& keySystem);
659     void scheduleNextSourceChild();
660     void loadNextSourceChild();
661     void userCancelledLoad();
662     void clearMediaPlayer(DelayedActionType flags);
663     bool havePotentialSourceChild();
664     void noneSupported();
665     void cancelPendingEventsAndCallbacks();
666     void waitForSourceChange();
667     void prepareToPlay();
668
669     URL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
670
671 #if ENABLE(VIDEO_TRACK)
672     void updateActiveTextTrackCues(const MediaTime&);
673     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
674
675     enum ReconfigureMode {
676         Immediately,
677         AfterDelay,
678     };
679     void markCaptionAndSubtitleTracksAsUnconfigured(ReconfigureMode);
680     void captionPreferencesChanged() override;
681 #endif
682
683     // These "internal" functions do not check user gesture restrictions.
684     void loadInternal();
685     bool playInternal();
686     void pauseInternal();
687
688     void prepareForLoad();
689     void allowVideoRendering();
690
691     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
692     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
693     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
694
695     void updateVolume();
696     void updatePlayState();
697     void setPlaying(bool);
698     bool potentiallyPlaying() const;
699     bool endedPlayback() const;
700     bool stoppedDueToErrors() const;
701     bool pausedForUserInteraction() const;
702     bool couldPlayIfEnoughData() const;
703     bool canTransitionFromAutoplayToPlay() const;
704
705     MediaTime minTimeSeekable() const;
706     MediaTime maxTimeSeekable() const;
707
708     // Pauses playback without changing any states or generating events
709     void setPausedInternal(bool);
710
711     void setPlaybackRateInternal(double);
712
713     void mediaCanStart() override;
714
715     void setShouldDelayLoadEvent(bool);
716     void invalidateCachedTime() const;
717     void refreshCachedTime() const;
718
719     bool hasMediaControls() const;
720     bool createMediaControls();
721     void configureMediaControls();
722
723     void prepareMediaFragmentURI();
724     void applyMediaFragmentURI();
725
726     void changeNetworkStateFromLoadingToIdle();
727
728     void removeBehaviorsRestrictionsAfterFirstUserGesture();
729
730     void updateMediaController();
731     bool isBlocked() const;
732     bool isBlockedOnMediaController() const;
733     bool hasCurrentSrc() const override { return !m_currentSrc.isEmpty(); }
734     bool isLiveStream() const override { return movieLoadType() == MediaPlayerEnums::LiveStream; }
735
736     void updateSleepDisabling();
737     bool shouldDisableSleep() const;
738
739 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
740     void didAddUserAgentShadowRoot(ShadowRoot*) override;
741     DOMWrapperWorld& ensureIsolatedWorld();
742     bool ensureMediaControlsInjectedScript();
743 #endif
744
745     // PlatformMediaSessionClient Overrides
746     PlatformMediaSession::MediaType mediaType() const override;
747     PlatformMediaSession::MediaType presentationType() const override;
748     PlatformMediaSession::DisplayType displayType() const override;
749     PlatformMediaSession::CharacteristicsFlags characteristics() const final;
750
751     void suspendPlayback() override;
752     void resumeAutoplaying() override;
753     void mayResumePlayback(bool shouldResume) override;
754     String mediaSessionTitle() const override;
755     double mediaSessionDuration() const override { return duration(); }
756     double mediaSessionCurrentTime() const override { return currentTime(); }
757     bool canReceiveRemoteControlCommands() const override { return true; }
758     void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType) override;
759     bool shouldOverrideBackgroundPlaybackRestriction(PlatformMediaSession::InterruptionType) const override;
760
761     void pageMutedStateDidChange() override;
762
763     bool effectiveMuted() const;
764
765     void registerWithDocument(Document&);
766     void unregisterWithDocument(Document&);
767
768     void updateCaptionContainer();
769     void ensureMediaControlsShadowRoot();
770
771 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
772     void prepareForDocumentSuspension() final;
773     void resumeFromDocumentSuspension() final;
774
775     enum class UpdateMediaState {
776         Asynchronously,
777         Synchronously,
778     };
779     void updateMediaState(UpdateMediaState updateState = UpdateMediaState::Synchronously);
780     bool hasPlaybackTargetAvailabilityListeners() const { return m_hasPlaybackTargetAvailabilityListeners; }
781 #endif
782
783     void isVisibleInViewportChanged() final;
784     void updateShouldAutoplay();
785
786     void pauseAfterDetachedTask();
787     void updatePlaybackControlsManager();
788
789     Timer m_pendingActionTimer;
790     Timer m_progressEventTimer;
791     Timer m_playbackProgressTimer;
792     Timer m_scanTimer;
793     GenericTaskQueue<Timer> m_seekTaskQueue;
794     GenericTaskQueue<Timer> m_resizeTaskQueue;
795     GenericTaskQueue<Timer> m_shadowDOMTaskQueue;
796     GenericTaskQueue<Timer> m_promiseTaskQueue;
797     GenericTaskQueue<Timer> m_pauseAfterDetachedTaskQueue;
798     RefPtr<TimeRanges> m_playedTimeRanges;
799     GenericEventQueue m_asyncEventQueue;
800
801     Vector<PlayPromise> m_pendingPlayPromises;
802
803     double m_requestedPlaybackRate;
804     double m_reportedPlaybackRate;
805     double m_defaultPlaybackRate;
806     bool m_webkitPreservesPitch;
807     NetworkState m_networkState;
808     ReadyState m_readyState;
809     ReadyState m_readyStateMaximum;
810     URL m_currentSrc;
811
812     RefPtr<MediaError> m_error;
813
814     struct PendingSeek {
815         PendingSeek(const MediaTime& now, const MediaTime& targetTime, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance)
816             : now(now)
817             , targetTime(targetTime)
818             , negativeTolerance(negativeTolerance)
819             , positiveTolerance(positiveTolerance)
820         {
821         }
822         MediaTime now;
823         MediaTime targetTime;
824         MediaTime negativeTolerance;
825         MediaTime positiveTolerance;
826     };
827     std::unique_ptr<PendingSeek> m_pendingSeek;
828     SeekType m_pendingSeekType { NoSeek };
829
830     double m_volume;
831     bool m_volumeInitialized;
832     MediaTime m_lastSeekTime;
833     
834     double m_previousProgressTime;
835
836     // The last time a timeupdate event was sent (based on monotonic clock).
837     double m_clockTimeAtLastUpdateEvent;
838
839     // The last time a timeupdate event was sent in movie time.
840     MediaTime m_lastTimeUpdateEventMovieTime;
841     
842     // Loading state.
843     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
844     LoadState m_loadState;
845     RefPtr<HTMLSourceElement> m_currentSourceNode;
846     RefPtr<Node> m_nextChildNodeToConsider;
847
848     VideoFullscreenMode m_videoFullscreenMode;
849 #if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
850     RetainPtr<PlatformLayer> m_videoFullscreenLayer;
851     FloatRect m_videoFullscreenFrame;
852     MediaPlayerEnums::VideoGravity m_videoFullscreenGravity;
853 #endif
854
855     std::unique_ptr<MediaPlayer> m_player;
856
857     MediaPlayerEnums::Preload m_preload;
858
859     DisplayMode m_displayMode;
860
861     // Counter incremented while processing a callback from the media player, so we can avoid
862     // calling the media engine recursively.
863     int m_processingMediaPlayerCallback;
864
865 #if ENABLE(MEDIA_SESSION)
866     String m_kind;
867     RefPtr<MediaSession> m_session;
868     bool m_shouldDuck { false };
869     uint64_t m_elementID;
870 #endif
871
872 #if ENABLE(MEDIA_SOURCE)
873     RefPtr<MediaSource> m_mediaSource;
874     unsigned long m_droppedVideoFrames;
875 #endif
876
877     mutable MediaTime m_cachedTime;
878     mutable double m_clockTimeAtLastCachedTimeUpdate;
879     mutable double m_minimumClockTimeToUpdateCachedTime;
880
881     MediaTime m_fragmentStartTime;
882     MediaTime m_fragmentEndTime;
883
884     typedef unsigned PendingActionFlags;
885     PendingActionFlags m_pendingActionFlags;
886
887     enum ActionAfterScanType {
888         Nothing, Play, Pause
889     };
890     ActionAfterScanType m_actionAfterScan;
891
892     enum ScanType { Seek, Scan };
893     ScanType m_scanType;
894     ScanDirection m_scanDirection;
895
896     bool m_firstTimePlaying : 1;
897     bool m_playing : 1;
898     bool m_isWaitingUntilMediaCanStart : 1;
899     bool m_shouldDelayLoadEvent : 1;
900     bool m_haveFiredLoadedData : 1;
901     bool m_inActiveDocument : 1;
902     bool m_autoplaying : 1;
903     bool m_muted : 1;
904     bool m_explicitlyMuted : 1;
905     bool m_initiallyMuted : 1;
906     bool m_paused : 1;
907     bool m_seeking : 1;
908
909     // data has not been loaded since sending a "stalled" event
910     bool m_sentStalledEvent : 1;
911
912     // time has not changed since sending an "ended" event
913     bool m_sentEndEvent : 1;
914
915     bool m_pausedInternal : 1;
916
917     // Not all media engines provide enough information about a file to be able to
918     // support progress events so setting m_sendProgressEvents disables them 
919     bool m_sendProgressEvents : 1;
920
921     bool m_closedCaptionsVisible : 1;
922     bool m_webkitLegacyClosedCaptionOverride : 1;
923     bool m_completelyLoaded : 1;
924     bool m_havePreparedToPlay : 1;
925     bool m_parsingInProgress : 1;
926     bool m_elementIsHidden : 1;
927     bool m_creatingControls : 1;
928
929 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
930     bool m_mediaControlsDependOnPageScaleFactor : 1;
931     bool m_haveSetUpCaptionContainer : 1;
932 #endif
933
934 #if ENABLE(VIDEO_TRACK)
935     bool m_tracksAreReady : 1;
936     bool m_haveVisibleTextTrack : 1;
937     bool m_processingPreferenceChange : 1;
938
939     String m_subtitleTrackLanguage;
940     MediaTime m_lastTextTrackUpdateTime;
941
942     CaptionUserPreferences::CaptionDisplayMode m_captionDisplayMode;
943
944     RefPtr<AudioTrackList> m_audioTracks;
945     RefPtr<TextTrackList> m_textTracks;
946     RefPtr<VideoTrackList> m_videoTracks;
947     Vector<RefPtr<TextTrack>> m_textTracksWhenResourceSelectionBegan;
948
949     CueIntervalTree m_cueTree;
950
951     CueList m_currentlyActiveCues;
952     int m_ignoreTrackDisplayUpdate;
953
954     bool m_requireCaptionPreferencesChangedCallbacks { false };
955 #endif
956
957 #if ENABLE(WEB_AUDIO)
958     // This is a weak reference, since m_audioSourceNode holds a reference to us.
959     // The value is set just after the MediaElementAudioSourceNode is created.
960     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
961     MediaElementAudioSourceNode* m_audioSourceNode;
962 #endif
963
964     String m_mediaGroup;
965     friend class MediaController;
966     RefPtr<MediaController> m_mediaController;
967
968     std::unique_ptr<DisplaySleepDisabler> m_sleepDisabler;
969
970     friend class TrackDisplayUpdateScope;
971
972 #if ENABLE(ENCRYPTED_MEDIA_V2)
973     RefPtr<MediaKeys> m_mediaKeys;
974 #endif
975
976     std::unique_ptr<MediaElementSession> m_mediaSession;
977     PageActivityAssertionToken m_activityToken;
978     size_t m_reportedExtraMemoryCost;
979
980 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
981     friend class MediaControlsHost;
982     RefPtr<MediaControlsHost> m_mediaControlsHost;
983     RefPtr<DOMWrapperWorld> m_isolatedWorld;
984 #endif
985
986 #if ENABLE(MEDIA_STREAM)
987     RefPtr<MediaStream> m_mediaStreamSrcObject;
988 #endif
989
990 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
991     MediaProducer::MediaStateFlags m_mediaState { MediaProducer::IsNotPlaying };
992     bool m_hasPlaybackTargetAvailabilityListeners { false };
993     bool m_failedToPlayToWirelessTarget { false };
994     bool m_isPlayingToWirelessTarget { false };
995 #endif
996 };
997
998 #if ENABLE(VIDEO_TRACK)
999 #ifndef NDEBUG
1000 // Template specialization required by PodIntervalTree in debug mode.
1001 template <>
1002 struct ValueToString<TextTrackCue*> {
1003     static String string(TextTrackCue* const& cue)
1004     {
1005         String text;
1006         if (cue->isRenderable())
1007             text = toVTTCue(cue)->text();
1008         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());
1009     }
1010 };
1011 #endif
1012 #endif
1013
1014 #ifndef NDEBUG
1015 template<>
1016 struct ValueToString<MediaTime> {
1017     static String string(const MediaTime& time)
1018     {
1019         return toString(time);
1020     }
1021 };
1022 #endif
1023
1024 } // namespace WebCore
1025
1026 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::HTMLMediaElement)
1027     static bool isType(const WebCore::Element& element) { return element.isMediaElement(); }
1028     static bool isType(const WebCore::Node& node) { return is<WebCore::Element>(node) && isType(downcast<WebCore::Element>(node)); }
1029 SPECIALIZE_TYPE_TRAITS_END()
1030
1031 #endif
1032 #endif