Changeset 232535 in webkit


Ignore:
Timestamp:
Jun 5, 2018 9:35:12 PM (6 years ago)
Author:
pvollan@apple.com
Message:

Move OpenGL display mask to screen data struct.
​https://bugs.webkit.org/show_bug.cgi?id=186198
<rdar://problem/40724854>

Reviewed by Brent Fulgham.

Currently, the OpenGL display mask is a global in the WebContent process. This is not correct in all cases, since
it is possible to have two Web views in the same WebContent process, displayed on different displays. This can be
resolved by moving the OpenGL display mask to a new ScreenData struct, containing information specific to each
display. The display ID of the host window is used to find the OpenGL display mask when needed. This patch makes
the host window available when creating an IOSurface, in order to find the right OpenGL display mask. If no host
window is available, the OpenGL display mask of the main display is used.

Source/WebCore:

No new tests, since testing this requires two Web views in the same WebContent process, displayed on
two different monitors.

  • html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::createImageBuffer const):

  • platform/PlatformScreen.h:
  • platform/ScreenProperties.h:

(WebCore::ScreenProperties::encode const):
(WebCore::ScreenProperties::decode):
(WebCore::ScreenData::encode const):
(WebCore::ScreenData::decode):

  • platform/graphics/GraphicsContext3D.h:
  • platform/graphics/ImageBuffer.cpp:

(WebCore::ImageBuffer::create):

  • platform/graphics/ImageBuffer.h:
  • platform/graphics/cg/ImageBufferCG.cpp:

(WebCore::ImageBuffer::createCompatibleBuffer):
(WebCore::ImageBuffer::ImageBuffer):

  • platform/graphics/cocoa/GraphicsContext3DCocoa.mm:

(WebCore::GraphicsContext3D::GraphicsContext3D):
(WebCore::GraphicsContext3D::allowOfflineRenderers const):
(WebCore::GraphicsContext3D::setOpenGLDisplayMask): Deleted.
(WebCore::GraphicsContext3D::getOpenGLDisplayMask): Deleted.

  • platform/graphics/cocoa/IOSurface.h:
  • platform/graphics/cocoa/IOSurface.mm:

(WebCore::IOSurface::ensurePlatformContext):

  • platform/mac/PlatformScreenMac.mm:

(WebCore::screenProperties):
(WebCore::collectScreenProperties):
(WebCore::setScreenProperties):
(WebCore::screenData):
(WebCore::primaryOpenGLDisplayMask):
(WebCore::displayMaskForDisplay):
(WebCore::getScreenProperties):
(WebCore::screenIsMonochrome):
(WebCore::screenHasInvertedColors):
(WebCore::screenDepth):
(WebCore::screenDepthPerComponent):
(WebCore::screenRectForDisplay):
(WebCore::screenRect):
(WebCore::screenAvailableRect):
(WebCore::screenColorSpace):
(WebCore::screenSupportsExtendedColor):

Source/WebKit:

  • Shared/WebPageCreationParameters.cpp:

(WebKit::WebPageCreationParameters::encode const):
(WebKit::WebPageCreationParameters::decode):

  • Shared/WebPageCreationParameters.h:
  • Shared/WebProcessCreationParameters.cpp:

(WebKit::WebProcessCreationParameters::encode const):
(WebKit::WebProcessCreationParameters::decode):

  • Shared/WebProcessCreationParameters.h:
  • UIProcess/Cocoa/WebProcessPoolCocoa.mm:

(WebKit::WebProcessPool::platformInitializeWebProcess):

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::windowScreenDidChange):
(WebKit::WebPageProxy::creationParameters):

  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::screenPropertiesStateChanged):
(WebKit::displayReconfigurationCallBack):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::m_credentialsMessenger):

  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/WebPage.messages.in:
  • WebProcess/WebPage/mac/WebPageMac.mm:

(WebKit::WebPage::openGLDisplayMaskChanged): Deleted.

  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::setScreenProperties):

  • WebProcess/WebProcess.h:
  • WebProcess/WebProcess.messages.in:
  • WebProcess/cocoa/WebProcessCocoa.mm:

(WebKit::WebProcess::platformInitializeWebProcess):

Location:
trunk/Source
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r232534 r232535  
     12018-06-05  Per Arne Vollan  <pvollan@apple.com>
     2
     3        Move OpenGL display mask to screen data struct.
     4        https://bugs.webkit.org/show_bug.cgi?id=186198
     5        <rdar://problem/40724854>
     6
     7        Reviewed by Brent Fulgham.
     8
     9        Currently, the OpenGL display mask is a global in the WebContent process. This is not correct in all cases, since
     10        it is possible to have two Web views in the same WebContent process, displayed on different displays. This can be
     11        resolved by moving the OpenGL display mask to a new ScreenData struct, containing information specific to each
     12        display. The display ID of the host window is used to find the OpenGL display mask when needed. This patch makes
     13        the host window available when creating an IOSurface, in order to find the right OpenGL display mask. If no host
     14        window is available, the OpenGL display mask of the main display is used.
     15
     16        No new tests, since testing this requires two Web views in the same WebContent process, displayed on
     17        two different monitors.
     18
     19        * html/HTMLCanvasElement.cpp:
     20        (WebCore::HTMLCanvasElement::createImageBuffer const):
     21        * platform/PlatformScreen.h:
     22        * platform/ScreenProperties.h:
     23        (WebCore::ScreenProperties::encode const):
     24        (WebCore::ScreenProperties::decode):
     25        (WebCore::ScreenData::encode const):
     26        (WebCore::ScreenData::decode):
     27        * platform/graphics/GraphicsContext3D.h:
     28        * platform/graphics/ImageBuffer.cpp:
     29        (WebCore::ImageBuffer::create):
     30        * platform/graphics/ImageBuffer.h:
     31        * platform/graphics/cg/ImageBufferCG.cpp:
     32        (WebCore::ImageBuffer::createCompatibleBuffer):
     33        (WebCore::ImageBuffer::ImageBuffer):
     34        * platform/graphics/cocoa/GraphicsContext3DCocoa.mm:
     35        (WebCore::GraphicsContext3D::GraphicsContext3D):
     36        (WebCore::GraphicsContext3D::allowOfflineRenderers const):
     37        (WebCore::GraphicsContext3D::setOpenGLDisplayMask): Deleted.
     38        (WebCore::GraphicsContext3D::getOpenGLDisplayMask): Deleted.
     39        * platform/graphics/cocoa/IOSurface.h:
     40        * platform/graphics/cocoa/IOSurface.mm:
     41        (WebCore::IOSurface::ensurePlatformContext):
     42        * platform/mac/PlatformScreenMac.mm:
     43        (WebCore::screenProperties):
     44        (WebCore::collectScreenProperties):
     45        (WebCore::setScreenProperties):
     46        (WebCore::screenData):
     47        (WebCore::primaryOpenGLDisplayMask):
     48        (WebCore::displayMaskForDisplay):
     49        (WebCore::getScreenProperties):
     50        (WebCore::screenIsMonochrome):
     51        (WebCore::screenHasInvertedColors):
     52        (WebCore::screenDepth):
     53        (WebCore::screenDepthPerComponent):
     54        (WebCore::screenRectForDisplay):
     55        (WebCore::screenRect):
     56        (WebCore::screenAvailableRect):
     57        (WebCore::screenColorSpace):
     58        (WebCore::screenSupportsExtendedColor):
     59
    1602018-06-05  Jer Noble  <jer.noble@apple.com>
    261

  • trunk/Source/WebCore/html/HTMLCanvasElement.cpp

    r232113 r232535  
    914914    RenderingMode renderingMode = shouldAccelerate(size()) ? Accelerated : Unaccelerated;
    915915
    916     setImageBuffer(ImageBuffer::create(size(), renderingMode));
     916    auto hostWindow = (document().view() && document().view()->root()) ? document().view()->root()->hostWindow() : nullptr;
     917    setImageBuffer(ImageBuffer::create(size(), renderingMode, 1, ColorSpaceSRGB, hostWindow));
    917918    if (!m_imageBuffer)
    918919        return;

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

    r232375 r232535  
    9696NSPoint flipScreenPoint(const NSPoint&, NSScreen *);
    9797
    98 typedef HashMap<PlatformDisplayID, ScreenProperties> ScreenPropertiesMap;
     98WEBCORE_EXPORT ScreenProperties collectScreenProperties();
     99WEBCORE_EXPORT void setScreenProperties(const ScreenProperties&);
    99100
    100 WEBCORE_EXPORT std::pair<PlatformDisplayID, ScreenPropertiesMap> getScreenProperties();
    101 WEBCORE_EXPORT void setScreenProperties(PlatformDisplayID primaryScreenID, const ScreenPropertiesMap&);
    102 ScreenProperties screenProperties(PlatformDisplayID);
    103 
     101uint32_t primaryOpenGLDisplayMask();
     102uint32_t displayMaskForDisplay(PlatformDisplayID);
    104103#endif
    105104

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

    r230356 r232535  
    2929
    3030#include "FloatRect.h"
     31#include "PlatformScreen.h"
    3132#include <wtf/RetainPtr.h>
    3233#include <wtf/text/WTFString.h>
    … …  
    3637namespace WebCore {
    3738
    38 struct ScreenProperties {
     39struct ScreenData {
    3940    FloatRect screenAvailableRect;
    4041    FloatRect screenRect;
    … …  
    4546    bool screenHasInvertedColors { false };
    4647    bool screenIsMonochrome { false };
     48    uint32_t displayMask { 0 };
    4749
    4850    enum EncodedColorSpaceDataType {
    … …  
    5355
    5456    template<class Encoder> void encode(Encoder&) const;
     57    template<class Decoder> static std::optional<ScreenData> decode(Decoder&);
     58};
     59
     60typedef HashMap<PlatformDisplayID, ScreenData> ScreenDataMap;
     61   
     62struct ScreenProperties {
     63    PlatformDisplayID primaryDisplayID { 0 };
     64    ScreenDataMap screenDataMap;
     65
     66    template<class Encoder> void encode(Encoder&) const;
    5567    template<class Decoder> static std::optional<ScreenProperties> decode(Decoder&);
    5668};
    … …  
    5971void ScreenProperties::encode(Encoder& encoder) const
    6072{
    61     encoder << screenAvailableRect << screenRect << screenDepth << screenDepthPerComponent << screenSupportsExtendedColor << screenHasInvertedColors << screenIsMonochrome;
     73    encoder << primaryDisplayID;
     74    encoder << screenDataMap;
     75}
     76
     77template<class Decoder>
     78std::optional<ScreenProperties> ScreenProperties::decode(Decoder& decoder)
     79{
     80    std::optional<PlatformDisplayID> primaryDisplayID;
     81    decoder >> primaryDisplayID;
     82    if (!primaryDisplayID)
     83        return std::nullopt;
     84
     85    std::optional<ScreenDataMap> screenDataMap;
     86    decoder >> screenDataMap;
     87    if (!screenDataMap)
     88        return std::nullopt;
     89
     90    return { { *primaryDisplayID, WTFMove(*screenDataMap) } };
     91}
     92
     93template<class Encoder>
     94void ScreenData::encode(Encoder& encoder) const
     95{
     96    encoder << screenAvailableRect << screenRect << screenDepth << screenDepthPerComponent << screenSupportsExtendedColor << screenHasInvertedColors << screenIsMonochrome << displayMask;
    6297
    6398    if (colorSpace) {
    … …  
    86121
    87122template<class Decoder>
    88 std::optional<ScreenProperties> ScreenProperties::decode(Decoder& decoder)
     123std::optional<ScreenData> ScreenData::decode(Decoder& decoder)
    89124{
    90125    std::optional<FloatRect> screenAvailableRect;
    … …  
    123158        return std::nullopt;
    124159
     160    std::optional<uint32_t> displayMask;
     161    decoder >> displayMask;
     162    if (!displayMask)
     163        return std::nullopt;
     164   
    125165    EncodedColorSpaceDataType dataType;
    126166    if (!decoder.decodeEnum(dataType))
    … …  
    158198    }
    159199
    160     return { { WTFMove(*screenAvailableRect), WTFMove(*screenRect), WTFMove(cgColorSpace), WTFMove(*screenDepth), WTFMove(*screenDepthPerComponent), WTFMove(*screenSupportsExtendedColor), WTFMove(*screenHasInvertedColors), WTFMove(*screenIsMonochrome) } };
     200    return { { WTFMove(*screenAvailableRect), WTFMove(*screenRect), WTFMove(cgColorSpace), WTFMove(*screenDepth), WTFMove(*screenDepthPerComponent), WTFMove(*screenSupportsExtendedColor), WTFMove(*screenHasInvertedColors), WTFMove(*screenIsMonochrome), WTFMove(*displayMask) } };
    161201}
    162202

  • trunk/Source/WebCore/platform/graphics/GraphicsContext3D.h

    r230278 r232535  
    12831283    unsigned textureSeed(GC3Duint texture) { return m_state.textureSeedCount.count(texture); }
    12841284
    1285 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    1286     WEBCORE_EXPORT static void setOpenGLDisplayMask(CGOpenGLDisplayMask);
    1287     WEBCORE_EXPORT static CGOpenGLDisplayMask getOpenGLDisplayMask();
    1288 #endif
    1289 
    12901285private:
    12911286    GraphicsContext3D(GraphicsContext3DAttributes, HostWindow*, RenderStyle = RenderOffscreen, GraphicsContext3D* sharedContext = nullptr);
    … …  
    15021497    Platform3DObject m_vao { 0 };
    15031498#endif
    1504 
    1505 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    1506     static std::optional<CGOpenGLDisplayMask> m_displayMask;
    1507 #endif
    15081499};
    15091500

  • trunk/Source/WebCore/platform/graphics/ImageBuffer.cpp

    r231638 r232535  
    3939static const float MaxClampedArea = MaxClampedLength * MaxClampedLength;
    4040
    41 std::unique_ptr<ImageBuffer> ImageBuffer::create(const FloatSize& size, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace)
     41std::unique_ptr<ImageBuffer> ImageBuffer::create(const FloatSize& size, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace, const HostWindow* hostWindow)
    4242{
    4343    bool success = false;
    44     std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(size, resolutionScale, colorSpace, renderingMode, success));
     44    std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(size, resolutionScale, colorSpace, renderingMode, hostWindow, success));
    4545    if (!success)
    4646        return nullptr;

  • trunk/Source/WebCore/platform/graphics/ImageBuffer.h

    r228218 r232535  
    5050class IntPoint;
    5151class IntRect;
    52 
     52class HostWindow;
     53   
    5354enum BackingStoreCopy {
    5455    CopyBackingStore, // Guarantee subsequent draws don't affect the copy.
    … …  
    6667public:
    6768    // Will return a null pointer on allocation failure.
    68     WEBCORE_EXPORT static std::unique_ptr<ImageBuffer> create(const FloatSize&, RenderingMode, float resolutionScale = 1, ColorSpace = ColorSpaceSRGB);
     69    WEBCORE_EXPORT static std::unique_ptr<ImageBuffer> create(const FloatSize&, RenderingMode, float resolutionScale = 1, ColorSpace = ColorSpaceSRGB, const HostWindow* = nullptr);
    6970#if USE(DIRECT2D)
    7071    WEBCORE_EXPORT static std::unique_ptr<ImageBuffer> create(const FloatSize&, RenderingMode, const GraphicsContext*, float resolutionScale = 1, ColorSpace = ColorSpaceSRGB);
    … …  
    165166    // This constructor will place its success into the given out-variable
    166167    // so that create() knows when it should return failure.
    167     WEBCORE_EXPORT ImageBuffer(const FloatSize&, float resolutionScale, ColorSpace, RenderingMode, bool& success);
     168    WEBCORE_EXPORT ImageBuffer(const FloatSize&, float resolutionScale, ColorSpace, RenderingMode, const HostWindow*, bool& success);
    168169#if USE(CG)
    169     ImageBuffer(const FloatSize&, float resolutionScale, CGColorSpaceRef, RenderingMode, bool& success);
     170    ImageBuffer(const FloatSize&, float resolutionScale, CGColorSpaceRef, RenderingMode, const HostWindow*, bool& success);
    170171    RetainPtr<CFDataRef> toCFData(const String& mimeType, std::optional<double> quality, PreserveResolution) const;
    171172#elif USE(DIRECT2D)

  • trunk/Source/WebCore/platform/graphics/cairo/ImageBufferCairo.cpp

    r230702 r232535  
    205205#endif
    206206
    207 ImageBuffer::ImageBuffer(const FloatSize& size, float resolutionScale, ColorSpace, RenderingMode renderingMode, bool& success)
     207ImageBuffer::ImageBuffer(const FloatSize& size, float resolutionScale, ColorSpace, RenderingMode renderingMode, const HostWindow*, bool& success)
    208208    : m_data(IntSize(size), renderingMode)
    209209    , m_logicalSize(size)

  • trunk/Source/WebCore/platform/graphics/cg/ImageBufferCG.cpp

    r231638 r232535  
    9797    IntSize scaledSize = ImageBuffer::compatibleBufferSize(size, context);
    9898    bool success = false;
    99     std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(scaledSize, 1, colorSpace.get(), renderingMode, success));
     99    std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(scaledSize, 1, colorSpace.get(), renderingMode, nullptr, success));
    100100
    101101    if (!success)
    … …  
    107107}
    108108
    109 ImageBuffer::ImageBuffer(const FloatSize& size, float resolutionScale, CGColorSpaceRef colorSpace, RenderingMode renderingMode, bool& success)
     109ImageBuffer::ImageBuffer(const FloatSize& size, float resolutionScale, CGColorSpaceRef colorSpace, RenderingMode renderingMode, const HostWindow* hostWindow, bool& success)
    110110    : m_logicalSize(size)
    111111    , m_resolutionScale(resolutionScale)
    … …  
    153153        m_data.surface = IOSurface::create(m_data.backingStoreSize, IntSize(userBounds), colorSpace);
    154154        if (m_data.surface) {
    155             cgContext = m_data.surface->ensurePlatformContext();
     155            cgContext = m_data.surface->ensurePlatformContext(hostWindow);
    156156            if (cgContext)
    157157                CGContextClearRect(cgContext.get(), FloatRect(FloatPoint(), userBounds));
    … …  
    159159                m_data.surface = nullptr;
    160160        }
     161#else
     162        UNUSED_PARAM(hostWindow);
    161163#endif
    162164        if (!cgContext)
    … …  
    194196}
    195197
    196 ImageBuffer::ImageBuffer(const FloatSize& size, float resolutionScale, ColorSpace imageColorSpace, RenderingMode renderingMode, bool& success)
    197     : ImageBuffer(size, resolutionScale, cachedCGColorSpace(imageColorSpace), renderingMode, success)
     198ImageBuffer::ImageBuffer(const FloatSize& size, float resolutionScale, ColorSpace imageColorSpace, RenderingMode renderingMode, const HostWindow* hostWindow, bool& success)
     199    : ImageBuffer(size, resolutionScale, cachedCGColorSpace(imageColorSpace), renderingMode, hostWindow, success)
    198200{
    199201}

  • trunk/Source/WebCore/platform/graphics/cocoa/GraphicsContext3DCocoa.mm

    r230278 r232535  
    3737#import "GraphicsContext.h"
    3838#import "HTMLCanvasElement.h"
     39#import "HostWindow.h"
    3940#import "ImageBuffer.h"
    4041#import "Logging.h"
    … …  
    6162#endif
    6263
     64#if PLATFORM(MAC)
     65#import "ScreenProperties.h"
     66#endif
     67
    6368namespace WebCore {
    6469
    6570static const unsigned statusCheckThreshold = 5;
    66 
    67 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    68 std::optional<CGOpenGLDisplayMask> GraphicsContext3D::m_displayMask;
    69 #endif
    7071
    7172#if HAVE(APPLE_GRAPHICS_CONTROL)
    … …  
    425426#endif
    426427
    427 GraphicsContext3D::GraphicsContext3D(GraphicsContext3DAttributes attrs, HostWindow*, GraphicsContext3D::RenderStyle, GraphicsContext3D* sharedContext)
     428GraphicsContext3D::GraphicsContext3D(GraphicsContext3DAttributes attrs, HostWindow* hostWindow, GraphicsContext3D::RenderStyle, GraphicsContext3D* sharedContext)
    428429    : m_attrs(attrs)
    429430#if PLATFORM(IOS)
    … …  
    433434{
    434435#if USE(OPENGL_ES)
     436    UNUSED_PARAM(hostWindow);
    435437    EAGLRenderingAPI api = m_attrs.useGLES3 ? kEAGLRenderingAPIOpenGLES3 : kEAGLRenderingAPIOpenGLES2;
    436438    if (!sharedContext)
    … …  
    493495   
    494496#if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    495     if (m_displayMask.has_value())
    496         identifyAndSetCurrentGPU(pixelFormatObj, numPixelFormats, m_displayMask.value(), m_contextObj);
     497    if (auto displayMask = primaryOpenGLDisplayMask()) {
     498        if (hostWindow && hostWindow->displayID())
     499            displayMask = displayMaskForDisplay(hostWindow->displayID());
     500        identifyAndSetCurrentGPU(pixelFormatObj, numPixelFormats, displayMask, m_contextObj);
     501    }
     502#else
     503    UNUSED_PARAM(hostWindow);
    497504#endif
    498505
    … …  
    790797}
    791798
    792 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    793 void GraphicsContext3D::setOpenGLDisplayMask(CGOpenGLDisplayMask displayMask)
    794 {
    795     m_displayMask = displayMask;
    796 }
    797    
    798 CGOpenGLDisplayMask GraphicsContext3D::getOpenGLDisplayMask()
    799 {
    800     if (m_displayMask.has_value())
    801         return m_displayMask.value();
    802     return 0;
    803 }
    804 #endif
    805 
    806799bool GraphicsContext3D::allowOfflineRenderers() const
    807800{
    … …  
    813806    // In WebKit legacy, there will still be a WindowServer connection, and
    814807    // m_displayMask will not be set in this case.
    815     if (m_displayMask.has_value())
     808    if (primaryOpenGLDisplayMask())
    816809        return true;
    817810#endif

  • trunk/Source/WebCore/platform/graphics/cocoa/IOSurface.h

    r232501 r232535  
    3939namespace WebCore {
    4040
     41class HostWindow;
     42   
    4143class IOSurface final {
    4244    WTF_MAKE_FAST_ALLOCATED;
    … …  
    108110    IOSurfaceRef surface() const { return m_surface.get(); }
    109111    WEBCORE_EXPORT GraphicsContext& ensureGraphicsContext();
    110     WEBCORE_EXPORT CGContextRef ensurePlatformContext();
     112    WEBCORE_EXPORT CGContextRef ensurePlatformContext(const HostWindow* = nullptr);
    111113
    112114    enum class SurfaceState {

  • trunk/Source/WebCore/platform/graphics/cocoa/IOSurface.mm

    r230278 r232535  
    273273}
    274274
    275 CGContextRef IOSurface::ensurePlatformContext()
     275CGContextRef IOSurface::ensurePlatformContext(const HostWindow* hostWindow)
    276276{
    277277    if (m_cgContext)
    … …  
    302302
    303303#if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    304     if (uint32_t mask = GraphicsContext3D::getOpenGLDisplayMask())
    305         CGIOSurfaceContextSetDisplayMask(m_cgContext.get(), mask);
     304    if (auto displayMask = primaryOpenGLDisplayMask()) {
     305        if (hostWindow && hostWindow->displayID())
     306            displayMask = displayMaskForDisplay(hostWindow->displayID());
     307        CGIOSurfaceContextSetDisplayMask(m_cgContext.get(), displayMask);
     308    }
     309#else
     310    UNUSED_PARAM(hostWindow);
    306311#endif
    307312

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

    r232375 r232535  
    9797}
    9898
    99 static ScreenPropertiesMap& screenProperties()
    100 {
    101     static NeverDestroyed<ScreenPropertiesMap> screenProperties;
     99static ScreenProperties& screenProperties()
     100{
     101    static NeverDestroyed<ScreenProperties> screenProperties;
    102102    return screenProperties;
    103103}
    … …  
    109109}
    110110
    111 std::pair<PlatformDisplayID, ScreenPropertiesMap> getScreenProperties()
    112 {
    113     ASSERT(hasProcessPrivilege(ProcessPrivilege::CanCommunicateWithWindowServer));
    114 
    115     ScreenPropertiesMap screenProperties;
    116     std::optional<PlatformDisplayID> firstScreen;
     111ScreenProperties collectScreenProperties()
     112{
     113    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanCommunicateWithWindowServer));
     114
     115    ScreenProperties screenProperties;
    117116
    118117    for (NSScreen *screen in [NSScreen screens]) {
    … …  
    129128        bool screenHasInvertedColors = CGDisplayUsesInvertedPolarity();
    130129        bool screenIsMonochrome = CGDisplayUsesForceToGray();
    131 
    132         screenProperties.set(displayID, ScreenProperties { screenAvailableRect, screenRect, colorSpace, screenDepth, screenDepthPerComponent, screenSupportsExtendedColor, screenHasInvertedColors, screenIsMonochrome });
    133 
    134         if (!firstScreen)
    135             firstScreen = displayID;
    136     }
    137 
    138     return { WTFMove(*firstScreen), WTFMove(screenProperties) };
    139 }
    140 
    141 void setScreenProperties(PlatformDisplayID primaryScreenID, const ScreenPropertiesMap& properties)
    142 {
    143     primaryScreenDisplayID() = primaryScreenID;
     130        uint32_t displayMask = CGDisplayIDToOpenGLDisplayMask(displayID);
     131
     132        screenProperties.screenDataMap.set(displayID, ScreenData { screenAvailableRect, screenRect, colorSpace, screenDepth, screenDepthPerComponent, screenSupportsExtendedColor, screenHasInvertedColors, screenIsMonochrome, displayMask });
     133
     134        if (!screenProperties.primaryDisplayID)
     135            screenProperties.primaryDisplayID = displayID;
     136    }
     137
     138    return screenProperties;
     139}
     140
     141void setScreenProperties(const ScreenProperties& properties)
     142{
    144143    screenProperties() = properties;
    145144}
    146145
    147 ScreenProperties screenProperties(PlatformDisplayID screendisplayID)
    148 {
    149     RELEASE_ASSERT(!screenProperties().isEmpty());
     146static ScreenData screenData(PlatformDisplayID screendisplayID)
     147{
     148    RELEASE_ASSERT(!screenProperties().screenDataMap.isEmpty());
    150149
    151150    // Return property of the first screen if the screen is not found in the map.
    152151    auto displayID = screendisplayID ? screendisplayID : primaryScreenDisplayID();
    153152    if (displayID) {
    154         auto screenPropertiesForDisplay = screenProperties().find(displayID);
    155         if (screenPropertiesForDisplay != screenProperties().end())
     153        auto screenPropertiesForDisplay = screenProperties().screenDataMap.find(displayID);
     154        if (screenPropertiesForDisplay != screenProperties().screenDataMap.end())
    156155            return screenPropertiesForDisplay->value;
    157156    }
    158157
    159158    // Last resort: use the first item in the screen list.
    160     return screenProperties().begin()->value;
    161 }
    162 
    163 static ScreenProperties getScreenProperties(Widget* widget)
    164 {
    165     return screenProperties(displayID(widget));
     159    return screenProperties().screenDataMap.begin()->value;
     160}
     161
     162uint32_t primaryOpenGLDisplayMask()
     163{
     164    if (!screenProperties().screenDataMap.isEmpty())
     165        return screenData(primaryScreenDisplayID()).displayMask;
     166   
     167    return 0;
     168}
     169
     170uint32_t displayMaskForDisplay(PlatformDisplayID displayID)
     171{
     172    if (!screenProperties().screenDataMap.isEmpty())
     173        return screenData(displayID).displayMask;
     174   
     175    ASSERT_NOT_REACHED();
     176    return 0;
     177}
     178
     179static ScreenData getScreenProperties(Widget* widget)
     180{
     181    return screenData(displayID(widget));
    166182}
    167183
    168184bool screenIsMonochrome(Widget* widget)
    169185{
    170     if (!screenProperties().isEmpty())
     186    if (!screenProperties().screenDataMap.isEmpty())
    171187        return getScreenProperties(widget).screenIsMonochrome;
    172188
    … …  
    178194bool screenHasInvertedColors()
    179195{
    180     if (!screenProperties().isEmpty())
    181         return screenProperties(primaryScreenDisplayID()).screenHasInvertedColors;
     196    if (!screenProperties().screenDataMap.isEmpty())
     197        return screenData(primaryScreenDisplayID()).screenHasInvertedColors;
    182198
    183199    // This is a system-wide accessibility setting, same on all screens.
    … …  
    188204int screenDepth(Widget* widget)
    189205{
    190     if (!screenProperties().isEmpty()) {
     206    if (!screenProperties().screenDataMap.isEmpty()) {
    191207        auto screenDepth = getScreenProperties(widget).screenDepth;
    192208        ASSERT(screenDepth);
    … …  
    200216int screenDepthPerComponent(Widget* widget)
    201217{
    202     if (!screenProperties().isEmpty()) {
     218    if (!screenProperties().screenDataMap.isEmpty()) {
    203219        auto depthPerComponent = getScreenProperties(widget).screenDepthPerComponent;
    204220        ASSERT(depthPerComponent);
    … …  
    212228FloatRect screenRectForDisplay(PlatformDisplayID displayID)
    213229{
    214     if (!screenProperties().isEmpty()) {
    215         auto screenRect = screenProperties(displayID).screenRect;
     230    if (!screenProperties().screenDataMap.isEmpty()) {
     231        auto screenRect = screenData(displayID).screenRect;
    216232        ASSERT(!screenRect.isEmpty());
    217233        return screenRect;
    … …  
    229245FloatRect screenRect(Widget* widget)
    230246{
    231     if (!screenProperties().isEmpty())
     247    if (!screenProperties().screenDataMap.isEmpty())
    232248        return getScreenProperties(widget).screenRect;
    233249
    … …  
    238254FloatRect screenAvailableRect(Widget* widget)
    239255{
    240     if (!screenProperties().isEmpty())
     256    if (!screenProperties().screenDataMap.isEmpty())
    241257        return getScreenProperties(widget).screenAvailableRect;
    242258
    … …  
    263279CGColorSpaceRef screenColorSpace(Widget* widget)
    264280{
    265     if (!screenProperties().isEmpty())
     281    if (!screenProperties().screenDataMap.isEmpty())
    266282        return getScreenProperties(widget).colorSpace.get();
    267283
    … …  
    272288bool screenSupportsExtendedColor(Widget* widget)
    273289{
    274     if (!screenProperties().isEmpty())
     290    if (!screenProperties().screenDataMap.isEmpty())
    275291        return getScreenProperties(widget).screenSupportsExtendedColor;
    276292

  • trunk/Source/WebKit/ChangeLog

    r232531 r232535  
     12018-06-05  Per Arne Vollan  <pvollan@apple.com>
     2
     3        Move OpenGL display mask to screen data struct.
     4        https://bugs.webkit.org/show_bug.cgi?id=186198
     5        <rdar://problem/40724854>
     6
     7        Reviewed by Brent Fulgham.
     8
     9        Currently, the OpenGL display mask is a global in the WebContent process. This is not correct in all cases, since
     10        it is possible to have two Web views in the same WebContent process, displayed on different displays. This can be
     11        resolved by moving the OpenGL display mask to a new ScreenData struct, containing information specific to each
     12        display. The display ID of the host window is used to find the OpenGL display mask when needed. This patch makes
     13        the host window available when creating an IOSurface, in order to find the right OpenGL display mask. If no host
     14        window is available, the OpenGL display mask of the main display is used.
     15
     16        * Shared/WebPageCreationParameters.cpp:
     17        (WebKit::WebPageCreationParameters::encode const):
     18        (WebKit::WebPageCreationParameters::decode):
     19        * Shared/WebPageCreationParameters.h:
     20        * Shared/WebProcessCreationParameters.cpp:
     21        (WebKit::WebProcessCreationParameters::encode const):
     22        (WebKit::WebProcessCreationParameters::decode):
     23        * Shared/WebProcessCreationParameters.h:
     24        * UIProcess/Cocoa/WebProcessPoolCocoa.mm:
     25        (WebKit::WebProcessPool::platformInitializeWebProcess):
     26        * UIProcess/WebPageProxy.cpp:
     27        (WebKit::WebPageProxy::windowScreenDidChange):
     28        (WebKit::WebPageProxy::creationParameters):
     29        * UIProcess/WebProcessPool.cpp:
     30        (WebKit::WebProcessPool::screenPropertiesStateChanged):
     31        (WebKit::displayReconfigurationCallBack):
     32        * WebProcess/WebPage/WebPage.cpp:
     33        (WebKit::m_credentialsMessenger):
     34        * WebProcess/WebPage/WebPage.h:
     35        * WebProcess/WebPage/WebPage.messages.in:
     36        * WebProcess/WebPage/mac/WebPageMac.mm:
     37        (WebKit::WebPage::openGLDisplayMaskChanged): Deleted.
     38        * WebProcess/WebProcess.cpp:
     39        (WebKit::WebProcess::setScreenProperties):
     40        * WebProcess/WebProcess.h:
     41        * WebProcess/WebProcess.messages.in:
     42        * WebProcess/cocoa/WebProcessCocoa.mm:
     43        (WebKit::WebProcess::platformInitializeWebProcess):
     44
    1452018-06-05  Keith Rollin  <krollin@apple.com>
    246

  • trunk/Source/WebKit/Shared/WebPageCreationParameters.cpp

    r232375 r232535  
    120120    encoder << contentRuleLists;
    121121#endif
    122 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    123     encoder << displayMask;
    124 #endif
    125122}
    126123
    … …  
    347344#endif
    348345
    349 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    350     if (!decoder.decode(parameters.displayMask))
    351         return std::nullopt;
    352 #endif
    353 
    354346    return WTFMove(parameters);
    355347}

  • trunk/Source/WebKit/Shared/WebPageCreationParameters.h

    r232375 r232535  
    186186    Vector<std::pair<String, WebCompiledContentRuleListData>> contentRuleLists;
    187187#endif
    188    
    189 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    190     CGOpenGLDisplayMask displayMask { 0 };
    191 #endif
    192188};
    193189

  • trunk/Source/WebKit/Shared/WebProcessCreationParameters.cpp

    r232277 r232535  
    157157
    158158#if PLATFORM(MAC)
    159     encoder << primaryDisplayID;
    160     encoder << screenPropertiesMap;
     159    encoder << screenProperties;
    161160#endif
    162161}
    … …  
    408407
    409408#if PLATFORM(MAC)
    410     if (!decoder.decode(parameters.primaryDisplayID))
    411         return false;
    412 
    413     std::optional<WebCore::ScreenPropertiesMap> screenPropertiesMap;
    414     decoder >> screenPropertiesMap;
    415     if (!screenPropertiesMap)
    416         return false;
    417     parameters.screenPropertiesMap = WTFMove(*screenPropertiesMap);
     409    std::optional<WebCore::ScreenProperties> screenProperties;
     410    decoder >> screenProperties;
     411    if (!screenProperties)
     412        return false;
     413    parameters.screenProperties = WTFMove(*screenProperties);
    418414#endif
    419415

  • trunk/Source/WebKit/Shared/WebProcessCreationParameters.h

    r232277 r232535  
    196196
    197197#if PLATFORM(MAC)
    198     WebCore::PlatformDisplayID primaryDisplayID { 0 };
    199     WebCore::ScreenPropertiesMap screenPropertiesMap;
     198    WebCore::ScreenProperties screenProperties;
    200199#endif
    201200};

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

    r232520 r232535  
    283283   
    284284#if PLATFORM(MAC)
    285     auto screenProperties = WebCore::getScreenProperties();
    286     parameters.primaryDisplayID = screenProperties.first;
    287     parameters.screenPropertiesMap = WTFMove(screenProperties.second);
     285    auto screenProperties = WebCore::collectScreenProperties();
     286    parameters.screenProperties = WTFMove(screenProperties);
    288287#endif
    289288}

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

    r232437 r232535  
    27792779
    27802780    m_process->send(Messages::WebPage::WindowScreenDidChange(displayID), m_pageID);
    2781 
    2782 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    2783     auto currentDisplaymask = CGDisplayIDToOpenGLDisplayMask(displayID);
    2784     m_process->send(Messages::WebPage::OpenGLDisplayMaskChanged(currentDisplaymask), m_pageID);
    2785 #endif
    27862781}
    27872782
    … …  
    61756170#endif
    61766171
    6177 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    6178     auto screen = WebCore::screen(m_pageClient.platformWindow());
    6179     auto displayID = WebCore::displayID(screen);
    6180     parameters.displayMask = CGDisplayIDToOpenGLDisplayMask(displayID);
    6181 #endif
    6182 
    61836172    m_process->addWebUserContentControllerProxy(m_userContentController, parameters);
    61846173

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

    r232531 r232535  
    440440{
    441441#if PLATFORM(MAC)
    442     auto screenProperties = WebCore::getScreenProperties();
    443     sendToAllProcesses(Messages::WebProcess::SetScreenProperties(screenProperties.first, screenProperties.second));
     442    auto screenProperties = WebCore::collectScreenProperties();
     443    sendToAllProcesses(Messages::WebProcess::SetScreenProperties(screenProperties));
    444444#endif
    445445}
    … …  
    811811static void displayReconfigurationCallBack(CGDirectDisplayID display, CGDisplayChangeSummaryFlags flags, void *userInfo)
    812812{
    813     auto screenProperties = WebCore::getScreenProperties();
     813    auto screenProperties = WebCore::collectScreenProperties();
    814814    for (auto& processPool : WebProcessPool::allProcessPools())
    815         processPool->sendToAllProcesses(Messages::WebProcess::SetScreenProperties(screenProperties.first, screenProperties.second));
     815        processPool->sendToAllProcesses(Messages::WebProcess::SetScreenProperties(screenProperties));
    816816}
    817817

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

    r232499 r232535  
    619619    setMaximumUnobscuredSize(parameters.maximumUnobscuredSize);
    620620#endif
    621    
    622 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    623     GraphicsContext3D::setOpenGLDisplayMask(parameters.displayMask);
    624 #endif
    625621}
    626622

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

    r232301 r232535  
    10741074#endif
    10751075
    1076 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    1077     void openGLDisplayMaskChanged(uint32_t displayMask);
    1078 #endif
    1079 
    10801076    UserContentControllerIdentifier userContentControllerIdentifier() const { return m_userContentController->identifier(); }
    10811077

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

    r232280 r232535  
    515515#endif
    516516
    517 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    518     OpenGLDisplayMaskChanged(uint32_t displayMask)
    519 #endif
    520 
    521517    SetDefersLoading(bool defersLoading)
    522518}

  • trunk/Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm

    r232520 r232535  
    11481148#endif
    11491149
    1150 #if ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
    1151 void WebPage::openGLDisplayMaskChanged(uint32_t displayMask)
    1152 {
    1153     GraphicsContext3D::setOpenGLDisplayMask(displayMask);
    1154 }
    1155 #endif
    1156 
    11571150} // namespace WebKit
    11581151

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

    r232516 r232535  
    16861686
    16871687#if PLATFORM(MAC)
    1688 void WebProcess::setScreenProperties(uint32_t primaryScreenID, const HashMap<uint32_t, WebCore::ScreenProperties>& properties)
    1689 {
    1690     WebCore::setScreenProperties(primaryScreenID, properties);
     1688void WebProcess::setScreenProperties(const WebCore::ScreenProperties& properties)
     1689{
     1690    WebCore::setScreenProperties(properties);
    16911691}
    16921692#endif

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

    r232263 r232535  
    372372
    373373#if PLATFORM(MAC)
    374     void setScreenProperties(uint32_t primaryScreenID, const HashMap<uint32_t, WebCore::ScreenProperties>&);
     374    void setScreenProperties(const WebCore::ScreenProperties&);
    375375#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400
    376376    void scrollerStylePreferenceChanged(bool useOverlayScrollbars);

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

    r232136 r232535  
    131131
    132132#if PLATFORM(MAC)
    133     SetScreenProperties(uint32_t primaryScreenID, HashMap<uint32_t, WebCore::ScreenProperties> screenProperties)
     133    SetScreenProperties(struct WebCore::ScreenProperties screenProperties)
    134134#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400
    135135    ScrollerStylePreferenceChanged(bool useOvelayScrollbars)

  • trunk/Source/WebKit/WebProcess/cocoa/WebProcessCocoa.mm

    r232260 r232535  
    194194
    195195#if PLATFORM(MAC)
    196     WebCore::setScreenProperties(parameters.primaryDisplayID, parameters.screenPropertiesMap);
     196    WebCore::setScreenProperties(parameters.screenProperties);
    197197#endif
    198198}
Note: See TracChangeset for help on using the changeset viewer.