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