Changeset 261948 in webkit


Ignore:
Timestamp:
May 20, 2020 1:23:38 PM (4 years ago)
Author:
Simon Fraser
Message:

Plumb the display's nominal refresh rate down to ScrollingTree for use in scroll synchronization
​https://bugs.webkit.org/show_bug.cgi?id=212159

Reviewed by Tim Horton.

Plumb an Optional<unsigned> down windowScreenDidChange, which contains the nominal
display refresh rate (as frames per second) if available. On macOS, we get this
from CVDisplayLinkGetNominalOutputVideoRefreshPeriod().

To read it, WebProcessPool::nominalFramesPerSecondForDisplay() makes a DisplayLink
that doesn't get any observers, but that DisplayLink will very likely get used
as soon as we schedule a rendering update.

Source/WebCore:

  • page/Chrome.cpp:

(WebCore::Chrome::windowScreenDidChange):

  • page/Chrome.h:
  • page/Page.cpp:

(WebCore::Page::scrollingCoordinator):
(WebCore::Page::windowScreenDidChange):

  • page/Page.h:

(WebCore::Page::displayNominalFramesPerSecond const):

  • page/scrolling/AsyncScrollingCoordinator.cpp:

(WebCore::AsyncScrollingCoordinator::windowScreenDidChange):

  • page/scrolling/AsyncScrollingCoordinator.h:
  • page/scrolling/ScrollingCoordinator.h:

(WebCore::ScrollingCoordinator::windowScreenDidChange):

  • page/scrolling/ScrollingTree.cpp:

(WebCore::ScrollingTree::windowScreenDidChange):

  • page/scrolling/ScrollingTree.h:
  • platform/HostWindow.h:

Source/WebKit:

  • UIProcess/Cocoa/WebProcessPoolCocoa.mm:

(WebKit::WebProcessPool::nominalFramesPerSecondForDisplay):

  • UIProcess/Cocoa/WebViewImpl.mm:

(WebKit::WebViewImpl::windowDidChangeScreen):

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::windowScreenDidChange):

  • UIProcess/WebPageProxy.h:
  • UIProcess/WebProcessPool.h:
  • UIProcess/mac/DisplayLink.cpp:

(WebKit::DisplayLink::DisplayLink):
(WebKit::DisplayLink::nominalFramesPerSecond const):

  • UIProcess/mac/DisplayLink.h:
  • WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:

(WebKit::RemoteLayerTreeDrawingArea::RemoteLayerTreeDrawingArea):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::windowScreenDidChange):

  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/WebPage.messages.in:

Source/WebKitLegacy/mac:

  • WebView/WebView.mm:

(-[WebView doWindowDidChangeScreen]):

Location:
trunk/Source
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r261946 r261948  
     12020-05-20  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Plumb the display's nominal refresh rate down to ScrollingTree for use in scroll synchronization
     4        https://bugs.webkit.org/show_bug.cgi?id=212159
     5
     6        Reviewed by Tim Horton.
     7
     8        Plumb an Optional<unsigned> down windowScreenDidChange, which contains the nominal
     9        display refresh rate (as frames per second) if available. On macOS, we get this
     10        from CVDisplayLinkGetNominalOutputVideoRefreshPeriod().
     11
     12        To read it, WebProcessPool::nominalFramesPerSecondForDisplay() makes a DisplayLink
     13        that doesn't get any observers, but that DisplayLink will very likely get used
     14        as soon as we schedule a rendering update.
     15
     16        * page/Chrome.cpp:
     17        (WebCore::Chrome::windowScreenDidChange):
     18        * page/Chrome.h:
     19        * page/Page.cpp:
     20        (WebCore::Page::scrollingCoordinator):
     21        (WebCore::Page::windowScreenDidChange):
     22        * page/Page.h:
     23        (WebCore::Page::displayNominalFramesPerSecond const):
     24        * page/scrolling/AsyncScrollingCoordinator.cpp:
     25        (WebCore::AsyncScrollingCoordinator::windowScreenDidChange):
     26        * page/scrolling/AsyncScrollingCoordinator.h:
     27        * page/scrolling/ScrollingCoordinator.h:
     28        (WebCore::ScrollingCoordinator::windowScreenDidChange):
     29        * page/scrolling/ScrollingTree.cpp:
     30        (WebCore::ScrollingTree::windowScreenDidChange):
     31        * page/scrolling/ScrollingTree.h:
     32        * platform/HostWindow.h:
     33
    1342020-05-20  Chris Dumez  <cdumez@apple.com>
    235

  • trunk/Source/WebCore/page/Chrome.cpp

    r260616 r261948  
    513513}
    514514
    515 void Chrome::windowScreenDidChange(PlatformDisplayID displayID)
    516 {
    517     if (displayID == m_page.displayID())
     515void Chrome::windowScreenDidChange(PlatformDisplayID displayID, Optional<unsigned> nominalFrameInterval)
     516{
     517    if (displayID == m_page.displayID() && nominalFrameInterval == m_page.displayNominalFramesPerSecond())
    518518        return;
    519519
    520     m_page.windowScreenDidChange(displayID);
     520    m_page.windowScreenDidChange(displayID, nominalFrameInterval);
    521521
    522522#if PLATFORM(MAC) && ENABLE(GRAPHICS_CONTEXT_GL)

  • trunk/Source/WebCore/page/Chrome.h

    r260616 r261948  
    8989
    9090    PlatformDisplayID displayID() const override;
    91     void windowScreenDidChange(PlatformDisplayID) override;
     91    void windowScreenDidChange(PlatformDisplayID, Optional<unsigned>) override;
    9292
    9393    FloatSize screenSize() const override;

  • trunk/Source/WebCore/page/Page.cpp

    r261876 r261948  
    436436            m_scrollingCoordinator = ScrollingCoordinator::create(this);
    437437
    438         m_scrollingCoordinator->windowScreenDidChange(m_displayID);
     438        m_scrollingCoordinator->windowScreenDidChange(m_displayID, m_displayNominalFramesPerSecond);
    439439    }
    440440
    … …  
    11111111}
    11121112
    1113 void Page::windowScreenDidChange(PlatformDisplayID displayID)
    1114 {
    1115     if (displayID == m_displayID)
     1113void Page::windowScreenDidChange(PlatformDisplayID displayID, Optional<unsigned> nominalFramesPerSecond)
     1114{
     1115    if (displayID == m_displayID && nominalFramesPerSecond == m_displayNominalFramesPerSecond)
    11161116        return;
    11171117
    11181118    m_displayID = displayID;
     1119    m_displayNominalFramesPerSecond = nominalFramesPerSecond;
    11191120
    11201121    for (Frame* frame = &mainFrame(); frame; frame = frame->tree().traverseNext()) {
    … …  
    11241125
    11251126    if (m_scrollingCoordinator)
    1126         m_scrollingCoordinator->windowScreenDidChange(displayID);
     1127        m_scrollingCoordinator->windowScreenDidChange(displayID, nominalFramesPerSecond);
    11271128
    11281129    renderingUpdateScheduler().windowScreenDidChange(displayID);

  • trunk/Source/WebCore/page/Page.h

    r261663 r261948  
    363363    WEBCORE_EXPORT void setInitialScaleIgnoringContentSize(float);
    364364
    365     void windowScreenDidChange(PlatformDisplayID);
     365    void windowScreenDidChange(PlatformDisplayID, Optional<unsigned> nominalFramesPerSecond);
    366366    PlatformDisplayID displayID() const { return m_displayID; }
     367    Optional<unsigned> displayNominalFramesPerSecond() const { return m_displayNominalFramesPerSecond; }
    367368
    368369    float topContentInset() const { return m_topContentInset; }
    … …  
    846847
    847848    PlatformDisplayID m_displayID { 0 };
     849    Optional<unsigned> m_displayNominalFramesPerSecond;
    848850
    849851    int m_nestedRunLoopCount { 0 };

  • trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp

    r261876 r261948  
    817817}
    818818
    819 void AsyncScrollingCoordinator::windowScreenDidChange(PlatformDisplayID displayID)
     819void AsyncScrollingCoordinator::windowScreenDidChange(PlatformDisplayID displayID, Optional<unsigned> nominalFramesPerSecond)
    820820{
    821821    if (m_scrollingTree)
    822         m_scrollingTree->windowScreenDidChange(displayID);
     822        m_scrollingTree->windowScreenDidChange(displayID, nominalFramesPerSecond);
    823823}
    824824

  • trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h

    r261876 r261948  
    139139    WEBCORE_EXPORT bool hasSynchronousScrollingReasons(ScrollingNodeID) const final;
    140140
    141     WEBCORE_EXPORT void windowScreenDidChange(PlatformDisplayID) final;
     141    WEBCORE_EXPORT void windowScreenDidChange(PlatformDisplayID, Optional<unsigned> nominalFramesPerSecond) final;
    142142
    143143    virtual void scheduleTreeStateCommit() = 0;

  • trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.h

    r261876 r261948  
    182182    virtual void scrollableAreaScrollbarLayerDidChange(ScrollableArea&, ScrollbarOrientation) { }
    183183
    184     virtual void windowScreenDidChange(PlatformDisplayID) { }
     184    virtual void windowScreenDidChange(PlatformDisplayID, Optional<unsigned> /* nominalFramesPerSecond */) { }
    185185
    186186    static String synchronousScrollingReasonsAsText(OptionSet<SynchronousScrollingReason>);

  • trunk/Source/WebCore/page/scrolling/ScrollingTree.cpp

    r261876 r261948  
    528528}
    529529
    530 void ScrollingTree::windowScreenDidChange(PlatformDisplayID displayID)
     530void ScrollingTree::windowScreenDidChange(PlatformDisplayID displayID, Optional<unsigned> nominalFramesPerSecond)
    531531{
    532532    LockHolder locker(m_treeStateMutex);
    533533    m_treeState.displayID = displayID;
     534    m_treeState.nominalFramesPerSecond = nominalFramesPerSecond;
    534535}
    535536

  • trunk/Source/WebCore/page/scrolling/ScrollingTree.h

    r261876 r261948  
    180180    virtual void unlockLayersForHitTesting() { }
    181181
    182     void windowScreenDidChange(PlatformDisplayID);
     182    void windowScreenDidChange(PlatformDisplayID, Optional<unsigned> nominalFramesPerSecond);
    183183    PlatformDisplayID displayID();
    184184
    … …  
    222222        FloatPoint mainFrameScrollPosition;
    223223        PlatformDisplayID displayID { 0 };
     224        Optional<unsigned> nominalFramesPerSecond;
    224225        bool mainFrameIsRubberBanding { false };
    225226        bool mainFrameIsScrollSnapping { false };

  • trunk/Source/WebCore/platform/HostWindow.h

    r257677 r261948  
    7777
    7878    virtual PlatformDisplayID displayID() const = 0;
    79     virtual void windowScreenDidChange(PlatformDisplayID) = 0;
     79    virtual void windowScreenDidChange(PlatformDisplayID, Optional<unsigned> nominalFramesPerSecond) = 0;
    8080
    8181    virtual FloatSize screenSize() const = 0;

  • trunk/Source/WebCore/platform/mac/PlatformScreenMac.mm

    r261546 r261948  
    4949{
    5050    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanCommunicateWithWindowServer));
    51     return [[[screen deviceDescription] objectForKey:@"NSScreenNumber"] intValue];
     51    return [[screen.deviceDescription objectForKey:@"NSScreenNumber"] intValue];
    5252}
    5353

  • trunk/Source/WebKit/ChangeLog

    r261940 r261948  
     12020-05-20  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Plumb the display's nominal refresh rate down to ScrollingTree for use in scroll synchronization
     4        https://bugs.webkit.org/show_bug.cgi?id=212159
     5
     6        Reviewed by Tim Horton.
     7
     8        Plumb an Optional<unsigned> down windowScreenDidChange, which contains the nominal
     9        display refresh rate (as frames per second) if available. On macOS, we get this
     10        from CVDisplayLinkGetNominalOutputVideoRefreshPeriod().
     11
     12        To read it, WebProcessPool::nominalFramesPerSecondForDisplay() makes a DisplayLink
     13        that doesn't get any observers, but that DisplayLink will very likely get used
     14        as soon as we schedule a rendering update.
     15
     16        * UIProcess/Cocoa/WebProcessPoolCocoa.mm:
     17        (WebKit::WebProcessPool::nominalFramesPerSecondForDisplay):
     18        * UIProcess/Cocoa/WebViewImpl.mm:
     19        (WebKit::WebViewImpl::windowDidChangeScreen):
     20        * UIProcess/WebPageProxy.cpp:
     21        (WebKit::WebPageProxy::windowScreenDidChange):
     22        * UIProcess/WebPageProxy.h:
     23        * UIProcess/WebProcessPool.h:
     24        * UIProcess/mac/DisplayLink.cpp:
     25        (WebKit::DisplayLink::DisplayLink):
     26        (WebKit::DisplayLink::nominalFramesPerSecond const):
     27        * UIProcess/mac/DisplayLink.h:
     28        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:
     29        (WebKit::RemoteLayerTreeDrawingArea::RemoteLayerTreeDrawingArea):
     30        * WebProcess/WebPage/WebPage.cpp:
     31        (WebKit::WebPage::windowScreenDidChange):
     32        * WebProcess/WebPage/WebPage.h:
     33        * WebProcess/WebPage/WebPage.messages.in:
     34
    1352020-05-20  Myles C. Maxfield  <mmaxfield@apple.com>
    236

  • trunk/Source/WebKit/UIProcess/Cocoa/WebProcessPoolCocoa.mm

    r261900 r261948  
    792792
    793793#if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
     794Optional<unsigned> WebProcessPool::nominalFramesPerSecondForDisplay(WebCore::PlatformDisplayID displayID)
     795{
     796    for (auto& displayLink : m_displayLinks) {
     797        if (displayLink->displayID() == displayID)
     798            return displayLink->nominalFramesPerSecond();
     799    }
     800
     801    // Note that this creates a DisplayLink with no observers, but it's highly likely that we'll soon call startDisplayLink() for it.
     802    auto displayLink = makeUnique<DisplayLink>(displayID);
     803    auto frameRate = displayLink->nominalFramesPerSecond();
     804    m_displayLinks.append(WTFMove(displayLink));
     805    return frameRate;
     806}
     807
    794808void WebProcessPool::startDisplayLink(IPC::Connection& connection, DisplayLinkObserverID observerID, PlatformDisplayID displayID)
    795809{

  • trunk/Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm

    r261875 r261948  
    9797#import <WebCore/Pasteboard.h>
    9898#import <WebCore/PlatformEventFactoryMac.h>
     99#import <WebCore/PlatformScreen.h>
    99100#import <WebCore/PromisedAttachmentInfo.h>
    100101#import <WebCore/TextAlternativeWithRange.h>
    … …  
    21232124{
    21242125    NSWindow *window = m_targetWindowForMovePreparation ? m_targetWindowForMovePreparation.get() : [m_view window];
    2125     m_page->windowScreenDidChange([[[[window screen] deviceDescription] objectForKey:@"NSScreenNumber"] intValue]);
     2126    PlatformDisplayID displayID = WebCore::displayID(window.screen);
     2127    auto framesPerSecond = m_page->process().processPool().nominalFramesPerSecondForDisplay(displayID);
     2128    m_page->windowScreenDidChange(displayID, framesPerSecond);
    21262129}
    21272130

  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r261875 r261948  
    37063706}
    37073707
    3708 void WebPageProxy::windowScreenDidChange(PlatformDisplayID displayID)
    3709 {
    3710     if (!hasRunningProcess())
    3711         return;
    3712 
    3713     send(Messages::WebPage::WindowScreenDidChange(displayID));
     3708void WebPageProxy::windowScreenDidChange(PlatformDisplayID displayID, Optional<unsigned> nominalFramesPerSecond)
     3709{
     3710    if (!hasRunningProcess())
     3711        return;
     3712
     3713    send(Messages::WebPage::WindowScreenDidChange(displayID, nominalFramesPerSecond));
    37143714}
    37153715

  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r261875 r261948  
    993993    void setIntrinsicDeviceScaleFactor(float);
    994994    void setCustomDeviceScaleFactor(float);
    995     void windowScreenDidChange(WebCore::PlatformDisplayID);
     995    void windowScreenDidChange(WebCore::PlatformDisplayID, Optional<unsigned> nominalFramesPerSecond);
    996996    void accessibilitySettingsDidChange();
    997997

  • trunk/Source/WebKit/UIProcess/WebProcessPool.h

    r261900 r261948  
    250250
    251251#if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
     252    Optional<unsigned> nominalFramesPerSecondForDisplay(WebCore::PlatformDisplayID);
    252253    void startDisplayLink(IPC::Connection&, DisplayLinkObserverID, WebCore::PlatformDisplayID);
    253254    void stopDisplayLink(IPC::Connection&, DisplayLinkObserverID, WebCore::PlatformDisplayID);

  • trunk/Source/WebKit/UIProcess/mac/DisplayLink.cpp

    r261900 r261948  
    3737    : m_displayID(displayID)
    3838{
     39    // FIXME: We can get here with displayID == 0 (webkit.org/b/212120), in which case CVDisplayLinkCreateWithCGDisplay()
     40    // probably defaults to the main screen.
    3941    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanCommunicateWithWindowServer));
    4042    CVReturn error = CVDisplayLinkCreateWithCGDisplay(displayID, &m_displayLink);
    4143    if (error) {
    42         WTFLogAlways("Could not create a display link: %d", error);
     44        WTFLogAlways("Could not create a display link for display %u: error %d", displayID, error);
    4345        return;
    4446    }
    … …  
    4648    error = CVDisplayLinkSetOutputCallback(m_displayLink, displayLinkCallback, this);
    4749    if (error) {
    48         WTFLogAlways("Could not set the display link output callback: %d", error);
     50        WTFLogAlways("Could not set the display link output callback for display %u: error %d", displayID, error);
    4951        return;
    5052    }
    … …  
    6062    CVDisplayLinkStop(m_displayLink);
    6163    CVDisplayLinkRelease(m_displayLink);
     64}
     65
     66Optional<unsigned> DisplayLink::nominalFramesPerSecond() const
     67{
     68    CVTime refreshPeriod = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(m_displayLink);
     69    return round((double)refreshPeriod.timeScale / (double)refreshPeriod.timeValue);
    6270}
    6371

  • trunk/Source/WebKit/UIProcess/mac/DisplayLink.h

    r261900 r261948  
    5252
    5353    WebCore::PlatformDisplayID displayID() const { return m_displayID; }
     54   
     55    Optional<unsigned> nominalFramesPerSecond() const;
    5456
    5557private:

  • trunk/Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/DrawingAreaCoordinatedGraphics.cpp

    r261333 r261948  
    577577        // In order to ensure that we get a unique DisplayRefreshMonitor per-DrawingArea (necessary because ThreadedDisplayRefreshMonitor
    578578        // is driven by the ThreadedCompositor of the drawing area), give each page a unique DisplayID derived from WebPage's unique ID.
    579         m_webPage.windowScreenDidChange(m_layerTreeHost->displayID());
     579        m_webPage.windowScreenDidChange(m_layerTreeHost->displayID(), WTF::nullopt);
    580580    };
    581581
    … …  
    633633
    634634    // Always use the primary display ID (0) when not in accelerated compositing mode.
    635     m_webPage.windowScreenDidChange(0);
     635    m_webPage.windowScreenDidChange(0, WTF::nullopt);
    636636
    637637    m_dirtyRegion = m_webPage.bounds();

  • trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm

    r261254 r261948  
    7373    // DisplayIDs less likely, it is not entirely safe to have a RemoteLayerTreeDrawingArea and TiledCoreAnimationDrawingArea
    7474    // coeexist in the same process.
    75     webPage.windowScreenDidChange(std::numeric_limits<uint32_t>::max() - webPage.identifier().toUInt64());
     75    webPage.windowScreenDidChange(std::numeric_limits<uint32_t>::max() - webPage.identifier().toUInt64(), WTF::nullopt);
    7676
    7777    if (auto viewExposedRect = parameters.viewExposedRect)

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r261802 r261948  
    19721972}
    19731973
    1974 void WebPage::windowScreenDidChange(uint32_t displayID)
    1975 {
    1976     m_page->chrome().windowScreenDidChange(static_cast<PlatformDisplayID>(displayID));
     1974void WebPage::windowScreenDidChange(PlatformDisplayID displayID, Optional<unsigned> nominalFramesPerSecond)
     1975{
     1976    m_page->chrome().windowScreenDidChange(displayID, nominalFramesPerSecond);
    19771977
    19781978#if PLATFORM(MAC)

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r261802 r261948  
    205205enum class WritingDirection : uint8_t;
    206206
     207using PlatformDisplayID = uint32_t;
     208
    207209struct AttributedString;
    208210struct BackForwardItemIdentifier;
    … …  
    518520    void setPageZoomFactor(double);
    519521    void setPageAndTextZoomFactors(double pageZoomFactor, double textZoomFactor);
    520     void windowScreenDidChange(uint32_t);
     522    void windowScreenDidChange(WebCore::PlatformDisplayID, Optional<unsigned> nominalFramesPerSecond);
    521523    String dumpHistoryForTesting(const String& directory);
    522524    void clearHistory();

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.messages.in

    r261802 r261948  
    268268    SetPageZoomFactor(double zoomFactor)
    269269    SetTextZoomFactor(double zoomFactor)
    270     WindowScreenDidChange(uint32_t displayID)
     270    WindowScreenDidChange(uint32_t displayID, Optional<unsigned> nominalFramesPerSecond)
    271271
    272272    AccessibilitySettingsDidChange()

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r261848 r261948  
     12020-05-20  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Plumb the display's nominal refresh rate down to ScrollingTree for use in scroll synchronization
     4        https://bugs.webkit.org/show_bug.cgi?id=212159
     5
     6        Reviewed by Tim Horton.
     7
     8        Plumb an Optional<unsigned> down windowScreenDidChange, which contains the nominal
     9        display refresh rate (as frames per second) if available. On macOS, we get this
     10        from CVDisplayLinkGetNominalOutputVideoRefreshPeriod().
     11
     12        To read it, WebProcessPool::nominalFramesPerSecondForDisplay() makes a DisplayLink
     13        that doesn't get any observers, but that DisplayLink will very likely get used
     14        as soon as we schedule a rendering update.
     15
     16        * WebView/WebView.mm:
     17        (-[WebView doWindowDidChangeScreen]):
     18
    1192020-05-18  David Kilzer  <ddkilzer@apple.com>
    220

  • trunk/Source/WebKitLegacy/mac/WebView/WebView.mm

    r261848 r261948  
    193193#import <WebCore/PathUtilities.h>
    194194#import <WebCore/PlatformEventFactoryMac.h>
     195#import <WebCore/PlatformScreen.h>
    195196#import <WebCore/ProgressTracker.h>
    196197#import <WebCore/RenderTheme.h>
    … …  
    60476048{
    60486049    if (_private && _private->page)
    6049         _private->page->chrome().windowScreenDidChange((WebCore::PlatformDisplayID)[[[[[self window] screen] deviceDescription] objectForKey:@"NSScreenNumber"] intValue]);
     6050        _private->page->chrome().windowScreenDidChange(WebCore::displayID(self.window.screen), WTF::nullopt);
    60506051}
    60516052
Note: See TracChangeset for help on using the changeset viewer.