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