Attachment 408890 Details for Bug 216426 – WIP patch v0

[patch] WIP patch v0

bug-216426-20200915200206.patch (text/plain), 48.45 KB, created by Peng Liu on 2020-09-15 20:02:06 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Peng Liu

Created: 2020-09-15 20:02:06 PDT

Size: 48.45 KB

patch

obsolete

>Subversion Revision: 267079
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 8baeb933ab79f99387d26ffc3850f29558f581f2..09034481f6d5008306c5cdecf64e7188488c8c87 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,36 @@
>+2020-09-15  Peng Liu  <peng.liu6@apple.com>
>+
>+        Let webkitDisplayingFullscreen() return true when a video elementâs fullscreen mode is not VideoFullscreenModeNone
>+        https://bugs.webkit.org/show_bug.cgi?id=216426
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Covered by existing tests.
>+
>+        * html/HTMLMediaElement.cpp:
>+        (WebCore::HTMLMediaElement::dispatchEvent):
>+        (WebCore::HTMLMediaElement::isFullscreen const):
>+        (WebCore::HTMLMediaElement::enterFullscreen):
>+        (WebCore::HTMLMediaElement::exitFullscreen):
>+        (WebCore::HTMLMediaElement::didBecomeFullscreenElement):
>+        (WebCore::HTMLMediaElement::didStopBeingFullscreenElement):
>+        * html/HTMLMediaElement.h:
>+        (WebCore::HTMLMediaElement::setChangingVideoFullscreenMode):
>+        (WebCore::HTMLMediaElement::isChangingVideoFullscreenMode const):
>+        (WebCore::HTMLMediaElement::waitingToEnterFullscreen): Deleted.
>+        * html/HTMLVideoElement.cpp:
>+        (WebCore::HTMLVideoElement::webkitDisplayingFullscreen):
>+        (WebCore::HTMLVideoElement::setPresentationMode):
>+        (WebCore::HTMLVideoElement::didEnterFullscreenOrPictureInPicture):
>+        (WebCore::HTMLVideoElement::didExitFullscreenOrPictureInPicture):
>+        (WebCore::HTMLVideoElement::isChangingPresentationMode const):
>+        (WebCore::HTMLVideoElement::didBecomeFullscreenElement): Deleted.
>+        * html/HTMLVideoElement.h:
>+        * testing/Internals.cpp:
>+        (WebCore::Internals::isChangingPresentationMode const):
>+        * testing/Internals.h:
>+        * testing/Internals.idl:
>+
> 2020-09-14  Fujii Hironori  <Hironori.Fujii@sony.com>
> 
>         [WinCairo] Unreviewed debug build fix after r267073
>diff --git a/Source/WebCore/html/HTMLMediaElement.cpp b/Source/WebCore/html/HTMLMediaElement.cpp
>index a4f36798e54af4fd394f423c6fb0a6fa08696b21..651e0dff4950fab7e96512053a419e03ca21c68e 100644
>--- a/Source/WebCore/html/HTMLMediaElement.cpp
>+++ b/Source/WebCore/html/HTMLMediaElement.cpp
>@@ -5779,8 +5779,8 @@ void HTMLMediaElement::dispatchEvent(Event& event)
>     // We need to fire the end fullscreen event to notify the page
>     // to change the position/size back *before* exiting fullscreen.
>     // Otherwise, the exit fullscreen animation will be incorrect.
>-    if (!m_videoFullscreenStandby && !m_waitingToEnterFullscreen && event.type() == eventNames().webkitendfullscreenEvent) {
>-        setFullscreenMode(VideoFullscreenModeNone);
>+    if (!m_videoFullscreenStandby && m_videoFullscreenMode == VideoFullscreenModeNone && event.type() == eventNames().webkitendfullscreenEvent) {
>+        m_changingVideoFullscreenMode = true;
>         document().page()->chrome().client().exitVideoFullscreenForVideoElement(downcast<HTMLVideoElement>(*this));
>     }
> }
>@@ -5911,15 +5911,12 @@ double HTMLMediaElement::maxFastForwardRate() const
> 
> bool HTMLMediaElement::isFullscreen() const
> {
>-    if (m_videoFullscreenMode != VideoFullscreenModeNone)
>-        return true;
>-
> #if ENABLE(FULLSCREEN_API)
>     if (document().fullscreenManager().isFullscreen() && document().fullscreenManager().currentFullscreenElement() == this)
>         return true;
> #endif
> 
>-    return false;
>+    return m_videoFullscreenMode != VideoFullscreenModeNone;
> }
> 
> bool HTMLMediaElement::isStandardFullscreen() const
>@@ -5955,6 +5952,7 @@ void HTMLMediaElement::enterFullscreen(VideoFullscreenMode mode)
>     if (document().settings().fullScreenEnabled() && mode == VideoFullscreenModeStandard) {
>         m_temporarilyAllowingInlinePlaybackAfterFullscreen = false;
>         m_waitingToEnterFullscreen = true;
>+        m_changingVideoFullscreenMode = true;
>         document().fullscreenManager().requestFullscreenForElement(this, FullscreenManager::ExemptIFrameAllowFullscreenRequirement);
>         return;
>     }
>@@ -5972,11 +5970,14 @@ void HTMLMediaElement::enterFullscreen(VideoFullscreenMode mode)
>                 ALWAYS_LOG(LOGIDENTIFIER, "Entering fullscreen mode ", mode, ", m_videoFullscreenStandby = ", m_videoFullscreenStandby);
> 
>                 m_temporarilyAllowingInlinePlaybackAfterFullscreen = false;
>-                m_waitingToEnterFullscreen = true;
>+                if (mode == VideoFullscreenModeStandard)
>+                    m_waitingToEnterFullscreen = true;
>+
>                 auto oldMode = m_videoFullscreenMode;
>                 setFullscreenMode(mode);
>                 configureMediaControls();
> 
>+                m_changingVideoFullscreenMode = true;
>                 document().page()->chrome().client().enterVideoFullscreenForVideoElement(asVideo, m_videoFullscreenMode, m_videoFullscreenStandby);
>                 if (m_videoFullscreenStandby)
>                     return;
>@@ -6003,8 +6004,10 @@ void HTMLMediaElement::exitFullscreen()
> 
> #if ENABLE(FULLSCREEN_API)
>     if (document().settings().fullScreenEnabled() && document().fullscreenManager().currentFullscreenElement() == this) {
>-        if (document().fullscreenManager().isFullscreen())
>+        if (document().fullscreenManager().isFullscreen()) {
>+            m_changingVideoFullscreenMode = true;
>             document().fullscreenManager().cancelFullscreen();
>+        }
> 
>         if (m_videoFullscreenMode == VideoFullscreenModeStandard)
>             return;
>@@ -6032,15 +6035,20 @@ void HTMLMediaElement::exitFullscreen()
> 
>     if (document().activeDOMObjectsAreSuspended() || document().activeDOMObjectsAreStopped()) {
>         setFullscreenMode(VideoFullscreenModeNone);
>+        m_changingVideoFullscreenMode = true;
>         document().page()->chrome().client().exitVideoFullscreenToModeWithoutAnimation(downcast<HTMLVideoElement>(*this), VideoFullscreenModeNone);
>     } else if (document().page()->chrome().client().supportsVideoFullscreen(oldVideoFullscreenMode)) {
>         if (m_videoFullscreenStandby) {
>             setFullscreenMode(VideoFullscreenModeNone);
>+            m_changingVideoFullscreenMode = true;
>             document().page()->chrome().client().enterVideoFullscreenForVideoElement(downcast<HTMLVideoElement>(*this), m_videoFullscreenMode, m_videoFullscreenStandby);
>             return;
>         }
> 
>+        m_changingVideoFullscreenMode = true;
>+
>         if (oldVideoFullscreenMode == VideoFullscreenModeStandard) {
>+            setFullscreenMode(VideoFullscreenModeNone);
>             // The exit fullscreen request will be sent in dispatchEvent().
>             scheduleEvent(eventNames().webkitendfullscreenEvent);
>             return;
>@@ -6110,6 +6118,7 @@ void HTMLMediaElement::didBecomeFullscreenElement()
> {
>     ALWAYS_LOG(LOGIDENTIFIER, ", fullscreen mode = ", fullscreenMode());
>     m_waitingToEnterFullscreen = false;
>+    m_changingVideoFullscreenMode = false;
>     scheduleUpdatePlayState();
> }
> 
>@@ -6119,6 +6128,11 @@ void HTMLMediaElement::willStopBeingFullscreenElement()
>         setFullscreenMode(VideoFullscreenModeNone);
> }
> 
>+void HTMLMediaElement::didStopBeingFullscreenElement()
>+{
>+    m_changingVideoFullscreenMode = false;
>+}
>+
> PlatformLayer* HTMLMediaElement::platformLayer() const
> {
>     return m_player ? m_player->platformLayer() : nullptr;
>diff --git a/Source/WebCore/html/HTMLMediaElement.h b/Source/WebCore/html/HTMLMediaElement.h
>index ab2b0011b59439ea51e8aa3e208fe012c63d12ed..2f8b74f5597f2200dfd77fd00f5ec13d2b967818 100644
>--- a/Source/WebCore/html/HTMLMediaElement.h
>+++ b/Source/WebCore/html/HTMLMediaElement.h
>@@ -554,8 +554,9 @@ public:
> 
>     bool isSuspended() const final;
> 
>-    WEBCORE_EXPORT void didBecomeFullscreenElement() override;
>+    WEBCORE_EXPORT void didBecomeFullscreenElement() final;
>     WEBCORE_EXPORT void willExitFullscreen();
>+    WEBCORE_EXPORT void didStopBeingFullscreenElement() final;
> 
> #if ENABLE(PICTURE_IN_PICTURE_API)
>     void scheduleEvent(Ref<Event>&&);
>@@ -610,7 +611,9 @@ protected:
>     void updateMediaControlsAfterPresentationModeChange();
> 
>     void scheduleEvent(const AtomString&);
>-    bool waitingToEnterFullscreen() { return m_waitingToEnterFullscreen; }
>+
>+    void setChangingVideoFullscreenMode(bool value) { m_changingVideoFullscreenMode = value; }
>+    bool isChangingVideoFullscreenMode() const { return m_changingVideoFullscreenMode; }
> 
> private:
>     void createMediaPlayer();
>@@ -1109,6 +1112,7 @@ private:
> 
>     bool m_isScrubbingRemotely : 1;
>     bool m_waitingToEnterFullscreen : 1;
>+    bool m_changingVideoFullscreenMode : 1;
> 
>     bool m_tracksAreReady : 1;
>     bool m_haveVisibleTextTrack : 1;
>diff --git a/Source/WebCore/html/HTMLVideoElement.cpp b/Source/WebCore/html/HTMLVideoElement.cpp
>index 8dfabb322c4000ba669861588c1badc7adf3982f..c7c12fc8b5662e995d8c81fa558fa1b051451d42 100644
>--- a/Source/WebCore/html/HTMLVideoElement.cpp
>+++ b/Source/WebCore/html/HTMLVideoElement.cpp
>@@ -353,11 +353,9 @@ bool HTMLVideoElement::webkitSupportsFullscreen()
> bool HTMLVideoElement::webkitDisplayingFullscreen()
> {
>     if (document().quirks().needsAkamaiMediaPlayerQuirk(*this))
>-        return isFullscreen() || m_isChangingVideoFullscreenMode;
>+        return isFullscreen() || isChangingVideoFullscreenMode();
> 
>-    // This function starts to return true after the video element has entered
>-    // fullscreen/picture-in-picture until it has exited fullscreen/picture-in-picture
>-    return (isFullscreen() && !waitingToEnterFullscreen()) || (!isFullscreen() && m_isChangingVideoFullscreenMode);
>+    return isFullscreen();
> }
> 
> void HTMLVideoElement::ancestorWillEnterFullscreen()
>@@ -474,7 +472,7 @@ void HTMLVideoElement::webkitSetPresentationMode(VideoPresentationMode mode)
> 
> void HTMLVideoElement::setPresentationMode(VideoPresentationMode mode)
> {
>-    if (m_isChangingVideoFullscreenMode || toPresentationMode(fullscreenMode()) == mode)
>+    if (isChangingVideoFullscreenMode() || toPresentationMode(fullscreenMode()) == mode)
>         return;
> 
>     auto videoFullscreenMode = toFullscreenMode(mode);
>@@ -485,7 +483,6 @@ void HTMLVideoElement::setPresentationMode(VideoPresentationMode mode)
>             if (toPresentationMode(fullscreenMode()) == VideoPresentationMode::PictureInPicture)
>                 m_isExitingPictureInPicture = true;
> 
>-            m_isChangingVideoFullscreenMode = true;
>             exitFullscreen();
>         }
> 
>@@ -500,7 +497,6 @@ void HTMLVideoElement::setPresentationMode(VideoPresentationMode mode)
>     else if (fullscreenMode() == VideoFullscreenModePictureInPicture)
>         m_isExitingPictureInPicture = true;
> 
>-    m_isChangingVideoFullscreenMode = true;
>     enterFullscreen(videoFullscreenMode);
> }
> 
>@@ -511,20 +507,25 @@ auto HTMLVideoElement::webkitPresentationMode() const -> VideoPresentationMode
> 
> void HTMLVideoElement::didEnterFullscreenOrPictureInPicture(const FloatSize& size)
> {
>-    m_isChangingVideoFullscreenMode = false;
>-    if (m_isEnteringPictureInPicture || m_isExitingPictureInPicture) {
>+    if (m_isEnteringPictureInPicture) {
>+        m_isEnteringPictureInPicture = false;
>+        setChangingVideoFullscreenMode(false);
>+
> #if ENABLE(PICTURE_IN_PICTURE_API)
>-        if (m_pictureInPictureObserver) {
>-            if (m_isEnteringPictureInPicture)
>-                m_pictureInPictureObserver->didEnterPictureInPicture(flooredIntSize(size));
>-            else
>-                m_pictureInPictureObserver->didExitPictureInPicture();
>-        }
>+        if (m_pictureInPictureObserver)
>+            m_pictureInPictureObserver->didEnterPictureInPicture(flooredIntSize(size));
> #else
>         UNUSED_PARAM(size);
> #endif
>-        m_isEnteringPictureInPicture = false;
>+        return;
>+    }
>+
>+    if (m_isExitingPictureInPicture) {
>         m_isExitingPictureInPicture = false;
>+#if ENABLE(PICTURE_IN_PICTURE_API)
>+        if (m_pictureInPictureObserver)
>+            m_pictureInPictureObserver->didExitPictureInPicture();
>+#endif
>     }
> 
>     HTMLMediaElement::didBecomeFullscreenElement();
>@@ -532,23 +533,24 @@ void HTMLVideoElement::didEnterFullscreenOrPictureInPicture(const FloatSize& siz
> 
> void HTMLVideoElement::didExitFullscreenOrPictureInPicture()
> {
>-    m_isChangingVideoFullscreenMode = false;
>     if (m_isExitingPictureInPicture) {
>         m_isExitingPictureInPicture = false;
>+        setChangingVideoFullscreenMode(false);
>+
> #if ENABLE(PICTURE_IN_PICTURE_API)
>         if (m_pictureInPictureObserver)
>             m_pictureInPictureObserver->didExitPictureInPicture();
> #endif
>+        return;
>     }
>+
>+    HTMLMediaElement::didStopBeingFullscreenElement();
> }
> 
>-#if ENABLE(FULLSCREEN_API) && ENABLE(VIDEO_USES_ELEMENT_FULLSCREEN)
>-void HTMLVideoElement::didBecomeFullscreenElement()
>+bool HTMLVideoElement::isChangingPresentationMode() const
> {
>-    m_isChangingVideoFullscreenMode = false;
>-    HTMLMediaElement::didBecomeFullscreenElement();
>+    return isChangingVideoFullscreenMode();
> }
>-#endif
> 
> void HTMLVideoElement::setVideoFullscreenFrame(const FloatRect& frame)
> {
>diff --git a/Source/WebCore/html/HTMLVideoElement.h b/Source/WebCore/html/HTMLVideoElement.h
>index ed34dd36dce7c6dcaeedb43f73245cd9cfa09343..db9380ed5814fa4e1492dfaa945e21a64e45da4d 100644
>--- a/Source/WebCore/html/HTMLVideoElement.h
>+++ b/Source/WebCore/html/HTMLVideoElement.h
>@@ -91,10 +91,7 @@ public:
>     WEBCORE_EXPORT void setPresentationMode(VideoPresentationMode);
>     WEBCORE_EXPORT void didEnterFullscreenOrPictureInPicture(const FloatSize&);
>     WEBCORE_EXPORT void didExitFullscreenOrPictureInPicture();
>-
>-#if ENABLE(FULLSCREEN_API) && ENABLE(VIDEO_USES_ELEMENT_FULLSCREEN)
>-    WEBCORE_EXPORT void didBecomeFullscreenElement() final;
>-#endif
>+    WEBCORE_EXPORT bool isChangingPresentationMode() const;
> 
>     void setVideoFullscreenFrame(const FloatRect&) final;
> 
>@@ -138,7 +135,6 @@ private:
> 
>     unsigned m_lastReportedVideoWidth { 0 };
>     unsigned m_lastReportedVideoHeight { 0 };
>-    bool m_isChangingVideoFullscreenMode { false };
> 
> #if ENABLE(VIDEO_PRESENTATION_MODE)
>     bool m_isEnteringPictureInPicture { false };
>diff --git a/Source/WebCore/testing/Internals.cpp b/Source/WebCore/testing/Internals.cpp
>index 1d14d70ed8f12a1e6d3d0f255cb1ba0f50783e8c..8bdb64e6e088de7f8dc266fb4d98dbb859652e4e 100644
>--- a/Source/WebCore/testing/Internals.cpp
>+++ b/Source/WebCore/testing/Internals.cpp
>@@ -3426,6 +3426,11 @@ void Internals::setFullscreenControlsHidden(bool hidden)
> }
> 
> #if ENABLE(VIDEO_PRESENTATION_MODE)
>+bool Internals::isChangingPresentationMode(HTMLVideoElement& element) const
>+{
>+    return element.isChangingPresentationMode();
>+}
>+
> void Internals::setMockVideoPresentationModeEnabled(bool enabled)
> {
>     Document* document = contextDocument();
>diff --git a/Source/WebCore/testing/Internals.h b/Source/WebCore/testing/Internals.h
>index 371176f6c2a3c787e036f5226625835fdc13ee8a..cd05f76afb5637dd0a85c17ff3a20bbb231c1cff 100644
>--- a/Source/WebCore/testing/Internals.h
>+++ b/Source/WebCore/testing/Internals.h
>@@ -514,6 +514,7 @@ public:
>     void setFullscreenControlsHidden(bool);
> 
> #if ENABLE(VIDEO_PRESENTATION_MODE)
>+    bool isChangingPresentationMode(HTMLVideoElement&) const;
>     void setMockVideoPresentationModeEnabled(bool);
> #endif
> 
>diff --git a/Source/WebCore/testing/Internals.idl b/Source/WebCore/testing/Internals.idl
>index 8d1ad42fd5a7b5004cb08fa66eef74abc4648d43..88378e54b814f69c8f677eca660d1c18ff4dd0a5 100644
>--- a/Source/WebCore/testing/Internals.idl
>+++ b/Source/WebCore/testing/Internals.idl
>@@ -570,6 +570,7 @@ enum ContentSizeCategory {
>     undefined setFullscreenAutoHideDuration(double duration);
>     undefined setFullscreenControlsHidden(boolean hidden);
> 
>+    [Conditional=VIDEO_PRESENTATION_MODE] boolean isChangingPresentationMode(HTMLVideoElement element);
>     [Conditional=VIDEO_PRESENTATION_MODE] undefined setMockVideoPresentationModeEnabled(boolean enabled);
> 
>     undefined setApplicationCacheOriginQuota(unsigned long long quota);
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index ff673e464918bd54e547b6140339a5696c97bdc8..3c84b023d50d3aa8f6f690f5ece6181e3d80032e 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,31 @@
>+2020-09-15  Peng Liu  <peng.liu6@apple.com>
>+
>+        Let webkitDisplayingFullscreen() return true when a video elementâs fullscreen mode is not VideoFullscreenModeNone
>+        https://bugs.webkit.org/show_bug.cgi?id=216426
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast-expected.txt:
>+        * http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast.html:
>+        * media/context-menu-actions.html:
>+        * media/media-fullscreen-loop-inline-expected.txt:
>+        * media/media-fullscreen-loop-inline.html:
>+        * media/media-fullscreen-pause-inline-expected.txt:
>+        * media/media-fullscreen-pause-inline.html:
>+        * media/media-fullscreen-return-to-inline-expected.txt:
>+        * media/media-fullscreen-return-to-inline.html:
>+        * media/presentationmodechanged-fired-once-expected.txt:
>+        * media/presentationmodechanged-fired-once.html:
>+        * media/video-fullscreen-only-playback-expected.txt:
>+        * media/video-fullscreen-only-playback.html:
>+        * media/video-playsinline-expected.txt:
>+        * media/video-playsinline.html:
>+        * media/video-presentation-mode-expected.txt:
>+        * media/video-presentation-mode.html:
>+        * media/video-webkit-playsinline-expected.txt:
>+        * media/video-webkit-playsinline.html:
>+        * platform/mac/TestExpectations:
>+
> 2020-09-14  Myles C. Maxfield  <mmaxfield@apple.com>
> 
>         [Apple Win] Migrate from FontPlatformDataWin.cpp to FontPlatformDataCoreText.cpp
>diff --git a/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast-expected.txt b/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast-expected.txt
>index b32a7c1749acbc76dd6ec1a07ff9efd7de427b3c..7b6694953d6e3408d07705b605a7d59d509359f0 100644
>--- a/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast-expected.txt
>+++ b/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast-expected.txt
>@@ -3,7 +3,7 @@ Testing that we do not show the seeking controls in fullscreen with a live broad
> On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
> 
> 
>-PASS media.webkitDisplayingFullscreen became true
>+PASS media.webkitDisplayingFullscreen is true
> PASS media.duration became Number.POSITIVE_INFINITY
> PASS mediaController.controls.rewindButton.enabled is false
> PASS mediaController.controls.forwardButton.enabled is false
>diff --git a/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast.html b/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast.html
>index afbe8814e685084cfab6599ba2bd45b5e70dfd0b..b64b43a233590dabf48e317a68f0b0c6b3c43422 100644
>--- a/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast.html
>+++ b/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast.html
>@@ -15,18 +15,17 @@ const media = document.querySelector("video");
> const mediaController = createControls(shadowRoot, media, null);
> 
> media.addEventListener("webkitfullscreenchange", () => {
>-    shouldBecomeEqual("media.webkitDisplayingFullscreen", "true", () => {
>-        shouldBecomeEqual("media.duration", "Number.POSITIVE_INFINITY", () => {
>-            shouldBeFalse("mediaController.controls.rewindButton.enabled");
>-            shouldBeFalse("mediaController.controls.forwardButton.enabled");
>-            shouldBe("mediaController.controls.timeControl.parent", "null");
>-            shouldBe("mediaController.controls.statusLabel.parent", "mediaController.controls.bottomControlsBar");
>-
>-            debug("");
>-            media.remove();
>-            shadowRoot.host.remove();
>-            finishJSTest();
>-        });
>+    shouldBeTrue("media.webkitDisplayingFullscreen");
>+    shouldBecomeEqual("media.duration", "Number.POSITIVE_INFINITY", () => {
>+        shouldBeFalse("mediaController.controls.rewindButton.enabled");
>+        shouldBeFalse("mediaController.controls.forwardButton.enabled");
>+        shouldBe("mediaController.controls.timeControl.parent", "null");
>+        shouldBe("mediaController.controls.statusLabel.parent", "mediaController.controls.bottomControlsBar");
>+
>+        debug("");
>+        media.remove();
>+        shadowRoot.host.remove();
>+        finishJSTest();
>     });
> });
> 
>diff --git a/LayoutTests/media/context-menu-actions.html b/LayoutTests/media/context-menu-actions.html
>index 059eea70952f857fbc6256b84967ff61a6327e36..d393c790b185d374049a373177a96de9942699ea 100644
>--- a/LayoutTests/media/context-menu-actions.html
>+++ b/LayoutTests/media/context-menu-actions.html
>@@ -1,87 +1,86 @@
>+<!DOCTYPE html>
> <html>
> <head>
>-        <script src="media-file.js"></script>
>-        <script src="video-test.js"></script>
>-        <script>
>-
>-            async function playing()
>-            {
>-                if (window.testRunner) {
>-                    if (!window.eventSender) {
>-                        testRunner.dumpAsText();
>-                        endTest();
>-                        return;
>-                    }
>-                } else {
>+    <script src="media-file.js"></script>
>+    <script src="video-test.js"></script>
>+    <script>
>+        async function playing()
>+        {
>+            if (window.testRunner) {
>+                if (!window.eventSender) {
>+                    testRunner.dumpAsText();
>                     endTest();
>                     return;
>                 }
>+            } else {
>+                endTest();
>+                return;
>+            }
> 
>-                findMediaElement();
>-
>-                var x, y, items;
>-                x = video.offsetParent.offsetLeft + video.offsetLeft + video.offsetWidth / 2;
>-                y = video.offsetParent.offsetTop + video.offsetTop + video.offsetHeight / 2;
>-                eventSender.mouseMoveTo(x, y);
>-                items = eventSender.contextClick();
>-
>+            findMediaElement();
> 
>-                for (var i = 0; i < items.length; i++)
>-                {
>-                    if (items[i].title.match("Controls")) {
>-                       testExpected("video.controls", true, '==');
>-                       consoleWrite("Toggling media controls");
>-                       items[i].click();
>-                       testExpected("video.controls", false, '==');
>-                       consoleWrite("");
>-                    }
>+            var x, y, items;
>+            x = video.offsetParent.offsetLeft + video.offsetLeft + video.offsetWidth / 2;
>+            y = video.offsetParent.offsetTop + video.offsetTop + video.offsetHeight / 2;
>+            eventSender.mouseMoveTo(x, y);
>+            items = eventSender.contextClick();
> 
>-                    if (items[i].title.match("Pause")) {
>-                       testExpected("video.paused", false, '==');
>-                       consoleWrite("Toggling play state");
>-                       items[i].click();
>-                       testExpected("video.paused", true, '==');
>-                       consoleWrite("");
>-                    }
>+            for (var i = 0; i < items.length; i++)
>+            {
>+                if (items[i].title.match("Controls")) {
>+                    testExpected("video.controls", true, '==');
>+                    consoleWrite("Toggling media controls");
>+                    items[i].click();
>+                    testExpected("video.controls", false, '==');
>+                    consoleWrite("");
>+                }
> 
>-                    if (items[i].title.match("Loop")) {
>-                       testExpected("video.loop", false, '==');
>-                       consoleWrite("Toggling loop state");
>-                       items[i].click();
>-                       testExpected("video.loop", true, '==');
>-                       consoleWrite("");
>-                    }
>+                if (items[i].title.match("Pause")) {
>+                    testExpected("video.paused", false, '==');
>+                    consoleWrite("Toggling play state");
>+                    items[i].click();
>+                    testExpected("video.paused", true, '==');
>+                    consoleWrite("");
>+                }
> 
>-                    if (items[i].title.match("Mute")) {
>-                       testExpected("video.muted", false, '==');
>-                       consoleWrite("Toggling mute state");
>-                       items[i].click();
>-                       testExpected("video.muted", true, '==');
>-                       consoleWrite("");
>-                    }
>+                if (items[i].title.match("Loop")) {
>+                    testExpected("video.loop", false, '==');
>+                    consoleWrite("Toggling loop state");
>+                    items[i].click();
>+                    testExpected("video.loop", true, '==');
>+                    consoleWrite("");
>+                }
> 
>-                    if (items[i].title.match("Fullscreen") && video.webkitSupportsFullscreen) {
>-                       testExpected("video.webkitDisplayingFullscreen", false, '==');
>-                       consoleWrite("Toggling fullscreen state");
>-                       items[i].click();
>-                       await testExpectedEventually("video.webkitDisplayingFullscreen", true, "==", 1000);
>-                       consoleWrite("");
>-                    }
>+                if (items[i].title.match("Mute")) {
>+                    testExpected("video.muted", false, '==');
>+                    consoleWrite("Toggling mute state");
>+                    items[i].click();
>+                    testExpected("video.muted", true, '==');
>+                    consoleWrite("");
>+                }
> 
>-                    // TODO: test copy link location and open in new window.
>-                 }
>-                 testRunner.dumpAsText();
>-                 endTest();
>-            }
>+                if (items[i].title.match("Fullscreen") && video.webkitSupportsFullscreen) {
>+                    testExpected("video.webkitDisplayingFullscreen", false, '==');
>+                    consoleWrite("Toggling fullscreen state");
>+                    items[i].click();
>+                    await testExpectedEventually("internals.isChangingPresentationMode(video)", false, '==', 1000);
>+                    testExpected("video.webkitDisplayingFullscreen", true, '==');
>+                    consoleWrite("");
>+                }
> 
>-            async function start()
>-            {
>-                findMediaElement();
>-                waitForEvent('play', playing);
>-                run("video.src = '" + findMediaFile("video", "content/test") + "'");
>+                // TODO: test copy link location and open in new window.
>             }
>+            testRunner.dumpAsText();
>+            endTest();
>+        }
> 
>-       </script>
>+        async function start()
>+        {
>+            findMediaElement();
>+            waitForEvent('play', playing);
>+            run("video.src = '" + findMediaFile("video", "content/test") + "'");
>+        }
>+    </script>
> </head>
> <body onload="start()">
>     <p>Test the various actions available in the HTML5 media element context-menu.</p>
>diff --git a/LayoutTests/media/media-fullscreen-loop-inline-expected.txt b/LayoutTests/media/media-fullscreen-loop-inline-expected.txt
>index 5a337a3e23e6f126e91c530995ff15d5bdd01c19..87c1ee7542064104c600e6fac3c8be98b99d886a 100644
>--- a/LayoutTests/media/media-fullscreen-loop-inline-expected.txt
>+++ b/LayoutTests/media/media-fullscreen-loop-inline-expected.txt
>@@ -7,12 +7,14 @@ EVENT(canplaythrough)
> RUN(video.play())
> Wait to enter fullscreen
> EVENT(webkitpresentationmodechanged)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> Entered fullscreen
> RUN(video.currentTime = 5)
> RUN(video.webkitExitFullscreen())
> Wait to exit fullscreen
> EVENT(webkitpresentationmodechanged)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
> Exited fullscreen
> EXPECTED (video.paused == 'false') OK
>diff --git a/LayoutTests/media/media-fullscreen-loop-inline.html b/LayoutTests/media/media-fullscreen-loop-inline.html
>index 4b8b199249d1950ad7ee035f2e8f6745c2f195d9..4f516cb92d266de48cb4381ad96e79a02dd85233 100644
>--- a/LayoutTests/media/media-fullscreen-loop-inline.html
>+++ b/LayoutTests/media/media-fullscreen-loop-inline.html
>@@ -35,7 +35,8 @@
> 
>     async function beginfullscreen()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', true);
>         consoleWrite("Entered fullscreen");
>         run('video.currentTime = 5');
>         run('video.webkitExitFullscreen()');
>@@ -45,7 +46,8 @@
> 
>     async function endfullscreen()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', false);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', false);
>         consoleWrite("Exited fullscreen");
>         testExpected('video.paused', false);
>         run('video.ontimeupdate = timeupdate');
>diff --git a/LayoutTests/media/media-fullscreen-pause-inline-expected.txt b/LayoutTests/media/media-fullscreen-pause-inline-expected.txt
>index 3abc9e292a646bc20ccf39e7e922c3289da42e55..93abf1a6e6b9878f13ff5488722240bfa28fc1bc 100644
>--- a/LayoutTests/media/media-fullscreen-pause-inline-expected.txt
>+++ b/LayoutTests/media/media-fullscreen-pause-inline-expected.txt
>@@ -4,15 +4,18 @@ Test that a <video> keeps playing after exiting fullscreen when the internal pro
> RUN(video.src = findMediaFile("video", "content/test"))
> EVENT(canplaythrough)
> RUN(video.play().then(playing);)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> RUN(video.webkitExitFullscreen())
> EVENT(webkitpresentationmodechanged)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
> EXPECTED (video.paused == 'false') OK
> RUN(video.pause())
> EVENT(pause)
> EXPECTED (video.paused == 'true') OK
> RUN(video.play().then(playingAgain))
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> END OF TEST
> 
>diff --git a/LayoutTests/media/media-fullscreen-pause-inline.html b/LayoutTests/media/media-fullscreen-pause-inline.html
>index 6ea103e8660f448b1bbf597dc39bc73dd761171e..ea824239dfb34565b2562530fd174774749e4742 100644
>--- a/LayoutTests/media/media-fullscreen-pause-inline.html
>+++ b/LayoutTests/media/media-fullscreen-pause-inline.html
>@@ -33,14 +33,16 @@
> 
>     async function playing()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', true);
>         waitForEventOnce('webkitpresentationmodechanged', endfullscreen);
>         run('video.webkitExitFullscreen()');
>     }
> 
>     async function endfullscreen()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', false);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', false);
>         testExpected('video.paused', false);
>         waitForEventOnce('pause', paused);
>         run('video.pause()');
>@@ -54,7 +56,8 @@
> 
>     async function playingAgain()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', true);
>         endTest();
>     }
>     </script>
>diff --git a/LayoutTests/media/media-fullscreen-return-to-inline-expected.txt b/LayoutTests/media/media-fullscreen-return-to-inline-expected.txt
>index ae8729ceb891f22e1ec118d26018e38f2817f0af..442d132d0ed4ee092a01a59015a3147e8ebe41ca 100644
>--- a/LayoutTests/media/media-fullscreen-return-to-inline-expected.txt
>+++ b/LayoutTests/media/media-fullscreen-return-to-inline-expected.txt
>@@ -5,16 +5,20 @@ RUN(video.src = findMediaFile("video", "content/test"))
> EVENT(canplaythrough)
> RUN(video.play())
> EVENT(webkitpresentationmodechanged)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> RUN(video.webkitExitFullscreen())
>-EVENT(pause)
>+EVENT(webkitpresentationmodechanged)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
> EXPECTED (video.paused == 'true') OK
> RUN(video.play())
> EVENT(webkitpresentationmodechanged)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> RUN(video.webkitExitFullscreen())
> EVENT(webkitpresentationmodechanged)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
> EXPECTED (video.paused == 'false') OK
> END OF TEST
>diff --git a/LayoutTests/media/media-fullscreen-return-to-inline.html b/LayoutTests/media/media-fullscreen-return-to-inline.html
>index 93220eded3ed46116209e8748ff4211679547b56..d8fe84d9a3ba35579bacb733314266c1277bf0d4 100644
>--- a/LayoutTests/media/media-fullscreen-return-to-inline.html
>+++ b/LayoutTests/media/media-fullscreen-return-to-inline.html
>@@ -34,14 +34,16 @@
> 
>     async function beginfullscreen1()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
>-        waitForEventOnce('pause', pause);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', true);
>+        waitForEventOnce('webkitpresentationmodechanged', endfullscreen1);
>         run('video.webkitExitFullscreen()');
>     }
> 
>-    async function pause()
>+    async function endfullscreen1()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', false);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', false);
>         testExpected('video.paused', true);
> 
>         internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true);
>@@ -52,14 +54,16 @@
> 
>     async function beginfullscreen2()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
>-        waitForEventOnce('webkitpresentationmodechanged', endfullscreen);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', true);
>+        waitForEventOnce('webkitpresentationmodechanged', endfullscreen2);
>         run('video.webkitExitFullscreen()');
>     }
> 
>-    async function endfullscreen()
>+    async function endfullscreen2()
>     {
>-        await testExpectedEventually('video.webkitDisplayingFullscreen', false);
>+        await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+        testExpected('video.webkitDisplayingFullscreen', false);
>         testExpected('video.paused', false);
>         endTest();
>     }
>diff --git a/LayoutTests/media/presentationmodechanged-fired-once-expected.txt b/LayoutTests/media/presentationmodechanged-fired-once-expected.txt
>index a18e8bb86ee37c239b87692d1801a85d2b0e2d9c..de4ca5bca4629b8e8398a2f59ecd3b0c4c34829b 100644
>--- a/LayoutTests/media/presentationmodechanged-fired-once-expected.txt
>+++ b/LayoutTests/media/presentationmodechanged-fired-once-expected.txt
>@@ -5,7 +5,7 @@ EVENT(canplaythrough)
> RUN(video.play())
> RUN(video.webkitSetPresentationMode("picture-in-picture"))
> EVENT(webkitpresentationmodechanged)
>-EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitPresentationMode == 'picture-in-picture') OK
> RUN(video.webkitSetPresentationMode("inline"))
> EVENT(webkitpresentationmodechanged)
>diff --git a/LayoutTests/media/presentationmodechanged-fired-once.html b/LayoutTests/media/presentationmodechanged-fired-once.html
>index 538bd127bc91a9990a507c924f3cbb5431aa47d4..c2b5d6c1c63598d41c4d9a5caa027b4154813355 100644
>--- a/LayoutTests/media/presentationmodechanged-fired-once.html
>+++ b/LayoutTests/media/presentationmodechanged-fired-once.html
>@@ -27,7 +27,7 @@
> 
>         async function presentationModeChanged1()
>         {
>-            await testExpectedEventually('video.webkitDisplayingFullscreen', true);
>+            await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>             testExpected("video.webkitPresentationMode", "picture-in-picture");
>             runWithKeyDown('video.webkitSetPresentationMode("inline")');
>             waitForEvent("webkitpresentationmodechanged", presentationModeChanged2);
>diff --git a/LayoutTests/media/video-fullscreen-only-playback-expected.txt b/LayoutTests/media/video-fullscreen-only-playback-expected.txt
>index c172b52ef464433d2988e9636993711f1c83330e..335c5b2e06ee25c1d9f59dfb9940994c831338d4 100644
>--- a/LayoutTests/media/video-fullscreen-only-playback-expected.txt
>+++ b/LayoutTests/media/video-fullscreen-only-playback-expected.txt
>@@ -7,13 +7,16 @@ EXPECTED (video.webkitSupportsFullscreen == 'true') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
> RUN(video.play())
> EVENT(playing)
>-EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> 
>-** Entered fullscreen
>+** Started playing
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
>+EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> RUN(video.webkitExitFullScreen())
> EVENT(webkitpresentationmodechanged)
>-EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
> 
>-** Exited fullscreen
>+** Received webkitpresentationmodechanged event
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
>+Exited fullscreen
>+EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
> END OF TEST
> 
>diff --git a/LayoutTests/media/video-fullscreen-only-playback.html b/LayoutTests/media/video-fullscreen-only-playback.html
>index c3aca3a046c4ebbc357c9bf588f47f7fed4b6d71..47889a61335b2417f59f67be024cef44df2c93c3 100644
>--- a/LayoutTests/media/video-fullscreen-only-playback.html
>+++ b/LayoutTests/media/video-fullscreen-only-playback.html
>@@ -40,16 +40,19 @@
> 
>             async function playing()
>             {
>-                await testExpectedEventually("video.webkitDisplayingFullscreen", true);
>-                consoleWrite("<br>** Entered fullscreen");
>+                consoleWrite("<br>** Started playing");
>+                await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+                testExpected("video.webkitDisplayingFullscreen", true);
>                 waitForEventOnce('webkitpresentationmodechanged', endfullscreen);
>                 run("video.webkitExitFullScreen()");
>             }
> 
>             async function endfullscreen()
>             {
>-                await testExpectedEventually("video.webkitDisplayingFullscreen", false);
>-                consoleWrite("<br>** Exited fullscreen");
>+                consoleWrite("<br>** Received webkitpresentationmodechanged event");
>+                await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>+                consoleWrite("Exited fullscreen");
>+                testExpected("video.webkitDisplayingFullscreen", false);
>                 endTest();
>             }
>         </script>
>diff --git a/LayoutTests/media/video-playsinline-expected.txt b/LayoutTests/media/video-playsinline-expected.txt
>index 0414573f0c46cd73fce2448ed69c9ff8d518fcaa..5edcad17c68d328a44c47111b8d0289b9a9b91c3 100644
>--- a/LayoutTests/media/video-playsinline-expected.txt
>+++ b/LayoutTests/media/video-playsinline-expected.txt
>@@ -3,6 +3,7 @@ RUN(video.playsInline = false)
> EVENT(canplaythrough)
> RUN(video.play())
> EVENT(playing)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> RUN(internals.settings.setInlineMediaPlaybackRequiresPlaysInlineAttribute(true))
> RUN(video.playsInline = true)
>diff --git a/LayoutTests/media/video-playsinline.html b/LayoutTests/media/video-playsinline.html
>index fa6a731244d970b3c92dda5b60b8d729249f51db..d09d4cc5d422c9b8269cad4c6263d42fc22d19be 100644
>--- a/LayoutTests/media/video-playsinline.html
>+++ b/LayoutTests/media/video-playsinline.html
>@@ -30,7 +30,10 @@ function testPlaysInline(requiresPlaysInline, hasPlaysInline, expectedDisplaying
>             run('video.play()');
>         });
>     })
>-    waitForEventOnce('playing', () => {
>+    waitForEventOnce('playing', async () => {
>+        if (expectedDisplayingFullscreen)
>+            await testExpectedEventually('internals.isChangingPresentationMode(video)', false);
>+
>         testExpected('video.webkitDisplayingFullscreen', expectedDisplayingFullscreen);
>         document.body.removeChild(video);
>         runNextTest();
>diff --git a/LayoutTests/media/video-presentation-mode-expected.txt b/LayoutTests/media/video-presentation-mode-expected.txt
>index 1d7db0282499d39309afa20d9ec75d1c8a251359..aba9f453600ae78efa5cbefc959d86a232976d7e 100644
>--- a/LayoutTests/media/video-presentation-mode-expected.txt
>+++ b/LayoutTests/media/video-presentation-mode-expected.txt
>@@ -4,30 +4,30 @@ Test the video presentation mode (video fullscreen and picture-in-picture) API.
> 
> EVENT(canplaythrough)
> EXPECTED (video.webkitSupportsFullscreen == 'true') OK
>-EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
>+EXPECTED (video.webkitPresentationMode == 'inline') OK
> 
> ** Try to enter fullscreen
> RUN(video.webkitSetPresentationMode('fullscreen'))
> EVENT(webkitpresentationmodechanged)
>-EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> 
>-** Entered fullscreen
>+** Received webkitpresentationmodechanged event
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitPresentationMode == 'fullscreen') OK
> 
> ** Try to enter picture-in-picture
> RUN(video.webkitSetPresentationMode('picture-in-picture'))
> EVENT(webkitpresentationmodechanged)
>-EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> 
>-** Entered picture-in-picture
>+** Received webkitpresentationmodechanged event
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitPresentationMode == 'picture-in-picture') OK
> 
> ** Try to return to inline
> RUN(video.webkitSetPresentationMode('inline'))
> EVENT(webkitpresentationmodechanged)
>-EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
> 
>-** Returned to inline
>+** Received webkitpresentationmodechanged event
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitPresentationMode == 'inline') OK
> 
> ** Test Completed
>diff --git a/LayoutTests/media/video-presentation-mode.html b/LayoutTests/media/video-presentation-mode.html
>index 3056d15e1a9c2d1cafcb1e0e28cfa4b7b97764d8..f105c8550c9052978420d4f5522347f2a64abf13 100644
>--- a/LayoutTests/media/video-presentation-mode.html
>+++ b/LayoutTests/media/video-presentation-mode.html
>@@ -21,7 +21,7 @@
>             async function canplaythrough()
>             {
>                 testExpected("video.webkitSupportsFullscreen", true);
>-                await testExpectedEventually('video.webkitDisplayingFullscreen', false);
>+                testExpected("video.webkitPresentationMode", "inline");
> 
>                 consoleWrite("<br>** Try to enter fullscreen");
>                 runWithKeyDown("video.webkitSetPresentationMode('fullscreen')");
>@@ -30,8 +30,8 @@
> 
>             async function presentationModeChanged1()
>             {
>-                await testExpectedEventually('video.webkitDisplayingFullscreen', true);
>-                consoleWrite("<br>** Entered fullscreen");
>+                consoleWrite("<br>** Received webkitpresentationmodechanged event");
>+                await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>                 testExpected("video.webkitPresentationMode", "fullscreen");
>                 consoleWrite("<br>** Try to enter picture-in-picture");
>                 waitForEventOnce('webkitpresentationmodechanged', presentationModeChanged2);
>@@ -40,8 +40,8 @@
> 
>             async function presentationModeChanged2()
>             {
>-                await testExpectedEventually('video.webkitDisplayingFullscreen', true);
>-                consoleWrite("<br>** Entered picture-in-picture");
>+                consoleWrite("<br>** Received webkitpresentationmodechanged event");
>+                await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>                 testExpected("video.webkitPresentationMode", "picture-in-picture");
>                 consoleWrite("<br>** Try to return to inline");
>                 waitForEventOnce('webkitpresentationmodechanged', testCompleted);
>@@ -50,8 +50,8 @@
> 
>             async function testCompleted()
>             {
>-                await testExpectedEventually('video.webkitDisplayingFullscreen', false);
>-                consoleWrite("<br>** Returned to inline");
>+                consoleWrite("<br>** Received webkitpresentationmodechanged event");
>+                await testExpectedEventually("internals.isChangingPresentationMode(video)", false);
>                 testExpected("video.webkitPresentationMode", "inline");
>                 consoleWrite("<br>** Test Completed");
>                 endTest();
>diff --git a/LayoutTests/media/video-webkit-playsinline-expected.txt b/LayoutTests/media/video-webkit-playsinline-expected.txt
>index 96748956e8b3684bfdbd58bba635e7c69c179684..09397e92fb8c96e2c486753a0825da1639e715d5 100644
>--- a/LayoutTests/media/video-webkit-playsinline-expected.txt
>+++ b/LayoutTests/media/video-webkit-playsinline-expected.txt
>@@ -3,12 +3,14 @@ RUN(video.removeAttribute("webkit-playsinline", ""))
> EVENT(canplaythrough)
> RUN(video.play())
> EVENT(playing)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> RUN(internals.settings.setInlineMediaPlaybackRequiresPlaysInlineAttribute(true))
> RUN(video.setAttribute("webkit-playsinline", ""))
> EVENT(canplaythrough)
> RUN(video.play())
> EVENT(playing)
>+EXPECTED (internals.isChangingPresentationMode(video) == 'false') OK
> EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
> RUN(internals.settings.setInlineMediaPlaybackRequiresPlaysInlineAttribute(false))
> RUN(video.removeAttribute("webkit-playsinline", ""))
>diff --git a/LayoutTests/media/video-webkit-playsinline.html b/LayoutTests/media/video-webkit-playsinline.html
>index 7ed95f48805fd306ce628222a5ab44b6f1baca35..ab730b032b48fe9f59bf63271c3db4323c3249ed 100644
>--- a/LayoutTests/media/video-webkit-playsinline.html
>+++ b/LayoutTests/media/video-webkit-playsinline.html
>@@ -30,7 +30,10 @@ function testPlaysInline(requiresPlaysInline, hasWebkitPlaysInline, expectedDisp
>             run('video.play()');
>         });
>     })
>-    waitForEventOnce('playing', () => {
>+    waitForEventOnce('playing', async () => {
>+        if (expectedDisplayingFullscreen)
>+            await testExpectedEventually('internals.isChangingPresentationMode(video)', false);
>+
>         testExpected('video.webkitDisplayingFullscreen', expectedDisplayingFullscreen);
>         document.body.removeChild(video);
>         runNextTest();
>diff --git a/LayoutTests/platform/mac/TestExpectations b/LayoutTests/platform/mac/TestExpectations
>index 26686c71cf3951e04bc91f8348747ac8eab8270f..eee3554533e706a2cd99b30a598f2a79288d09d1 100644
>--- a/LayoutTests/platform/mac/TestExpectations
>+++ b/LayoutTests/platform/mac/TestExpectations
>@@ -1460,8 +1460,6 @@ webkit.org/b/183490 media/modern-media-controls/media-controller/media-controlle
> webkit.org/b/183490 media/modern-media-controls/media-controller/media-controller-fullscreen-change.html [ Failure ]
> webkit.org/b/183490 media/modern-media-controls/media-controller/media-controller-inline-to-fullscreen-to-inline.html [ Failure ]
> webkit.org/b/183490 media/modern-media-controls/start-support/start-support-fullscreen.html [ Failure ]
>-webkit.org/b/183490 media/video-playsinline.html [ Failure ]
>-webkit.org/b/183490 media/video-webkit-playsinline.html [ Failure ]
> 
> webkit.org/b/183764 fast/css/apple-system-control-colors.html [ Pass ]
>

Actions: View | Formatted Diff | Diff

Attachments on bug 216426: 408890 | 408935 | 409091 | 409104 | 409156 | 411804 | 412065