Changeset 261493 in webkit


Ignore:
Timestamp:
May 11, 2020 2:03:24 PM (4 years ago)
Author:
Peng Liu
Message:

Enable the mock video presentation mode in related layout tests and fix test failures
https://bugs.webkit.org/show_bug.cgi?id=211645

Reviewed by Darin Adler.

Source/WebCore:

Clean up the internal states of video element regarding video presentation mode
to simplify the task to write reliable layout tests for video fullscreen and
Picture-in-Picture.

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::enterFullscreen):
Update the states after we are sure the video element will enter fullscreen.

(WebCore::HTMLMediaElement::exitFullscreen):
Remove the unnecessary "fullscreenModeChanged(VideoFullscreenModeNone)".

  • html/HTMLMediaElement.h:

(WebCore::HTMLMediaElement::waitingToEnterFullscreen):

  • html/HTMLVideoElement.cpp:

(WebCore::HTMLVideoElement::webkitDisplayingFullscreen):
The function webkitDisplayingFullscreen() will return true after the process
to enter fullscreen is completed.

  • html/HTMLVideoElement.h:

Expose didBecomeFullscreenElement() when VIDEO_PRESENTATION_MODE is enabled.

Source/WebKit:

Fix the mistake in VideoFullscreenManager::supportsVideoFullscreen() introduced in r202274.

  • WebProcess/cocoa/VideoFullscreenManager.mm:

(WebKit::VideoFullscreenManager::supportsVideoFullscreen const):

Source/WebKitLegacy/mac:

Call HTMLVideoElement::didBecomeFullscreenElement() after a video element enters
fullscreen (to be consistent with WK2).

  • WebView/WebVideoFullscreenController.mm:

(-[WebVideoFullscreenController windowDidEnterFullScreen:]):

  • WebView/WebView.mm:

(-[WebView _enterVideoFullscreenForVideoElement:mode:]):

LayoutTests:

  • 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/media-fullscreen-inline.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/media-fullscreen.js:

(async beginfullscreen):
(async fullscreenerror):
(addEventListeners):
(beginfullscreen): Deleted.
(fullscreenerror): Deleted.

  • media/modern-media-controls/css/webkit-cursor-visibility-auto-hide-expected.txt:
  • media/modern-media-controls/css/webkit-cursor-visibility-auto-hide.html:
  • media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-expected.txt:
  • media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-is-prevented-over-button-expected.txt:
  • media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-is-prevented-over-button.html:
  • media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag.html:
  • media/modern-media-controls/media-controller/media-controller-click-on-video-background-should-pause-fullscreen-expected.txt:
  • media/modern-media-controls/media-controller/media-controller-click-on-video-background-should-pause-fullscreen.html:
  • media/modern-media-controls/media-controller/media-controller-fullscreen-ltr-expected.txt:
  • media/modern-media-controls/media-controller/media-controller-fullscreen-ltr.html:
  • media/modern-media-controls/media-controller/media-controller-space-bar-toggle-playback-expected.txt:
  • media/modern-media-controls/media-controller/media-controller-space-bar-toggle-playback.html:
  • media/modern-media-controls/tracks-support/tracks-support-show-panel-fullscreen-expected.txt:
  • media/modern-media-controls/tracks-support/tracks-support-show-panel-fullscreen.html:
  • media/video-fullscreen-only-playback-expected.txt:
  • media/video-fullscreen-only-playback.html:
  • platform/ios/TestExpectations:
  • platform/mac-wk1/TestExpectations:
  • platform/mac-wk2/TestExpectations:
  • platform/mac/TestExpectations:
Location:
trunk
Files:
41 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r261492 r261493  
     12020-05-11  Peng Liu  <peng.liu6@apple.com>
     2
     3        Enable the mock video presentation mode in related layout tests and fix test failures
     4        https://bugs.webkit.org/show_bug.cgi?id=211645
     5
     6        Reviewed by Darin Adler.
     7
     8        * http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast-expected.txt:
     9        * http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast.html:
     10        * media/media-fullscreen-inline.html:
     11        * media/media-fullscreen-loop-inline-expected.txt:
     12        * media/media-fullscreen-loop-inline.html:
     13        * media/media-fullscreen-pause-inline-expected.txt:
     14        * media/media-fullscreen-pause-inline.html:
     15        * media/media-fullscreen-return-to-inline-expected.txt:
     16        * media/media-fullscreen-return-to-inline.html:
     17        * media/media-fullscreen.js:
     18        (async beginfullscreen):
     19        (async fullscreenerror):
     20        (addEventListeners):
     21        (beginfullscreen): Deleted.
     22        (fullscreenerror): Deleted.
     23        * media/modern-media-controls/css/webkit-cursor-visibility-auto-hide-expected.txt:
     24        * media/modern-media-controls/css/webkit-cursor-visibility-auto-hide.html:
     25        * media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-expected.txt:
     26        * media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-is-prevented-over-button-expected.txt:
     27        * media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-is-prevented-over-button.html:
     28        * media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag.html:
     29        * media/modern-media-controls/media-controller/media-controller-click-on-video-background-should-pause-fullscreen-expected.txt:
     30        * media/modern-media-controls/media-controller/media-controller-click-on-video-background-should-pause-fullscreen.html:
     31        * media/modern-media-controls/media-controller/media-controller-fullscreen-ltr-expected.txt:
     32        * media/modern-media-controls/media-controller/media-controller-fullscreen-ltr.html:
     33        * media/modern-media-controls/media-controller/media-controller-space-bar-toggle-playback-expected.txt:
     34        * media/modern-media-controls/media-controller/media-controller-space-bar-toggle-playback.html:
     35        * media/modern-media-controls/tracks-support/tracks-support-show-panel-fullscreen-expected.txt:
     36        * media/modern-media-controls/tracks-support/tracks-support-show-panel-fullscreen.html:
     37        * media/video-fullscreen-only-playback-expected.txt:
     38        * media/video-fullscreen-only-playback.html:
     39        * platform/ios/TestExpectations:
     40        * platform/mac-wk1/TestExpectations:
     41        * platform/mac-wk2/TestExpectations:
     42        * platform/mac/TestExpectations:
     43
    1442020-05-11  Ryan Haddad  <ryanhaddad@apple.com>
    245
  • trunk/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast-expected.txt

    r228097 r261493  
    44
    55
     6PASS media.webkitDisplayingFullscreen became true
    67PASS media.duration became Number.POSITIVE_INFINITY
    78PASS mediaController.controls.rewindButton.enabled is false
  • trunk/LayoutTests/http/tests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-live-broadcast.html

    r228445 r261493  
    1616
    1717media.addEventListener("webkitfullscreenchange", () => {
    18     if (!media.webkitDisplayingFullscreen)
    19         return;
     18    shouldBecomeEqual("media.webkitDisplayingFullscreen", "true", () => {
     19        shouldBecomeEqual("media.duration", "Number.POSITIVE_INFINITY", () => {
     20            shouldBeFalse("mediaController.controls.rewindButton.enabled");
     21            shouldBeFalse("mediaController.controls.forwardButton.enabled");
     22            shouldBe("mediaController.controls.timeControl.parent", "null");
     23            shouldBe("mediaController.controls.statusLabel.parent", "mediaController.controls.bottomControlsBar");
    2024
    21     shouldBecomeEqual("media.duration", "Number.POSITIVE_INFINITY", () => {
    22         shouldBeFalse("mediaController.controls.rewindButton.enabled");
    23         shouldBeFalse("mediaController.controls.forwardButton.enabled");
    24         shouldBe("mediaController.controls.timeControl.parent", "null");
    25         shouldBe("mediaController.controls.statusLabel.parent", "mediaController.controls.bottomControlsBar");
    26 
    27         debug("");
    28         media.remove();
    29         shadowRoot.host.remove();
    30         finishJSTest();
     25            debug("");
     26            media.remove();
     27            shadowRoot.host.remove();
     28            finishJSTest();
     29        });
    3130    });
    3231});
  • trunk/LayoutTests/media/media-fullscreen-inline.html

    r117326 r261493  
     1<!DOCTYPE html>
    12<html>
    23    <head>
  • trunk/LayoutTests/media/media-fullscreen-loop-inline-expected.txt

    r212314 r261493  
    11
    2 RUN(internals.settings.setAllowsInlineMediaPlayback(false))
    3 RUN(internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true))
    4 RUN(internals.settings.setFullScreenEnabled(false))
    5 RUN(internals.setMediaElementRestrictions(video, "NoRestrictions"))
     2Test that a <video> keeps playing and looping after exiting fullscreen when the internal property "allowsInlineMediaPlaybackAfterFullscreen" is true.
     3
    64RUN(video.loop = true)
    75RUN(video.src = findMediaFile("video", "content/test"))
     6EVENT(canplaythrough)
    87RUN(video.play())
    9 EVENT(webkitbeginfullscreen)
     8Wait to enter fullscreen
     9EVENT(webkitpresentationmodechanged)
     10EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
     11Entered fullscreen
    1012RUN(video.currentTime = 5)
    1113RUN(video.webkitExitFullscreen())
    12 EVENT(webkitendfullscreen)
     14Wait to exit fullscreen
     15EVENT(webkitpresentationmodechanged)
     16EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
     17Exited fullscreen
    1318EXPECTED (video.paused == 'false') OK
    1419RUN(video.ontimeupdate = timeupdate)
     20Looped
    1521RUN(video.ontimeupdate = null)
    16 Looped
    1722EXPECTED (video.playsInline == 'false') OK
    1823EXPECTED (video.paused == 'false') OK
  • trunk/LayoutTests/media/media-fullscreen-loop-inline.html

    r212314 r261493  
    22<html>
    33<head>
    4     <title>media-fullscreen-return-to-inline</title>
    5 
     4    <title>media-fullscreen-loop-inline</title>
    65    <script src="video-test.js"></script>
    76    <script src="media-file.js"></script>
    8 
    97    <script>
    108    function go()
    119    {
     10        if (!window.internals) {
     11            failTest('This test requires window.internals.');
     12            return;
     13        }
     14
    1215        findMediaElement();
    13         run('internals.settings.setAllowsInlineMediaPlayback(false)');
    14         run('internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true)');
    15         run('internals.settings.setFullScreenEnabled(false)');
    16         run('internals.setMediaElementRestrictions(video, "NoRestrictions")');
     16
     17        internals.settings.setAllowsInlineMediaPlayback(false);
     18        internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true);
     19        // Disable the Fullscreen API (element fullscreen) support
     20        internals.settings.setFullScreenEnabled(false);
     21        internals.setMockVideoPresentationModeEnabled(true);
     22        internals.setMediaElementRestrictions(video, "NoRestrictions");
     23
     24        waitForEventOnce('canplaythrough', canplaythrough);
    1725        run('video.loop = true');
    1826        run('video.src = findMediaFile("video", "content/test")');
    19         waitForEventOnce('webkitbeginfullscreen', beginfullscreen);
    20         run('video.play()');
    2127    }
    2228
    23     function beginfullscreen()
     29    function canplaythrough()
    2430    {
     31        waitForEventOnce('webkitpresentationmodechanged', beginfullscreen);
     32        run('video.play()');
     33        consoleWrite("Wait to enter fullscreen");
     34    }
     35
     36    async function beginfullscreen()
     37    {
     38        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
     39        consoleWrite("Entered fullscreen");
    2540        run('video.currentTime = 5');
    2641        run('video.webkitExitFullscreen()');
    27         waitForEventOnce('webkitendfullscreen', endfullscreen);
     42        waitForEventOnce('webkitpresentationmodechanged', endfullscreen);
     43        consoleWrite("Wait to exit fullscreen");
    2844    }
    2945
    30     function endfullscreen()
     46    async function endfullscreen()
    3147    {
     48        await testExpectedEventually('video.webkitDisplayingFullscreen', false);
     49        consoleWrite("Exited fullscreen");
    3250        testExpected('video.paused', false);
    3351        run('video.ontimeupdate = timeupdate');
    34         waitForEventAndFail('webkitbeginfullscreen');
     52        waitForEventAndFail('webkitpresentationmodechanged');
    3553    }
    3654
     
    3856    {
    3957        if (video.currentTime == 0) {
     58            consoleWrite("Looped");
    4059            run('video.ontimeupdate = null');
    41             consoleWrite("Looped");
    4260            testExpected('video.playsInline', false);
    4361            setTimeout(function loopCompleted() {
     
    4765        }
    4866    }
    49 
    5067    </script>
    51 
    5268</head>
    53 
    5469<body onload="go()">
    5570    <video controls></video>
     71    <p>Test that a &lt;video&gt; keeps playing and looping after exiting fullscreen when the internal property "allowsInlineMediaPlaybackAfterFullscreen" is true.</p>
    5672</body>
    5773</html>
  • trunk/LayoutTests/media/media-fullscreen-pause-inline-expected.txt

    r218847 r261493  
    11
    2 RUN(internals.settings.setAllowsInlineMediaPlayback(false))
    3 RUN(internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true))
    4 RUN(internals.settings.setFullScreenEnabled(false))
    5 RUN(internals.setMediaElementRestrictions(video, "NoRestrictions"))
     2Test that a <video> keeps playing after exiting fullscreen when the internal property "allowsInlineMediaPlaybackAfterFullscreen" is true.
     3
    64RUN(video.src = findMediaFile("video", "content/test"))
     5EVENT(canplaythrough)
    76RUN(video.play().then(playing);)
    87EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
    98RUN(video.webkitExitFullscreen())
    10 EVENT(webkitendfullscreen)
     9EVENT(webkitpresentationmodechanged)
     10EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
    1111EXPECTED (video.paused == 'false') OK
    1212RUN(video.pause())
  • trunk/LayoutTests/media/media-fullscreen-pause-inline.html

    r218847 r261493  
    22<html>
    33<head>
    4     <title>media-fullscreen-return-to-inline</title>
    5 
     4    <title>media-fullscreen-pause-inline</title>
    65    <script src="video-test.js"></script>
    76    <script src="media-file.js"></script>
     
    109    function go()
    1110    {
     11        if (!window.internals) {
     12            failTest('This test requires window.internals.');
     13            return;
     14        }
     15
    1216        findMediaElement();
    13         run('internals.settings.setAllowsInlineMediaPlayback(false)');
    14         run('internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true)');
    15         run('internals.settings.setFullScreenEnabled(false)');
    16         run('internals.setMediaElementRestrictions(video, "NoRestrictions")');
     17
     18        internals.settings.setAllowsInlineMediaPlayback(false);
     19        internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true);
     20        // Disable the Fullscreen API (element fullscreen) support
     21        internals.settings.setFullScreenEnabled(false);
     22        internals.setMockVideoPresentationModeEnabled(true);
     23        internals.setMediaElementRestrictions(video, "NoRestrictions");
     24
     25        waitForEventOnce('canplaythrough', canplaythrough);
    1726        run('video.src = findMediaFile("video", "content/test")');
     27    }
     28
     29    function canplaythrough()
     30    {
    1831        run('video.play().then(playing);');
    1932    }
    2033
    21     function playing()
     34    async function playing()
    2235    {
    23         testExpected('video.webkitDisplayingFullscreen', true);
    24         waitForEventOnce('webkitendfullscreen', endfullscreen);
     36        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
     37        waitForEventOnce('webkitpresentationmodechanged', endfullscreen);
    2538        run('video.webkitExitFullscreen()');
    2639    }
    2740
    28     function endfullscreen()
     41    async function endfullscreen()
    2942    {
     43        await testExpectedEventually('video.webkitDisplayingFullscreen', false);
    3044        testExpected('video.paused', false);
     45        waitForEventOnce('pause', paused);
    3146        run('video.pause()');
    32         waitForEventOnce('pause', paused);
    3347    }
    3448
     
    3650    {
    3751        testExpected('video.paused', true);
    38         setTimeout(function(){ run('video.play().then(playingAgain)');}, 0)
     52        setTimeout(function(){ run('video.play().then(playingAgain)'); }, 0);
    3953    }
    4054
    41     function playingAgain()
     55    async function playingAgain()
    4256    {
    43 
    44         testExpected('video.webkitDisplayingFullscreen', true);
     57        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
    4558        endTest();
    4659    }
    47 
    4860    </script>
    49 
    5061</head>
    51 
    5262<body onload="go()">
    5363    <video controls></video>
     64    <p>Test that a &lt;video&gt; keeps playing after exiting fullscreen when the internal property "allowsInlineMediaPlaybackAfterFullscreen" is true.</p>
    5465</body>
    5566</html>
  • trunk/LayoutTests/media/media-fullscreen-return-to-inline-expected.txt

    r201187 r261493  
    11
    2 RUN(internals.settings.setAllowsInlineMediaPlayback(false))
    3 RUN(internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(false))
     2Test that a <video> pauses after exiting fullscreen when the internal property "allowsInlineMediaPlaybackAfterFullscreen" is false.
     3
    44RUN(video.src = findMediaFile("video", "content/test"))
    55EVENT(canplaythrough)
    66RUN(video.play())
    7 EVENT(webkitfullscreenchange)
     7EVENT(webkitpresentationmodechanged)
     8EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
    89RUN(video.webkitExitFullscreen())
    910EVENT(pause)
    10 RUN(internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true))
     11EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
     12EXPECTED (video.paused == 'true') OK
    1113RUN(video.play())
    12 EVENT(webkitfullscreenchange)
     14EVENT(webkitpresentationmodechanged)
     15EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
    1316RUN(video.webkitExitFullscreen())
    14 EVENT(webkitfullscreenchange)
     17EVENT(webkitpresentationmodechanged)
     18EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
    1519EXPECTED (video.paused == 'false') OK
    1620END OF TEST
  • trunk/LayoutTests/media/media-fullscreen-return-to-inline.html

    r210959 r261493  
    1010    function go()
    1111    {
     12        if (!window.internals) {
     13            failTest('This test requires window.internals.');
     14            return;
     15        }
     16
    1217        findMediaElement();
    13         run('internals.settings.setAllowsInlineMediaPlayback(false)');
    14         run('internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(false)');
     18
     19        internals.settings.setAllowsInlineMediaPlayback(false);
     20        internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(false);
     21        // Disable the Fullscreen API (element fullscreen) support
     22        internals.settings.setFullScreenEnabled(false);
     23        internals.setMockVideoPresentationModeEnabled(true);
     24
     25        waitForEventOnce('canplaythrough', canplaythrough);
    1526        run('video.src = findMediaFile("video", "content/test")');
    16         waitForEventOnce('canplaythrough', canplaythrough);
    1727    }
    1828
    1929    function canplaythrough()
    2030    {
     31        waitForEventOnce('webkitpresentationmodechanged', beginfullscreen1);
    2132        runWithKeyDown('video.play()');
    22         waitForEventOnce('webkitfullscreenchange', beginfullscreen1);
    2333    }
    2434
    25     function beginfullscreen1()
     35    async function beginfullscreen1()
    2636    {
     37        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
     38        waitForEventOnce('pause', pause);
    2739        run('video.webkitExitFullscreen()');
    28         waitForEventOnce('pause', pause);
    2940    }
    3041
    31     function pause()
     42    async function pause()
    3243    {
    33         run('internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true)');
     44        await testExpectedEventually('video.webkitDisplayingFullscreen', false);
     45        testExpected('video.paused', true);
     46
     47        internals.settings.setAllowsInlineMediaPlaybackAfterFullscreen(true);
     48
     49        waitForEventOnce('webkitpresentationmodechanged', beginfullscreen2);
    3450        runWithKeyDown('video.play()');
    35         waitForEventOnce('webkitfullscreenchange', beginfullscreen2);
    3651    }
    3752
    38     function beginfullscreen2()
     53    async function beginfullscreen2()
    3954    {
     55        await testExpectedEventually('video.webkitDisplayingFullscreen', true);
     56        waitForEventOnce('webkitpresentationmodechanged', endfullscreen);
    4057        run('video.webkitExitFullscreen()');
    41         waitForEventOnce('webkitfullscreenchange', endfullscreen);
    4258    }
    4359
    44     function endfullscreen()
     60    async function endfullscreen()
    4561    {
     62        await testExpectedEventually('video.webkitDisplayingFullscreen', false);
    4663        testExpected('video.paused', false);
    4764        endTest();
    4865    }
    4966    </script>
    50 
    5167</head>
    5268
    5369<body onload="go()">
    54     <video controls></video>
     70    <video controls loop></video>
     71    <p>Test that a &lt;video&gt; pauses after exiting fullscreen when the internal property "allowsInlineMediaPlaybackAfterFullscreen" is false.</p>
    5572</body>
    5673</html>
  • trunk/LayoutTests/media/media-fullscreen.js

    r245467 r261493  
    3939}
    4040
    41 function beginfullscreen()
     41async function beginfullscreen()
    4242{
    43     testExpected("mediaElement.webkitDisplayingFullscreen", true);
     43    await testExpectedEventually("mediaElement.webkitDisplayingFullscreen", true);
    4444    run("mediaElement.webkitExitFullScreen()");
    4545}
     
    5050}
    5151
    52 function fullscreenerror()
     52async function fullscreenerror()
    5353{
    5454    var movie = movieInfo.movies[movieInfo.current];
     
    5656        failTest("Unexpected fullscreenerror event");
    5757    } else {
    58         testExpected("mediaElement.webkitDisplayingFullscreen", false);
     58        await testExpectedEventually("mediaElement.webkitDisplayingFullscreen", false);
    5959        openNextMovie();
    6060    }
     
    139139    waitForEvent('webkitfullscreenerror', fullscreenerror);
    140140}
    141 
  • trunk/LayoutTests/media/modern-media-controls/css/webkit-cursor-visibility-auto-hide-expected.txt

    r219625 r261493  
    77PASS getComputedStyle(window.internals.shadowRoot(media).querySelector('.media-controls-container')).webkitCursorVisibility is "auto"
    88
    9 PASS media.webkitDisplayingFullscreen is true
     9PASS media.webkitDisplayingFullscreen became true
    1010PASS getComputedStyle(window.internals.shadowRoot(media).querySelector('.media-controls-container')).webkitCursorVisibility is "auto-hide"
    1111
  • trunk/LayoutTests/media/modern-media-controls/css/webkit-cursor-visibility-auto-hide.html

    r219625 r261493  
    1818
    1919    media.addEventListener("webkitfullscreenchange", () => {
    20         shouldBeTrue("media.webkitDisplayingFullscreen");
    21         shouldBeEqualToString("getComputedStyle(window.internals.shadowRoot(media).querySelector('.media-controls-container')).webkitCursorVisibility", "auto-hide");
    22         debug("");
    23         button.remove();
    24         media.remove();
    25         finishJSTest();
     20        shouldBecomeEqual("media.webkitDisplayingFullscreen", "true", () => {
     21            shouldBeEqualToString("getComputedStyle(window.internals.shadowRoot(media).querySelector('.media-controls-container')).webkitCursorVisibility", "auto-hide");
     22            debug("");
     23            button.remove();
     24            media.remove();
     25            finishJSTest();
     26        });
    2627    });
    2728
  • trunk/LayoutTests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-expected.txt

    r217659 r261493  
    44
    55
     6PASS media.webkitDisplayingFullscreen became true
    67PASS !!mediaControls.querySelector('.buttons-container.left') became true
    78PASS mediaControls.querySelector('.buttons-container.left').style.width became "118px"
  • trunk/LayoutTests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-is-prevented-over-button-expected.txt

    r217659 r261493  
    44
    55
     6PASS media.webkitDisplayingFullscreen became true
    67PASS !!mediaControls.querySelector('.buttons-container.left') became true
    78PASS mediaControls.querySelector('.buttons-container.left').style.width became "118px"
  • trunk/LayoutTests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag-is-prevented-over-button.html

    r217659 r261493  
    1818
    1919media.addEventListener("webkitfullscreenchange", () => {
    20     if (media.webkitDisplayingFullscreen) {
     20    shouldBecomeEqual("media.webkitDisplayingFullscreen", "true", () => {
    2121        mediaControls = shadowRoot.lastChild;
    2222        shouldBecomeEqual("!!mediaControls.querySelector('.buttons-container.left')", "true", () => {
     
    3434            });
    3535        });
    36     }
     36    });
    3737});
    3838
  • trunk/LayoutTests/media/modern-media-controls/macos-fullscreen-media-controls/macos-fullscreen-media-controls-drag.html

    r217659 r261493  
    1818
    1919media.addEventListener("webkitfullscreenchange", () => {
    20     if (media.webkitDisplayingFullscreen) {
     20    shouldBecomeEqual("media.webkitDisplayingFullscreen", "true", () => {
    2121        mediaControls = shadowRoot.lastChild;
    2222        shouldBecomeEqual("!!mediaControls.querySelector('.buttons-container.left')", "true", () => {
     
    3434            });
    3535        });
    36     }
     36    });
    3737});
    3838
  • trunk/LayoutTests/media/modern-media-controls/media-controller/media-controller-click-on-video-background-should-pause-fullscreen-expected.txt

    r212872 r261493  
    77
    88Entering fullscreen
    9 PASS media.webkitDisplayingFullscreen is true
     9PASS media.webkitDisplayingFullscreen became true
    1010PASS media.paused is false
    1111
  • trunk/LayoutTests/media/modern-media-controls/media-controller/media-controller-click-on-video-background-should-pause-fullscreen.html

    r212872 r261493  
    2323
    2424media.addEventListener("webkitfullscreenchange", () => {
    25     shouldBeTrue("media.webkitDisplayingFullscreen");
    26     shouldBeFalse("media.paused");
     25    shouldBecomeEqual("media.webkitDisplayingFullscreen", "true", () => {
     26        shouldBeFalse("media.paused");
    2727
    28     const bounds = media.getBoundingClientRect();
    29     debug("");
    30     debug("Clicking on video background");
    31     eventSender.mouseMoveTo(bounds.left + 5, bounds.top + 5);
    32     eventSender.mouseDown();
    33     eventSender.mouseUp();
     28        const bounds = media.getBoundingClientRect();
     29        debug("");
     30        debug("Clicking on video background");
     31        eventSender.mouseMoveTo(bounds.left + 5, bounds.top + 5);
     32        eventSender.mouseDown();
     33        eventSender.mouseUp();
    3434
    35     shouldBeTrue("media.paused");
     35        shouldBeTrue("media.paused");
    3636
    37     debug("");
    38     media.remove();
    39     finishJSTest();
     37        debug("");
     38        media.remove();
     39        finishJSTest();
     40    });
    4041});
    4142
  • trunk/LayoutTests/media/modern-media-controls/media-controller/media-controller-fullscreen-ltr-expected.txt

    r209170 r261493  
    44
    55
     6PASS media.webkitDisplayingFullscreen became true
    67Media entered fullscreen
    78PASS mediaControlsElement.classList.contains('uses-ltr-user-interface-layout-direction') is true
  • trunk/LayoutTests/media/modern-media-controls/media-controller/media-controller-fullscreen-ltr.html

    r211723 r261493  
    1616
    1717media.addEventListener("webkitfullscreenchange", function() {
    18     if (media.webkitDisplayingFullscreen) {
     18    shouldBecomeEqual("media.webkitDisplayingFullscreen", "true", () => {
    1919        window.requestAnimationFrame(() => {
    2020            window.requestAnimationFrame(() => {
     
    4545            });
    4646        });
    47     }
     47    });
    4848});
    4949
  • trunk/LayoutTests/media/modern-media-controls/media-controller/media-controller-space-bar-toggle-playback-expected.txt

    r225265 r261493  
    1010
    1111Obtained a 'webkitfullscreenchange' event.
    12 media.webkitDisplayingFullscreen = true.
     12PASS media.webkitDisplayingFullscreen became true
    1313PASS media.paused is false
    1414
     
    2222
    2323Obtained a 'webkitfullscreenchange' event.
    24 media.webkitDisplayingFullscreen = false.
    2524
    2625PASS successfullyParsed is true
  • trunk/LayoutTests/media/modern-media-controls/media-controller/media-controller-space-bar-toggle-playback.html

    r225265 r261493  
    1717    debug("");
    1818    debug("Obtained a 'webkitfullscreenchange' event.");
    19     debug(`media.webkitDisplayingFullscreen = ${media.webkitDisplayingFullscreen}.`);
    2019
    21     if (media.webkitDisplayingFullscreen) {
    22         shouldBeFalse("media.paused");
    23         pressSpace();
     20    if (playCount == 1) {
     21        shouldBecomeEqual('media.webkitDisplayingFullscreen', 'true', () => {
     22            shouldBeFalse("media.paused");
     23            pressSpace();
     24        });
    2425    } else
    2526        endTest();
     
    4647    pressSpace();
    4748});
    48 
    4949
    5050function enterFullscreen() {
  • trunk/LayoutTests/media/modern-media-controls/tracks-support/tracks-support-show-panel-fullscreen-expected.txt

    r228010 r261493  
    66PASS internals.shadowRoot(media).querySelector("button.fullscreen") became different from null
    77PASS internals.shadowRoot(media).querySelector("button.fullscreen").getBoundingClientRect().width became different from 0
     8PASS media.webkitDisplayingFullscreen became true
    89PASS internals.shadowRoot(media).querySelector("button.tracks") became different from null
    910PASS internals.shadowRoot(media).querySelector("button.tracks").getBoundingClientRect().width became different from 0
  • trunk/LayoutTests/media/modern-media-controls/tracks-support/tracks-support-show-panel-fullscreen.html

    r228010 r261493  
    1313
    1414media.addEventListener("webkitfullscreenchange", () => {
    15     if (!media.webkitDisplayingFullscreen)
    16         return;
    17 
    18     shouldBecomeDifferent(`internals.shadowRoot(media).querySelector("button.tracks")`, "null", () => {
    19         shouldBecomeDifferent(`internals.shadowRoot(media).querySelector("button.tracks").getBoundingClientRect().width`, "0", () => {
    20             shouldBecomeEqual(`internals.shadowRoot(media).querySelector("button.tracks").getBoundingClientRect().right`, "582", () => {
    21                 pressOnElement(internals.shadowRoot(media).querySelector("button.tracks"));
    22                 shouldBecomeDifferent(`internals.shadowRoot(media).querySelector('.tracks-panel')`, "null", () => {
    23                     shouldBeEqualToString("internals.shadowRoot(media).querySelector('.tracks-panel').style.right", "218px");
    24                     shouldBeEqualToString("internals.shadowRoot(media).querySelector('.tracks-panel').style.bottom", "101px");
    25                     debug("");
    26                     media.remove();
    27                     finishJSTest();
     15    shouldBecomeEqual("media.webkitDisplayingFullscreen", "true", () => {
     16        shouldBecomeDifferent(`internals.shadowRoot(media).querySelector("button.tracks")`, "null", () => {
     17            shouldBecomeDifferent(`internals.shadowRoot(media).querySelector("button.tracks").getBoundingClientRect().width`, "0", () => {
     18                shouldBecomeEqual(`internals.shadowRoot(media).querySelector("button.tracks").getBoundingClientRect().right`, "582", () => {
     19                    pressOnElement(internals.shadowRoot(media).querySelector("button.tracks"));
     20                    shouldBecomeDifferent(`internals.shadowRoot(media).querySelector('.tracks-panel')`, "null", () => {
     21                        shouldBeEqualToString("internals.shadowRoot(media).querySelector('.tracks-panel').style.right", "218px");
     22                        shouldBeEqualToString("internals.shadowRoot(media).querySelector('.tracks-panel').style.bottom", "101px");
     23                        debug("");
     24                        media.remove();
     25                        finishJSTest();
     26                    });
    2827                });
    2928            });
  • trunk/LayoutTests/media/video-fullscreen-only-playback-expected.txt

    r252676 r261493  
    11
    2 Test play() when <video> playback requires fullscreen.
     2Test the play() function of <video> when fullscreen is required.
    33
    4 RUN(internals.settings.setAllowsInlineMediaPlayback(false))
    54
    65EVENT(canplaythrough)
    76EXPECTED (video.webkitSupportsFullscreen == 'true') OK
    87EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
    9 
    10 ** Clicking 'play' button...
     8RUN(video.play())
    119EVENT(playing)
     10EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
    1211
    1312** Entered fullscreen
    14 EXPECTED (video.webkitDisplayingFullscreen == 'true') OK
    1513RUN(video.webkitExitFullScreen())
     14EVENT(webkitpresentationmodechanged)
     15EXPECTED (video.webkitDisplayingFullscreen == 'false') OK
    1616
    1717** Exited fullscreen
  • trunk/LayoutTests/media/video-fullscreen-only-playback.html

    r252676 r261493  
    1 <!-- webkit-test-runner [ enableModernMediaControls=false ] -->
     1<!DOCTYPE html><!-- webkit-test-runner [ enableModernMediaControls=false ] -->
    22<html>
    33    <head>
     
    66        <script src=media-controls.js></script>
    77        <script>
    8 
    9             function fullscreenchange()
    10             {
    11                 if (!document.webkitIsFullScreen)
    12                     endfullscreen();
    13             }
    14 
    15             function playing()
    16             {
    17                 consoleWrite("<br>** Entered fullscreen");
    18                 testExpected("video.webkitDisplayingFullscreen", true);
    19                 run("video.webkitExitFullScreen()");
    20             }
    21 
    22             function endfullscreen()
    23             {
    24                 consoleWrite("<br>** Exited fullscreen");
    25                 endTest();
    26             }
    27 
    28             function canplaythrough()
    29             {
    30                 testExpected("video.webkitSupportsFullscreen", true);
    31                 testExpected("video.webkitDisplayingFullscreen", false);
    32 
    33                 consoleWrite("<br>** Clicking \'play\' button...");
    34 
    35                 try {
    36                     clickPlayButton(video);
    37                 } catch (exception) {
    38                     failTest(exception.description);
    39                     return;
    40                 }
    41             }
    42 
    43 
    448            function start()
    459            {
     
    5216                waitForEvent("canplaythrough", canplaythrough);
    5317                waitForEvent('playing', playing);
    54 
    55                 video.addEventListener('webkitendfullscreen', endfullscreen, true);
    56                 video.addEventListener('webkitfullscreenchange', fullscreenchange, true);
    57 
    5818                video.src = findMediaFile("video", "content/test");
    5919
    60                 run("internals.settings.setAllowsInlineMediaPlayback(false)");
     20                internals.settings.setAllowsInlineMediaPlayback(false);
     21                // Disable the Fullscreen API (element fullscreen) support
     22                internals.settings.setFullScreenEnabled(false);
     23                internals.setMockVideoPresentationModeEnabled(true);
     24
    6125                consoleWrite("");
     26            }
     27
     28            function canplaythrough()
     29            {
     30                testExpected("video.webkitSupportsFullscreen", true);
     31                testExpected("video.webkitDisplayingFullscreen", false);
     32
     33                try {
     34                    runWithKeyDown("video.play()");
     35                } catch (exception) {
     36                    failTest(exception.description);
     37                    return;
     38                }
     39            }
     40
     41            async function playing()
     42            {
     43                await testExpectedEventually("video.webkitDisplayingFullscreen", true);
     44                consoleWrite("<br>** Entered fullscreen");
     45                waitForEvent('webkitpresentationmodechanged', endfullscreen);
     46                run("video.webkitExitFullScreen()");
     47            }
     48
     49            async function endfullscreen()
     50            {
     51                await testExpectedEventually("video.webkitDisplayingFullscreen", false);
     52                consoleWrite("<br>** Exited fullscreen");
     53                endTest();
    6254            }
    6355        </script>
     
    6658    <body onload="start()">
    6759        <video controls></video>
    68         <p>Test play() when &lt;video&gt; playback requires fullscreen.</p>
     60        <p>Test the play() function of &lt;video&gt; when fullscreen is required.</p>
    6961    </body>
    7062</html>
  • trunk/LayoutTests/platform/ios/TestExpectations

    r261373 r261493  
    24312431
    24322432media/media-controls-accessibility.html [ Timeout ]
    2433 media/media-fullscreen-return-to-inline.html
    24342433media/no-autoplay-with-user-gesture-requirement.html
    24352434media/video-controls-drag.html
     
    25682567webkit.org/b/163291 media/video-controls-transformed.html [ Failure ]
    25692568webkit.org/b/163291 media/video-controls-visible-audio-only.html [ Failure ]
    2570 webkit.org/b/163291 media/video-fullscreen-only-playback.html [ Failure ]
    25712569webkit.org/b/163291 media/video-play-audio-require-user-gesture.html [ Failure ]
    25722570webkit.org/b/163291 media/video-play-require-user-gesture.html
     
    31563154# <rdar://problem/36455339> LayoutTest compositing/ios/overflow-scroll-touch-tiles.html is a flaky failure
    31573155compositing/ios/overflow-scroll-touch-tiles.html [ Pass Failure ]
    3158 
    3159 # <rdar://problem/41546970> REGRESSION: LayoutTest media/media-fullscreen-loop-inline.html is a flaky timeout
    3160 media/media-fullscreen-loop-inline.html [ Pass Timeout ]
    3161 
    3162 webkit.org/b/187618 [ Release ] media/media-fullscreen-pause-inline.html [ Pass Failure ]
    31633156
    31643157# Disabled globally.
  • trunk/LayoutTests/platform/mac-wk1/TestExpectations

    r261477 r261493  
    617617
    618618webkit.org/b/168409 media/modern-media-controls/airplay-button/airplay-button.html [ Pass Timeout ]
    619 webkit.org/b/175195 media/modern-media-controls/css/webkit-cursor-visibility-auto-hide.html [ Pass Failure ]
    620619webkit.org/b/168265 media/modern-media-controls/forward-button/forward-button.html [ Pass Timeout ]
    621620
  • trunk/LayoutTests/platform/mac-wk2/TestExpectations

    r261380 r261493  
    342342webkit.org/b/151709 [ Release ] http/tests/xmlhttprequest/workers/methods.html [ Pass Timeout ]
    343343
    344 # Video fullscreen is not implemented for mac wk2 in webkittestrunner
    345 media/media-fullscreen-loop-inline.html [ Skip ]
    346 media/media-fullscreen-pause-inline.html [ Skip ]
    347 
    348344### END OF (1) Classified failures with bug reports
    349345########################################
  • trunk/LayoutTests/platform/mac/TestExpectations

    r261492 r261493  
    760760webkit.org/b/135160 media/track/track-in-band-subtitles-too-large.html [ Failure ]
    761761webkit.org/b/135160 media/track/track-long-word-container-sizing.html [ Failure ]
    762 webkit.org/b/137311 media/video-fullscreen-only-playback.html [ Pass Timeout Crash ]
    763762webkit.org/b/139789 media/media-controls-timeline-updates.html [ Pass Failure ]
    764763webkit.org/b/139825 media/video-seek-past-end-paused.html [ Pass Timeout ]
     
    16421641webkit.org/b/195466 imported/w3c/web-platform-tests/html/semantics/embedded-content/media-elements/error-codes/error.html [ Pass Failure ]
    16431642
    1644 webkit.org/b/193399 media/media-fullscreen-return-to-inline.html [ Pass Timeout ]
    1645 
    16461643http/tests/websocket/tests/hybi/handshake-ok-with-legacy-sec-websocket-response-headers.html [ Pass Failure ]
    16471644
     
    19491946webkit.org/b/210046 [ Release ] storage/indexeddb/value-cursor-cycle.html [ Pass Failure ]
    19501947
    1951 webkit.org/b/182571 [ Debug ] media/modern-media-controls/tracks-support/tracks-support-show-panel-fullscreen.html [ Pass Timeout ]
    1952 
    19531948webkit.org/b/207160 css2.1/20110323/replaced-intrinsic-ratio-001.htm [ Pass Failure ]
    19541949
  • trunk/Source/WebCore/ChangeLog

    r261488 r261493  
     12020-05-11  Peng Liu  <peng.liu6@apple.com>
     2
     3        Enable the mock video presentation mode in related layout tests and fix test failures
     4        https://bugs.webkit.org/show_bug.cgi?id=211645
     5
     6        Reviewed by Darin Adler.
     7
     8        Clean up the internal states of video element regarding video presentation mode
     9        to simplify the task to write reliable layout tests for video fullscreen and
     10        Picture-in-Picture.
     11
     12        * html/HTMLMediaElement.cpp:
     13        (WebCore::HTMLMediaElement::enterFullscreen):
     14        Update the states after we are sure the video element will enter fullscreen.
     15
     16        (WebCore::HTMLMediaElement::exitFullscreen):
     17        Remove the unnecessary "fullscreenModeChanged(VideoFullscreenModeNone)".
     18
     19        * html/HTMLMediaElement.h:
     20        (WebCore::HTMLMediaElement::waitingToEnterFullscreen):
     21
     22        * html/HTMLVideoElement.cpp:
     23        (WebCore::HTMLVideoElement::webkitDisplayingFullscreen):
     24        The function webkitDisplayingFullscreen() will return true after the process
     25        to enter fullscreen is completed.
     26
     27        * html/HTMLVideoElement.h:
     28        Expose didBecomeFullscreenElement() when VIDEO_PRESENTATION_MODE is enabled.
     29
    1302020-05-11  Antoine Quint  <graouts@apple.com>
    231
  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r261409 r261493  
    59905990        return;
    59915991
    5992     m_temporarilyAllowingInlinePlaybackAfterFullscreen = false;
    5993     m_waitingToEnterFullscreen = true;
    5994 
    59955992#if ENABLE(FULLSCREEN_API) && ENABLE(VIDEO_USES_ELEMENT_FULLSCREEN)
    59965993    if (document().settings().fullScreenEnabled() && mode == VideoFullscreenModeStandard) {
     5994        m_temporarilyAllowingInlinePlaybackAfterFullscreen = false;
     5995        m_waitingToEnterFullscreen = true;
    59975996        document().fullscreenManager().requestFullscreenForElement(this, FullscreenManager::ExemptIFrameAllowFullscreenRequirement);
    59985997        return;
     
    60066005        }
    60076006
    6008         fullscreenModeChanged(mode);
    6009         configureMediaControls();
    60106007        if (is<HTMLVideoElement>(*this)) {
    60116008            HTMLVideoElement& asVideo = downcast<HTMLVideoElement>(*this);
    6012             if (document().page()->chrome().client().supportsVideoFullscreen(m_videoFullscreenMode)) {
    6013                 INFO_LOG(LOGIDENTIFIER, "Entering fullscreen mode ", m_videoFullscreenMode, ", m_videoFullscreenStandby = ", m_videoFullscreenStandby);
     6009            if (document().page()->chrome().client().supportsVideoFullscreen(mode)) {
     6010                INFO_LOG(LOGIDENTIFIER, "Entering fullscreen mode ", mode, ", m_videoFullscreenStandby = ", m_videoFullscreenStandby);
     6011
     6012                m_temporarilyAllowingInlinePlaybackAfterFullscreen = false;
     6013                m_waitingToEnterFullscreen = true;
     6014                fullscreenModeChanged(mode);
     6015                configureMediaControls();
     6016
    60146017                document().page()->chrome().client().enterVideoFullscreenForVideoElement(asVideo, m_videoFullscreenMode, m_videoFullscreenStandby);
    60156018                scheduleEvent(eventNames().webkitbeginfullscreenEvent);
     
    60426045    ASSERT(m_videoFullscreenMode != VideoFullscreenModeNone);
    60436046    VideoFullscreenMode oldVideoFullscreenMode = m_videoFullscreenMode;
    6044     fullscreenModeChanged(VideoFullscreenModeNone);
    60456047    Ref<HTMLMediaElement> protectedThis(*this); // updateMediaControlsAfterPresentationModeChange calls methods that can trigger arbitrary DOM mutations.
    60466048    updateMediaControlsAfterPresentationModeChange();
  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r261409 r261493  
    615615
    616616    void scheduleEvent(const AtomString&);
     617    bool waitingToEnterFullscreen() { return m_waitingToEnterFullscreen; }
    617618
    618619private:
  • trunk/Source/WebCore/html/HTMLVideoElement.cpp

    r261409 r261493  
    347347bool HTMLVideoElement::webkitDisplayingFullscreen()
    348348{
    349     return isFullscreen();
     349    return isFullscreen() && !waitingToEnterFullscreen();
    350350}
    351351
     
    524524}
    525525
    526 #if ENABLE(PICTURE_IN_PICTURE_API)
    527526void HTMLVideoElement::didBecomeFullscreenElement()
    528527{
     
    532531}
    533532
     533#if ENABLE(PICTURE_IN_PICTURE_API)
    534534void HTMLVideoElement::setPictureInPictureObserver(PictureInPictureObserver* observer)
    535535{
  • trunk/Source/WebCore/html/HTMLVideoElement.h

    r261409 r261493  
    8989    void setFullscreenMode(VideoFullscreenMode);
    9090    void fullscreenModeChanged(VideoFullscreenMode) final;
     91    WEBCORE_EXPORT void didBecomeFullscreenElement() final;
    9192
    9293#if ENABLE(PICTURE_IN_PICTURE_API)
    93     WEBCORE_EXPORT void didBecomeFullscreenElement() final;
    9494    void setPictureInPictureObserver(PictureInPictureObserver*);
    9595    WEBCORE_EXPORT void setPictureInPictureAPITestEnabled(bool);
  • trunk/Source/WebKit/ChangeLog

    r261490 r261493  
     12020-05-11  Peng Liu  <peng.liu6@apple.com>
     2
     3        Enable the mock video presentation mode in related layout tests and fix test failures
     4        https://bugs.webkit.org/show_bug.cgi?id=211645
     5
     6        Reviewed by Darin Adler.
     7
     8        Fix the mistake in VideoFullscreenManager::supportsVideoFullscreen() introduced in r202274.
     9
     10        * WebProcess/cocoa/VideoFullscreenManager.mm:
     11        (WebKit::VideoFullscreenManager::supportsVideoFullscreen const):
     12
    1132020-05-11  Per Arne Vollan  <pvollan@apple.com>
    214
  • trunk/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm

    r261001 r261493  
    224224    return DeprecatedGlobalSettings::avKitEnabled();
    225225#else
    226     return mode == HTMLMediaElementEnums::VideoFullscreenModePictureInPicture && supportsPictureInPicture();
     226    return mode == HTMLMediaElementEnums::VideoFullscreenModeStandard || (mode == HTMLMediaElementEnums::VideoFullscreenModePictureInPicture && supportsPictureInPicture());
    227227#endif
    228228}
  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r261320 r261493  
     12020-05-11  Peng Liu  <peng.liu6@apple.com>
     2
     3        Enable the mock video presentation mode in related layout tests and fix test failures
     4        https://bugs.webkit.org/show_bug.cgi?id=211645
     5
     6        Reviewed by Darin Adler.
     7
     8        Call HTMLVideoElement::didBecomeFullscreenElement() after a video element enters
     9        fullscreen (to be consistent with WK2).
     10
     11        * WebView/WebVideoFullscreenController.mm:
     12        (-[WebVideoFullscreenController windowDidEnterFullScreen:]):
     13        * WebView/WebView.mm:
     14        (-[WebView _enterVideoFullscreenForVideoElement:mode:]):
     15
    1162020-05-07  Darin Adler  <darin@apple.com>
    217
  • trunk/Source/WebKitLegacy/mac/WebView/WebVideoFullscreenController.mm

    r257290 r261493  
    313313    _isFullScreen = YES;
    314314    [_playerView didChangeValueForKey:@"isFullScreen"];
     315    if (_videoElement)
     316        _videoElement->didBecomeFullscreenElement();
    315317}
    316318
  • trunk/Source/WebKitLegacy/mac/WebView/WebView.mm

    r261232 r261493  
    92709270- (void)_enterVideoFullscreenForVideoElement:(NakedPtr<WebCore::HTMLVideoElement>)videoElement mode:(WebCore::HTMLMediaElementEnums::VideoFullscreenMode)mode
    92719271{
    9272     if (_private->mockVideoPresentationModeEnabled)
    9273         return;
     9272    if (_private->mockVideoPresentationModeEnabled) {
     9273        videoElement->didBecomeFullscreenElement();
     9274        return;
     9275    }
    92749276
    92759277    if (_private->fullscreenController) {
Note: See TracChangeset for help on using the changeset viewer.