2296c66df97bac4bcc9ea3c27b200fb30bb6e289
[WebKit-https.git] / Source / WebCore / html / HTMLMediaElement.h
1 /*
2  * Copyright (C) 2007-2017 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 #pragma once
27
28 #if ENABLE(VIDEO)
29
30 #include "ActiveDOMObject.h"
31 #include "ApplicationStateChangeListener.h"
32 #include "AutoplayEvent.h"
33 #include "DeferrableTask.h"
34 #include "GenericEventQueue.h"
35 #include "HTMLElement.h"
36 #include "HTMLMediaElementEnums.h"
37 #include "MediaCanStartListener.h"
38 #include "MediaControllerInterface.h"
39 #include "MediaElementSession.h"
40 #include "MediaPlayer.h"
41 #include "MediaProducer.h"
42 #include "VisibilityChangeClient.h"
43 #include <wtf/Function.h>
44 #include <wtf/LoggerHelper.h>
45 #include <wtf/WeakPtr.h>
46
47 #if ENABLE(VIDEO_TRACK)
48 #include "AudioTrack.h"
49 #include "CaptionUserPreferences.h"
50 #include "PODIntervalTree.h"
51 #include "TextTrack.h"
52 #include "TextTrackCue.h"
53 #include "VTTCue.h"
54 #include "VideoTrack.h"
55 #endif
56
57 #if USE(AUDIO_SESSION) && PLATFORM(MAC)
58 #include "AudioSession.h"
59 #endif
60
61 #if ENABLE(ENCRYPTED_MEDIA)
62 #include "CDMClient.h"
63 #endif
64
65 #ifndef NDEBUG
66 #include <wtf/StringPrintStream.h>
67 #endif
68
69 namespace PAL {
70 class SleepDisabler;
71 }
72
73 namespace WebCore {
74
75 class AudioSourceProvider;
76 class AudioTrackList;
77 class AudioTrackPrivate;
78 class Blob;
79 class DOMException;
80 class DOMWrapperWorld;
81 class DeferredPromise;
82 class Event;
83 class HTMLSourceElement;
84 class HTMLTrackElement;
85 class InbandTextTrackPrivate;
86 class JSDOMGlobalObject;
87 class MediaController;
88 class MediaControls;
89 class MediaControlsHost;
90 class MediaElementAudioSourceNode;
91 class MediaError;
92 class MediaKeys;
93 class MediaResourceLoader;
94 class MediaSession;
95 class MediaSource;
96 class MediaStream;
97 class RenderMedia;
98 class ScriptController;
99 class ScriptExecutionContext;
100 class SourceBuffer;
101 class TextTrackList;
102 class TimeRanges;
103 class VideoPlaybackQuality;
104 class VideoTrackList;
105 class VideoTrackPrivate;
106 class WebKitMediaKeys;
107
108 template<typename> class DOMPromiseDeferred;
109
110 #if ENABLE(VIDEO_TRACK)
111 using CueIntervalTree = PODIntervalTree<MediaTime, TextTrackCue*>;
112 using CueInterval = CueIntervalTree::IntervalType;
113 using CueList = Vector<CueInterval>;
114 #endif
115
116 using MediaProvider = Optional<Variant<
117 #if ENABLE(MEDIA_STREAM)
118     RefPtr<MediaStream>,
119 #endif
120 #if ENABLE(MEDIA_SOURCE)
121     RefPtr<MediaSource>,
122 #endif
123     RefPtr<Blob>>>;
124
125 class HTMLMediaElement
126     : public HTMLElement
127     , public ActiveDOMObject
128     , public MediaControllerInterface
129     , public PlatformMediaSessionClient
130     , private MediaCanStartListener
131     , private MediaPlayerClient
132     , private MediaProducer
133     , private VisibilityChangeClient
134     , private ApplicationStateChangeListener
135 #if ENABLE(VIDEO_TRACK)
136     , private AudioTrackClient
137     , private TextTrackClient
138     , private VideoTrackClient
139 #endif
140 #if USE(AUDIO_SESSION) && PLATFORM(MAC)
141     , private AudioSession::MutedStateObserver
142 #endif
143 #if ENABLE(ENCRYPTED_MEDIA)
144     , private CDMClient
145 #endif
146 #if !RELEASE_LOG_DISABLED
147     , private LoggerHelper
148 #endif
149 {
150     WTF_MAKE_ISO_ALLOCATED(HTMLMediaElement);
151 public:
152     RefPtr<MediaPlayer> player() const { return m_player; }
153
154     virtual bool isVideo() const { return false; }
155     bool hasVideo() const override { return false; }
156     bool hasAudio() const override;
157
158     static HashSet<HTMLMediaElement*>& allMediaElements();
159
160     WEBCORE_EXPORT static RefPtr<HTMLMediaElement> bestMediaElementForShowingPlaybackControlsManager(MediaElementSession::PlaybackControlsPurpose);
161
162     static bool isRunningDestructor();
163
164     WEBCORE_EXPORT void rewind(double timeDelta);
165     WEBCORE_EXPORT void returnToRealtime() override;
166
167     // Eventually overloaded in HTMLVideoElement
168     bool supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenMode) const override { return false; };
169
170     bool supportsScanning() const override;
171
172     bool canSaveMediaData() const;
173
174     bool doesHaveAttribute(const AtomicString&, AtomicString* value = nullptr) const override;
175
176     PlatformLayer* platformLayer() const;
177     bool isVideoLayerInline();
178     void setPreparedToReturnVideoLayerToInline(bool);
179     void waitForPreparedForInlineThen(WTF::Function<void()>&& completionHandler = [] { });
180 #if PLATFORM(IOS_FAMILY) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
181     void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler = [] { });
182 #ifdef __OBJC__
183     PlatformLayer* videoFullscreenLayer() const { return m_videoFullscreenLayer.get(); }
184 #endif
185     void setVideoFullscreenFrame(FloatRect);
186     void setVideoFullscreenGravity(MediaPlayerEnums::VideoGravity);
187     MediaPlayerEnums::VideoGravity videoFullscreenGravity() const { return m_videoFullscreenGravity; }
188 #endif
189
190     void scheduleCheckPlaybackTargetCompatability();
191     void checkPlaybackTargetCompatablity();
192     void scheduleResolvePendingPlayPromises();
193     void scheduleRejectPendingPlayPromises(Ref<DOMException>&&);
194     using PlayPromiseVector = Vector<DOMPromiseDeferred<void>>;
195     void rejectPendingPlayPromises(PlayPromiseVector&&, Ref<DOMException>&&);
196     void resolvePendingPlayPromises(PlayPromiseVector&&);
197     void scheduleNotifyAboutPlaying();
198     void notifyAboutPlaying(PlayPromiseVector&&);
199     
200     MediaPlayerEnums::MovieLoadType movieLoadType() const;
201     
202     bool inActiveDocument() const { return m_inActiveDocument; }
203
204     Document* hostingDocument() const final { return &document(); }
205
206 // DOM API
207 // error state
208     WEBCORE_EXPORT MediaError* error() const;
209
210     const URL& currentSrc() const { return m_currentSrc; }
211
212     const MediaProvider& srcObject() const { return m_mediaProvider; }
213     void setSrcObject(MediaProvider&&);
214
215     WEBCORE_EXPORT void setCrossOrigin(const AtomicString&);
216     WEBCORE_EXPORT String crossOrigin() const;
217
218 // network state
219     using HTMLMediaElementEnums::NetworkState;
220     WEBCORE_EXPORT NetworkState networkState() const;
221
222     WEBCORE_EXPORT String preload() const;
223     WEBCORE_EXPORT void setPreload(const String&);
224
225     Ref<TimeRanges> buffered() const override;
226     WEBCORE_EXPORT void load();
227     WEBCORE_EXPORT String canPlayType(const String& mimeType) const;
228
229 // ready state
230     using HTMLMediaElementEnums::ReadyState;
231     ReadyState readyState() const override;
232     WEBCORE_EXPORT bool seeking() const;
233
234 // playback state
235     WEBCORE_EXPORT double currentTime() const override;
236     WEBCORE_EXPORT void setCurrentTime(double) override;
237     void setCurrentTimeWithTolerance(double, double toleranceBefore, double toleranceAfter);
238     double currentTimeForBindings() const { return currentTime(); }
239     WEBCORE_EXPORT ExceptionOr<void> setCurrentTimeForBindings(double);
240     WEBCORE_EXPORT double getStartDate() const;
241     WEBCORE_EXPORT double duration() const override;
242     WEBCORE_EXPORT bool paused() const override;
243     double defaultPlaybackRate() const override;
244     void setDefaultPlaybackRate(double) override;
245     WEBCORE_EXPORT double playbackRate() const override;
246     void setPlaybackRate(double) override;
247
248 // MediaTime versions of playback state
249     MediaTime currentMediaTime() const;
250     void setCurrentTime(const MediaTime&);
251     MediaTime durationMediaTime() const;
252     WEBCORE_EXPORT void fastSeek(const MediaTime&);
253
254     void updatePlaybackRate();
255     WEBCORE_EXPORT bool webkitPreservesPitch() const;
256     WEBCORE_EXPORT void setWebkitPreservesPitch(bool);
257     Ref<TimeRanges> played() override;
258     Ref<TimeRanges> seekable() const override;
259     double seekableTimeRangesLastModifiedTime() const;
260     double liveUpdateInterval() const;
261     WEBCORE_EXPORT bool ended() const;
262     bool autoplay() const;
263     bool isAutoplaying() const { return m_autoplaying; }
264     bool loop() const;
265     void setLoop(bool b);
266
267     void play(DOMPromiseDeferred<void>&&);
268
269     WEBCORE_EXPORT void play() override;
270     WEBCORE_EXPORT void pause() override;
271     void setShouldBufferData(bool);
272     WEBCORE_EXPORT bool shouldBufferData() const { return m_shouldBufferData; }
273     WEBCORE_EXPORT void fastSeek(double);
274     double minFastReverseRate() const;
275     double maxFastForwardRate() const;
276
277     void purgeBufferedDataIfPossible();
278
279 // captions
280     WEBCORE_EXPORT bool webkitHasClosedCaptions() const;
281     WEBCORE_EXPORT bool webkitClosedCaptionsVisible() const;
282     WEBCORE_EXPORT void setWebkitClosedCaptionsVisible(bool);
283
284     bool elementIsHidden() const { return m_elementIsHidden; }
285
286 #if ENABLE(MEDIA_STATISTICS)
287 // Statistics
288     unsigned webkitAudioDecodedByteCount() const;
289     unsigned webkitVideoDecodedByteCount() const;
290 #endif
291
292 #if ENABLE(MEDIA_SOURCE)
293 //  Media Source.
294     void detachMediaSource();
295     void incrementDroppedFrameCount() { ++m_droppedVideoFrames; }
296     size_t maximumSourceBufferSize(const SourceBuffer&) const;
297 #endif
298
299 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
300     WebKitMediaKeys* webkitKeys() const { return m_webKitMediaKeys.get(); }
301     void webkitSetMediaKeys(WebKitMediaKeys*);
302
303     void keyAdded();
304 #endif
305
306 #if ENABLE(ENCRYPTED_MEDIA)
307     MediaKeys* mediaKeys() const;
308
309     void setMediaKeys(MediaKeys*, Ref<DeferredPromise>&&);
310 #endif
311
312 // controls
313     WEBCORE_EXPORT bool controls() const;
314     WEBCORE_EXPORT void setControls(bool);
315     WEBCORE_EXPORT double volume() const override;
316     WEBCORE_EXPORT ExceptionOr<void> setVolume(double) override;
317     WEBCORE_EXPORT bool muted() const override;
318     WEBCORE_EXPORT void setMuted(bool) override;
319
320     WEBCORE_EXPORT void togglePlayState();
321     WEBCORE_EXPORT void beginScrubbing() override;
322     WEBCORE_EXPORT void endScrubbing() override;
323
324     void beginScanning(ScanDirection) override;
325     void endScanning() override;
326     double nextScanRate();
327
328     WEBCORE_EXPORT bool canPlay() const override;
329
330     double percentLoaded() const;
331
332     bool shouldForceControlsDisplay() const;
333
334 #if ENABLE(VIDEO_TRACK)
335     ExceptionOr<TextTrack&> addTextTrack(const String& kind, const String& label, const String& language);
336
337     AudioTrackList& ensureAudioTracks();
338     TextTrackList& ensureTextTracks();
339     VideoTrackList& ensureVideoTracks();
340     AudioTrackList* audioTracks() const { return m_audioTracks.get(); }
341     TextTrackList* textTracks() const { return m_textTracks.get(); }
342     VideoTrackList* videoTracks() const { return m_videoTracks.get(); }
343
344     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
345
346     void addAudioTrack(Ref<AudioTrack>&&);
347     void addTextTrack(Ref<TextTrack>&&);
348     void addVideoTrack(Ref<VideoTrack>&&);
349     void removeAudioTrack(Ref<AudioTrack>&&);
350     void removeTextTrack(Ref<TextTrack>&&, bool scheduleEvent = true);
351     void removeVideoTrack(Ref<VideoTrack>&&);
352     void forgetResourceSpecificTracks();
353     void closeCaptionTracksChanged();
354     void notifyMediaPlayerOfTextTrackChanges();
355
356     virtual void didAddTextTrack(HTMLTrackElement&);
357     virtual void didRemoveTextTrack(HTMLTrackElement&);
358
359     void mediaPlayerDidAddAudioTrack(AudioTrackPrivate&) final;
360     void mediaPlayerDidAddTextTrack(InbandTextTrackPrivate&) final;
361     void mediaPlayerDidAddVideoTrack(VideoTrackPrivate&) final;
362     void mediaPlayerDidRemoveAudioTrack(AudioTrackPrivate&) final;
363     void mediaPlayerDidRemoveTextTrack(InbandTextTrackPrivate&) final;
364     void mediaPlayerDidRemoveVideoTrack(VideoTrackPrivate&) final;
365
366 #if ENABLE(AVF_CAPTIONS)
367     Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() final;
368 #endif
369
370     struct TrackGroup;
371     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
372     void scheduleConfigureTextTracks();
373     void configureTextTracks();
374     void configureTextTrackGroup(const TrackGroup&);
375
376     void setSelectedTextTrack(TextTrack*);
377
378     bool textTracksAreReady() const;
379     using HTMLMediaElementEnums::TextTrackVisibilityCheckType;
380     void configureTextTrackDisplay(TextTrackVisibilityCheckType checkType = CheckTextTrackVisibility);
381     void updateTextTrackDisplay();
382
383     // AudioTrackClient
384     void audioTrackEnabledChanged(AudioTrack&) final;
385
386     void textTrackReadyStateChanged(TextTrack*);
387
388     // TextTrackClient
389     void textTrackKindChanged(TextTrack&) override;
390     void textTrackModeChanged(TextTrack&) override;
391     void textTrackAddCues(TextTrack&, const TextTrackCueList&) override;
392     void textTrackRemoveCues(TextTrack&, const TextTrackCueList&) override;
393     void textTrackAddCue(TextTrack&, TextTrackCue&) override;
394     void textTrackRemoveCue(TextTrack&, TextTrackCue&) override;
395
396     // VideoTrackClient
397     void videoTrackSelectedChanged(VideoTrack&) final;
398
399     bool requiresTextTrackRepresentation() const;
400     void setTextTrackRepresentation(TextTrackRepresentation*);
401     void syncTextTrackBounds();
402 #endif
403
404 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
405     void webkitShowPlaybackTargetPicker();
406     bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
407     bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
408
409     void wirelessRoutesAvailableDidChange() override;
410     void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&) override;
411     void setShouldPlayToPlaybackTarget(bool) override;
412 #endif
413     bool isPlayingToWirelessPlaybackTarget() const override { return m_isPlayingToWirelessTarget; };
414     void setIsPlayingToWirelessTarget(bool);
415     bool webkitCurrentPlaybackTargetIsWireless() const;
416
417     void setPlayingOnSecondScreen(bool value);
418     bool isPlayingOnSecondScreen() const override { return m_playingOnSecondScreen; }
419
420     bool isPlayingToExternalTarget() const { return isPlayingToWirelessPlaybackTarget() || isPlayingOnSecondScreen(); }
421
422     // EventTarget function.
423     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
424     // causes an ambiguity error at compile time. This class's constructor
425     // ensures that both implementations return document, so return the result
426     // of one of them here.
427     using HTMLElement::scriptExecutionContext;
428
429     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
430     bool didPassCORSAccessCheck() const { return m_player && m_player->didPassCORSAccessCheck(); }
431     bool wouldTaintOrigin(const SecurityOrigin& origin) const { return m_player && m_player->wouldTaintOrigin(origin); }
432     
433     WEBCORE_EXPORT bool isFullscreen() const override;
434     bool isStandardFullscreen() const;
435     void toggleStandardFullscreenState();
436
437     using MediaPlayerEnums::VideoFullscreenMode;
438     VideoFullscreenMode fullscreenMode() const { return m_videoFullscreenMode; }
439     virtual void fullscreenModeChanged(VideoFullscreenMode);
440
441     void enterFullscreen(VideoFullscreenMode);
442     void enterFullscreen() override;
443     WEBCORE_EXPORT void exitFullscreen();
444     WEBCORE_EXPORT void setVideoFullscreenStandby(bool);
445
446     bool hasClosedCaptions() const override;
447     bool closedCaptionsVisible() const override;
448     void setClosedCaptionsVisible(bool) override;
449
450     MediaControls* mediaControls() const;
451
452     void sourceWasRemoved(HTMLSourceElement&);
453     void sourceWasAdded(HTMLSourceElement&);
454
455     void privateBrowsingStateDidChange() override;
456
457     // Media cache management.
458     WEBCORE_EXPORT static void setMediaCacheDirectory(const String&);
459     WEBCORE_EXPORT static const String& mediaCacheDirectory();
460     WEBCORE_EXPORT static HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String&);
461     WEBCORE_EXPORT static void clearMediaCache(const String&, WallTime modifiedSince = { });
462     WEBCORE_EXPORT static void clearMediaCacheForOrigins(const String&, const HashSet<RefPtr<SecurityOrigin>>&);
463     static void resetMediaEngines();
464
465     bool isPlaying() const { return m_playing; }
466
467     bool hasPendingActivity() const override;
468
469 #if ENABLE(WEB_AUDIO)
470     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
471     void setAudioSourceNode(MediaElementAudioSourceNode*);
472
473     AudioSourceProvider* audioSourceProvider();
474 #endif
475
476     using HTMLMediaElementEnums::InvalidURLAction;
477     bool isSafeToLoadURL(const URL&, InvalidURLAction);
478
479     const String& mediaGroup() const;
480     void setMediaGroup(const String&);
481
482     MediaController* controller() const;
483     void setController(RefPtr<MediaController>&&);
484
485     MediaController* controllerForBindings() const { return controller(); }
486     void setControllerForBindings(MediaController*);
487
488     void enteredOrExitedFullscreen() { configureMediaControls(); }
489
490     unsigned long long fileSize() const;
491
492     void mediaLoadingFailed(MediaPlayerEnums::NetworkState);
493     void mediaLoadingFailedFatally(MediaPlayerEnums::NetworkState);
494
495 #if ENABLE(MEDIA_SESSION)
496     WEBCORE_EXPORT double playerVolume() const;
497
498     const String& kind() const { return m_kind; }
499     void setKind(const String& kind) { m_kind = kind; }
500
501     MediaSession* session() const;
502     void setSession(MediaSession*);
503
504     void setShouldDuck(bool);
505
506     static HTMLMediaElement* elementWithID(uint64_t);
507     uint64_t elementID() const { return m_elementID; }
508 #endif
509
510     RefPtr<VideoPlaybackQuality> getVideoPlaybackQuality();
511
512     MediaPlayerEnums::Preload preloadValue() const { return m_preload; }
513     MediaElementSession& mediaSession() const { return *m_mediaSession; }
514
515 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
516     void pageScaleFactorChanged();
517     void userInterfaceLayoutDirectionChanged();
518     WEBCORE_EXPORT String getCurrentMediaControlsStatus();
519
520     MediaControlsHost* mediaControlsHost() { return m_mediaControlsHost.get(); }
521 #endif
522
523     bool isDisablingSleep() const { return m_sleepDisabler.get(); }
524
525     double maxBufferedTime() const;
526
527     MediaProducer::MediaStateFlags mediaState() const override;
528
529     void layoutSizeChanged();
530     void visibilityDidChange();
531
532     void allowsMediaDocumentInlinePlaybackChanged();
533     void updateShouldPlay();
534
535     RenderMedia* renderer() const;
536
537     void resetPlaybackSessionState();
538     bool isVisibleInViewport() const;
539     bool hasEverNotifiedAboutPlaying() const;
540     void setShouldDelayLoadEvent(bool);
541
542     bool hasEverHadAudio() const { return m_hasEverHadAudio; }
543     bool hasEverHadVideo() const { return m_hasEverHadVideo; }
544
545     double playbackStartedTime() const { return m_playbackStartedTime; }
546
547     bool isTemporarilyAllowingInlinePlaybackAfterFullscreen() const {return m_temporarilyAllowingInlinePlaybackAfterFullscreen; }
548
549     void isVisibleInViewportChanged();
550     void updateRateChangeRestrictions();
551
552     WEBCORE_EXPORT const MediaResourceLoader* lastMediaResourceLoaderForTesting() const;
553
554 #if ENABLE(MEDIA_STREAM)
555     void mediaStreamCaptureStarted() { resumeAutoplaying(); }
556     bool hasMediaStreamSrcObject() const { return m_mediaProvider && WTF::holds_alternative<RefPtr<MediaStream>>(*m_mediaProvider); }
557 #endif
558
559     bool supportsSeeking() const override;
560
561 #if !RELEASE_LOG_DISABLED
562     const Logger& logger() const final { return *m_logger.get(); }
563     const void* logIdentifier() const final { return m_logIdentifier; }
564     WTFLogChannel& logChannel() const final;
565 #endif
566
567     bool willLog(WTFLogLevel) const;
568
569     bool isSuspended() const final;
570
571     WEBCORE_EXPORT void didBecomeFullscreenElement() override;
572     WEBCORE_EXPORT void willExitFullscreen();
573
574     enum class AutoplayEventPlaybackState { None, PreventedAutoplay, StartedWithUserGesture, StartedWithoutUserGesture };
575
576     using HTMLElement::weakPtrFactory;
577
578 protected:
579     HTMLMediaElement(const QualifiedName&, Document&, bool createdByParser);
580     virtual void finishInitialization();
581     virtual ~HTMLMediaElement();
582
583     void parseAttribute(const QualifiedName&, const AtomicString&) override;
584     void finishParsingChildren() override;
585     bool isURLAttribute(const Attribute&) const override;
586     void willAttachRenderers() override;
587     void didAttachRenderers() override;
588     void willDetachRenderers() override;
589     void didDetachRenderers() override;
590
591     void didMoveToNewDocument(Document& oldDocument, Document& newDocument) override;
592
593     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
594     DisplayMode displayMode() const { return m_displayMode; }
595     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
596     
597     bool isMediaElement() const final { return true; }
598
599 #if ENABLE(VIDEO_TRACK)
600     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
601     void beginIgnoringTrackDisplayUpdateRequests();
602     void endIgnoringTrackDisplayUpdateRequests();
603 #endif
604
605     RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
606
607 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
608     bool mediaControlsDependOnPageScaleFactor() const { return m_mediaControlsDependOnPageScaleFactor; }
609     void setMediaControlsDependOnPageScaleFactor(bool);
610     void updateMediaControlsAfterPresentationModeChange();
611 #endif
612
613     void scheduleEvent(const AtomicString& eventName);
614
615 private:
616     void createMediaPlayer();
617
618     bool supportsFocus() const override;
619     bool isMouseFocusable() const override;
620     bool rendererIsNeeded(const RenderStyle&) override;
621     bool childShouldCreateRenderer(const Node&) const override;
622     InsertedIntoAncestorResult insertedIntoAncestor(InsertionType, ContainerNode&) override;
623     void didFinishInsertingNode() override;
624     void removedFromAncestor(RemovalType, ContainerNode&) override;
625     void didRecalcStyle(Style::Change) override;
626
627     void willBecomeFullscreenElement() override;
628     void willStopBeingFullscreenElement() override;
629
630     // ActiveDOMObject API.
631     const char* activeDOMObjectName() const override;
632     bool canSuspendForDocumentSuspension() const override;
633     void suspend(ReasonForSuspension) override;
634     void resume() override;
635     void stop() override;
636     void stopWithoutDestroyingMediaPlayer();
637     void contextDestroyed() override;
638     
639     void mediaVolumeDidChange() override;
640
641     void visibilityStateChanged() override;
642
643     virtual void updateDisplayState() { }
644     
645     void setReadyState(MediaPlayerEnums::ReadyState);
646     void setNetworkState(MediaPlayerEnums::NetworkState);
647
648     double effectivePlaybackRate() const;
649     double requestedPlaybackRate() const;
650
651     void mediaPlayerNetworkStateChanged(MediaPlayer*) override;
652     void mediaPlayerReadyStateChanged(MediaPlayer*) override;
653     void mediaPlayerTimeChanged(MediaPlayer*) override;
654     void mediaPlayerVolumeChanged(MediaPlayer*) override;
655     void mediaPlayerMuteChanged(MediaPlayer*) override;
656     void mediaPlayerDurationChanged(MediaPlayer*) override;
657     void mediaPlayerRateChanged(MediaPlayer*) override;
658     void mediaPlayerPlaybackStateChanged(MediaPlayer*) override;
659     void mediaPlayerSawUnsupportedTracks(MediaPlayer*) override;
660     void mediaPlayerResourceNotSupported(MediaPlayer*) override;
661     void mediaPlayerRepaint(MediaPlayer*) override;
662     void mediaPlayerSizeChanged(MediaPlayer*) override;
663     bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) override;
664     void mediaPlayerRenderingModeChanged(MediaPlayer*) override;
665     bool mediaPlayerAcceleratedCompositingEnabled() override;
666     void mediaPlayerEngineUpdated(MediaPlayer*) override;
667
668     void scheduleMediaEngineWasUpdated();
669     void mediaEngineWasUpdated();
670
671     void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) override;
672     void mediaPlayerCharacteristicChanged(MediaPlayer*) override;
673
674 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
675     RefPtr<ArrayBuffer> mediaPlayerCachedKeyForKeyId(const String& keyId) const override;
676     bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) override;
677     String mediaPlayerMediaKeysStorageDirectory() const override;
678 #endif
679
680 #if ENABLE(ENCRYPTED_MEDIA)
681     void mediaPlayerInitializationDataEncountered(const String&, RefPtr<ArrayBuffer>&&) final;
682     void mediaPlayerWaitingForKeyChanged() final;
683
684     void attemptToDecrypt();
685     void attemptToResumePlaybackIfNecessary();
686
687     // CDMClient
688     void cdmClientAttemptToResumePlaybackIfNecessary() final;
689 #endif
690     
691 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
692     void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) override;
693     void enqueuePlaybackTargetAvailabilityChangedEvent();
694
695     using EventTarget::dispatchEvent;
696     void dispatchEvent(Event&) override;
697 #endif
698
699 #if ENABLE(MEDIA_SESSION)
700     void setSessionInternal(MediaSession&);
701 #endif
702
703     String mediaPlayerReferrer() const override;
704     String mediaPlayerUserAgent() const override;
705
706     void mediaPlayerEnterFullscreen() override;
707     void mediaPlayerExitFullscreen() override;
708     bool mediaPlayerIsFullscreen() const override;
709     bool mediaPlayerIsFullscreenPermitted() const override;
710     bool mediaPlayerIsVideo() const override;
711     LayoutRect mediaPlayerContentBoxRect() const override;
712     float mediaPlayerContentsScale() const override;
713     void mediaPlayerSetSize(const IntSize&) override;
714     void mediaPlayerPause() override;
715     void mediaPlayerPlay() override;
716     bool mediaPlayerPlatformVolumeConfigurationRequired() const override;
717     bool mediaPlayerIsPaused() const override;
718     bool mediaPlayerIsLooping() const override;
719     CachedResourceLoader* mediaPlayerCachedResourceLoader() override;
720     RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() override;
721     bool mediaPlayerShouldUsePersistentCache() const override;
722     const String& mediaPlayerMediaCacheDirectory() const override;
723
724 #if PLATFORM(WIN) && USE(AVFOUNDATION)
725     GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const override;
726 #endif
727
728     void mediaPlayerActiveSourceBuffersChanged(const MediaPlayer*) override;
729
730     void mediaPlayerHandlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType command) override { didReceiveRemoteControlCommand(command, nullptr); }
731     String sourceApplicationIdentifier() const override;
732     String mediaPlayerSourceApplicationIdentifier() const override { return sourceApplicationIdentifier(); }
733     Vector<String> mediaPlayerPreferredAudioCharacteristics() const override;
734
735 #if PLATFORM(IOS_FAMILY)
736     String mediaPlayerNetworkInterfaceName() const override;
737     bool mediaPlayerGetRawCookies(const URL&, Vector<Cookie>&) const override;
738 #endif
739
740     bool mediaPlayerIsInMediaDocument() const final;
741     void mediaPlayerEngineFailedToLoad() const final;
742
743     double mediaPlayerRequestedPlaybackRate() const final;
744     VideoFullscreenMode mediaPlayerFullscreenMode() const final { return fullscreenMode(); }
745     bool mediaPlayerIsVideoFullscreenStandby() const final { return m_videoFullscreenStandby; }
746     bool mediaPlayerShouldDisableSleep() const final { return shouldDisableSleep() == SleepType::Display; }
747     bool mediaPlayerShouldCheckHardwareSupport() const final;
748     const Vector<ContentType>& mediaContentTypesRequiringHardwareSupport() const final;
749
750 #if USE(GSTREAMER)
751     void requestInstallMissingPlugins(const String& details, const String& description, MediaPlayerRequestInstallMissingPluginsCallback&) final;
752 #endif
753
754     void pendingActionTimerFired();
755     void progressEventTimerFired();
756     void playbackProgressTimerFired();
757     void scanTimerFired();
758     void seekTask();
759     void startPlaybackProgressTimer();
760     void startProgressEventTimer();
761     void stopPeriodicTimers();
762     void cancelPendingTasks();
763     void closeTaskQueues();
764
765     void seek(const MediaTime&);
766     void seekInternal(const MediaTime&);
767     void seekWithTolerance(const MediaTime&, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance, bool fromDOM);
768     void finishSeek();
769     void clearSeeking();
770     void addPlayedRange(const MediaTime& start, const MediaTime& end);
771     
772     void scheduleTimeupdateEvent(bool periodicEvent);
773     virtual void scheduleResizeEvent() { }
774     virtual void scheduleResizeEventIfSizeChanged() { }
775
776     void selectMediaResource();
777     void loadResource(const URL&, ContentType&, const String& keySystem);
778     void scheduleNextSourceChild();
779     void loadNextSourceChild();
780     void userCancelledLoad();
781     void clearMediaPlayer();
782     bool havePotentialSourceChild();
783     void noneSupported();
784     void cancelPendingEventsAndCallbacks();
785     void waitForSourceChange();
786     void prepareToPlay();
787
788     URL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
789
790 #if ENABLE(VIDEO_TRACK)
791     void updateActiveTextTrackCues(const MediaTime&);
792     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
793
794     enum ReconfigureMode {
795         Immediately,
796         AfterDelay,
797     };
798     void markCaptionAndSubtitleTracksAsUnconfigured(ReconfigureMode);
799     void captionPreferencesChanged() override;
800     CaptionUserPreferences::CaptionDisplayMode captionDisplayMode();
801 #endif
802
803     // These "internal" functions do not check user gesture restrictions.
804     void playInternal();
805     void pauseInternal();
806
807     void prepareForLoad();
808     void allowVideoRendering();
809
810     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
811     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
812     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
813
814     void scheduleUpdatePlayState();
815     void updatePlayState();
816
817     void updateVolume();
818     void setPlaying(bool);
819     bool potentiallyPlaying() const;
820     bool endedPlayback() const;
821     bool stoppedDueToErrors() const;
822     bool pausedForUserInteraction() const;
823     bool couldPlayIfEnoughData() const;
824     void dispatchPlayPauseEventsIfNeedsQuirks();
825     SuccessOr<MediaPlaybackDenialReason> canTransitionFromAutoplayToPlay() const;
826
827     void setAutoplayEventPlaybackState(AutoplayEventPlaybackState);
828     void userDidInterfereWithAutoplay();
829     void handleAutoplayEvent(AutoplayEvent);
830
831     MediaTime minTimeSeekable() const;
832     MediaTime maxTimeSeekable() const;
833
834     // Pauses playback without changing any states or generating events
835     void setPausedInternal(bool);
836
837     void setPlaybackRateInternal(double);
838
839     void mediaCanStart(Document&) final;
840
841     void invalidateCachedTime() const;
842     void refreshCachedTime() const;
843
844     bool hasMediaControls() const;
845     bool createMediaControls();
846     void configureMediaControls();
847
848     void prepareMediaFragmentURI();
849     void applyMediaFragmentURI();
850
851     void changeNetworkStateFromLoadingToIdle();
852
853     void removeBehaviorsRestrictionsAfterFirstUserGesture(MediaElementSession::BehaviorRestrictions mask = MediaElementSession::AllRestrictions);
854
855     void updateMediaController();
856     bool isBlocked() const;
857     bool isBlockedOnMediaController() const;
858     bool hasCurrentSrc() const override { return !m_currentSrc.isEmpty(); }
859     bool isLiveStream() const override { return movieLoadType() == MediaPlayerEnums::LiveStream; }
860
861     void updateSleepDisabling();
862     enum class SleepType {
863         None,
864         Display,
865         System,
866     };
867     SleepType shouldDisableSleep() const;
868
869 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
870     void didAddUserAgentShadowRoot(ShadowRoot&) override;
871     DOMWrapperWorld& ensureIsolatedWorld();
872     bool ensureMediaControlsInjectedScript();
873 #endif
874
875     PlatformMediaSession::MediaType mediaType() const override;
876     PlatformMediaSession::MediaType presentationType() const override;
877     PlatformMediaSession::DisplayType displayType() const override;
878     PlatformMediaSession::CharacteristicsFlags characteristics() const final;
879
880     void suspendPlayback() override;
881     void resumeAutoplaying() override;
882     void mayResumePlayback(bool shouldResume) override;
883     uint64_t mediaSessionUniqueIdentifier() const final;
884     String mediaSessionTitle() const override;
885     double mediaSessionDuration() const override { return duration(); }
886     double mediaSessionCurrentTime() const override { return currentTime(); }
887     bool canReceiveRemoteControlCommands() const override { return true; }
888     void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType, const PlatformMediaSession::RemoteCommandArgument*) override;
889     bool shouldOverrideBackgroundPlaybackRestriction(PlatformMediaSession::InterruptionType) const override;
890     bool shouldOverrideBackgroundLoadingRestriction() const override;
891     bool canProduceAudio() const final;
892     bool processingUserGestureForMedia() const final;
893
894     void pageMutedStateDidChange() override;
895
896 #if USE(AUDIO_SESSION) && PLATFORM(MAC)
897     void hardwareMutedStateDidChange(AudioSession*) final;
898 #endif
899
900     bool effectiveMuted() const;
901
902     void registerWithDocument(Document&);
903     void unregisterWithDocument(Document&);
904
905     void updateCaptionContainer();
906     void ensureMediaControlsShadowRoot();
907
908     using JSSetupFunction = WTF::Function<bool(JSDOMGlobalObject&, JSC::ExecState&, ScriptController&, DOMWrapperWorld&)>;
909     bool setupAndCallJS(const JSSetupFunction&);
910
911 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
912     void prepareForDocumentSuspension() final;
913     void resumeFromDocumentSuspension() final;
914
915     void scheduleUpdateMediaState();
916     void updateMediaState();
917     bool hasPlaybackTargetAvailabilityListeners() const { return m_hasPlaybackTargetAvailabilityListeners; }
918 #endif
919
920     bool isVideoTooSmallForInlinePlayback();
921     void updateShouldAutoplay();
922
923     void pauseAfterDetachedTask();
924     void updatePlaybackControlsManager();
925     void schedulePlaybackControlsManagerUpdate();
926     void playbackControlsManagerBehaviorRestrictionsTimerFired();
927
928     void updateRenderer();
929
930     void updatePageScaleFactorJSProperty();
931     void updateUsesLTRUserInterfaceLayoutDirectionJSProperty();
932     void setControllerJSProperty(const char*, JSC::JSValue);
933
934     void addBehaviorRestrictionsOnEndIfNecessary();
935     void handleSeekToPlaybackPosition(double);
936     void seekToPlaybackPositionEndedTimerFired();
937
938     void applicationWillResignActive() final;
939     void applicationDidBecomeActive() final;
940
941     void setInActiveDocument(bool);
942
943 #if !RELEASE_LOG_DISABLED
944     const char* logClassName() const final { return "HTMLMediaElement"; }
945
946     const void* mediaPlayerLogIdentifier() final { return logIdentifier(); }
947     const Logger& mediaPlayerLogger() final { return logger(); }
948 #endif
949
950     Timer m_progressEventTimer;
951     Timer m_playbackProgressTimer;
952     Timer m_scanTimer;
953     Timer m_playbackControlsManagerBehaviorRestrictionsTimer;
954     Timer m_seekToPlaybackPositionEndedTimer;
955     DeferrableTask<Timer> m_configureTextTracksTask;
956     DeferrableTask<Timer> m_checkPlaybackTargetCompatablityTask;
957     DeferrableTask<Timer> m_updateMediaStateTask;
958     DeferrableTask<Timer> m_mediaEngineUpdatedTask;
959     DeferrableTask<Timer> m_updatePlayStateTask;
960     DeferrableTask<Timer> m_resumeTaskQueue;
961     DeferrableTask<Timer> m_seekTaskQueue;
962     DeferrableTask<Timer> m_playbackControlsManagerBehaviorRestrictionsQueue;
963     GenericTaskQueue<Timer> m_promiseTaskQueue;
964     GenericTaskQueue<Timer> m_pauseAfterDetachedTaskQueue;
965     GenericTaskQueue<Timer> m_resourceSelectionTaskQueue;
966     GenericTaskQueue<Timer> m_visibilityChangeTaskQueue;
967     GenericTaskQueue<Timer> m_fullscreenTaskQueue;
968     GenericTaskQueue<Timer> m_playbackTargetIsWirelessQueue;
969     RefPtr<TimeRanges> m_playedTimeRanges;
970     GenericEventQueue m_asyncEventQueue;
971 #if PLATFORM(IOS_FAMILY)
972     DeferrableTask<Timer> m_volumeRevertTaskQueue;
973 #endif
974
975     PlayPromiseVector m_pendingPlayPromises;
976
977     double m_requestedPlaybackRate { 1 };
978     double m_reportedPlaybackRate { 1 };
979     double m_defaultPlaybackRate { 1 };
980     bool m_webkitPreservesPitch { true };
981     NetworkState m_networkState { NETWORK_EMPTY };
982     ReadyState m_readyState { HAVE_NOTHING };
983     ReadyState m_readyStateMaximum { HAVE_NOTHING };
984     URL m_currentSrc;
985
986     RefPtr<MediaError> m_error;
987
988     struct PendingSeek {
989         PendingSeek(const MediaTime& now, const MediaTime& targetTime, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance)
990             : now(now)
991             , targetTime(targetTime)
992             , negativeTolerance(negativeTolerance)
993             , positiveTolerance(positiveTolerance)
994         {
995         }
996         MediaTime now;
997         MediaTime targetTime;
998         MediaTime negativeTolerance;
999         MediaTime positiveTolerance;
1000     };
1001     std::unique_ptr<PendingSeek> m_pendingSeek;
1002     SeekType m_pendingSeekType { NoSeek };
1003
1004     double m_volume { 1 };
1005     bool m_volumeInitialized { false };
1006     MediaTime m_lastSeekTime;
1007     
1008     MonotonicTime m_previousProgressTime { MonotonicTime::infinity() };
1009     double m_playbackStartedTime { 0 };
1010
1011     // The last time a timeupdate event was sent (based on monotonic clock).
1012     MonotonicTime m_clockTimeAtLastUpdateEvent;
1013
1014     // The last time a timeupdate event was sent in movie time.
1015     MediaTime m_lastTimeUpdateEventMovieTime;
1016     
1017     // Loading state.
1018     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
1019     LoadState m_loadState { WaitingForSource };
1020     RefPtr<HTMLSourceElement> m_currentSourceNode;
1021     RefPtr<HTMLSourceElement> m_nextChildNodeToConsider;
1022
1023     VideoFullscreenMode m_videoFullscreenMode { VideoFullscreenModeNone };
1024     bool m_videoFullscreenStandby { false };
1025     bool m_preparedForInline;
1026     WTF::Function<void()> m_preparedForInlineCompletionHandler;
1027
1028     bool m_temporarilyAllowingInlinePlaybackAfterFullscreen { false };
1029
1030 #if PLATFORM(IOS_FAMILY) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
1031     RetainPtr<PlatformLayer> m_videoFullscreenLayer;
1032     FloatRect m_videoFullscreenFrame;
1033     MediaPlayerEnums::VideoGravity m_videoFullscreenGravity { MediaPlayer::VideoGravityResizeAspect };
1034 #endif
1035
1036     RefPtr<MediaPlayer> m_player;
1037
1038     MediaPlayerEnums::Preload m_preload { MediaPlayer::Auto };
1039
1040     DisplayMode m_displayMode { Unknown };
1041
1042     // Counter incremented while processing a callback from the media player, so we can avoid
1043     // calling the media engine recursively.
1044     int m_processingMediaPlayerCallback { 0 };
1045
1046 #if ENABLE(MEDIA_SESSION)
1047     String m_kind;
1048     RefPtr<MediaSession> m_session;
1049     bool m_shouldDuck { false };
1050     uint64_t m_elementID;
1051 #endif
1052
1053 #if ENABLE(MEDIA_SOURCE)
1054     RefPtr<MediaSource> m_mediaSource;
1055     unsigned m_droppedVideoFrames { 0 };
1056 #endif
1057
1058     mutable MediaTime m_cachedTime;
1059     mutable MonotonicTime m_clockTimeAtLastCachedTimeUpdate;
1060     mutable MonotonicTime m_minimumClockTimeToUpdateCachedTime;
1061
1062     MediaTime m_fragmentStartTime;
1063     MediaTime m_fragmentEndTime;
1064
1065     using PendingActionFlags = unsigned;
1066     PendingActionFlags m_pendingActionFlags { 0 };
1067
1068     enum ActionAfterScanType { Nothing, Play, Pause };
1069     ActionAfterScanType m_actionAfterScan { Nothing };
1070
1071     enum ScanType { Seek, Scan };
1072     ScanType m_scanType { Scan };
1073     ScanDirection m_scanDirection { Forward };
1074
1075     bool m_firstTimePlaying : 1;
1076     bool m_playing : 1;
1077     bool m_isWaitingUntilMediaCanStart : 1;
1078     bool m_shouldDelayLoadEvent : 1;
1079     bool m_haveFiredLoadedData : 1;
1080     bool m_inActiveDocument : 1;
1081     bool m_autoplaying : 1;
1082     bool m_muted : 1;
1083     bool m_explicitlyMuted : 1;
1084     bool m_initiallyMuted : 1;
1085     bool m_paused : 1;
1086     bool m_seeking : 1;
1087     bool m_seekRequested : 1;
1088
1089     // data has not been loaded since sending a "stalled" event
1090     bool m_sentStalledEvent : 1;
1091
1092     // time has not changed since sending an "ended" event
1093     bool m_sentEndEvent : 1;
1094
1095     bool m_pausedInternal : 1;
1096
1097     bool m_closedCaptionsVisible : 1;
1098     bool m_webkitLegacyClosedCaptionOverride : 1;
1099     bool m_completelyLoaded : 1;
1100     bool m_havePreparedToPlay : 1;
1101     bool m_parsingInProgress : 1;
1102     bool m_shouldBufferData : 1;
1103     bool m_elementIsHidden : 1;
1104     bool m_elementWasRemovedFromDOM : 1;
1105     bool m_creatingControls : 1;
1106     bool m_receivedLayoutSizeChanged : 1;
1107     bool m_hasEverNotifiedAboutPlaying : 1;
1108
1109     bool m_hasEverHadAudio : 1;
1110     bool m_hasEverHadVideo : 1;
1111
1112 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
1113     bool m_mediaControlsDependOnPageScaleFactor : 1;
1114     bool m_haveSetUpCaptionContainer : 1;
1115 #endif
1116
1117     bool m_isScrubbingRemotely : 1;
1118     bool m_waitingToEnterFullscreen : 1;
1119
1120 #if ENABLE(VIDEO_TRACK)
1121     bool m_tracksAreReady : 1;
1122     bool m_haveVisibleTextTrack : 1;
1123     bool m_processingPreferenceChange : 1;
1124
1125     AutoplayEventPlaybackState m_autoplayEventPlaybackState { AutoplayEventPlaybackState::None };
1126
1127     String m_subtitleTrackLanguage;
1128     MediaTime m_lastTextTrackUpdateTime { -1, 1 };
1129
1130     Optional<CaptionUserPreferences::CaptionDisplayMode> m_captionDisplayMode;
1131
1132     RefPtr<AudioTrackList> m_audioTracks;
1133     RefPtr<TextTrackList> m_textTracks;
1134     RefPtr<VideoTrackList> m_videoTracks;
1135     Vector<RefPtr<TextTrack>> m_textTracksWhenResourceSelectionBegan;
1136
1137     CueIntervalTree m_cueTree;
1138
1139     CueList m_currentlyActiveCues;
1140     int m_ignoreTrackDisplayUpdate { 0 };
1141
1142     bool m_requireCaptionPreferencesChangedCallbacks { false };
1143 #endif
1144
1145 #if ENABLE(WEB_AUDIO)
1146     // This is a weak reference, since m_audioSourceNode holds a reference to us.
1147     // The value is set just after the MediaElementAudioSourceNode is created.
1148     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
1149     MediaElementAudioSourceNode* m_audioSourceNode { nullptr };
1150 #endif
1151
1152     String m_mediaGroup;
1153     friend class MediaController;
1154     RefPtr<MediaController> m_mediaController;
1155
1156     std::unique_ptr<PAL::SleepDisabler> m_sleepDisabler;
1157
1158     WeakPtr<const MediaResourceLoader> m_lastMediaResourceLoaderForTesting;
1159
1160     friend class TrackDisplayUpdateScope;
1161
1162     RefPtr<Blob> m_blob;
1163     MediaProvider m_mediaProvider;
1164
1165 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
1166     RefPtr<WebKitMediaKeys> m_webKitMediaKeys;
1167 #endif
1168 #if ENABLE(ENCRYPTED_MEDIA)
1169     RefPtr<MediaKeys> m_mediaKeys;
1170     bool m_attachingMediaKeys { false };
1171     bool m_playbackBlockedWaitingForKey { false };
1172     GenericTaskQueue<Timer> m_encryptedMediaQueue;
1173 #endif
1174
1175     std::unique_ptr<MediaElementSession> m_mediaSession;
1176     size_t m_reportedExtraMemoryCost { 0 };
1177
1178 #if !RELEASE_LOG_DISABLED
1179     RefPtr<Logger> m_logger;
1180     const void* m_logIdentifier;
1181 #endif
1182
1183 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
1184     friend class MediaControlsHost;
1185     RefPtr<MediaControlsHost> m_mediaControlsHost;
1186     RefPtr<DOMWrapperWorld> m_isolatedWorld;
1187 #endif
1188
1189 #if ENABLE(MEDIA_STREAM)
1190     RefPtr<MediaStream> m_mediaStreamSrcObject;
1191     bool m_settingMediaStreamSrcObject { false };
1192 #endif
1193
1194 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
1195     MediaProducer::MediaStateFlags m_mediaState { MediaProducer::IsNotPlaying };
1196     bool m_hasPlaybackTargetAvailabilityListeners { false };
1197     bool m_failedToPlayToWirelessTarget { false };
1198 #endif
1199
1200     bool m_isPlayingToWirelessTarget { false };
1201     bool m_playingOnSecondScreen { false };
1202 };
1203
1204 String convertEnumerationToString(HTMLMediaElement::AutoplayEventPlaybackState);
1205
1206 } // namespace WebCore
1207
1208 namespace WTF {
1209
1210 template<> struct LogArgument<WebCore::HTMLMediaElement::AutoplayEventPlaybackState> {
1211     static String toString(WebCore::HTMLMediaElement::AutoplayEventPlaybackState reason) { return convertEnumerationToString(reason); }
1212 };
1213
1214 #if ENABLE(VIDEO_TRACK) && !defined(NDEBUG)
1215
1216 // Template specialization required by PodIntervalTree in debug mode.
1217 template<> struct ValueToString<WebCore::TextTrackCue*> {
1218     static String string(const WebCore::TextTrackCue* cue) { return cue->debugString(); }
1219 };
1220
1221 #endif
1222
1223 #ifndef NDEBUG
1224
1225 template<> struct ValueToString<MediaTime> {
1226     static String string(const MediaTime& time) { return toString(time); }
1227 };
1228
1229 #endif
1230
1231 } // namespace WTF
1232
1233 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::HTMLMediaElement)
1234     static bool isType(const WebCore::Element& element) { return element.isMediaElement(); }
1235     static bool isType(const WebCore::Node& node) { return is<WebCore::Element>(node) && isType(downcast<WebCore::Element>(node)); }
1236 SPECIALIZE_TYPE_TRAITS_END()
1237
1238 #endif