⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 286838 in webkit


Ignore:
Timestamp:
Dec 10, 2021, 12:24:30 AM (5 years ago)
Author:
commit-queue@webkit.org
Message:

IOSurface memory attribution is hard to use in constructors
​https://bugs.webkit.org/show_bug.cgi?id=232988
<rdar://problem/85541918>

Patch by Kimmo Kinnunen <​kkinnunen@apple.com> on 2021-12-10
Reviewed by Chris Dumez.

Source/WebCore:

Add WebCore::ProcessIdentity type that can be used to communicate memory attribution.
For non-Cocoa ports, this is nullptr.
This is used in WebCore to set the memory attribution of IOSurface and objects
that hold IOSurfaces.
This is instantiated in WebKit.
Currently the only useful way to instantiate ProcessIdentity is by receiving
the ProcessIdentity as a message and create it this way for the
sender process.

No new tests, refactor.

  • Headers.cmake:
  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • platform/Logging.h:

Add WebCore Process log tag since the code moved from WebKit to ProcessIdentity
used that tag to log.

  • platform/ProcessIdentity.cpp: Added.

(WebCore::ProcessIdentity::ProcessIdentity):
(WebCore::ProcessIdentity::taskIdToken const):
(WebCore::ProcessIdentity::sendRight const):
(WebCore::ProcessIdentity::operator bool const):

  • platform/ProcessIdentity.h: Added.

Add the ProcessIdentity type that can be used to communicate memory attribution.

  • platform/graphics/RemoteVideoSample.h:

(WebCore::RemoteVideoSample::setOwnershipIdentity):

  • platform/graphics/angle/GraphicsContextGLANGLE.h:
  • platform/graphics/cocoa/GraphicsContextGLCocoa.h:
  • platform/graphics/cocoa/GraphicsContextGLCocoa.mm:

(WebCore::GraphicsContextGLCocoa::create):
(WebCore::GraphicsContextGLCocoa::GraphicsContextGLCocoa):
(WebCore::GraphicsContextGLANGLE::allocateAndBindDisplayBufferBacking):
Add an example use where the constructor takes the memory attribution token.
This may be needed in the future when the token is used as a parameter in
the ANGLE context creation.
Use the token in creating the IOSurface. This fixes a bug where WebGL
back buffers would not be attributed until they were sent to WP.

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

(WebCore::IOSurface::setOwnershipIdentity):

  • platform/graphics/cocoa/WebProcessGraphicsContextGLCocoa.mm:

Source/WebKit:

Remove ifdefs and direct use of task_id_token_t.
Instead, use WebCore::ProcessIdentifier. This way the
cross-platform code is easier to author.

  • GPUProcess/GPUConnectionToWebProcess.cpp:

(WebKit::GPUConnectionToWebProcess::GPUConnectionToWebProcess):

  • GPUProcess/GPUConnectionToWebProcess.h:

(WebKit::GPUConnectionToWebProcess::webProcessIdentity const):
(WebKit::GPUConnectionToWebProcess::webProcessIdentityToken const): Deleted.

  • GPUProcess/graphics/RemoteGraphicsContextGLCocoa.cpp:

(WebKit::RemoteGraphicsContextGLCocoa::RemoteGraphicsContextGLCocoa):
(WebKit::RemoteGraphicsContextGLCocoa::platformWorkQueueInitialize):
(WebKit::RemoteGraphicsContextGLCocoa::prepareForDisplay):

  • GPUProcess/graphics/RemoteImageBuffer.h:

(WebKit::RemoteImageBuffer::setOwnershipIdentity):
(WebKit::RemoteImageBuffer::setProcessOwnership): Deleted.

  • GPUProcess/graphics/RemoteRenderingBackend.cpp:

(WebKit::RemoteRenderingBackend::RemoteRenderingBackend):
(WebKit::RemoteRenderingBackend::createImageBufferWithQualifiedIdentifier):

  • GPUProcess/graphics/RemoteRenderingBackend.h:
  • GPUProcess/webrtc/LibWebRTCCodecsProxy.mm:

(WebKit::Function<void):

  • Shared/GPUProcessConnectionParameters.h:

(WebKit::GPUProcessConnectionParameters::encode const):
(WebKit::GPUProcessConnectionParameters::decode):

  • UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp:

(WebKit::UserMediaCaptureManagerProxy::SourceProxy::SourceProxy):
(WebKit::UserMediaCaptureManagerProxy::SourceProxy::setShouldApplyRotation):
(WebKit::UserMediaCaptureManagerProxy::createMediaSourceForCaptureDeviceWithConstraints):
(WebKit::UserMediaCaptureManagerProxy::clone):
(WebKit::UserMediaCaptureManagerProxy::SourceProxy::setWebProcessIdentityToken): Deleted.

  • UIProcess/Cocoa/UserMediaCaptureManagerProxy.h:

(WebKit::UserMediaCaptureManagerProxy::ConnectionProxy::webProcessIdentityToken const): Deleted.

  • UIProcess/WebProcessProxy.cpp:
  • WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h:

(WebKit::ImageBufferShareableBitmapBackend::setOwnershipIdentity):

  • WebProcess/GPU/graphics/cocoa/ImageBufferShareableMappedIOSurfaceBackend.cpp:

(WebKit::ImageBufferShareableMappedIOSurfaceBackend::setOwnershipIdentity):
(WebKit::ImageBufferShareableMappedIOSurfaceBackend::setProcessOwnership): Deleted.

  • WebProcess/GPU/graphics/cocoa/ImageBufferShareableMappedIOSurfaceBackend.h:
  • WebProcess/cocoa/WebProcessCocoa.mm:

(WebKit::WebProcess::platformInitializeGPUProcessConnectionParameters):

Tools:

Update constructor calling base class constructor, add empty
ProcesseIdentity.

  • TestWebKitAPI/Tests/WebCore/cocoa/TestGraphicsContextGLCocoa.mm:
Location:
trunk
Files:
1 added
30 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r286837 r286838  
     12021-12-10  Kimmo Kinnunen  <kkinnunen@apple.com>
     2
     3        IOSurface memory attribution is hard to use in constructors
     4        https://bugs.webkit.org/show_bug.cgi?id=232988
     5        <rdar://problem/85541918>
     6
     7        Reviewed by Chris Dumez.
     8
     9        Add WebCore::ProcessIdentity type that can be used to communicate memory attribution.
     10        For non-Cocoa ports, this is nullptr.
     11        This is used in WebCore to set the memory attribution of IOSurface and objects
     12        that hold IOSurfaces.
     13        This is instantiated in WebKit.
     14        Currently the only useful way to instantiate ProcessIdentity is by receiving
     15        the ProcessIdentity as a message and create it this way for the
     16        sender process.
     17
     18        No new tests, refactor.
     19
     20        * Headers.cmake:
     21        * Sources.txt:
     22        * WebCore.xcodeproj/project.pbxproj:
     23        * platform/Logging.h:
     24        Add WebCore Process log tag since the code moved from WebKit to ProcessIdentity
     25        used that tag to log.
     26        * platform/ProcessIdentity.cpp: Added.
     27        (WebCore::ProcessIdentity::ProcessIdentity):
     28        (WebCore::ProcessIdentity::taskIdToken const):
     29        (WebCore::ProcessIdentity::sendRight const):
     30        (WebCore::ProcessIdentity::operator bool const):
     31        * platform/ProcessIdentity.h: Added.
     32        Add the ProcessIdentity type that can be used to communicate memory attribution.
     33        * platform/graphics/RemoteVideoSample.h:
     34        (WebCore::RemoteVideoSample::setOwnershipIdentity):
     35        * platform/graphics/angle/GraphicsContextGLANGLE.h:
     36        * platform/graphics/cocoa/GraphicsContextGLCocoa.h:
     37        * platform/graphics/cocoa/GraphicsContextGLCocoa.mm:
     38        (WebCore::GraphicsContextGLCocoa::create):
     39        (WebCore::GraphicsContextGLCocoa::GraphicsContextGLCocoa):
     40        (WebCore::GraphicsContextGLANGLE::allocateAndBindDisplayBufferBacking):
     41        Add an example use where the constructor takes the memory attribution token.
     42        This may be needed in the future when the token is used as a parameter in
     43        the ANGLE context creation.
     44        Use the token in creating the IOSurface. This fixes a bug where WebGL
     45        back buffers would not be attributed until they were sent to WP.
     46        * platform/graphics/cocoa/IOSurface.h:
     47        * platform/graphics/cocoa/IOSurface.mm:
     48        (WebCore::IOSurface::setOwnershipIdentity):
     49        * platform/graphics/cocoa/WebProcessGraphicsContextGLCocoa.mm:
     50
    1512021-12-10  Adrian Perez de Castro  <aperez@igalia.com>
    252

  • trunk/Source/WebCore/Headers.cmake

    r286824 r286838  
    12921292    platform/PopupMenuStyle.h
    12931293    platform/ProcessIdentifier.h
     1294    platform/ProcessIdentity.h
    12941295    platform/ProcessQualified.h
    12951296    platform/PromisedAttachmentInfo.h

  • trunk/Source/WebCore/Sources.txt

    r286821 r286838  
    18871887platform/PreviewConverter.cpp
    18881888platform/ProcessIdentifier.cpp
     1889platform/ProcessIdentity.cpp
    18891890platform/ReferrerPolicy.cpp
    18901891platform/RemoteCommandListener.cpp

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r286824 r286838  
    23922392                7BB680BA25BA1BE4002B8738 /* GraphicsChecksMac.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BB680B825BA1BE4002B8738 /* GraphicsChecksMac.h */; settings = {ATTRIBUTES = (Private, ); }; };
    23932393                7BDDA31F274FA0210038659E /* GraphicsContextGLCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BDDA31D274F9DA50038659E /* GraphicsContextGLCocoa.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2394                7BDDA34C275A01310038659E /* ProcessIdentity.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BDDA349275A01300038659E /* ProcessIdentity.h */; settings = {ATTRIBUTES = (Private, ); }; };
    23942395                7BE7427381FA906FBB4F0F2C /* JSSVGGraphicsElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 950C4C02BED8936F818E2F99 /* JSSVGGraphicsElement.h */; };
    23952396                7BFF59F42757726700773D39 /* DisplayConfigurationMonitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BFF59EF275771E800773D39 /* DisplayConfigurationMonitor.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    1141911420                7BDDA31C274F9DA40038659E /* GraphicsContextGLCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = GraphicsContextGLCocoa.mm; sourceTree = "<group>"; };
    1142011421                7BDDA31D274F9DA50038659E /* GraphicsContextGLCocoa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GraphicsContextGLCocoa.h; sourceTree = "<group>"; };
     11422                7BDDA349275A01300038659E /* ProcessIdentity.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProcessIdentity.h; sourceTree = "<group>"; };
     11423                7BDDA34B275A01300038659E /* ProcessIdentity.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProcessIdentity.cpp; sourceTree = "<group>"; };
    1142111424                7BE7265B25763B8D00E85D98 /* RemoteGraphicsContextGLProxyBase.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteGraphicsContextGLProxyBase.cpp; sourceTree = "<group>"; };
    1142211425                7BFF59EF275771E800773D39 /* DisplayConfigurationMonitor.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; path = DisplayConfigurationMonitor.h; sourceTree = "<group>"; };
    … …  
    2977929782                                51F645D21FECDBC800B54DED /* ProcessIdentifier.cpp */,
    2978029783                                51F645D31FECDBC800B54DED /* ProcessIdentifier.h */,
     29784                                7BDDA34B275A01300038659E /* ProcessIdentity.cpp */,
     29785                                7BDDA349275A01300038659E /* ProcessIdentity.h */,
    2978129786                                1CC54AFB270F92DA005BF8BE /* ProcessQualified.h */,
    2978229787                                F47A633C1FF6FD500081B3CC /* PromisedAttachmentInfo.h */,
    … …  
    3632136326                                6B0A07F221FA4B5C00D57391 /* PrivateClickMeasurement.h in Headers */,
    3632236327                                51F645D51FECDBCE00B54DED /* ProcessIdentifier.h in Headers */,
     36328                                7BDDA34C275A01310038659E /* ProcessIdentity.h in Headers */,
    3632336329                                A8EA7EBC0A1945D000A8EF5F /* ProcessingInstruction.h in Headers */,
    3632436330                                1CC54AFE270F96AE005BF8BE /* ProcessQualified.h in Headers */,

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

    r285528 r286838  
    9595    M(PopupBlocking) \
    9696    M(PrivateClickMeasurement) \
     97    M(Process) \
    9798    M(Progress) \
    9899    M(RemoteInspector) \

  • trunk/Source/WebCore/platform/ProcessIdentity.cpp

    r286837 r286838  
    11/*
    2  * Copyright (C) 2020 Apple Inc. All rights reserved.
     2 * Copyright (C) 2021 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2424 */
    2525
    26 #pragma once
     26#include "config.h"
     27#include "ProcessIdentity.h"
    2728
    28 #if ENABLE(GPU_PROCESS) && HAVE(IOSURFACE)
     29#include "Logging.h"
    2930
    30 #include "ImageBufferBackendHandle.h"
    31 #include <WebCore/ImageBufferIOSurfaceBackend.h>
    32 #include <wtf/IsoMalloc.h>
     31#if HAVE(TASK_IDENTITY_TOKEN)
     32#include <mach/mach.h>
     33#endif
    3334
    34 namespace WebKit {
     35namespace WebCore {
    3536
    36 class ShareableBitmap;
     37ProcessIdentity::ProcessIdentity(CurrentProcessTag)
     38{
     39#if HAVE(TASK_IDENTITY_TOKEN)
     40    task_id_token_t identityToken;
     41    kern_return_t kr = task_create_identity_token(mach_task_self(), &identityToken);
     42    if (kr == KERN_SUCCESS)
     43        m_taskIdToken = MachSendRight::adopt(identityToken);
     44    else
     45        RELEASE_LOG_ERROR(Process, "task_create_identity_token() failed: %{private}s (%x)", mach_error_string(kr), kr);
     46#endif
     47}
    3748
    38 class ImageBufferShareableMappedIOSurfaceBackend final : public WebCore::ImageBufferIOSurfaceBackend {
    39     WTF_MAKE_ISO_ALLOCATED(ImageBufferShareableMappedIOSurfaceBackend);
    40     WTF_MAKE_NONCOPYABLE(ImageBufferShareableMappedIOSurfaceBackend);
    41 public:
    42     static std::unique_ptr<ImageBufferShareableMappedIOSurfaceBackend> create(const Parameters&, const WebCore::HostWindow*);
    43     static std::unique_ptr<ImageBufferShareableMappedIOSurfaceBackend> create(const Parameters&, ImageBufferBackendHandle);
     49ProcessIdentity::operator bool() const
     50{
     51#if HAVE(TASK_IDENTITY_TOKEN)
     52    return static_cast<bool>(m_taskIdToken);
     53#else
     54    return false;
     55#endif
     56}
    4457
    45     using WebCore::ImageBufferIOSurfaceBackend::ImageBufferIOSurfaceBackend;
     58#if HAVE(TASK_IDENTITY_TOKEN)
     59ProcessIdentity::ProcessIdentity(MachSendRight&& taskIdToken)
     60    : m_taskIdToken(WTFMove(taskIdToken))
     61{
     62}
     63#endif
    4664
    47     ImageBufferBackendHandle createImageBufferBackendHandle() const;
    48 
    49 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    50     void setProcessOwnership(task_id_token_t);
    51 #endif
    52 };
    53 
    54 } // namespace WebKit
    55 
    56 #endif // ENABLE(GPU_PROCESS) && HAVE(IOSURFACE)
     65}

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

    r284857 r286838  
    3838namespace WebCore {
    3939
     40class ProcessIdentity;
     41
    4042class RemoteVideoSample {
    4143public:
    … …  
    4951    WEBCORE_EXPORT IOSurfaceRef surface() const;
    5052
    51 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    52     void setOwnershipIdentity(task_id_token_t newOwner);
    53 #endif
     53    void setOwnershipIdentity(const ProcessIdentity&);
    5454
    5555    const MediaTime& time() const { return m_time; }
    … …  
    120120};
    121121
    122 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    123 inline void RemoteVideoSample::setOwnershipIdentity(task_id_token_t newOwner)
     122inline void RemoteVideoSample::setOwnershipIdentity(const ProcessIdentity& resourceOwner)
    124123{
    125124    if (m_ioSurface)
    126         m_ioSurface->setOwnershipIdentity(newOwner);
     125        m_ioSurface->setOwnershipIdentity(resourceOwner);
    127126}
    128 #endif
    129127
    130128}

  • trunk/Source/WebCore/platform/graphics/angle/GraphicsContextGLANGLE.h

    r286423 r286838  
    3737#include "GraphicsContextGLIOSurfaceSwapChain.h"
    3838#include "IOSurface.h"
     39#include "ProcessIdentity.h"
    3940#endif
    4041
    … …  
    428429
    429430#if PLATFORM(COCOA)
     431    // FIXME: Move these to GraphicsContextGLCocoa.
    430432    GraphicsContextGLIOSurfaceSwapChain m_swapChain;
    431433    EGLDisplay m_displayObj { nullptr };
    … …  
    437439    std::unique_ptr<IOSurface> m_displayBufferBacking;
    438440    void* m_displayBufferPbuffer { nullptr };
     441    ProcessIdentity m_resourceOwner;
    439442#endif
    440443#if USE(COORDINATED_GRAPHICS)

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

    r286709 r286838  
    4343namespace WebCore {
    4444
     45class ProcessIdentity;
     46
    4547class WEBCORE_EXPORT GraphicsContextGLCocoa : public GraphicsContextGLANGLE {
    4648public:
    47     static RefPtr<GraphicsContextGLCocoa> create(WebCore::GraphicsContextGLAttributes&&);
     49    static RefPtr<GraphicsContextGLCocoa> create(WebCore::GraphicsContextGLAttributes&&, ProcessIdentity&& resourceOwner);
    4850    ~GraphicsContextGLCocoa();
    4951    IOSurface* displayBuffer();
    … …  
    7779#endif
    7880protected:
    79     GraphicsContextGLCocoa(WebCore::GraphicsContextGLAttributes&&);
     81    GraphicsContextGLCocoa(WebCore::GraphicsContextGLAttributes&&, ProcessIdentity&& resourceOwner);
    8082    bool isValid() const;
    81 
    8283#if ENABLE(VIDEO)
    8384    std::unique_ptr<GraphicsContextGLCVCocoa> m_cv;

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

    r286709 r286838  
    3636#import "GraphicsContextGLOpenGLManager.h"
    3737#import "Logging.h"
     38#import "ProcessIdentity.h"
    3839#import "RuntimeApplicationChecks.h"
    3940#import <CoreGraphics/CGBitmapContext.h>
    … …  
    193194#endif
    194195
    195 RefPtr<GraphicsContextGLCocoa> GraphicsContextGLCocoa::create(GraphicsContextGLAttributes&& attributes)
    196 {
    197     auto context = adoptRef(*new GraphicsContextGLCocoa(WTFMove(attributes)));
     196RefPtr<GraphicsContextGLCocoa> GraphicsContextGLCocoa::create(GraphicsContextGLAttributes&& attributes, ProcessIdentity&& resourceOwner)
     197{
     198    auto context = adoptRef(*new GraphicsContextGLCocoa(WTFMove(attributes), WTFMove(resourceOwner)));
    198199    if (!context->isValid())
    199200        return nullptr;
    … …  
    201202}
    202203
    203 GraphicsContextGLCocoa::GraphicsContextGLCocoa(GraphicsContextGLAttributes&& creationAttributes)
     204GraphicsContextGLCocoa::GraphicsContextGLCocoa(GraphicsContextGLAttributes&& creationAttributes, ProcessIdentity&& resourceOwner)
    204205    : GraphicsContextGLANGLE(WTFMove(creationAttributes))
    205206{
    206207    if (!isValid())
    207208        return;
     209    // FIXME: Move this to initializer list once m_resourceOwner moves to GraphicsContextGLCocoa.
     210    m_resourceOwner = WTFMove(resourceOwner);
     211
    208212#if PLATFORM(MAC)
    209213    auto attributes = contextAttributes();
    … …  
    558562    if (!backing)
    559563        return false;
    560 
     564    if (m_resourceOwner)
     565        backing->setOwnershipIdentity(m_resourceOwner);
    561566    backing->migrateColorSpaceToProperties();
    562567

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

    r284857 r286838  
    4747class HostWindow;
    4848class ImageBuffer;
     49class ProcessIdentity;
    4950
    5051enum class PixelFormat : uint8_t;
    … …  
    160161#endif // HAVE(IOSURFACE_ACCELERATOR)
    161162
    162 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    163     WEBCORE_EXPORT void setOwnershipIdentity(task_id_token_t newOwner);
    164 #endif
     163    WEBCORE_EXPORT void setOwnershipIdentity(const ProcessIdentity&);
    165164
    166165    void migrateColorSpaceToProperties();

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

    r286816 r286838  
    3535#import "Logging.h"
    3636#import "PlatformScreen.h"
     37#import "ProcessIdentity.h"
    3738#import <pal/spi/cg/CoreGraphicsSPI.h>
    3839#import <wtf/Assertions.h>
    … …  
    485486#endif // HAVE(IOSURFACE_ACCELERATOR)
    486487
    487 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    488 void IOSurface::setOwnershipIdentity(task_id_token_t newOwner)
    489 {
    490     auto result = IOSurfaceSetOwnershipIdentity(m_surface.get(), newOwner, kIOSurfaceMemoryLedgerTagGraphics, 0);
     488void IOSurface::setOwnershipIdentity(const ProcessIdentity& resourceOwner)
     489{
     490#if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY) && HAVE(TASK_IDENTITY_TOKEN)
     491    ASSERT(resourceOwner);
     492    task_id_token_t ownerTaskIdToken = resourceOwner.taskIdToken();
     493    auto result = IOSurfaceSetOwnershipIdentity(m_surface.get(), ownerTaskIdToken, kIOSurfaceMemoryLedgerTagGraphics, 0);
    491494    if (result != kIOReturnSuccess)
    492         RELEASE_LOG_ERROR(IOSurface, "IOSurface::setOwnershipIdentity: Failed to claim ownership of IOSurface %p, newOwner: %d, error: %d", m_surface.get(), (int)newOwner, result);
    493 }
    494 #endif
     495        RELEASE_LOG_ERROR(IOSurface, "IOSurface::setOwnershipIdentity: Failed to claim ownership of IOSurface %p, task id token: %d, error: %d", m_surface.get(), (int)ownerTaskIdToken, result);
     496#else
     497    UNUSED_PARAM(resourceOwner);
     498#endif
     499}
    495500
    496501void IOSurface::migrateColorSpaceToProperties()

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

    r286709 r286838  
    3030#import "GraphicsContextGLCocoa.h" // NOLINT
    3131#import "GraphicsContextGLOpenGLManager.h"
     32#import "ProcessIdentity.h"
    3233#import "WebGLLayer.h"
    3334#import <wtf/BlockObjCExceptions.h>
    … …  
    7879
    7980WebProcessGraphicsContextGLCocoa::WebProcessGraphicsContextGLCocoa(GraphicsContextGLAttributes&& attributes)
    80     : GraphicsContextGLCocoa(WTFMove(attributes))
     81    : GraphicsContextGLCocoa(WTFMove(attributes), { })
    8182    , m_webGLLayer(createWebGLLayer(contextAttributes()))
    8283{

  • trunk/Source/WebKit/ChangeLog

    r286837 r286838  
     12021-12-10  Kimmo Kinnunen  <kkinnunen@apple.com>
     2
     3        IOSurface memory attribution is hard to use in constructors
     4        https://bugs.webkit.org/show_bug.cgi?id=232988
     5        <rdar://problem/85541918>
     6
     7        Reviewed by Chris Dumez.
     8
     9        Remove ifdefs and direct use of task_id_token_t.
     10        Instead, use WebCore::ProcessIdentifier. This way the
     11        cross-platform code is easier to author.
     12
     13        * GPUProcess/GPUConnectionToWebProcess.cpp:
     14        (WebKit::GPUConnectionToWebProcess::GPUConnectionToWebProcess):
     15        * GPUProcess/GPUConnectionToWebProcess.h:
     16        (WebKit::GPUConnectionToWebProcess::webProcessIdentity const):
     17        (WebKit::GPUConnectionToWebProcess::webProcessIdentityToken const): Deleted.
     18        * GPUProcess/graphics/RemoteGraphicsContextGLCocoa.cpp:
     19        (WebKit::RemoteGraphicsContextGLCocoa::RemoteGraphicsContextGLCocoa):
     20        (WebKit::RemoteGraphicsContextGLCocoa::platformWorkQueueInitialize):
     21        (WebKit::RemoteGraphicsContextGLCocoa::prepareForDisplay):
     22        * GPUProcess/graphics/RemoteImageBuffer.h:
     23        (WebKit::RemoteImageBuffer::setOwnershipIdentity):
     24        (WebKit::RemoteImageBuffer::setProcessOwnership): Deleted.
     25        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
     26        (WebKit::RemoteRenderingBackend::RemoteRenderingBackend):
     27        (WebKit::RemoteRenderingBackend::createImageBufferWithQualifiedIdentifier):
     28        * GPUProcess/graphics/RemoteRenderingBackend.h:
     29        * GPUProcess/webrtc/LibWebRTCCodecsProxy.mm:
     30        (WebKit::Function<void):
     31        * Shared/GPUProcessConnectionParameters.h:
     32        (WebKit::GPUProcessConnectionParameters::encode const):
     33        (WebKit::GPUProcessConnectionParameters::decode):
     34        * UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp:
     35        (WebKit::UserMediaCaptureManagerProxy::SourceProxy::SourceProxy):
     36        (WebKit::UserMediaCaptureManagerProxy::SourceProxy::setShouldApplyRotation):
     37        (WebKit::UserMediaCaptureManagerProxy::createMediaSourceForCaptureDeviceWithConstraints):
     38        (WebKit::UserMediaCaptureManagerProxy::clone):
     39        (WebKit::UserMediaCaptureManagerProxy::SourceProxy::setWebProcessIdentityToken): Deleted.
     40        * UIProcess/Cocoa/UserMediaCaptureManagerProxy.h:
     41        (WebKit::UserMediaCaptureManagerProxy::ConnectionProxy::webProcessIdentityToken const): Deleted.
     42        * UIProcess/WebProcessProxy.cpp:
     43        * WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h:
     44        (WebKit::ImageBufferShareableBitmapBackend::setOwnershipIdentity):
     45        * WebProcess/GPU/graphics/cocoa/ImageBufferShareableMappedIOSurfaceBackend.cpp:
     46        (WebKit::ImageBufferShareableMappedIOSurfaceBackend::setOwnershipIdentity):
     47        (WebKit::ImageBufferShareableMappedIOSurfaceBackend::setProcessOwnership): Deleted.
     48        * WebProcess/GPU/graphics/cocoa/ImageBufferShareableMappedIOSurfaceBackend.h:
     49        * WebProcess/cocoa/WebProcessCocoa.mm:
     50        (WebKit::WebProcess::platformInitializeGPUProcessConnectionParameters):
     51
    1522021-12-10  Adrian Perez de Castro  <aperez@igalia.com>
    253

  • trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.cpp

    r286650 r286838  
    208208    }
    209209#endif
    210 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    211     std::optional<task_id_token_t> webProcessIdentityToken() const final
     210
     211    const ProcessIdentity& resourceOwner() const final
    212212    {
    213         return m_process.webProcessIdentityToken();
    214     }
    215 #endif
     213        return m_process.webProcessIdentity();
     214    }
    216215
    217216    GPUConnectionToWebProcess& m_process;
    … …  
    229228    , m_gpuProcess(gpuProcess)
    230229    , m_webProcessIdentifier(webProcessIdentifier)
    231 #if HAVE(TASK_IDENTITY_TOKEN)
    232     , m_webProcessIdentityToken(WTFMove(parameters.webProcessIdentityToken))
    233 #endif
     230    , m_webProcessIdentity(WTFMove(parameters.webProcessIdentity))
    234231    , m_remoteMediaPlayerManagerProxy(makeUniqueRef<RemoteMediaPlayerManagerProxy>(*this))
    235232    , m_sessionID(sessionID)

  • trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.h

    r286650 r286838  
    4242#include <WebCore/PageIdentifier.h>
    4343#include <WebCore/ProcessIdentifier.h>
     44#include <WebCore/ProcessIdentity.h>
    4445#include <pal/SessionID.h>
    4546#include <wtf/Logger.h>
    … …  
    156157#endif
    157158
    158 #if HAVE(TASK_IDENTITY_TOKEN)
    159     task_id_token_t webProcessIdentityToken() const { return static_cast<task_id_token_t>(m_webProcessIdentityToken.sendRight()); }
    160 #endif
    161 
     159    const WebCore::ProcessIdentity& webProcessIdentity() const { return m_webProcessIdentity; }
    162160#if ENABLE(ENCRYPTED_MEDIA)
    163161    RemoteCDMFactoryProxy& cdmFactoryProxy();
    … …  
    284282    Ref<GPUProcess> m_gpuProcess;
    285283    const WebCore::ProcessIdentifier m_webProcessIdentifier;
    286 #if HAVE(TASK_IDENTITY_TOKEN)
    287     MachSendRight m_webProcessIdentityToken;
    288 #endif
     284    const WebCore::ProcessIdentity m_webProcessIdentity;
    289285#if ENABLE(WEB_AUDIO)
    290286    std::unique_ptr<RemoteAudioDestinationManager> m_remoteAudioDestinationManager;

  • trunk/Source/WebKit/GPUProcess/graphics/RemoteGraphicsContextGLCocoa.cpp

    r286709 r286838  
    3030
    3131#include "GPUConnectionToWebProcess.h"
     32#include <WebCore/ProcessIdentity.h>
    3233#include <wtf/MachSendRight.h>
    3334
    … …  
    4647    void prepareForDisplay(CompletionHandler<void(WTF::MachSendRight&&)>&&) final;
    4748private:
    48 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    49     task_id_token_t m_webProcessIdentityToken;
    50 #endif
     49    const ProcessIdentity m_resourceOwner;
    5150};
    5251
    … …  
    6261RemoteGraphicsContextGLCocoa::RemoteGraphicsContextGLCocoa(GPUConnectionToWebProcess& gpuConnectionToWebProcess, GraphicsContextGLIdentifier graphicsContextGLIdentifier, RemoteRenderingBackend& renderingBackend, IPC::StreamConnectionBuffer&& stream)
    6362    : RemoteGraphicsContextGL(gpuConnectionToWebProcess, graphicsContextGLIdentifier, renderingBackend, WTFMove(stream))
    64 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    65     , m_webProcessIdentityToken(gpuConnectionToWebProcess.webProcessIdentityToken())
    66 #endif
     63    , m_resourceOwner(gpuConnectionToWebProcess.webProcessIdentity())
    6764{
    6865
    … …  
    7269{
    7370    assertIsCurrent(m_streamThread);
    74     m_context = GraphicsContextGLCocoa::create(WTFMove(attributes));
     71    m_context = GraphicsContextGLCocoa::create(WTFMove(attributes), ProcessIdentity { m_resourceOwner });
    7572}
    7673
    … …  
    8380    if (displayBuffer) {
    8481        m_context->markDisplayBufferInUse();
    85 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    86         // Mark the IOSurface as being owned by the WebProcess even though it was constructed by the GPUProcess so that Jetsam knows which process to kill.
    87         displayBuffer->setOwnershipIdentity(m_webProcessIdentityToken);
    88 #endif
    8982        sendRight = displayBuffer->createSendRight();
    9083    }

  • trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h

    r284079 r286838  
    7070    }
    7171
    72 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    73     void setProcessOwnership(task_id_token_t newOwner)
     72    void setOwnershipIdentity(const WebCore::ProcessIdentity& resourceOwner)
    7473    {
    7574        if (m_backend)
    76             m_backend->setProcessOwnership(newOwner);
     75            m_backend->setOwnershipIdentity(resourceOwner);
    7776    }
    78 #endif
    7977
    8078private:

  • trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp

    r286538 r286838  
    8686    , m_remoteResourceCache(gpuConnectionToWebProcess.webProcessIdentifier())
    8787    , m_gpuConnectionToWebProcess(gpuConnectionToWebProcess)
     88    , m_resourceOwner(gpuConnectionToWebProcess.webProcessIdentity())
    8889    , m_renderingBackendIdentifier(creationParameters.identifier)
    8990{
    … …  
    175176    if (renderingMode == RenderingMode::Accelerated) {
    176177        if (auto acceleratedImageBuffer = AcceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, pixelFormat, *this, imageBufferResourceIdentifier)) {
    177 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    178178            // Mark the IOSurface as being owned by the WebProcess even though it was constructed by the GPUProcess so that Jetsam knows which process to kill.
    179             acceleratedImageBuffer->setProcessOwnership(m_gpuConnectionToWebProcess->webProcessIdentityToken());
    180 #endif
     179            if (m_resourceOwner)
     180                acceleratedImageBuffer->setOwnershipIdentity(m_resourceOwner);
    181181            imageBuffer = WTFMove(acceleratedImageBuffer);
    182182        }

  • trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h

    r286538 r286838  
    4747#include <WebCore/DisplayListReplayer.h>
    4848#include <WebCore/ProcessIdentifier.h>
     49#include <WebCore/ProcessIdentity.h>
    4950#include <wtf/WeakPtr.h>
    5051
    … …  
    134135    RemoteResourceCache m_remoteResourceCache;
    135136    Ref<GPUConnectionToWebProcess> m_gpuConnectionToWebProcess;
     137    WebCore::ProcessIdentity m_resourceOwner;
    136138    RenderingBackendIdentifier m_renderingBackendIdentifier;
    137139    IPC::Semaphore m_getPixelBufferSemaphore;

  • trunk/Source/WebKit/GPUProcess/webrtc/LibWebRTCCodecsProxy.mm

    r283369 r286838  
    7777static Function<void(CVPixelBufferRef pixelBuffer, uint32_t timeStampNs, uint32_t timeStamp)> createDecoderCallback(RTCDecoderIdentifier identifier, GPUConnectionToWebProcess& gpuConnectionToWebProcess)
    7878{
    79     return [connection = Ref { gpuConnectionToWebProcess.connection() },
    80 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    81         token = gpuConnectionToWebProcess.webProcessIdentityToken(),
    82 #endif
    83         identifier](CVPixelBufferRef pixelBuffer, uint32_t timeStampNs, uint32_t timeStamp) {
     79    return [connection = Ref { gpuConnectionToWebProcess.connection() }, resourceOwner = gpuConnectionToWebProcess.webProcessIdentity(), identifier] (CVPixelBufferRef pixelBuffer, uint32_t timeStampNs, uint32_t timeStamp) {
    8480        if (auto sample = WebCore::RemoteVideoSample::create(pixelBuffer, MediaTime(timeStampNs, 1))) {
    85 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    86             sample->setOwnershipIdentity(token);
    87 #endif
     81            if (resourceOwner)
     82                sample->setOwnershipIdentity(resourceOwner);
    8883            connection->send(Messages::LibWebRTCCodecs::CompletedDecoding { identifier, timeStamp, *sample }, 0);
    8984        }

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

    r285979 r286838  
    2929
    3030#include "WebCoreArgumentCoders.h"
     31#include <WebCore/ProcessIdentity.h>
    3132#include <wtf/MachSendRight.h>
    3233
    … …  
    3435
    3536struct GPUProcessConnectionParameters {
    36 #if HAVE(TASK_IDENTITY_TOKEN)
    37     MachSendRight webProcessIdentityToken;
    38 #endif
     37    WebCore::ProcessIdentity webProcessIdentity;
    3938    Vector<String> overrideLanguages;
    4039#if ENABLE(IPC_TESTING_API)
    … …  
    4746    void encode(IPC::Encoder& encoder) const
    4847    {
    49 #if HAVE(TASK_IDENTITY_TOKEN)
    50         encoder << webProcessIdentityToken;
    51 #endif
     48        encoder << webProcessIdentity;
    5249        encoder << overrideLanguages;
    5350#if ENABLE(IPC_TESTING_API)
    … …  
    6158    static std::optional<GPUProcessConnectionParameters> decode(IPC::Decoder& decoder)
    6259    {
    63 #if HAVE(TASK_IDENTITY_TOKEN)
    64         std::optional<MachSendRight> webProcessIdentityToken;
    65         decoder >> webProcessIdentityToken;
    66         if (!webProcessIdentityToken)
     60        std::optional<WebCore::ProcessIdentity> webProcessIdentity;
     61        decoder >> webProcessIdentity;
     62        if (!webProcessIdentity)
    6763            return std::nullopt;
    68 #endif
    6964
    7065        std::optional<Vector<String>> overrideLanguages;
    … …  
    8782
    8883        return GPUProcessConnectionParameters {
    89 #if HAVE(TASK_IDENTITY_TOKEN)
    90             WTFMove(*webProcessIdentityToken),
    91 #endif
     84            WTFMove(*webProcessIdentity),
    9285            WTFMove(*overrideLanguages),
    9386#if ENABLE(IPC_TESTING_API)

  • trunk/Source/WebKit/UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp

    r286650 r286838  
    5858    WTF_MAKE_FAST_ALLOCATED;
    5959public:
    60     SourceProxy(RealtimeMediaSourceIdentifier id, Ref<IPC::Connection>&& connection, Ref<RealtimeMediaSource>&& source)
     60    SourceProxy(RealtimeMediaSourceIdentifier id, Ref<IPC::Connection>&& connection, ProcessIdentity&& resourceOwner, Ref<RealtimeMediaSource>&& source)
    6161        : m_id(id)
    6262        , m_connection(WTFMove(connection))
     63        , m_resourceOwner(WTFMove(resourceOwner))
    6364        , m_source(WTFMove(source))
    6465    {
    … …  
    126127
    127128    void setShouldApplyRotation(bool shouldApplyRotation) { m_shouldApplyRotation = true; }
    128 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    129     void setWebProcessIdentityToken(std::optional<task_id_token_t> token) { m_webProcessIdentityToken = token;}
    130 #endif
    131129
    132130private:
    … …  
    189187            remoteSample = RemoteVideoSample::create(sample);
    190188        if (remoteSample) {
    191 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    192             if (m_webProcessIdentityToken)
    193                 remoteSample->setOwnershipIdentity(*m_webProcessIdentityToken);
    194 #endif
     189            if (m_resourceOwner)
     190                remoteSample->setOwnershipIdentity(m_resourceOwner);
    195191            m_connection->send(Messages::RemoteCaptureSampleManager::VideoSampleAvailable(m_id, WTFMove(*remoteSample), metadata), 0);
    196192        }
    … …  
    245241    WeakPtr<PlatformMediaSessionManager> m_sessionManager;
    246242    Ref<IPC::Connection> m_connection;
     243    ProcessIdentity m_resourceOwner;
    247244    Ref<RealtimeMediaSource> m_source;
    248245    std::unique_ptr<CARingBuffer> m_ringBuffer;
    … …  
    258255    MediaTime m_startTime;
    259256    bool m_shouldReset { false };
    260 #if HAVE(TASK_IDENTITY_TOKEN)
    261     std::optional<task_id_token_t> m_webProcessIdentityToken;
    262 #endif
    263257};
    264258
    … …  
    324318
    325319        ASSERT(!m_proxies.contains(id));
    326         auto proxy = makeUnique<SourceProxy>(id, m_connectionProxy->connection(), WTFMove(source));
    327 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    328         if (device.type() != WebCore::CaptureDevice::DeviceType::Microphone)
    329             proxy->setWebProcessIdentityToken(m_connectionProxy->webProcessIdentityToken());
    330 #endif
    331 
     320        auto proxy = makeUnique<SourceProxy>(id, m_connectionProxy->connection(), ProcessIdentity { m_connectionProxy->resourceOwner() }, WTFMove(source));
    332321        m_proxies.add(id, WTFMove(proxy));
    333322    } else
    … …  
    395384    MESSAGE_CHECK(!m_proxies.contains(newSourceID));
    396385    if (auto* proxy = m_proxies.get(clonedID))
    397         m_proxies.add(newSourceID, makeUnique<SourceProxy>(newSourceID, m_connectionProxy->connection(), proxy->source().clone()));
     386        m_proxies.add(newSourceID, makeUnique<SourceProxy>(newSourceID, m_connectionProxy->connection(), ProcessIdentity { m_connectionProxy->resourceOwner() }, proxy->source().clone()));
    398387}
    399388

  • trunk/Source/WebKit/UIProcess/Cocoa/UserMediaCaptureManagerProxy.h

    r286650 r286838  
    3333#include <WebCore/CaptureDevice.h>
    3434#include <WebCore/OrientationNotifier.h>
     35#include <WebCore/ProcessIdentity.h>
    3536#include <WebCore/RealtimeMediaSource.h>
    3637#include <WebCore/RealtimeMediaSourceIdentifier.h>
    … …  
    6061        virtual Logger& logger() = 0;
    6162        virtual bool setCaptureAttributionString() { return true; }
    62 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    63         virtual std::optional<task_id_token_t> webProcessIdentityToken() const { return { }; };
    64 #endif
     63        virtual const WebCore::ProcessIdentity& resourceOwner() const = 0;
    6564#if ENABLE(APP_PRIVACY_REPORT)
    6665        virtual void setTCCIdentity() { }

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

    r286800 r286838  
    217217    }
    218218
     219    const WebCore::ProcessIdentity& resourceOwner() const final
     220    {
     221        // FIXME: should obtain WebContent process identity from WebContent.
     222        static NeverDestroyed<WebCore::ProcessIdentity> dummy;
     223        return dummy.get();
     224    }
     225
    219226    RefPtr<Logger> m_logger;
    220227    WebProcessProxy& m_process;

  • trunk/Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h

    r278253 r286838  
    3232#include <wtf/IsoMalloc.h>
    3333
     34namespace WebCore {
     35class ProcessIdentity;
     36}
     37
    3438namespace WebKit {
    3539
    … …  
    6266    void putPixelBuffer(const WebCore::PixelBuffer&, const WebCore::IntRect& srcRect, const WebCore::IntPoint& destPoint, WebCore::AlphaPremultiplication destFormat) override;
    6367
     68    void setOwnershipIdentity(const WebCore::ProcessIdentity&) { }
    6469private:
    6570    unsigned bytesPerRow() const override;

  • trunk/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableMappedIOSurfaceBackend.cpp

    r284095 r286838  
    7878}
    7979
    80 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    81 void ImageBufferShareableMappedIOSurfaceBackend::setProcessOwnership(task_id_token_t processIdentityToken)
     80void ImageBufferShareableMappedIOSurfaceBackend::setOwnershipIdentity(const WebCore::ProcessIdentity& resourceOwner)
    8281{
    8382    ASSERT(surface());
    84     surface()->setOwnershipIdentity(processIdentityToken);
     83    surface()->setOwnershipIdentity(resourceOwner);
    8584}
    86 #endif
    8785
    8886} // namespace WebKit

  • trunk/Source/WebKit/WebProcess/GPU/graphics/cocoa/ImageBufferShareableMappedIOSurfaceBackend.h

    r273903 r286838  
    3232#include <wtf/IsoMalloc.h>
    3333
     34namespace WebCore {
     35class ProcessIdentity;
     36}
     37
    3438namespace WebKit {
    3539
    … …  
    4751    ImageBufferBackendHandle createImageBufferBackendHandle() const;
    4852
    49 #if HAVE(IOSURFACE_SET_OWNERSHIP_IDENTITY)
    50     void setProcessOwnership(task_id_token_t);
    51 #endif
     53    void setOwnershipIdentity(const WebCore::ProcessIdentity&);
    5254};
    5355

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

    r286590 r286838  
    12271227void WebProcess::platformInitializeGPUProcessConnectionParameters(GPUProcessConnectionParameters& parameters)
    12281228{
    1229 #if HAVE(TASK_IDENTITY_TOKEN)
    1230     task_id_token_t identityToken;
    1231     kern_return_t kr = task_create_identity_token(mach_task_self(), &identityToken);
    1232     if (kr == KERN_SUCCESS)
    1233         parameters.webProcessIdentityToken = MachSendRight::adopt(identityToken);
    1234     else
    1235         RELEASE_LOG_ERROR(Process, "Call to task_create_identity_token() failed: %{private}s (%x)", mach_error_string(kr), kr);
    1236 #endif
     1229    parameters.webProcessIdentity = ProcessIdentity { ProcessIdentity::CurrentProcess };
    12371230
    12381231    parameters.overrideLanguages = userPreferredLanguagesOverride();

  • trunk/Tools/ChangeLog

    r286836 r286838  
     12021-12-10  Kimmo Kinnunen  <kkinnunen@apple.com>
     2
     3        IOSurface memory attribution is hard to use in constructors
     4        https://bugs.webkit.org/show_bug.cgi?id=232988
     5        <rdar://problem/85541918>
     6
     7        Reviewed by Chris Dumez.
     8
     9        Update constructor calling base class constructor, add empty
     10        ProcesseIdentity.
     11
     12        * TestWebKitAPI/Tests/WebCore/cocoa/TestGraphicsContextGLCocoa.mm:
     13
    1142021-12-09  Antoine Quint  <graouts@webkit.org>
    215

  • trunk/Tools/TestWebKitAPI/Tests/WebCore/cocoa/TestGraphicsContextGLCocoa.mm

    r286709 r286838  
    3333#import <WebCore/Color.h>
    3434#import <WebCore/GraphicsContextGLCocoa.h>
     35#import <WebCore/ProcessIdentity.h>
    3536#import <optional>
    3637#import <wtf/HashSet.h>
    … …  
    6869    attributes.alpha = true;
    6970    attributes.preserveDrawingBuffer = false;
    70     auto context = WebCore::GraphicsContextGLCocoa::create(WTFMove(attributes));
     71    auto context = WebCore::GraphicsContextGLCocoa::create(WTFMove(attributes), { });
    7172    if (!context)
    7273        return nullptr;
    … …  
    120121    attributes.useMetal = true;
    121122    EXPECT_EQ(attributes.powerPreference, WebCore::GraphicsContextGLPowerPreference::Default);
    122     auto defaultContext = WebCore::GraphicsContextGLCocoa::create(WebCore::GraphicsContextGLAttributes { attributes });
     123    auto defaultContext = WebCore::GraphicsContextGLCocoa::create(WebCore::GraphicsContextGLAttributes { attributes }, { });
    123124    ASSERT_NE(defaultContext, nullptr);
    124125
    125126    attributes.powerPreference = WebCore::GraphicsContextGLPowerPreference::LowPower;
    126     auto lowPowerContext = WebCore::GraphicsContextGLCocoa::create(WebCore::GraphicsContextGLAttributes { attributes });
     127    auto lowPowerContext = WebCore::GraphicsContextGLCocoa::create(WebCore::GraphicsContextGLAttributes { attributes }, { });
    127128    ASSERT_NE(lowPowerContext, nullptr);
    128129
    129130    attributes.powerPreference = WebCore::GraphicsContextGLPowerPreference::HighPerformance;
    130     auto highPerformanceContext = WebCore::GraphicsContextGLCocoa::create(WebCore::GraphicsContextGLAttributes { attributes });
     131    auto highPerformanceContext = WebCore::GraphicsContextGLCocoa::create(WebCore::GraphicsContextGLAttributes { attributes }, { });
    131132    ASSERT_NE(highPerformanceContext, nullptr);
    132133
Note: See TracChangeset for help on using the changeset viewer.