Attachment 338776 Details for Bug 184992 – Patch

[patch] Patch

bug-184992-20180425131548.patch (text/plain), 43.56 KB, created by Eric Carlson on 2018-04-25 13:15:49 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Eric Carlson

Created: 2018-04-25 13:15:49 PDT

Size: 43.56 KB

patch

obsolete

>Subversion Revision: 230960
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 5a83ef5c33ae8751a95812fc8a7a5829244a18a9..9a12e796745d2a3d50e9f3cf130ca3ba8ec3fe30 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,78 @@
>+2018-04-25  Eric Carlson  <eric.carlson@apple.com>
>+
>+        [iOS] remove media element parameter from MediaElementSession methods
>+        https://bugs.webkit.org/show_bug.cgi?id=184992
>+        <rdar://problem/39731624>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No new tests, no behavior change.
>+
>+        * Modules/mediacontrols/MediaControlsHost.cpp:
>+        (WebCore::MediaControlsHost::allowsInlineMediaPlayback const):
>+        (WebCore::MediaControlsHost::userGestureRequired const):
>+        * accessibility/AccessibilityMediaObject.cpp:
>+        (WebCore::AccessibilityMediaObject::isPlayingInline const):
>+        * html/HTMLMediaElement.cpp:
>+        (WebCore::HTMLMediaElement::~HTMLMediaElement):
>+        (WebCore::HTMLMediaElement::parseAttribute):
>+        (WebCore::HTMLMediaElement::prepareForLoad):
>+        (WebCore::HTMLMediaElement::selectMediaResource):
>+        (WebCore::HTMLMediaElement::loadResource):
>+        (WebCore::HTMLMediaElement::canTransitionFromAutoplayToPlay const):
>+        (WebCore::HTMLMediaElement::setReadyState):
>+        (WebCore::HTMLMediaElement::play):
>+        (WebCore::HTMLMediaElement::pause):
>+        (WebCore::HTMLMediaElement::pauseInternal):
>+        (WebCore::HTMLMediaElement::setVolume):
>+        (WebCore::HTMLMediaElement::mediaPlayerDidAddAudioTrack):
>+        (WebCore::HTMLMediaElement::sourceWasAdded):
>+        (WebCore::HTMLMediaElement::mediaEngineWasUpdated):
>+        (WebCore::HTMLMediaElement::mediaPlayerCharacteristicChanged):
>+        (WebCore::HTMLMediaElement::updatePlayState):
>+        (WebCore::HTMLMediaElement::clearMediaPlayer):
>+        (WebCore::HTMLMediaElement::resume):
>+        (WebCore::HTMLMediaElement::webkitShowPlaybackTargetPicker):
>+        (WebCore::HTMLMediaElement::addEventListener):
>+        (WebCore::HTMLMediaElement::removeEventListener):
>+        (WebCore::HTMLMediaElement::enqueuePlaybackTargetAvailabilityChangedEvent):
>+        (WebCore::HTMLMediaElement::exitFullscreen):
>+        (WebCore::HTMLMediaElement::configureMediaControls):
>+        (WebCore::HTMLMediaElement::createMediaPlayer):
>+        (WebCore::HTMLMediaElement::mediaPlayerIsFullscreenPermitted const):
>+        (WebCore::HTMLMediaElement::updateMediaState):
>+        (WebCore::HTMLMediaElement::mediaState const):
>+        (WebCore::HTMLMediaElement::allowsMediaDocumentInlinePlaybackChanged):
>+        (WebCore::HTMLMediaElement::updateShouldPlay):
>+        * html/HTMLVideoElement.cpp:
>+        (WebCore::HTMLVideoElement::parseAttribute):
>+        (WebCore::HTMLVideoElement::supportsFullscreen const):
>+        (WebCore::HTMLVideoElement::webkitEnterFullscreen):
>+        (WebCore::HTMLVideoElement::webkitWirelessVideoPlaybackDisabled const):
>+        (WebCore::HTMLVideoElement::webkitSupportsPresentationMode const):
>+        (WebCore::HTMLVideoElement::setFullscreenMode):
>+        * html/MediaElementSession.cpp:
>+        (WebCore::MediaElementSession::playbackPermitted const):
>+        (WebCore::MediaElementSession::dataLoadingPermitted const):
>+        (WebCore::MediaElementSession::fullscreenPermitted const):
>+        (WebCore::MediaElementSession::pageAllowsDataLoading const):
>+        (WebCore::MediaElementSession::pageAllowsPlaybackAfterResuming const):
>+        (WebCore::MediaElementSession::canShowControlsManager const):
>+        (WebCore::MediaElementSession::showPlaybackTargetPicker):
>+        (WebCore::MediaElementSession::hasWirelessPlaybackTargets const):
>+        (WebCore::MediaElementSession::wirelessVideoPlaybackDisabled const):
>+        (WebCore::MediaElementSession::setWirelessVideoPlaybackDisabled):
>+        (WebCore::MediaElementSession::setHasPlaybackTargetAvailabilityListeners):
>+        (WebCore::MediaElementSession::mediaStateDidChange):
>+        (WebCore::MediaElementSession::effectivePreloadForElement const):
>+        (WebCore::MediaElementSession::requiresFullscreenForVideoPlayback const):
>+        (WebCore::MediaElementSession::allowsAutomaticMediaDataLoading const):
>+        (WebCore::MediaElementSession::mediaEngineUpdated):
>+        (WebCore::MediaElementSession::allowsPictureInPicture const):
>+        * html/MediaElementSession.h:
>+        * platform/cocoa/PlaybackSessionModelMediaElement.mm:
>+        (WebCore::PlaybackSessionModelMediaElement::wirelessVideoPlaybackDisabled const):
>+
> 2018-04-24  Jer Noble  <jer.noble@apple.com>
> 
>         Don't add system framework paths to FRAMEWORK_SEARCH_PATHS
>diff --git a/Source/WebCore/Modules/mediacontrols/MediaControlsHost.cpp b/Source/WebCore/Modules/mediacontrols/MediaControlsHost.cpp
>index fda8613381f99c23d0f7f60635e7f2452f1dd905..26fe18752fb712337631365e6208366026f5b96c 100644
>--- a/Source/WebCore/Modules/mediacontrols/MediaControlsHost.cpp
>+++ b/Source/WebCore/Modules/mediacontrols/MediaControlsHost.cpp
>@@ -185,7 +185,7 @@ void MediaControlsHost::updateCaptionDisplaySizes()
>     
> bool MediaControlsHost::allowsInlineMediaPlayback() const
> {
>-    return !m_mediaElement->mediaSession().requiresFullscreenForVideoPlayback(*m_mediaElement);
>+    return !m_mediaElement->mediaSession().requiresFullscreenForVideoPlayback();
> }
> 
> bool MediaControlsHost::supportsFullscreen() const
>@@ -210,7 +210,7 @@ void MediaControlsHost::setPreparedToReturnVideoLayerToInline(bool value)
> 
> bool MediaControlsHost::userGestureRequired() const
> {
>-    return !m_mediaElement->mediaSession().playbackPermitted(*m_mediaElement);
>+    return !m_mediaElement->mediaSession().playbackPermitted();
> }
> 
> bool MediaControlsHost::shouldForceControlsDisplay() const
>diff --git a/Source/WebCore/accessibility/AccessibilityMediaObject.cpp b/Source/WebCore/accessibility/AccessibilityMediaObject.cpp
>index b377ce968eaebaa021311491862d89ea0fbf1847..eaa18742fd062e894d4024979d671b477faf55f9 100644
>--- a/Source/WebCore/accessibility/AccessibilityMediaObject.cpp
>+++ b/Source/WebCore/accessibility/AccessibilityMediaObject.cpp
>@@ -173,7 +173,7 @@ bool AccessibilityMediaObject::isPlayingInline() const
>     if (!element)
>         return false;
>     
>-    return !element->mediaSession().requiresFullscreenForVideoPlayback(*element);
>+    return !element->mediaSession().requiresFullscreenForVideoPlayback();
> }
> 
> void AccessibilityMediaObject::enterFullscreen() const
>diff --git a/Source/WebCore/html/HTMLMediaElement.cpp b/Source/WebCore/html/HTMLMediaElement.cpp
>index 8e2d554e1c7e00f08d846685216b08d5e21ba14e..de1c2e866dd5d4ac2f84ce56affc32f793910299 100644
>--- a/Source/WebCore/html/HTMLMediaElement.cpp
>+++ b/Source/WebCore/html/HTMLMediaElement.cpp
>@@ -609,7 +609,7 @@ HTMLMediaElement::~HTMLMediaElement()
> #if ENABLE(WIRELESS_PLAYBACK_TARGET)
>     if (hasEventListeners(eventNames().webkitplaybacktargetavailabilitychangedEvent)) {
>         m_hasPlaybackTargetAvailabilityListeners = false;
>-        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(*this, false);
>+        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(false);
>         updateMediaState();
>     }
> #endif
>@@ -860,7 +860,7 @@ void HTMLMediaElement::parseAttribute(const QualifiedName& name, const AtomicStr
> 
>         // The attribute must be ignored if the autoplay attribute is present
>         if (!autoplay() && !m_havePreparedToPlay && m_player)
>-            m_player->setPreload(m_mediaSession->effectivePreloadForElement(*this));
>+            m_player->setPreload(m_mediaSession->effectivePreloadForElement());
> 
>     } else if (name == mediagroupAttr)
>         setMediaGroup(value);
>@@ -1343,7 +1343,7 @@ void HTMLMediaElement::prepareForLoad()
>         // 9 - Invoke the media element's resource selection algorithm.
>         // Note, unless the restriction on requiring user action has been removed,
>         // do not begin downloading data.
>-        if (m_mediaSession->dataLoadingPermitted(*this))
>+        if (m_mediaSession->dataLoadingPermitted())
>             selectMediaResource();
>     }
> 
>@@ -1370,7 +1370,7 @@ void HTMLMediaElement::selectMediaResource()
>     if (m_resourceSelectionTaskQueue.hasPendingTasks())
>         return;
> 
>-    if (!m_mediaSession->pageAllowsDataLoading(*this)) {
>+    if (!m_mediaSession->pageAllowsDataLoading()) {
>         ALWAYS_LOG(LOGIDENTIFIER, "not allowed to load in background, waiting");
>         setShouldDelayLoadEvent(false);
>         if (m_isWaitingUntilMediaCanStart)
>@@ -1611,7 +1611,7 @@ void HTMLMediaElement::loadResource(const URL& initialURL, ContentType& contentT
>     setDisplayMode(Unknown);
> 
>     if (!autoplay() && !m_havePreparedToPlay)
>-        m_player->setPreload(m_mediaSession->effectivePreloadForElement(*this));
>+        m_player->setPreload(m_mediaSession->effectivePreloadForElement());
>     m_player->setPreservesPitch(m_webkitPreservesPitch);
> 
>     if (!m_explicitlyMuted) {
>@@ -2411,7 +2411,7 @@ SuccessOr<MediaPlaybackDenialReason> HTMLMediaElement::canTransitionFromAutoplay
>         && !pausedForUserInteraction()
>         && !document().isSandboxed(SandboxAutomaticFeatures)
>         && m_readyState == HAVE_ENOUGH_DATA)
>-        return mediaSession().playbackPermitted(*this);
>+        return mediaSession().playbackPermitted();
> 
>     ALWAYS_LOG(LOGIDENTIFIER, "page consent required");
>     return MediaPlaybackDenialReason::PageConsentRequired;
>@@ -2554,7 +2554,7 @@ void HTMLMediaElement::setReadyState(MediaPlayer::ReadyState state)
> 
>     // If we transition to the Future Data state and we're about to begin playing, ensure playback is actually permitted first,
>     // honoring any playback denial reasons such as the requirement of a user gesture.
>-    if (m_readyState == HAVE_FUTURE_DATA && oldState < HAVE_FUTURE_DATA && potentiallyPlaying() && !m_mediaSession->playbackPermitted(*this)) {
>+    if (m_readyState == HAVE_FUTURE_DATA && oldState < HAVE_FUTURE_DATA && potentiallyPlaying() && !m_mediaSession->playbackPermitted()) {
>         auto canTransition = canTransitionFromAutoplayToPlay();
>         if (canTransition && canTransition.value() == MediaPlaybackDenialReason::UserGestureRequired)
>             ALWAYS_LOG(LOGIDENTIFIER, "Autoplay blocked, user gesture required");
>@@ -3408,7 +3408,7 @@ void HTMLMediaElement::play(DOMPromiseDeferred<void>&& promise)
> {
>     ALWAYS_LOG(LOGIDENTIFIER);
> 
>-    auto success = m_mediaSession->playbackPermitted(*this);
>+    auto success = m_mediaSession->playbackPermitted();
>     if (!success) {
>         if (success.value() == MediaPlaybackDenialReason::UserGestureRequired)
>             setPlaybackWithoutUserGesture(PlaybackWithoutUserGesture::Prevented);
>@@ -3432,7 +3432,7 @@ void HTMLMediaElement::play()
> {
>     ALWAYS_LOG(LOGIDENTIFIER);
> 
>-    auto success = m_mediaSession->playbackPermitted(*this);
>+    auto success = m_mediaSession->playbackPermitted();
>     if (!success) {
>         if (success.value() == MediaPlaybackDenialReason::UserGestureRequired)
>             setPlaybackWithoutUserGesture(PlaybackWithoutUserGesture::Prevented);
>@@ -3525,7 +3525,7 @@ void HTMLMediaElement::pause()
>     if (m_waitingToEnterFullscreen)
>         m_waitingToEnterFullscreen = false;
> 
>-    if (!m_mediaSession->playbackPermitted(*this))
>+    if (!m_mediaSession->playbackPermitted())
>         return;
> 
>     if (processingUserGestureForMedia())
>@@ -3553,7 +3553,7 @@ void HTMLMediaElement::pauseInternal()
>     if (!m_player || m_networkState == NETWORK_EMPTY) {
>         // Unless the restriction on media requiring user action has been lifted
>         // don't trigger loading if a script calls pause().
>-        if (!m_mediaSession->playbackPermitted(*this))
>+        if (!m_mediaSession->playbackPermitted())
>             return;
>         selectMediaResource();
>     }
>@@ -3642,7 +3642,7 @@ ExceptionOr<void> HTMLMediaElement::setVolume(double volume)
>     updateVolume();
>     scheduleEvent(eventNames().volumechangeEvent);
> 
>-    if (isPlaying() && !m_mediaSession->playbackPermitted(*this)) {
>+    if (isPlaying() && !m_mediaSession->playbackPermitted()) {
>         pauseInternal();
>         setPlaybackWithoutUserGesture(PlaybackWithoutUserGesture::Prevented);
>     }
>@@ -3907,7 +3907,7 @@ double HTMLMediaElement::percentLoaded() const
> 
> void HTMLMediaElement::mediaPlayerDidAddAudioTrack(AudioTrackPrivate& track)
> {
>-    if (isPlaying() && !m_mediaSession->playbackPermitted(*this)) {
>+    if (isPlaying() && !m_mediaSession->playbackPermitted()) {
>         pauseInternal();
>         setPlaybackWithoutUserGesture(PlaybackWithoutUserGesture::Prevented);
>     }
>@@ -4615,7 +4615,7 @@ void HTMLMediaElement::sourceWasAdded(HTMLSourceElement& source)
>     if (m_networkState == NETWORK_EMPTY) {
>         m_nextChildNodeToConsider = &source;
> #if PLATFORM(IOS)
>-        if (m_mediaSession->dataLoadingPermitted(*this))
>+        if (m_mediaSession->dataLoadingPermitted())
> #endif
>             selectMediaResource();
>         return;
>@@ -4956,7 +4956,7 @@ void HTMLMediaElement::mediaEngineWasUpdated()
>     updateRenderer();
>     endProcessingMediaPlayerCallback();
> 
>-    m_mediaSession->mediaEngineUpdated(*this);
>+    m_mediaSession->mediaEngineUpdated();
> 
> #if ENABLE(WEB_AUDIO)
>     if (m_audioSourceNode && audioSourceProvider()) {
>@@ -5029,7 +5029,7 @@ void HTMLMediaElement::mediaPlayerCharacteristicChanged(MediaPlayer*)
>         mediaControls()->reset();
>     updateRenderer();
> 
>-    if (!paused() && !m_mediaSession->playbackPermitted(*this)) {
>+    if (!paused() && !m_mediaSession->playbackPermitted()) {
>         pauseInternal();
>         setPlaybackWithoutUserGesture(PlaybackWithoutUserGesture::Prevented);
>     }
>@@ -5265,7 +5265,7 @@ void HTMLMediaElement::updatePlayState(UpdateState updateState)
> 
>     INFO_LOG(LOGIDENTIFIER, "shouldBePlaying = ", shouldBePlaying, ", playerPaused = ", playerPaused);
> 
>-    if (shouldBePlaying && playerPaused && m_mediaSession->requiresFullscreenForVideoPlayback(*this) && (m_waitingToEnterFullscreen || !isFullscreen())) {
>+    if (shouldBePlaying && playerPaused && m_mediaSession->requiresFullscreenForVideoPlayback() && (m_waitingToEnterFullscreen || !isFullscreen())) {
>         if (!m_waitingToEnterFullscreen)
>             enterFullscreen();
> 
>@@ -5447,7 +5447,7 @@ void HTMLMediaElement::clearMediaPlayer(DelayedActionType flags)
> #if ENABLE(WIRELESS_PLAYBACK_TARGET)
>     if (hasEventListeners(eventNames().webkitplaybacktargetavailabilitychangedEvent)) {
>         m_hasPlaybackTargetAvailabilityListeners = false;
>-        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(*this, false);
>+        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(false);
> 
>         // Send an availability event in case scripts want to hide the picker when the element
>         // doesn't support playback to a target.
>@@ -5596,7 +5596,7 @@ void HTMLMediaElement::resume()
> 
>     setShouldBufferData(true);
> 
>-    if (!m_mediaSession->pageAllowsPlaybackAfterResuming(*this))
>+    if (!m_mediaSession->pageAllowsPlaybackAfterResuming())
>         document().addMediaCanStartListener(this);
>     else
>         setPausedInternal(false);
>@@ -5672,7 +5672,7 @@ void HTMLMediaElement::webkitShowPlaybackTargetPicker()
>     INFO_LOG(LOGIDENTIFIER);
>     if (processingUserGestureForMedia())
>         removeBehaviorsRestrictionsAfterFirstUserGesture();
>-    m_mediaSession->showPlaybackTargetPicker(*this);
>+    m_mediaSession->showPlaybackTargetPicker();
> }
> 
> bool HTMLMediaElement::webkitCurrentPlaybackTargetIsWireless() const
>@@ -5722,7 +5722,7 @@ bool HTMLMediaElement::addEventListener(const AtomicString& eventType, Ref<Event
> 
>     if (isFirstAvailabilityChangedListener) {
>         m_hasPlaybackTargetAvailabilityListeners = true;
>-        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(*this, true);
>+        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(true);
>     }
> 
>     INFO_LOG(LOGIDENTIFIER, "'webkitplaybacktargetavailabilitychanged'");
>@@ -5743,7 +5743,7 @@ bool HTMLMediaElement::removeEventListener(const AtomicString& eventType, EventL
>     INFO_LOG(LOGIDENTIFIER, "removed last listener = ", didRemoveLastAvailabilityChangedListener);
>     if (didRemoveLastAvailabilityChangedListener) {
>         m_hasPlaybackTargetAvailabilityListeners = false;
>-        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(*this, false);
>+        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(false);
>         updateMediaState(UpdateState::Asynchronously);
>     }
> 
>@@ -5752,7 +5752,7 @@ bool HTMLMediaElement::removeEventListener(const AtomicString& eventType, EventL
> 
> void HTMLMediaElement::enqueuePlaybackTargetAvailabilityChangedEvent()
> {
>-    bool hasTargets = m_mediaSession->hasWirelessPlaybackTargets(*this);
>+    bool hasTargets = m_mediaSession->hasWirelessPlaybackTargets();
>     INFO_LOG(LOGIDENTIFIER, "hasTargets = ", hasTargets);
>     auto event = WebKitPlaybackTargetAvailabilityEvent::create(eventNames().webkitplaybacktargetavailabilitychangedEvent, hasTargets);
>     event->setTarget(this);
>@@ -5912,7 +5912,7 @@ void HTMLMediaElement::exitFullscreen()
>     if (!document().page() || !is<HTMLVideoElement>(*this))
>         return;
> 
>-    if (!paused() && m_mediaSession->requiresFullscreenForVideoPlayback(*this)) {
>+    if (!paused() && m_mediaSession->requiresFullscreenForVideoPlayback()) {
>         if (!document().settings().allowsInlineMediaPlaybackAfterFullscreen() || isVideoTooSmallForInlinePlayback())
>             pauseInternal();
>         else {
>@@ -6325,7 +6325,7 @@ void HTMLMediaElement::configureMediaControls()
>     bool requireControls = controls();
> 
>     // Always create controls for video when fullscreen playback is required.
>-    if (isVideo() && m_mediaSession->requiresFullscreenForVideoPlayback(*this))
>+    if (isVideo() && m_mediaSession->requiresFullscreenForVideoPlayback())
>         requireControls = true;
> 
>     if (shouldForceControlsDisplay())
>@@ -6492,7 +6492,7 @@ void HTMLMediaElement::createMediaPlayer()
> #if ENABLE(WIRELESS_PLAYBACK_TARGET)
>     if (hasEventListeners(eventNames().webkitplaybacktargetavailabilitychangedEvent)) {
>         m_hasPlaybackTargetAvailabilityListeners = true;
>-        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(*this, true);
>+        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(true);
>         enqueuePlaybackTargetAvailabilityChangedEvent(); // Ensure the event listener gets at least one event.
>     }
> #endif
>@@ -6816,7 +6816,7 @@ bool HTMLMediaElement::mediaPlayerIsFullscreen() const
> 
> bool HTMLMediaElement::mediaPlayerIsFullscreenPermitted() const
> {
>-    return m_mediaSession->fullscreenPermitted(*this);
>+    return m_mediaSession->fullscreenPermitted();
> }
> 
> bool HTMLMediaElement::mediaPlayerIsVideo() const
>@@ -7514,7 +7514,7 @@ void HTMLMediaElement::updateMediaState(UpdateState updateState)
>         return;
> 
>     m_mediaState = state;
>-    m_mediaSession->mediaStateDidChange(*this, m_mediaState);
>+    m_mediaSession->mediaStateDidChange(m_mediaState);
> #if ENABLE(MEDIA_SESSION)
>     document().updateIsPlayingMedia(m_elementID);
> #else
>@@ -7535,7 +7535,7 @@ MediaProducer::MediaStateFlags HTMLMediaElement::mediaState() const
> 
>     if (m_hasPlaybackTargetAvailabilityListeners) {
>         state |= HasPlaybackTargetAvailabilityListener;
>-        if (!m_mediaSession->wirelessVideoPlaybackDisabled(*this))
>+        if (!m_mediaSession->wirelessVideoPlaybackDisabled())
>             state |= RequiresPlaybackTargetMonitoring;
>     }
> 
>@@ -7735,7 +7735,7 @@ void HTMLMediaElement::setShouldDuck(bool duck)
> 
> void HTMLMediaElement::allowsMediaDocumentInlinePlaybackChanged()
> {
>-    if (potentiallyPlaying() && m_mediaSession->requiresFullscreenForVideoPlayback(*this) && !isFullscreen())
>+    if (potentiallyPlaying() && m_mediaSession->requiresFullscreenForVideoPlayback() && !isFullscreen())
>         enterFullscreen();
> }
> 
>@@ -7778,7 +7778,7 @@ void HTMLMediaElement::updateShouldAutoplay()
> 
> void HTMLMediaElement::updateShouldPlay()
> {
>-    if (!paused() && !m_mediaSession->playbackPermitted(*this)) {
>+    if (!paused() && !m_mediaSession->playbackPermitted()) {
>         pauseInternal();
>         setPlaybackWithoutUserGesture(PlaybackWithoutUserGesture::Prevented);
>     } else if (canTransitionFromAutoplayToPlay())
>diff --git a/Source/WebCore/html/HTMLVideoElement.cpp b/Source/WebCore/html/HTMLVideoElement.cpp
>index 3fc0e99420b214fa1ad2beb05c0aac128d40401f..908ed4ca6836ce320c1c3f9083ecec9b3210c8c9 100644
>--- a/Source/WebCore/html/HTMLVideoElement.cpp
>+++ b/Source/WebCore/html/HTMLVideoElement.cpp
>@@ -136,7 +136,7 @@ void HTMLVideoElement::parseAttribute(const QualifiedName& name, const AtomicStr
>     }
> #if ENABLE(WIRELESS_PLAYBACK_TARGET)
>     else if (name == webkitwirelessvideoplaybackdisabledAttr)
>-        mediaSession().setWirelessVideoPlaybackDisabled(*this, true);
>+        mediaSession().setWirelessVideoPlaybackDisabled(true);
> #endif
>     else {
>         HTMLMediaElement::parseAttribute(name, value);    
>@@ -146,7 +146,7 @@ void HTMLVideoElement::parseAttribute(const QualifiedName& name, const AtomicStr
>             bool disabled = false;
>             if (equalLettersIgnoringASCIICase(attributeWithoutSynchronization(HTMLNames::webkitairplayAttr), "deny"))
>                 disabled = true;
>-            mediaSession().setWirelessVideoPlaybackDisabled(*this, disabled);
>+            mediaSession().setWirelessVideoPlaybackDisabled(disabled);
>         }
> #endif
>     }
>@@ -159,7 +159,7 @@ bool HTMLVideoElement::supportsFullscreen(HTMLMediaElementEnums::VideoFullscreen
>         return false;
>     
>     if (videoFullscreenMode == HTMLMediaElementEnums::VideoFullscreenModePictureInPicture) {
>-        if (!mediaSession().allowsPictureInPicture(*this))
>+        if (!mediaSession().allowsPictureInPicture())
>             return false;
>         if (!player()->supportsPictureInPicture())
>             return false;
>@@ -316,7 +316,7 @@ ExceptionOr<void> HTMLVideoElement::webkitEnterFullscreen()
> 
>     // Generate an exception if this isn't called in response to a user gesture, or if the 
>     // element does not support fullscreen.
>-    if (!mediaSession().fullscreenPermitted(*this) || !supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenModeStandard))
>+    if (!mediaSession().fullscreenPermitted() || !supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenModeStandard))
>         return Exception { InvalidStateError };
> 
>     enterFullscreen();
>@@ -355,7 +355,7 @@ void HTMLVideoElement::ancestorWillEnterFullscreen()
> #if ENABLE(WIRELESS_PLAYBACK_TARGET)
> bool HTMLVideoElement::webkitWirelessVideoPlaybackDisabled() const
> {
>-    return mediaSession().wirelessVideoPlaybackDisabled(*this);
>+    return mediaSession().wirelessVideoPlaybackDisabled();
> }
> 
> void HTMLVideoElement::setWebkitWirelessVideoPlaybackDisabled(bool disabled)
>@@ -414,7 +414,7 @@ bool HTMLVideoElement::webkitSupportsPresentationMode(VideoPresentationMode mode
>     }
> 
>     if (mode == VideoPresentationMode::Inline)
>-        return !mediaSession().requiresFullscreenForVideoPlayback(*this);
>+        return !mediaSession().requiresFullscreenForVideoPlayback();
> 
>     return false;
> }
>@@ -446,7 +446,7 @@ void HTMLVideoElement::setFullscreenMode(HTMLMediaElementEnums::VideoFullscreenM
>         return;
>     }
> 
>-    if (!mediaSession().fullscreenPermitted(*this) || !supportsFullscreen(mode))
>+    if (!mediaSession().fullscreenPermitted() || !supportsFullscreen(mode))
>         return;
> 
>     enterFullscreen(mode);
>diff --git a/Source/WebCore/html/MediaElementSession.cpp b/Source/WebCore/html/MediaElementSession.cpp
>index e4a5fe6d1217731546370150438a469bb082d126..a4959e155fa421d9509a86ed0ea3c447b515b7a2 100644
>--- a/Source/WebCore/html/MediaElementSession.cpp
>+++ b/Source/WebCore/html/MediaElementSession.cpp
>@@ -158,18 +158,19 @@ static bool needsArbitraryUserGestureAutoplayQuirk(const Document& document)
> }
> #endif // PLATFORM(MAC)
> 
>-SuccessOr<MediaPlaybackDenialReason> MediaElementSession::playbackPermitted(const HTMLMediaElement& element) const
>+SuccessOr<MediaPlaybackDenialReason> MediaElementSession::playbackPermitted() const
> {
>     if (m_element.isSuspended())
>         return { };
> 
>-    if (element.document().isMediaDocument() && !element.document().ownerElement())
>+    auto& document = m_element.document();
>+    if (document.isMediaDocument() && !document.ownerElement())
>         return { };
> 
>-    if (pageExplicitlyAllowsElementToAutoplayInline(element))
>+    if (pageExplicitlyAllowsElementToAutoplayInline(m_element))
>         return { };
> 
>-    if (requiresFullscreenForVideoPlayback(element) && !fullscreenPermitted(element)) {
>+    if (requiresFullscreenForVideoPlayback() && !fullscreenPermitted()) {
>         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because of fullscreen restriction");
>         return MediaPlaybackDenialReason::FullscreenRequired;
>     }
>@@ -178,35 +179,35 @@ SuccessOr<MediaPlaybackDenialReason> MediaElementSession::playbackPermitted(cons
>         return { };
> 
> #if ENABLE(MEDIA_STREAM)
>-    if (element.hasMediaStreamSrcObject()) {
>-        if (element.document().isCapturing())
>+    if (m_element.hasMediaStreamSrcObject()) {
>+        if (document.isCapturing())
>             return { };
>-        if (element.document().mediaState() & MediaProducer::IsPlayingAudio)
>+        if (document.mediaState() & MediaProducer::IsPlayingAudio)
>             return { };
>     }
> #endif
> 
> #if PLATFORM(MAC)
>     // FIXME <https://webkit.org/b/175856>: Make this dependent on a runtime flag for desktop autoplay restrictions.
>-    const auto& topDocument = element.document().topDocument();
>+    const auto& topDocument = document.topDocument();
>     if (topDocument.mediaState() & MediaProducer::HasUserInteractedWithMediaElement && topDocument.settings().needsSiteSpecificQuirks())
>         return { };
> 
>-    if (element.document().hasHadUserInteraction() && needsArbitraryUserGestureAutoplayQuirk(element.document()))
>+    if (document.hasHadUserInteraction() && needsArbitraryUserGestureAutoplayQuirk(document))
>         return { };
> #endif
> 
>-    if (m_restrictions & RequireUserGestureForVideoRateChange && element.isVideo() && !element.document().processingUserGestureForMedia()) {
>+    if (m_restrictions & RequireUserGestureForVideoRateChange && m_element.isVideo() && !document.processingUserGestureForMedia()) {
>         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because a user gesture is required for video rate change restriction");
>         return MediaPlaybackDenialReason::UserGestureRequired;
>     }
> 
>-    if (m_restrictions & RequireUserGestureForAudioRateChange && (!element.isVideo() || element.hasAudio()) && !element.muted() && element.volume() && !element.document().processingUserGestureForMedia()) {
>+    if (m_restrictions & RequireUserGestureForAudioRateChange && (!m_element.isVideo() || m_element.hasAudio()) && !m_element.muted() && m_element.volume() && !document.processingUserGestureForMedia()) {
>         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because a user gesture is required for audio rate change restriction");
>         return MediaPlaybackDenialReason::UserGestureRequired;
>     }
> 
>-    if (m_restrictions & RequireUserGestureForVideoDueToLowPowerMode && element.isVideo() && !element.document().processingUserGestureForMedia()) {
>+    if (m_restrictions & RequireUserGestureForVideoDueToLowPowerMode && m_element.isVideo() && !document.processingUserGestureForMedia()) {
>         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because of video low power mode restriction");
>         return MediaPlaybackDenialReason::UserGestureRequired;
>     }
>@@ -249,12 +250,12 @@ bool MediaElementSession::autoplayPermitted() const
>     return true;
> }
> 
>-bool MediaElementSession::dataLoadingPermitted(const HTMLMediaElement& element) const
>+bool MediaElementSession::dataLoadingPermitted() const
> {
>     if (m_restrictions & OverrideUserGestureRequirementForMainContent && updateIsMainContent())
>         return true;
> 
>-    if (m_restrictions & RequireUserGestureForLoad && !element.document().processingUserGestureForMedia()) {
>+    if (m_restrictions & RequireUserGestureForLoad && !m_element.document().processingUserGestureForMedia()) {
>         LOG(Media, "MediaElementSession::dataLoadingPermitted - returning FALSE");
>         return false;
>     }
>@@ -262,9 +263,9 @@ bool MediaElementSession::dataLoadingPermitted(const HTMLMediaElement& element)
>     return true;
> }
> 
>-bool MediaElementSession::fullscreenPermitted(const HTMLMediaElement& element) const
>+bool MediaElementSession::fullscreenPermitted() const
> {
>-    if (m_restrictions & RequireUserGestureForFullscreen && !element.document().processingUserGestureForMedia()) {
>+    if (m_restrictions & RequireUserGestureForFullscreen && !m_element.document().processingUserGestureForMedia()) {
>         LOG(Media, "MediaElementSession::fullscreenPermitted - returning FALSE");
>         return false;
>     }
>@@ -272,9 +273,9 @@ bool MediaElementSession::fullscreenPermitted(const HTMLMediaElement& element) c
>     return true;
> }
> 
>-bool MediaElementSession::pageAllowsDataLoading(const HTMLMediaElement& element) const
>+bool MediaElementSession::pageAllowsDataLoading() const
> {
>-    Page* page = element.document().page();
>+    Page* page = m_element.document().page();
>     if (m_restrictions & RequirePageConsentToLoadMedia && page && !page->canStartMedia()) {
>         LOG(Media, "MediaElementSession::pageAllowsDataLoading - returning FALSE");
>         return false;
>@@ -283,9 +284,9 @@ bool MediaElementSession::pageAllowsDataLoading(const HTMLMediaElement& element)
>     return true;
> }
> 
>-bool MediaElementSession::pageAllowsPlaybackAfterResuming(const HTMLMediaElement& element) const
>+bool MediaElementSession::pageAllowsPlaybackAfterResuming() const
> {
>-    Page* page = element.document().page();
>+    Page* page = m_element.document().page();
>     if (m_restrictions & RequirePageConsentToResumeMedia && page && !page->canStartMedia()) {
>         LOG(Media, "MediaElementSession::pageAllowsPlaybackAfterResuming - returning FALSE");
>         return false;
>@@ -341,7 +342,7 @@ bool MediaElementSession::canShowControlsManager(PlaybackControlsPurpose purpose
>         return false;
>     }
> 
>-    if (!playbackPermitted(m_element)) {
>+    if (!playbackPermitted()) {
>         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Playback not permitted");
>         return false;
>     }
>@@ -411,31 +412,32 @@ bool MediaElementSession::wantsToObserveViewportVisibilityForAutoplay() const
> }
> 
> #if ENABLE(WIRELESS_PLAYBACK_TARGET)
>-void MediaElementSession::showPlaybackTargetPicker(const HTMLMediaElement& element)
>+void MediaElementSession::showPlaybackTargetPicker()
> {
>     LOG(Media, "MediaElementSession::showPlaybackTargetPicker");
> 
>-    if (m_restrictions & RequireUserGestureToShowPlaybackTargetPicker && !element.document().processingUserGestureForMedia()) {
>+    auto& document = m_element.document();
>+    if (m_restrictions & RequireUserGestureToShowPlaybackTargetPicker && !document.processingUserGestureForMedia()) {
>         LOG(Media, "MediaElementSession::showPlaybackTargetPicker - returning early because of permissions");
>         return;
>     }
> 
>-    if (!element.document().page()) {
>+    if (!document.page()) {
>         LOG(Media, "MediaElementSession::showingPlaybackTargetPickerPermitted - returning early because page is NULL");
>         return;
>     }
> 
> #if !PLATFORM(IOS)
>-    if (element.readyState() < HTMLMediaElementEnums::HAVE_METADATA) {
>+    if (m_element.readyState() < HTMLMediaElementEnums::HAVE_METADATA) {
>         LOG(Media, "MediaElementSession::showPlaybackTargetPicker - returning early because element is not playable");
>         return;
>     }
> #endif
> 
>-    element.document().showPlaybackTargetPicker(*this, is<HTMLVideoElement>(element));
>+    document.showPlaybackTargetPicker(*this, is<HTMLVideoElement>(m_element));
> }
> 
>-bool MediaElementSession::hasWirelessPlaybackTargets(const HTMLMediaElement&) const
>+bool MediaElementSession::hasWirelessPlaybackTargets() const
> {
> #if PLATFORM(IOS)
>     // FIXME: consolidate Mac and iOS implementations
>@@ -447,20 +449,20 @@ bool MediaElementSession::hasWirelessPlaybackTargets(const HTMLMediaElement&) co
>     return m_hasPlaybackTargets;
> }
> 
>-bool MediaElementSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement& element) const
>+bool MediaElementSession::wirelessVideoPlaybackDisabled() const
> {
>-    if (!element.document().settings().allowsAirPlayForMediaPlayback()) {
>+    if (!m_element.document().settings().allowsAirPlayForMediaPlayback()) {
>         LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of settings");
>         return true;
>     }
> 
>-    if (element.hasAttributeWithoutSynchronization(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
>+    if (m_element.hasAttributeWithoutSynchronization(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
>         LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of attribute");
>         return true;
>     }
> 
> #if PLATFORM(IOS)
>-    auto& legacyAirplayAttributeValue = element.attributeWithoutSynchronization(HTMLNames::webkitairplayAttr);
>+    auto& legacyAirplayAttributeValue = m_element.attributeWithoutSynchronization(HTMLNames::webkitairplayAttr);
>     if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "deny")) {
>         LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of legacy attribute");
>         return true;
>@@ -471,7 +473,7 @@ bool MediaElementSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement&
>     }
> #endif
> 
>-    auto player = element.player();
>+    auto player = m_element.player();
>     if (!player)
>         return true;
> 
>@@ -481,14 +483,14 @@ bool MediaElementSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement&
>     return disabled;
> }
> 
>-void MediaElementSession::setWirelessVideoPlaybackDisabled(const HTMLMediaElement& element, bool disabled)
>+void MediaElementSession::setWirelessVideoPlaybackDisabled(bool disabled)
> {
>     if (disabled)
>         addBehaviorRestriction(WirelessVideoPlaybackDisabled);
>     else
>         removeBehaviorRestriction(WirelessVideoPlaybackDisabled);
> 
>-    auto player = element.player();
>+    auto player = m_element.player();
>     if (!player)
>         return;
> 
>@@ -496,17 +498,16 @@ void MediaElementSession::setWirelessVideoPlaybackDisabled(const HTMLMediaElemen
>     player->setWirelessVideoPlaybackDisabled(disabled);
> }
> 
>-void MediaElementSession::setHasPlaybackTargetAvailabilityListeners(const HTMLMediaElement& element, bool hasListeners)
>+void MediaElementSession::setHasPlaybackTargetAvailabilityListeners(bool hasListeners)
> {
>     LOG(Media, "MediaElementSession::setHasPlaybackTargetAvailabilityListeners - hasListeners %s", hasListeners ? "TRUE" : "FALSE");
> 
> #if PLATFORM(IOS)
>-    UNUSED_PARAM(element);
>     m_hasPlaybackTargetAvailabilityListeners = hasListeners;
>     PlatformMediaSessionManager::sharedManager().configureWireLessTargetMonitoring();
> #else
>     UNUSED_PARAM(hasListeners);
>-    element.document().playbackTargetPickerClientStateDidChange(*this, element.mediaState());
>+    m_element.document().playbackTargetPickerClientStateDidChange(*this, element.mediaState());
> #endif
> }
> 
>@@ -559,17 +560,17 @@ void MediaElementSession::setShouldPlayToPlaybackTarget(bool shouldPlay)
>     client().setShouldPlayToPlaybackTarget(shouldPlay);
> }
> 
>-void MediaElementSession::mediaStateDidChange(const HTMLMediaElement& element, MediaProducer::MediaStateFlags state)
>+void MediaElementSession::mediaStateDidChange(MediaProducer::MediaStateFlags state)
> {
>-    element.document().playbackTargetPickerClientStateDidChange(*this, state);
>+    m_element.document().playbackTargetPickerClientStateDidChange(*this, state);
> }
> #endif
> 
>-MediaPlayer::Preload MediaElementSession::effectivePreloadForElement(const HTMLMediaElement& element) const
>+MediaPlayer::Preload MediaElementSession::effectivePreloadForElement() const
> {
>-    MediaPlayer::Preload preload = element.preloadValue();
>+    MediaPlayer::Preload preload = m_element.preloadValue();
> 
>-    if (pageExplicitlyAllowsElementToAutoplayInline(element))
>+    if (pageExplicitlyAllowsElementToAutoplayInline(m_element))
>         return preload;
> 
>     if (m_restrictions & MetadataPreloadingNotPermitted)
>@@ -583,67 +584,65 @@ MediaPlayer::Preload MediaElementSession::effectivePreloadForElement(const HTMLM
>     return preload;
> }
> 
>-bool MediaElementSession::requiresFullscreenForVideoPlayback(const HTMLMediaElement& element) const
>+bool MediaElementSession::requiresFullscreenForVideoPlayback() const
> {
>-    if (pageExplicitlyAllowsElementToAutoplayInline(element))
>+    if (pageExplicitlyAllowsElementToAutoplayInline(m_element))
>         return false;
> 
>-    if (is<HTMLAudioElement>(element))
>+    if (is<HTMLAudioElement>(m_element))
>         return false;
> 
>-    if (element.document().isMediaDocument()) {
>-        ASSERT(is<HTMLVideoElement>(element));
>-        const HTMLVideoElement& videoElement = *downcast<const HTMLVideoElement>(&element);
>-        if (element.readyState() < HTMLVideoElement::HAVE_METADATA || !videoElement.hasEverHadVideo())
>+    if (m_element.document().isMediaDocument()) {
>+        ASSERT(is<HTMLVideoElement>(m_element));
>+        const HTMLVideoElement& videoElement = *downcast<const HTMLVideoElement>(&m_element);
>+        if (m_element.readyState() < HTMLVideoElement::HAVE_METADATA || !videoElement.hasEverHadVideo())
>             return false;
>     }
> 
>-    if (element.isTemporarilyAllowingInlinePlaybackAfterFullscreen())
>+    if (m_element.isTemporarilyAllowingInlinePlaybackAfterFullscreen())
>         return false;
> 
>-    if (!element.document().settings().allowsInlineMediaPlayback())
>+    if (!m_element.document().settings().allowsInlineMediaPlayback())
>         return true;
> 
>-    if (!element.document().settings().inlineMediaPlaybackRequiresPlaysInlineAttribute())
>+    if (!m_element.document().settings().inlineMediaPlaybackRequiresPlaysInlineAttribute())
>         return false;
> 
> #if PLATFORM(IOS)
>     if (IOSApplication::isIBooks())
>-        return !element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr) && !element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr);
>+        return !m_element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr) && !m_element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr);
>     if (dyld_get_program_sdk_version() < DYLD_IOS_VERSION_10_0)
>-        return !element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr);
>+        return !m_element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr);
> #endif
> 
>-    if (element.document().isMediaDocument() && element.document().ownerElement())
>+    if (m_element.document().isMediaDocument() && m_element.document().ownerElement())
>         return false;
> 
>-    return !element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr);
>+    return !m_element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr);
> }
> 
>-bool MediaElementSession::allowsAutomaticMediaDataLoading(const HTMLMediaElement& element) const
>+bool MediaElementSession::allowsAutomaticMediaDataLoading() const
> {
>-    if (pageExplicitlyAllowsElementToAutoplayInline(element))
>+    if (pageExplicitlyAllowsElementToAutoplayInline(m_element))
>         return true;
> 
>-    if (element.document().settings().mediaDataLoadsAutomatically())
>+    if (m_element.document().settings().mediaDataLoadsAutomatically())
>         return true;
> 
>     return false;
> }
> 
>-void MediaElementSession::mediaEngineUpdated(const HTMLMediaElement& element)
>+void MediaElementSession::mediaEngineUpdated()
> {
>     LOG(Media, "MediaElementSession::mediaEngineUpdated");
> 
> #if ENABLE(WIRELESS_PLAYBACK_TARGET)
>     if (m_restrictions & WirelessVideoPlaybackDisabled)
>-        setWirelessVideoPlaybackDisabled(element, true);
>+        setWirelessVideoPlaybackDisabled(true);
>     if (m_playbackTarget)
>         client().setWirelessPlaybackTarget(*m_playbackTarget.copyRef());
>     if (m_shouldPlayToPlaybackTarget)
>         client().setShouldPlayToPlaybackTarget(true);
>-#else
>-    UNUSED_PARAM(element);
> #endif
>     
> }
>@@ -654,9 +653,9 @@ void MediaElementSession::resetPlaybackSessionState()
>     addBehaviorRestriction(RequireUserGestureToControlControlsManager | RequirePlaybackToControlControlsManager);
> }
> 
>-bool MediaElementSession::allowsPictureInPicture(const HTMLMediaElement& element) const
>+bool MediaElementSession::allowsPictureInPicture() const
> {
>-    return element.document().settings().allowsPictureInPictureMediaPlayback() && !element.webkitCurrentPlaybackTargetIsWireless();
>+    return m_element.document().settings().allowsPictureInPictureMediaPlayback() && !m_element.webkitCurrentPlaybackTargetIsWireless();
> }
> 
> #if PLATFORM(IOS)
>diff --git a/Source/WebCore/html/MediaElementSession.h b/Source/WebCore/html/MediaElementSession.h
>index 7add5be76b13b1371784378a1cf176221c60c177..31af7604b964ac9b397a1d7fd59de485722b798f 100644
>--- a/Source/WebCore/html/MediaElementSession.h
>+++ b/Source/WebCore/html/MediaElementSession.h
>@@ -65,34 +65,34 @@ public:
>     void registerWithDocument(Document&);
>     void unregisterWithDocument(Document&);
> 
>-    SuccessOr<MediaPlaybackDenialReason> playbackPermitted(const HTMLMediaElement&) const;
>+    SuccessOr<MediaPlaybackDenialReason> playbackPermitted() const;
>     bool autoplayPermitted() const;
>-    bool dataLoadingPermitted(const HTMLMediaElement&) const;
>-    bool fullscreenPermitted(const HTMLMediaElement&) const;
>-    bool pageAllowsDataLoading(const HTMLMediaElement&) const;
>-    bool pageAllowsPlaybackAfterResuming(const HTMLMediaElement&) const;
>+    bool dataLoadingPermitted() const;
>+    bool fullscreenPermitted() const;
>+    bool pageAllowsDataLoading() const;
>+    bool pageAllowsPlaybackAfterResuming() const;
> 
> #if ENABLE(WIRELESS_PLAYBACK_TARGET)
>-    void showPlaybackTargetPicker(const HTMLMediaElement&);
>-    bool hasWirelessPlaybackTargets(const HTMLMediaElement&) const;
>+    void showPlaybackTargetPicker();
>+    bool hasWirelessPlaybackTargets() const;
> 
>-    bool wirelessVideoPlaybackDisabled(const HTMLMediaElement&) const;
>-    void setWirelessVideoPlaybackDisabled(const HTMLMediaElement&, bool);
>+    bool wirelessVideoPlaybackDisabled() const;
>+    void setWirelessVideoPlaybackDisabled(bool);
> 
>-    void setHasPlaybackTargetAvailabilityListeners(const HTMLMediaElement&, bool);
>+    void setHasPlaybackTargetAvailabilityListeners(bool);
> 
>     bool canPlayToWirelessPlaybackTarget() const override;
>     bool isPlayingToWirelessPlaybackTarget() const override;
> 
>-    void mediaStateDidChange(const HTMLMediaElement&, MediaProducer::MediaStateFlags);
>+    void mediaStateDidChange(MediaProducer::MediaStateFlags);
> #endif
> 
>-    bool requiresFullscreenForVideoPlayback(const HTMLMediaElement&) const;
>-    WEBCORE_EXPORT bool allowsPictureInPicture(const HTMLMediaElement&) const;
>-    MediaPlayer::Preload effectivePreloadForElement(const HTMLMediaElement&) const;
>-    bool allowsAutomaticMediaDataLoading(const HTMLMediaElement&) const;
>+    bool requiresFullscreenForVideoPlayback() const;
>+    WEBCORE_EXPORT bool allowsPictureInPicture() const;
>+    MediaPlayer::Preload effectivePreloadForElement() const;
>+    bool allowsAutomaticMediaDataLoading() const;
> 
>-    void mediaEngineUpdated(const HTMLMediaElement&);
>+    void mediaEngineUpdated();
> 
>     void resetPlaybackSessionState() override;
> 
>diff --git a/Source/WebCore/platform/cocoa/PlaybackSessionModelMediaElement.mm b/Source/WebCore/platform/cocoa/PlaybackSessionModelMediaElement.mm
>index 49eddd8616dac59ad2248c1c6c71ff9028b7ee1e..b8610efa1e59fc3febdd2718a16639bc38124b15 100644
>--- a/Source/WebCore/platform/cocoa/PlaybackSessionModelMediaElement.mm
>+++ b/Source/WebCore/platform/cocoa/PlaybackSessionModelMediaElement.mm
>@@ -530,7 +530,7 @@ String PlaybackSessionModelMediaElement::externalPlaybackLocalizedDeviceName() c
> 
> bool PlaybackSessionModelMediaElement::wirelessVideoPlaybackDisabled() const
> {
>-    return m_mediaElement && m_mediaElement->mediaSession().wirelessVideoPlaybackDisabled(*m_mediaElement);
>+    return m_mediaElement && m_mediaElement->mediaSession().wirelessVideoPlaybackDisabled();
> }
> 
> bool PlaybackSessionModelMediaElement::isMuted() const

Actions: View | Formatted Diff | Diff

Attachments on bug 184992: 338776 | 338793