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

Changeset 243563 in webkit


Ignore:
Timestamp:
Mar 27, 2019, 1:47:55 PM (7 years ago)
Author:
Justin Fan
Message:

[Web GPU] Standardize Web GPU object reference counting and creation logic
​https://bugs.webkit.org/show_bug.cgi?id=196183

Reviewed by Dean Jackson.

Source/WebCore:

Make getters return raw refs/pointers and provide const versions if necessary.
All Web GPU objects are non-nullable, but become no-op if invalid, and descriptors are not moved unless needed.

No new tests; no change in behavior.

Getter updates and const qualifications:

  • Modules/webgpu/WebGPUAdapter.h:

(WebCore::WebGPUAdapter::options const):

  • Modules/webgpu/WebGPUBindGroup.h:

(WebCore::WebGPUBindGroup::bindGroup):
(WebCore::WebGPUBindGroup::bindGroup const): Deleted.

  • Modules/webgpu/WebGPUBindGroupDescriptor.cpp:

(WebCore::WebGPUBindGroupDescriptor::tryCreateGPUBindGroupDescriptor const):

  • Modules/webgpu/WebGPUBindGroupDescriptor.h:
  • Modules/webgpu/WebGPUBindGroupLayout.h:

(WebCore::WebGPUBindGroupLayout::bindGroupLayout const):

  • Modules/webgpu/WebGPUBuffer.h:

(WebCore::WebGPUBuffer::buffer):
(WebCore::WebGPUBuffer::buffer const):

  • Modules/webgpu/WebGPURenderPassDescriptor.cpp:

(WebCore::WebGPURenderPassDescriptor::tryCreateGPURenderPassDescriptor const):

  • Modules/webgpu/WebGPURenderPassEncoder.cpp:

(WebCore::WebGPURenderPassEncoder::setVertexBuffers):

  • Modules/webgpu/WebGPUSampler.h:

(WebCore::WebGPUSampler::sampler const):

  • Modules/webgpu/WebGPUSwapChain.h:

(WebCore::WebGPUSwapChain::swapChain):
(WebCore::WebGPUSwapChain::swapChain const): Deleted.

  • Modules/webgpu/WebGPUTexture.h:

(WebCore::WebGPUTexture::texture):
(WebCore::WebGPUTexture::texture const): Deleted.

  • Modules/webgpu/WebGPUTextureView.h:

(WebCore::WebGPUTextureView::texture):
(WebCore::WebGPUTextureView::texture const): Deleted.

  • platform/graphics/gpu/GPUBindGroupBinding.h:
  • platform/graphics/gpu/GPUBindGroupDescriptor.h:
  • platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm:

(WebCore::tryGetResourceAsMTLSamplerState):

Web GPU object creation logic:

  • Modules/webgpu/WebGPUCommandEncoder.cpp:

(WebCore::WebGPUBufferCopyView::tryCreateGPUBufferCopyView const):
(WebCore::WebGPUTextureCopyView::tryCreateGPUTextureCopyView const):
(WebCore::WebGPUCommandEncoder::beginRenderPass):
(WebCore::WebGPUCommandEncoder::copyBufferToBuffer):

  • Modules/webgpu/WebGPUCommandEncoder.h:
  • Modules/webgpu/WebGPUDevice.cpp:

(WebCore::WebGPUDevice::createBuffer const):
(WebCore::WebGPUDevice::createTexture const):
(WebCore::WebGPUDevice::createPipelineLayout const):
(WebCore::WebGPUDevice::createBindGroup const):
(WebCore::WebGPUDevice::createShaderModule const):
(WebCore::WebGPUDevice::createRenderPipeline const):
(WebCore::WebGPUDevice::getQueue const):

  • Modules/webgpu/WebGPUDevice.h:
  • Modules/webgpu/WebGPUPipelineLayout.cpp:

(WebCore::WebGPUPipelineLayout::create):
(WebCore::WebGPUPipelineLayout::WebGPUPipelineLayout):

  • Modules/webgpu/WebGPUPipelineLayout.h:

(WebCore::WebGPUPipelineLayout::pipelineLayout):

  • Modules/webgpu/WebGPUPipelineLayoutDescriptor.cpp:

(WebCore::WebGPUPipelineLayoutDescriptor::tryCreateGPUPipelineLayoutDescriptor const):

  • Modules/webgpu/WebGPUPipelineLayoutDescriptor.h:
  • Modules/webgpu/WebGPUQueue.cpp:

(WebCore::WebGPUQueue::create):
(WebCore::WebGPUQueue::WebGPUQueue):
(WebCore::WebGPUQueue::submit):

  • Modules/webgpu/WebGPUQueue.h:
  • Modules/webgpu/WebGPUShaderModule.cpp:

(WebCore::WebGPUShaderModule::create):
(WebCore::WebGPUShaderModule::WebGPUShaderModule):

  • Modules/webgpu/WebGPUShaderModule.h:

(WebCore::WebGPUShaderModule::module const):

  • platform/graphics/gpu/GPUBuffer.h:
  • platform/graphics/gpu/GPUDevice.cpp:

(WebCore::GPUDevice::tryCreateBuffer):
(WebCore::GPUDevice::tryCreateTexture const):
(WebCore::GPUDevice::tryCreateShaderModule const):
(WebCore::GPUDevice::tryCreateRenderPipeline const):
(WebCore::GPUDevice::tryGetQueue const):
(WebCore::GPUDevice::createShaderModule const): Deleted.
(WebCore::GPUDevice::createRenderPipeline const): Deleted.
(WebCore::GPUDevice::getQueue const): Deleted.

  • platform/graphics/gpu/GPUDevice.h:
  • platform/graphics/gpu/GPUPipelineLayout.cpp:

(WebCore::GPUPipelineLayout::create):
(WebCore::GPUPipelineLayout::GPUPipelineLayout):

  • platform/graphics/gpu/GPUPipelineLayout.h:

(WebCore::GPUPipelineLayout::bindGroupLayouts const):

  • platform/graphics/gpu/GPUPipelineLayoutDescriptor.h:
  • platform/graphics/gpu/GPURenderPipeline.h:
  • platform/graphics/gpu/GPUShaderModule.h:
  • platform/graphics/gpu/cocoa/GPUBufferMetal.mm:

(WebCore::GPUBuffer::tryCreate):
(WebCore::GPUBuffer::GPUBuffer):
(WebCore::GPUBuffer::setSubData):

  • platform/graphics/gpu/cocoa/GPUCommandBufferMetal.mm:

(WebCore::GPUCommandBuffer::tryCreate):

  • platform/graphics/gpu/cocoa/GPUDeviceMetal.mm:

(WebCore::GPUDevice::tryCreate):

  • platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm:

(WebCore::GPURenderPipeline::tryCreate):
(WebCore::GPURenderPipeline::GPURenderPipeline):
(WebCore::GPURenderPipeline::create): Deleted.

  • platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm:

(WebCore::GPUShaderModule::tryCreate):
(WebCore::GPUShaderModule::create): Deleted.

Add WebGPUPipelineLayoutDescriptor.cpp to project:

  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:

LayoutTests:

GPUShaderModule is no longer nullable.

  • webgpu/shader-modules.html:
Location:
trunk
Files:
44 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r243561 r243563  
     12019-03-27  Justin Fan  <justin_fan@apple.com>
     2
     3        [Web GPU] Standardize Web GPU object reference counting and creation logic
     4        https://bugs.webkit.org/show_bug.cgi?id=196183
     5
     6        Reviewed by Dean Jackson.
     7
     8        GPUShaderModule is no longer nullable.
     9
     10        * webgpu/shader-modules.html:
     11
    1122019-03-27  Shawn Roberts  <sroberts@apple.com>
    213

  • trunk/LayoutTests/webgpu/shader-modules.html

    r242839 r243563  
    2828`
    2929
    30 const incompleteShaders = `
    31 #include <metal_stdlib>
    32    
    33 using namespace metal;
    34 
    35 vertex Vertex vertex_main(uint vid [[vertex_id]])
    36 {
    37     return Vertex { float4(0, 0, 0, 1) };
    38 }
    39 
    40 fragment float4 fragment_main(Vertex vertexIn [[stage_in]])
    41 {
    42     rreturn vertexIn.position;
    43 }
    44 `
    45 
    4630promise_test(async () => {
    4731    const device = await getBasicDevice();
    4832
    49     const shaderDescriptor0 = {
    50         code : "Hello World"
    51     };
    52     let shaderModule = device.createShaderModule(shaderDescriptor0);
    53     assert_equals(shaderModule, null, "Bad shader code did not create a module.");
    54 
    55     shaderModule = device.createShaderModule({ code: incompleteShaders });
    56     assert_equals(shaderModule, null, "Incomplete shader code did not create a module.");
    57 
    58     shaderModule = device.createShaderModule({ code: shaders });
     33    let shaderModule = device.createShaderModule({ code: shaders });
    5934    assert_true(shaderModule instanceof GPUShaderModule, "Shader module created successfully.");
    6035}, "Test shader code validation when creating modules.");

  • trunk/Source/WebCore/ChangeLog

    r243561 r243563  
     12019-03-27  Justin Fan  <justin_fan@apple.com>
     2
     3        [Web GPU] Standardize Web GPU object reference counting and creation logic
     4        https://bugs.webkit.org/show_bug.cgi?id=196183
     5
     6        Reviewed by Dean Jackson.
     7
     8        Make getters return raw refs/pointers and provide const versions if necessary.
     9        All Web GPU objects are non-nullable, but become no-op if invalid, and descriptors are not moved unless needed.
     10
     11        No new tests; no change in behavior.
     12
     13        Getter updates and const qualifications:
     14        * Modules/webgpu/WebGPUAdapter.h:
     15        (WebCore::WebGPUAdapter::options const):
     16        * Modules/webgpu/WebGPUBindGroup.h:
     17        (WebCore::WebGPUBindGroup::bindGroup):
     18        (WebCore::WebGPUBindGroup::bindGroup const): Deleted.
     19        * Modules/webgpu/WebGPUBindGroupDescriptor.cpp:
     20        (WebCore::WebGPUBindGroupDescriptor::tryCreateGPUBindGroupDescriptor const):
     21        * Modules/webgpu/WebGPUBindGroupDescriptor.h:
     22        * Modules/webgpu/WebGPUBindGroupLayout.h:
     23        (WebCore::WebGPUBindGroupLayout::bindGroupLayout const):
     24        * Modules/webgpu/WebGPUBuffer.h:
     25        (WebCore::WebGPUBuffer::buffer):
     26        (WebCore::WebGPUBuffer::buffer const):
     27        * Modules/webgpu/WebGPURenderPassDescriptor.cpp:
     28        (WebCore::WebGPURenderPassDescriptor::tryCreateGPURenderPassDescriptor const):
     29        * Modules/webgpu/WebGPURenderPassEncoder.cpp:
     30        (WebCore::WebGPURenderPassEncoder::setVertexBuffers):
     31        * Modules/webgpu/WebGPUSampler.h:
     32        (WebCore::WebGPUSampler::sampler const):
     33        * Modules/webgpu/WebGPUSwapChain.h:
     34        (WebCore::WebGPUSwapChain::swapChain):
     35        (WebCore::WebGPUSwapChain::swapChain const): Deleted.
     36        * Modules/webgpu/WebGPUTexture.h:
     37        (WebCore::WebGPUTexture::texture):
     38        (WebCore::WebGPUTexture::texture const): Deleted.
     39        * Modules/webgpu/WebGPUTextureView.h:
     40        (WebCore::WebGPUTextureView::texture):
     41        (WebCore::WebGPUTextureView::texture const): Deleted.
     42        * platform/graphics/gpu/GPUBindGroupBinding.h:
     43        * platform/graphics/gpu/GPUBindGroupDescriptor.h:
     44        * platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm:
     45        (WebCore::tryGetResourceAsMTLSamplerState):
     46
     47        Web GPU object creation logic:
     48        * Modules/webgpu/WebGPUCommandEncoder.cpp:
     49        (WebCore::WebGPUBufferCopyView::tryCreateGPUBufferCopyView const):
     50        (WebCore::WebGPUTextureCopyView::tryCreateGPUTextureCopyView const):
     51        (WebCore::WebGPUCommandEncoder::beginRenderPass):
     52        (WebCore::WebGPUCommandEncoder::copyBufferToBuffer):
     53        * Modules/webgpu/WebGPUCommandEncoder.h:
     54        * Modules/webgpu/WebGPUDevice.cpp:
     55        (WebCore::WebGPUDevice::createBuffer const):
     56        (WebCore::WebGPUDevice::createTexture const):
     57        (WebCore::WebGPUDevice::createPipelineLayout const):
     58        (WebCore::WebGPUDevice::createBindGroup const):
     59        (WebCore::WebGPUDevice::createShaderModule const):
     60        (WebCore::WebGPUDevice::createRenderPipeline const):
     61        (WebCore::WebGPUDevice::getQueue const):
     62        * Modules/webgpu/WebGPUDevice.h:
     63        * Modules/webgpu/WebGPUPipelineLayout.cpp:
     64        (WebCore::WebGPUPipelineLayout::create):
     65        (WebCore::WebGPUPipelineLayout::WebGPUPipelineLayout):
     66        * Modules/webgpu/WebGPUPipelineLayout.h:
     67        (WebCore::WebGPUPipelineLayout::pipelineLayout):
     68        * Modules/webgpu/WebGPUPipelineLayoutDescriptor.cpp:
     69        (WebCore::WebGPUPipelineLayoutDescriptor::tryCreateGPUPipelineLayoutDescriptor const):
     70        * Modules/webgpu/WebGPUPipelineLayoutDescriptor.h:
     71        * Modules/webgpu/WebGPUQueue.cpp:
     72        (WebCore::WebGPUQueue::create):
     73        (WebCore::WebGPUQueue::WebGPUQueue):
     74        (WebCore::WebGPUQueue::submit):
     75        * Modules/webgpu/WebGPUQueue.h:
     76        * Modules/webgpu/WebGPUShaderModule.cpp:
     77        (WebCore::WebGPUShaderModule::create):
     78        (WebCore::WebGPUShaderModule::WebGPUShaderModule):
     79        * Modules/webgpu/WebGPUShaderModule.h:
     80        (WebCore::WebGPUShaderModule::module const):
     81        * platform/graphics/gpu/GPUBuffer.h:
     82        * platform/graphics/gpu/GPUDevice.cpp:
     83        (WebCore::GPUDevice::tryCreateBuffer):
     84        (WebCore::GPUDevice::tryCreateTexture const):
     85        (WebCore::GPUDevice::tryCreateShaderModule const):
     86        (WebCore::GPUDevice::tryCreateRenderPipeline const):
     87        (WebCore::GPUDevice::tryGetQueue const):
     88        (WebCore::GPUDevice::createShaderModule const): Deleted.
     89        (WebCore::GPUDevice::createRenderPipeline const): Deleted.
     90        (WebCore::GPUDevice::getQueue const): Deleted.
     91        * platform/graphics/gpu/GPUDevice.h:
     92        * platform/graphics/gpu/GPUPipelineLayout.cpp:
     93        (WebCore::GPUPipelineLayout::create):
     94        (WebCore::GPUPipelineLayout::GPUPipelineLayout):
     95        * platform/graphics/gpu/GPUPipelineLayout.h:
     96        (WebCore::GPUPipelineLayout::bindGroupLayouts const):
     97        * platform/graphics/gpu/GPUPipelineLayoutDescriptor.h:
     98        * platform/graphics/gpu/GPURenderPipeline.h:
     99        * platform/graphics/gpu/GPUShaderModule.h:
     100        * platform/graphics/gpu/cocoa/GPUBufferMetal.mm:
     101        (WebCore::GPUBuffer::tryCreate):
     102        (WebCore::GPUBuffer::GPUBuffer):
     103        (WebCore::GPUBuffer::setSubData):
     104        * platform/graphics/gpu/cocoa/GPUCommandBufferMetal.mm:
     105        (WebCore::GPUCommandBuffer::tryCreate):
     106        * platform/graphics/gpu/cocoa/GPUDeviceMetal.mm:
     107        (WebCore::GPUDevice::tryCreate):
     108        * platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm:
     109        (WebCore::GPURenderPipeline::tryCreate):
     110        (WebCore::GPURenderPipeline::GPURenderPipeline):
     111        (WebCore::GPURenderPipeline::create): Deleted.
     112        * platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm:
     113        (WebCore::GPUShaderModule::tryCreate):
     114        (WebCore::GPUShaderModule::create): Deleted.
     115
     116        Add WebGPUPipelineLayoutDescriptor.cpp to project:
     117        * Sources.txt:
     118        * WebCore.xcodeproj/project.pbxproj:
     119       
    11202019-03-27  Shawn Roberts  <sroberts@apple.com>
    2121

  • trunk/Source/WebCore/Modules/webgpu/WebGPUAdapter.h

    r243090 r243563  
    4646    void requestDevice(DeviceRequestPromise&&) const;
    4747   
    48     Optional<GPURequestAdapterOptions> options() const { return m_options; }
     48    const Optional<GPURequestAdapterOptions>& options() const { return m_options; }
    4949
    5050private:

  • trunk/Source/WebCore/Modules/webgpu/WebGPUBindGroup.h

    r242148 r243563  
    3838    static Ref<WebGPUBindGroup> create(RefPtr<GPUBindGroup>&&);
    3939
    40     GPUBindGroup* bindGroup() const { return m_bindGroup.get(); }
     40    GPUBindGroup* bindGroup() { return m_bindGroup.get(); }
    4141
    4242private:

  • trunk/Source/WebCore/Modules/webgpu/WebGPUBindGroupDescriptor.cpp

    r242972 r243563  
    104104                return WTF::nullopt;
    105105
    106             return static_cast<GPUBindingResource>(texture.releaseNonNull());
     106            return static_cast<GPUBindingResource>(makeRef(*texture));
    107107        }, [&layoutBinding, functionName] (WebGPUBufferBinding bufferBinding) -> Optional<GPUBindingResource> {
    108108            if (!bufferBinding.buffer)
    … …  
    112112                return WTF::nullopt;
    113113
    114             if (!validateBufferBindingType(buffer.get(), layoutBinding, functionName))
     114            if (!validateBufferBindingType(buffer, layoutBinding, functionName))
    115115                return WTF::nullopt;
    116116
    117             return static_cast<GPUBindingResource>(GPUBufferBinding { buffer.releaseNonNull(), bufferBinding.offset, bufferBinding.size });
     117            return static_cast<GPUBindingResource>(GPUBufferBinding { makeRef(*buffer), bufferBinding.offset, bufferBinding.size });
    118118        });
    119119
    … …  
    127127    }
    128128
    129     return GPUBindGroupDescriptor { layout->bindGroupLayout().releaseNonNull(), WTFMove(bindGroupBindings) };
     129    return GPUBindGroupDescriptor { makeRef(*layout->bindGroupLayout()), WTFMove(bindGroupBindings) };
    130130}
    131131

  • trunk/Source/WebCore/Modules/webgpu/WebGPUBindGroupDescriptor.h

    r242839 r243563  
    4141    Optional<GPUBindGroupDescriptor> tryCreateGPUBindGroupDescriptor() const;
    4242
    43     RefPtr<WebGPUBindGroupLayout> layout;
     43    RefPtr<const WebGPUBindGroupLayout> layout;
    4444    Vector<WebGPUBindGroupBinding> bindings;
    4545};

  • trunk/Source/WebCore/Modules/webgpu/WebGPUBindGroupLayout.h

    r239515 r243563  
    2929
    3030#include "GPUBindGroupLayout.h"
    31 
    3231#include <wtf/RefCounted.h>
    3332#include <wtf/RefPtr.h>
    … …  
    3938    static Ref<WebGPUBindGroupLayout> create(RefPtr<GPUBindGroupLayout>&&);
    4039
    41     RefPtr<GPUBindGroupLayout> bindGroupLayout() const { return m_bindGroupLayout; }
     40    const GPUBindGroupLayout* bindGroupLayout() const { return m_bindGroupLayout.get(); }
    4241
    4342private:

  • trunk/Source/WebCore/Modules/webgpu/WebGPUBuffer.h

    r242164 r243563  
    4646    static Ref<WebGPUBuffer> create(RefPtr<GPUBuffer>&&);
    4747
    48     RefPtr<GPUBuffer> buffer() const { return m_buffer; }
     48    GPUBuffer* buffer() { return m_buffer.get(); }
     49    const GPUBuffer* buffer() const { return m_buffer.get(); }
    4950
    5051    void setSubData(unsigned long long, const JSC::ArrayBuffer&);

  • trunk/Source/WebCore/Modules/webgpu/WebGPUCommandEncoder.cpp

    r243457 r243563  
    4848    // FIXME: Add Web GPU validation.
    4949
    50     return GPUBufferCopyView { buffer->buffer().releaseNonNull(), *this };
     50    return GPUBufferCopyView { makeRef(*buffer->buffer()), *this };
    5151}
    5252
    … …  
    6060    // FIXME: Add Web GPU validation.
    6161
    62     return GPUTextureCopyView { texture->texture().releaseNonNull(), *this };
     62    return GPUTextureCopyView { makeRef(*texture->texture()), *this };
    6363}
    6464
    … …  
    7373}
    7474
    75 Ref<WebGPURenderPassEncoder> WebGPUCommandEncoder::beginRenderPass(WebGPURenderPassDescriptor&& descriptor)
     75Ref<WebGPURenderPassEncoder> WebGPUCommandEncoder::beginRenderPass(const WebGPURenderPassDescriptor& descriptor)
    7676{
    7777    if (!m_commandBuffer) {
    … …  
    8787}
    8888
    89 void WebGPUCommandEncoder::copyBufferToBuffer(const WebGPUBuffer& src, unsigned long srcOffset, const WebGPUBuffer& dst, unsigned long dstOffset, unsigned long size)
     89void WebGPUCommandEncoder::copyBufferToBuffer(WebGPUBuffer& src, unsigned long srcOffset, WebGPUBuffer& dst, unsigned long dstOffset, unsigned long size)
    9090{
    9191    if (!m_commandBuffer) {

  • trunk/Source/WebCore/Modules/webgpu/WebGPUCommandEncoder.h

    r243457 r243563  
    5858    static Ref<WebGPUCommandEncoder> create(RefPtr<GPUCommandBuffer>&&);
    5959
    60     Ref<WebGPURenderPassEncoder> beginRenderPass(WebGPURenderPassDescriptor&&);
    61     void copyBufferToBuffer(const WebGPUBuffer&, unsigned long srcOffset, const WebGPUBuffer&, unsigned long dstOffset, unsigned long size);
     60    Ref<WebGPURenderPassEncoder> beginRenderPass(const WebGPURenderPassDescriptor&);
     61    void copyBufferToBuffer(WebGPUBuffer&, unsigned long srcOffset, WebGPUBuffer&, unsigned long dstOffset, unsigned long size);
    6262    void copyBufferToTexture(const WebGPUBufferCopyView&, const WebGPUTextureCopyView&, const GPUExtent3D&);
    6363    void copyTextureToBuffer(const WebGPUTextureCopyView&, const WebGPUBufferCopyView&, const GPUExtent3D&);

  • trunk/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp

    r243457 r243563  
    7777}
    7878
    79 Ref<WebGPUBuffer> WebGPUDevice::createBuffer(GPUBufferDescriptor&& descriptor) const
     79Ref<WebGPUBuffer> WebGPUDevice::createBuffer(const GPUBufferDescriptor& descriptor) const
    8080{
    81     auto buffer = m_device->tryCreateBuffer(WTFMove(descriptor));
     81    auto buffer = m_device->tryCreateBuffer(descriptor);
    8282    return WebGPUBuffer::create(WTFMove(buffer));
    8383}
    8484
    85 Ref<WebGPUTexture> WebGPUDevice::createTexture(GPUTextureDescriptor&& descriptor) const
     85Ref<WebGPUTexture> WebGPUDevice::createTexture(const GPUTextureDescriptor& descriptor) const
    8686{
    87     auto texture = m_device->tryCreateTexture(WTFMove(descriptor));
     87    auto texture = m_device->tryCreateTexture(descriptor);
    8888    return WebGPUTexture::create(WTFMove(texture));
    8989}
    … …  
    101101}
    102102
    103 Ref<WebGPUPipelineLayout> WebGPUDevice::createPipelineLayout(WebGPUPipelineLayoutDescriptor&& descriptor) const
     103Ref<WebGPUPipelineLayout> WebGPUDevice::createPipelineLayout(const WebGPUPipelineLayoutDescriptor& descriptor) const
    104104{
    105     auto bindGroupLayouts = descriptor.bindGroupLayouts.map([] (const auto& layout) -> RefPtr<const GPUBindGroupLayout> {
    106         return layout->bindGroupLayout();
    107     });
    108     auto layout = m_device->createPipelineLayout(GPUPipelineLayoutDescriptor { WTFMove(bindGroupLayouts) });
     105    auto gpuDescriptor = descriptor.tryCreateGPUPipelineLayoutDescriptor();
     106    if (!gpuDescriptor)
     107        return WebGPUPipelineLayout::create(nullptr);
     108   
     109    auto layout = m_device->createPipelineLayout(WTFMove(*gpuDescriptor));
    109110    return WebGPUPipelineLayout::create(WTFMove(layout));
    110111}
    111112
    112 Ref<WebGPUBindGroup> WebGPUDevice::createBindGroup(WebGPUBindGroupDescriptor&& descriptor) const
     113Ref<WebGPUBindGroup> WebGPUDevice::createBindGroup(const WebGPUBindGroupDescriptor& descriptor) const
    113114{
    114115    auto gpuDescriptor = descriptor.tryCreateGPUBindGroupDescriptor();
    … …  
    120121}
    121122
    122 RefPtr<WebGPUShaderModule> WebGPUDevice::createShaderModule(WebGPUShaderModuleDescriptor&& descriptor) const
     123Ref<WebGPUShaderModule> WebGPUDevice::createShaderModule(const WebGPUShaderModuleDescriptor& descriptor) const
    123124{
    124125    // FIXME: What can be validated here?
    125     if (auto module = m_device->createShaderModule(GPUShaderModuleDescriptor { descriptor.code, descriptor.isWHLSL }))
    126         return WebGPUShaderModule::create(module.releaseNonNull());
    127     return nullptr;
     126    auto module = m_device->tryCreateShaderModule(GPUShaderModuleDescriptor { descriptor.code, descriptor.isWHLSL });
     127    return WebGPUShaderModule::create(WTFMove(module));
    128128}
    129129
    … …  
    134134        return WebGPURenderPipeline::create(nullptr);
    135135
    136     auto pipeline = m_device->createRenderPipeline(WTFMove(*gpuDescriptor));
     136    auto pipeline = m_device->tryCreateRenderPipeline(*gpuDescriptor);
    137137    return WebGPURenderPipeline::create(WTFMove(pipeline));
    138138}
    … …  
    158158}
    159159
    160 RefPtr<WebGPUQueue> WebGPUDevice::getQueue() const
     160Ref<WebGPUQueue> WebGPUDevice::getQueue() const
    161161{
    162162    if (!m_queue)
    163         m_queue = WebGPUQueue::create(m_device->getQueue());
     163        m_queue = WebGPUQueue::create(m_device->tryGetQueue());
    164164
    165     return m_queue;
     165    return makeRef(*m_queue.get());
    166166}
    167167

  • trunk/Source/WebCore/Modules/webgpu/WebGPUDevice.h

    r243457 r243563  
    6666    const GPUDevice& device() const { return m_device.get(); }
    6767
    68     Ref<WebGPUBuffer> createBuffer(GPUBufferDescriptor&&) const;
    69     Ref<WebGPUTexture> createTexture(GPUTextureDescriptor&&) const;
     68    Ref<WebGPUBuffer> createBuffer(const GPUBufferDescriptor&) const;
     69    Ref<WebGPUTexture> createTexture(const GPUTextureDescriptor&) const;
    7070    Ref<WebGPUSampler> createSampler(const GPUSamplerDescriptor&) const;
    7171
    7272    Ref<WebGPUBindGroupLayout> createBindGroupLayout(const GPUBindGroupLayoutDescriptor&) const;
    73     Ref<WebGPUPipelineLayout> createPipelineLayout(WebGPUPipelineLayoutDescriptor&&) const;
    74     Ref<WebGPUBindGroup> createBindGroup(WebGPUBindGroupDescriptor&&) const;
     73    Ref<WebGPUPipelineLayout> createPipelineLayout(const WebGPUPipelineLayoutDescriptor&) const;
     74    Ref<WebGPUBindGroup> createBindGroup(const WebGPUBindGroupDescriptor&) const;
    7575
    76     RefPtr<WebGPUShaderModule> createShaderModule(WebGPUShaderModuleDescriptor&&) const;
     76    Ref<WebGPUShaderModule> createShaderModule(const WebGPUShaderModuleDescriptor&) const;
    7777    Ref<WebGPURenderPipeline> createRenderPipeline(const WebGPURenderPipelineDescriptor&) const;
    7878
    … …  
    8181    Ref<WebGPUSwapChain> createSwapChain(const WebGPUSwapChainDescriptor&) const;
    8282
    83     RefPtr<WebGPUQueue> getQueue() const;
     83    Ref<WebGPUQueue> getQueue() const;
    8484
    8585private:

  • trunk/Source/WebCore/Modules/webgpu/WebGPUPipelineLayout.cpp

    r239410 r243563  
    3131namespace WebCore {
    3232
    33 Ref<WebGPUPipelineLayout> WebGPUPipelineLayout::create(Ref<GPUPipelineLayout>&& layout)
     33Ref<WebGPUPipelineLayout> WebGPUPipelineLayout::create(RefPtr<GPUPipelineLayout>&& layout)
    3434{
    3535    return adoptRef(*new WebGPUPipelineLayout(WTFMove(layout)));
    3636}
    3737
    38 WebGPUPipelineLayout::WebGPUPipelineLayout(Ref<GPUPipelineLayout>&& layout)
     38WebGPUPipelineLayout::WebGPUPipelineLayout(RefPtr<GPUPipelineLayout>&& layout)
    3939    : m_pipelineLayout(WTFMove(layout))
    4040{

  • trunk/Source/WebCore/Modules/webgpu/WebGPUPipelineLayout.h

    r242839 r243563  
    3737class WebGPUPipelineLayout : public RefCounted<WebGPUPipelineLayout> {
    3838public:
    39     static Ref<WebGPUPipelineLayout> create(Ref<GPUPipelineLayout>&&);
     39    static Ref<WebGPUPipelineLayout> create(RefPtr<GPUPipelineLayout>&&);
    4040
    41     GPUPipelineLayout& pipelineLayout() { return m_pipelineLayout.get(); }
     41    GPUPipelineLayout* pipelineLayout() { return m_pipelineLayout.get(); }
    4242
    4343private:
    44     explicit WebGPUPipelineLayout(Ref<GPUPipelineLayout>&&);
     44    explicit WebGPUPipelineLayout(RefPtr<GPUPipelineLayout>&&);
    4545
    46     Ref<GPUPipelineLayout> m_pipelineLayout;
     46    RefPtr<GPUPipelineLayout> m_pipelineLayout;
    4747};
    4848

  • trunk/Source/WebCore/Modules/webgpu/WebGPUPipelineLayoutDescriptor.cpp

    r243561 r243563  
    2424 */
    2525
    26 #pragma once
     26#include "config.h"
     27#include "WebGPUPipelineLayoutDescriptor.h"
    2728
    2829#if ENABLE(WEBGPU)
    2930
    30 #include "GPUBindGroup.h"
    31 #include <wtf/RefCounted.h>
    32 #include <wtf/RefPtr.h>
     31#include "GPUPipelineLayoutDescriptor.h"
     32#include "Logging.h"
    3333
    3434namespace WebCore {
    35 
    36 class WebGPUBindGroup : public RefCounted<WebGPUBindGroup> {
    37 public:
    38     static Ref<WebGPUBindGroup> create(RefPtr<GPUBindGroup>&&);
    39 
    40     GPUBindGroup* bindGroup() const { return m_bindGroup.get(); }
    41 
    42 private:
    43     explicit WebGPUBindGroup(RefPtr<GPUBindGroup>&&);
    44 
    45     RefPtr<GPUBindGroup> m_bindGroup;
    46 };
     35   
     36Optional<GPUPipelineLayoutDescriptor> WebGPUPipelineLayoutDescriptor::tryCreateGPUPipelineLayoutDescriptor() const
     37{
     38    Vector<Ref<const GPUBindGroupLayout>> gpuLayouts;
     39    gpuLayouts.reserveCapacity(bindGroupLayouts.size());
     40   
     41    for (const auto& layout : bindGroupLayouts) {
     42        if (!layout || !layout->bindGroupLayout()) {
     43            LOG(WebGPU, "GPUDevice::createPipelineLayout(): Invalid GPUBindGroupLayout!");
     44            return WTF::nullopt;
     45        }
     46       
     47        gpuLayouts.uncheckedAppend(makeRef(*layout->bindGroupLayout()));
     48    }
     49   
     50    return GPUPipelineLayoutDescriptor { WTFMove(gpuLayouts) };
     51}
    4752
    4853} // namespace WebCore

  • trunk/Source/WebCore/Modules/webgpu/WebGPUPipelineLayoutDescriptor.h

    r239410 r243563  
    2929
    3030#include "WebGPUBindGroupLayout.h"
    31 
     31#include <wtf/Optional.h>
    3232#include <wtf/RefPtr.h>
    3333#include <wtf/Vector.h>
    3434
    3535namespace WebCore {
     36   
     37struct GPUPipelineLayoutDescriptor;
    3638
    3739struct WebGPUPipelineLayoutDescriptor {
     40    Optional<GPUPipelineLayoutDescriptor> tryCreateGPUPipelineLayoutDescriptor() const;
     41
    3842    Vector<RefPtr<WebGPUBindGroupLayout>> bindGroupLayouts;
    3943};

  • trunk/Source/WebCore/Modules/webgpu/WebGPUQueue.cpp

    r242974 r243563  
    3636namespace WebCore {
    3737
    38 RefPtr<WebGPUQueue> WebGPUQueue::create(RefPtr<GPUQueue>&& queue)
     38Ref<WebGPUQueue> WebGPUQueue::create(RefPtr<GPUQueue>&& queue)
    3939{
    40     return queue ? adoptRef(new WebGPUQueue(queue.releaseNonNull())) : nullptr;
     40    return adoptRef(*new WebGPUQueue(WTFMove(queue)));
    4141}
    4242
    43 WebGPUQueue::WebGPUQueue(Ref<GPUQueue>&& queue)
     43WebGPUQueue::WebGPUQueue(RefPtr<GPUQueue>&& queue)
    4444    : m_queue(WTFMove(queue))
    4545{
    … …  
    4848void WebGPUQueue::submit(const Vector<RefPtr<WebGPUCommandBuffer>>& buffers)
    4949{
     50    if (!m_queue) {
     51        LOG(WebGPU, "GPUQueue::submit(): Invalid operation!");
     52        return;
     53    }
    5054    Vector<Ref<GPUCommandBuffer>> gpuBuffers;
    5155    gpuBuffers.reserveCapacity(buffers.size());

  • trunk/Source/WebCore/Modules/webgpu/WebGPUQueue.h

    r242974 r243563  
    4040class WebGPUQueue : public RefCounted<WebGPUQueue> {
    4141public:
    42     static RefPtr<WebGPUQueue> create(RefPtr<GPUQueue>&&);
     42    static Ref<WebGPUQueue> create(RefPtr<GPUQueue>&&);
    4343
    4444    void submit(const Vector<RefPtr<WebGPUCommandBuffer>>&);
    … …  
    4848
    4949private:
    50     WebGPUQueue(Ref<GPUQueue>&&);
     50    WebGPUQueue(RefPtr<GPUQueue>&&);
    5151
    52     Ref<GPUQueue> m_queue;
     52    RefPtr<GPUQueue> m_queue;
    5353};
    5454

  • trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassDescriptor.cpp

    r242839 r243563  
    6363            return WTF::nullopt;
    6464        }
    65         gpuColorAttachments.append(GPURenderPassColorAttachmentDescriptor { colorAttachment.attachment->texture().releaseNonNull(), colorAttachment });
     65        gpuColorAttachments.append(GPURenderPassColorAttachmentDescriptor { makeRef(*colorAttachment.attachment->texture()), colorAttachment });
    6666    }
    6767
    … …  
    7575            return WTF::nullopt;
    7676        }
    77         gpuDepthAttachment = GPURenderPassDepthStencilAttachmentDescriptor { depthStencilAttachment->attachment->texture().releaseNonNull(), *depthStencilAttachment };
     77        gpuDepthAttachment = GPURenderPassDepthStencilAttachmentDescriptor { makeRef(*depthStencilAttachment->attachment->texture()), *depthStencilAttachment };
    7878    }
    7979

  • trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp

    r243457 r243563  
    9393        }
    9494
    95         gpuBuffers.uncheckedAppend(buffer->buffer().releaseNonNull());
     95        gpuBuffers.uncheckedAppend(makeRef(*buffer->buffer()));
    9696    }
    9797

  • trunk/Source/WebCore/Modules/webgpu/WebGPUSampler.h

    r242615 r243563  
    3838    static Ref<WebGPUSampler> create(RefPtr<GPUSampler>&&);
    3939
    40     GPUSampler* sampler() const { return m_sampler.get(); }
     40    const GPUSampler* sampler() const { return m_sampler.get(); }
    4141
    4242private:

  • trunk/Source/WebCore/Modules/webgpu/WebGPUShaderModule.cpp

    r239535 r243563  
    3131namespace WebCore {
    3232
    33 Ref<WebGPUShaderModule> WebGPUShaderModule::create(Ref<GPUShaderModule>&& module)
     33Ref<WebGPUShaderModule> WebGPUShaderModule::create(RefPtr<GPUShaderModule>&& module)
    3434{
    3535    return adoptRef(*new WebGPUShaderModule(WTFMove(module)));
    3636}
    3737
    38 WebGPUShaderModule::WebGPUShaderModule(Ref<GPUShaderModule>&& module)
     38WebGPUShaderModule::WebGPUShaderModule(RefPtr<GPUShaderModule>&& module)
    3939    : m_module(WTFMove(module))
    4040{
    41     UNUSED_PARAM(m_module);
    4241}
    4342

  • trunk/Source/WebCore/Modules/webgpu/WebGPUShaderModule.h

    r239535 r243563  
    3737class WebGPUShaderModule : public RefCounted<WebGPUShaderModule> {
    3838public:
    39     static Ref<WebGPUShaderModule> create(Ref<GPUShaderModule>&&);
     39    static Ref<WebGPUShaderModule> create(RefPtr<GPUShaderModule>&&);
    4040
    41     const GPUShaderModule* module() const { return m_module.ptr(); }
     41    const GPUShaderModule* module() const { return m_module.get(); }
    4242
    4343private:
    44     WebGPUShaderModule(Ref<GPUShaderModule>&&);
     44    WebGPUShaderModule(RefPtr<GPUShaderModule>&&);
    4545
    46     Ref<GPUShaderModule> m_module;
     46    RefPtr<GPUShaderModule> m_module;
    4747};
    4848

  • trunk/Source/WebCore/Modules/webgpu/WebGPUSwapChain.h

    r242759 r243563  
    4141    static Ref<WebGPUSwapChain> create(RefPtr<GPUSwapChain>&&);
    4242
    43     GPUSwapChain* swapChain() const { return m_swapChain.get(); }
     43    GPUSwapChain* swapChain() { return m_swapChain.get(); }
    4444
    4545    Ref<WebGPUTexture> getCurrentTexture();

  • trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.h

    r243089 r243563  
    4040    static Ref<WebGPUTexture> create(RefPtr<GPUTexture>&&);
    4141
    42     RefPtr<GPUTexture> texture() const { return m_texture; }
     42    GPUTexture* texture() { return m_texture.get(); }
    4343
    4444    Ref<WebGPUTextureView> createDefaultView();

  • trunk/Source/WebCore/Modules/webgpu/WebGPUTextureView.h

    r242582 r243563  
    3939    ~WebGPUTextureView() { destroy(); }
    4040
    41     RefPtr<GPUTexture> texture() const { return m_texture; }
     41    GPUTexture* texture() { return m_texture.get(); }
    4242
    4343    void destroy();

  • trunk/Source/WebCore/Sources.txt

    r243555 r243563  
    359359Modules/webgpu/WebGPUQueue.cpp
    360360Modules/webgpu/WebGPUPipelineLayout.cpp
     361Modules/webgpu/WebGPUPipelineLayoutDescriptor.cpp
    361362Modules/webgpu/WebGPUProgrammablePassEncoder.cpp
    362363Modules/webgpu/WebGPURenderPassDescriptor.cpp

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

    r243555 r243563  
    1393113931                D003288721C9A4E500622AA6 /* GPUPipelineLayout.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = GPUPipelineLayout.cpp; sourceTree = "<group>"; };
    1393213932                D003914122248D400098998C /* GPUProgrammablePassEncoder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = GPUProgrammablePassEncoder.cpp; sourceTree = "<group>"; };
     13933                D00487D222457BEA00EED7D9 /* WebGPUPipelineLayoutDescriptor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUPipelineLayoutDescriptor.cpp; sourceTree = "<group>"; };
    1393313934                D00F5940216ECC7A000D71DB /* DOMWindowWebGPU.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DOMWindowWebGPU.h; sourceTree = "<group>"; };
    1393413935                D00F5941216ECC7A000D71DB /* DOMWindowWebGPU.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = DOMWindowWebGPU.cpp; sourceTree = "<group>"; };
    … …  
    2613626137                                D05A99E421C9BF2C00032B75 /* WebGPUPipelineLayout.h */,
    2613726138                                D05A99E621C9BF2C00032B75 /* WebGPUPipelineLayout.idl */,
     26139                                D00487D222457BEA00EED7D9 /* WebGPUPipelineLayoutDescriptor.cpp */,
    2613826140                                D05A99E121C9B50F00032B75 /* WebGPUPipelineLayoutDescriptor.h */,
    2613926141                                D05A99E221C9B50F00032B75 /* WebGPUPipelineLayoutDescriptor.idl */,
    … …  
    2617626178                                D0EACF872193EE4E000FA75C /* WebGPUTextureView.h */,
    2617726179                                D0EACF892193EE4E000FA75C /* WebGPUTextureView.idl */,
     26180                                D00487D222457BEA00EED7D9 /* WebGPUPipelineLayoutDescriptor.cpp */,
    2617826181                        );
    2617926182                        path = webgpu;

  • trunk/Source/WebCore/platform/graphics/gpu/GPUBindGroupBinding.h

    r242615 r243563  
    3535namespace WebCore {
    3636
    37 using GPUBindingResource = Variant<Ref<GPUSampler>, Ref<GPUTexture>, GPUBufferBinding>;
     37using GPUBindingResource = Variant<Ref<const GPUSampler>, Ref<GPUTexture>, GPUBufferBinding>;
    3838
    3939struct GPUBindGroupBinding {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUBindGroupDescriptor.h

    r239837 r243563  
    3636
    3737struct GPUBindGroupDescriptor {
    38     Ref<GPUBindGroupLayout> layout;
     38    Ref<const GPUBindGroupLayout> layout;
    3939    Vector<GPUBindGroupBinding> bindings;
    4040};

  • trunk/Source/WebCore/platform/graphics/gpu/GPUBuffer.h

    r242615 r243563  
    6969    ~GPUBuffer();
    7070
    71     static RefPtr<GPUBuffer> tryCreate(Ref<GPUDevice>&&, GPUBufferDescriptor&&);
     71    static RefPtr<GPUBuffer> tryCreate(Ref<GPUDevice>&&, const GPUBufferDescriptor&);
    7272
    7373    PlatformBuffer *platformBuffer() const { return m_platformBuffer.get(); }
    … …  
    110110    static bool validateBufferUsage(const GPUDevice&, OptionSet<GPUBufferUsage::Flags>);
    111111
    112     GPUBuffer(PlatformBufferSmartPtr&&, const GPUBufferDescriptor&, OptionSet<GPUBufferUsage::Flags>, Ref<GPUDevice>&&);
     112    GPUBuffer(PlatformBufferSmartPtr&&, unsigned long, OptionSet<GPUBufferUsage::Flags>, Ref<GPUDevice>&&);
    113113
    114114    JSC::ArrayBuffer* stagingBufferForRead();

  • trunk/Source/WebCore/platform/graphics/gpu/GPUDevice.cpp

    r243457 r243563  
    4949namespace WebCore {
    5050
    51 RefPtr<GPUBuffer> GPUDevice::tryCreateBuffer(GPUBufferDescriptor&& descriptor)
     51RefPtr<GPUBuffer> GPUDevice::tryCreateBuffer(const GPUBufferDescriptor& descriptor)
    5252{
    53     return GPUBuffer::tryCreate(makeRef(*this), WTFMove(descriptor));
     53    return GPUBuffer::tryCreate(makeRef(*this), descriptor);
    5454}
    5555
    56 RefPtr<GPUTexture> GPUDevice::tryCreateTexture(GPUTextureDescriptor&& descriptor) const
     56RefPtr<GPUTexture> GPUDevice::tryCreateTexture(const GPUTextureDescriptor& descriptor) const
    5757{
    58     return GPUTexture::tryCreate(*this, WTFMove(descriptor));
     58    return GPUTexture::tryCreate(*this, descriptor);
    5959}
    6060
    … …  
    7474}
    7575
    76 RefPtr<GPUShaderModule> GPUDevice::createShaderModule(GPUShaderModuleDescriptor&& descriptor) const
     76RefPtr<GPUShaderModule> GPUDevice::tryCreateShaderModule(const GPUShaderModuleDescriptor& descriptor) const
    7777{
    78     return GPUShaderModule::create(*this, WTFMove(descriptor));
     78    return GPUShaderModule::tryCreate(*this, descriptor);
    7979}
    8080
    81 RefPtr<GPURenderPipeline> GPUDevice::createRenderPipeline(GPURenderPipelineDescriptor&& descriptor) const
     81RefPtr<GPURenderPipeline> GPUDevice::tryCreateRenderPipeline(const GPURenderPipelineDescriptor& descriptor) const
    8282{
    83     return GPURenderPipeline::create(*this, WTFMove(descriptor));
     83    return GPURenderPipeline::tryCreate(*this, descriptor);
    8484}
    8585
    … …  
    9595}
    9696
    97 RefPtr<GPUQueue> GPUDevice::getQueue() const
     97RefPtr<GPUQueue> GPUDevice::tryGetQueue() const
    9898{
    9999    if (!m_queue)

  • trunk/Source/WebCore/platform/graphics/gpu/GPUDevice.h

    r243457 r243563  
    6262class GPUDevice : public RefCounted<GPUDevice>, public CanMakeWeakPtr<GPUDevice> {
    6363public:
    64     static RefPtr<GPUDevice> tryCreate(Optional<GPURequestAdapterOptions>&&);
     64    static RefPtr<GPUDevice> tryCreate(const Optional<GPURequestAdapterOptions>&);
    6565
    66     RefPtr<GPUBuffer> tryCreateBuffer(GPUBufferDescriptor&&);
    67     RefPtr<GPUTexture> tryCreateTexture(GPUTextureDescriptor&&) const;
     66    RefPtr<GPUBuffer> tryCreateBuffer(const GPUBufferDescriptor&);
     67    RefPtr<GPUTexture> tryCreateTexture(const GPUTextureDescriptor&) const;
    6868    RefPtr<GPUSampler> tryCreateSampler(const GPUSamplerDescriptor&) const;
    6969
    … …  
    7171    Ref<GPUPipelineLayout> createPipelineLayout(GPUPipelineLayoutDescriptor&&) const;
    7272
    73     RefPtr<GPUShaderModule> createShaderModule(GPUShaderModuleDescriptor&&) const;
    74     RefPtr<GPURenderPipeline> createRenderPipeline(GPURenderPipelineDescriptor&&) const;
     73    RefPtr<GPUShaderModule> tryCreateShaderModule(const GPUShaderModuleDescriptor&) const;
     74    RefPtr<GPURenderPipeline> tryCreateRenderPipeline(const GPURenderPipelineDescriptor&) const;
    7575
    7676    RefPtr<GPUCommandBuffer> tryCreateCommandBuffer() const;
    … …  
    7878    RefPtr<GPUSwapChain> tryCreateSwapChain(const GPUSwapChainDescriptor&, int width, int height) const;
    7979
    80     RefPtr<GPUQueue> getQueue() const;
     80    RefPtr<GPUQueue> tryGetQueue() const;
    8181    PlatformDevice* platformDevice() const { return m_platformDevice.get(); }
    8282    GPUSwapChain* swapChain() const { return m_swapChain.get(); }
    8383
    8484private:
    85     GPUDevice(PlatformDeviceSmartPtr&&);
     85    explicit GPUDevice(PlatformDeviceSmartPtr&&);
    8686
    8787    PlatformDeviceSmartPtr m_platformDevice;

  • trunk/Source/WebCore/platform/graphics/gpu/GPUPipelineLayout.cpp

    r242575 r243563  
    3333Ref<GPUPipelineLayout> GPUPipelineLayout::create(GPUPipelineLayoutDescriptor&& descriptor)
    3434{
    35     return adoptRef(*new GPUPipelineLayout(WTFMove(descriptor)));
     35    return adoptRef(*new GPUPipelineLayout(WTFMove(descriptor.bindGroupLayouts)));
    3636}
    3737
    38 GPUPipelineLayout::GPUPipelineLayout(GPUPipelineLayoutDescriptor&& descriptor)
    39     : m_bindGroupLayouts(WTFMove(descriptor.bindGroupLayouts))
     38GPUPipelineLayout::GPUPipelineLayout(Vector<Ref<const GPUBindGroupLayout>>&& layouts)
     39    : m_bindGroupLayouts(WTFMove(layouts))
    4040{
    4141}

  • trunk/Source/WebCore/platform/graphics/gpu/GPUPipelineLayout.h

    r243091 r243563  
    2929
    3030#include "GPUPipelineLayoutDescriptor.h"
    31 
    3231#include <wtf/Ref.h>
    3332#include <wtf/RefCounted.h>
    … …  
    3938    static Ref<GPUPipelineLayout> create(GPUPipelineLayoutDescriptor&&);
    4039
    41     const Vector<RefPtr<const GPUBindGroupLayout>>& bindGroupLayouts() const { return m_bindGroupLayouts; }
     40    const Vector<Ref<const GPUBindGroupLayout>>& bindGroupLayouts() const { return m_bindGroupLayouts; }
    4241
    4342private:
    44     explicit GPUPipelineLayout(GPUPipelineLayoutDescriptor&&);
     43    explicit GPUPipelineLayout(Vector<Ref<const GPUBindGroupLayout>>&&);
    4544
    46     Vector<RefPtr<const GPUBindGroupLayout>> m_bindGroupLayouts;
     45    Vector<Ref<const GPUBindGroupLayout>> m_bindGroupLayouts;
    4746};
    4847

  • trunk/Source/WebCore/platform/graphics/gpu/GPUPipelineLayoutDescriptor.h

    r239410 r243563  
    3535
    3636struct GPUPipelineLayoutDescriptor {
    37     Vector<RefPtr<const GPUBindGroupLayout>> bindGroupLayouts;
     37    Vector<Ref<const GPUBindGroupLayout>> bindGroupLayouts;
    3838};
    3939

  • trunk/Source/WebCore/platform/graphics/gpu/GPURenderPipeline.h

    r243457 r243563  
    4747class GPURenderPipeline : public RefCounted<GPURenderPipeline> {
    4848public:
    49     static RefPtr<GPURenderPipeline> create(const GPUDevice&, GPURenderPipelineDescriptor&&);
     49    static RefPtr<GPURenderPipeline> tryCreate(const GPUDevice&, const GPURenderPipelineDescriptor&);
    5050
    5151#if USE(METAL)
    … …  
    5757private:
    5858#if USE(METAL)
    59     GPURenderPipeline(RetainPtr<MTLDepthStencilState>&&, PlatformRenderPipelineSmartPtr&&, GPURenderPipelineDescriptor&&);
     59    GPURenderPipeline(RetainPtr<MTLDepthStencilState>&&, PlatformRenderPipelineSmartPtr&&, GPUPrimitiveTopology);
    6060
    6161    RetainPtr<MTLDepthStencilState> m_depthStencilState;

  • trunk/Source/WebCore/platform/graphics/gpu/GPUShaderModule.h

    r243091 r243563  
    4545class GPUShaderModule : public RefCounted<GPUShaderModule> {
    4646public:
    47     static RefPtr<GPUShaderModule> create(const GPUDevice&, GPUShaderModuleDescriptor&&);
     47    static RefPtr<GPUShaderModule> tryCreate(const GPUDevice&, const GPUShaderModuleDescriptor&);
    4848
    4949    PlatformShaderModule* platformShaderModule() const { return m_whlslSource.isNull() ? m_platformShaderModule.get() : nullptr; }

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm

    r243457 r243563  
    7878}
    7979   
    80 static RefPtr<GPUSampler> tryGetResourceAsSampler(const GPUBindingResource& resource, const char* const functionName)
     80static MTLSamplerState *tryGetResourceAsMtlSampler(const GPUBindingResource& resource, const char* const functionName)
    8181{
    8282#if LOG_DISABLED
    8383    UNUSED_PARAM(functionName);
    8484#endif
    85     if (!WTF::holds_alternative<Ref<GPUSampler>>(resource)) {
     85    if (!WTF::holds_alternative<Ref<const GPUSampler>>(resource)) {
    8686        LOG(WebGPU, "%s: Resource is not a GPUSampler!", functionName);
    8787        return nullptr;
    8888    }
    89     auto& samplerRef = WTF::get<Ref<GPUSampler>>(resource);
    90     if (!samplerRef->platformSampler()) {
     89    auto samplerState = WTF::get<Ref<const GPUSampler>>(resource)->platformSampler();
     90    if (!samplerState) {
    9191        LOG(WebGPU, "%s: Invalid MTLSamplerState in GPUSampler binding!", functionName);
    9292        return nullptr;
    9393    }
    94     return samplerRef.copyRef();
     94    return samplerState;
    9595}
    9696
    … …  
    187187        }
    188188        case GPUBindingType::Sampler: {
    189             auto samplerResource = tryGetResourceAsSampler(resourceBinding.resource, functionName);
    190             if (!samplerResource)
     189            auto sampler = tryGetResourceAsMtlSampler(resourceBinding.resource, functionName);
     190            if (!sampler)
    191191                return nullptr;
    192192            if (layoutBinding.visibility & GPUShaderStageBit::Flags::Vertex)
    193                 setSamplerOnEncoder(vertexEncoder, samplerResource->platformSampler(), resourceBinding.binding);
     193                setSamplerOnEncoder(vertexEncoder, sampler, resourceBinding.binding);
    194194            if (layoutBinding.visibility & GPUShaderStageBit::Flags::Fragment)
    195                 setSamplerOnEncoder(fragmentEncoder, samplerResource->platformSampler(), resourceBinding.binding);
     195                setSamplerOnEncoder(fragmentEncoder, sampler, resourceBinding.binding);
    196196            break;
    197197        }

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUBufferMetal.mm

    r242759 r243563  
    6363}
    6464
    65 RefPtr<GPUBuffer> GPUBuffer::tryCreate(Ref<GPUDevice>&& device, GPUBufferDescriptor&& descriptor)
     65RefPtr<GPUBuffer> GPUBuffer::tryCreate(Ref<GPUDevice>&& device, const GPUBufferDescriptor& descriptor)
    6666{
    6767    auto usage = OptionSet<GPUBufferUsage::Flags>::fromRaw(descriptor.usage);
    … …  
    8989    }
    9090
    91     return adoptRef(*new GPUBuffer(WTFMove(mtlBuffer), descriptor, usage, WTFMove(device)));
    92 }
    93 
    94 GPUBuffer::GPUBuffer(RetainPtr<MTLBuffer>&& buffer, const GPUBufferDescriptor& descriptor, OptionSet<GPUBufferUsage::Flags> usage, Ref<GPUDevice>&& device)
     91    return adoptRef(*new GPUBuffer(WTFMove(mtlBuffer), descriptor.size, usage, WTFMove(device)));
     92}
     93
     94GPUBuffer::GPUBuffer(RetainPtr<MTLBuffer>&& buffer, unsigned long size, OptionSet<GPUBufferUsage::Flags> usage, Ref<GPUDevice>&& device)
    9595    : m_platformBuffer(WTFMove(buffer))
    9696    , m_device(WTFMove(device))
    97     , m_byteLength(descriptor.size)
     97    , m_byteLength(size)
    9898    , m_usage(usage)
    9999{
    … …  
    122122void GPUBuffer::setSubData(unsigned long offset, const JSC::ArrayBuffer& data)
    123123{
     124    MTLCommandQueue *queue;
     125    if (!m_device->tryGetQueue() || !(queue = m_device->tryGetQueue()->platformQueue()))
     126        return;
     127   
    124128    if (!isTransferDestination() || state() != State::Unmapped) {
    125129        LOG(WebGPU, "GPUBuffer::setSubData(): Invalid operation!");
    … …  
    157161    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    158162
    159     auto commandBuffer = retainPtr([m_device->getQueue()->platformQueue() commandBuffer]);
     163    auto commandBuffer = retainPtr([queue commandBuffer]);
    160164    auto blitEncoder = retainPtr([commandBuffer blitCommandEncoder]);
    161165

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUCommandBufferMetal.mm

    r242974 r243563  
    4747    }
    4848
    49     auto gpuCommandQueue = device.getQueue();
     49    auto gpuCommandQueue = device.tryGetQueue();
    5050    if (!gpuCommandQueue)
    5151        return nullptr;

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUDeviceMetal.mm

    r243090 r243563  
    3737namespace WebCore {
    3838
    39 RefPtr<GPUDevice> GPUDevice::tryCreate(Optional<GPURequestAdapterOptions>&& options)
     39RefPtr<GPUDevice> GPUDevice::tryCreate(const Optional<GPURequestAdapterOptions>& options)
    4040{
    4141    RetainPtr<MTLDevice> devicePtr;

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm

    r243457 r243563  
    418418}
    419419
    420 RefPtr<GPURenderPipeline> GPURenderPipeline::create(const GPUDevice& device, GPURenderPipelineDescriptor&& descriptor)
     420RefPtr<GPURenderPipeline> GPURenderPipeline::tryCreate(const GPUDevice& device, const GPURenderPipelineDescriptor& descriptor)
    421421{
    422422    const char* const functionName = "GPURenderPipeline::create()";
    … …  
    436436        return nullptr;
    437437
    438     return adoptRef(new GPURenderPipeline(WTFMove(depthStencil), WTFMove(pipeline), WTFMove(descriptor)));
    439 }
    440 
    441 GPURenderPipeline::GPURenderPipeline(RetainPtr<MTLDepthStencilState>&& depthStencil, RetainPtr<MTLRenderPipelineState>&& pipeline, GPURenderPipelineDescriptor&& descriptor)
     438    return adoptRef(new GPURenderPipeline(WTFMove(depthStencil), WTFMove(pipeline), descriptor.primitiveTopology));
     439}
     440
     441GPURenderPipeline::GPURenderPipeline(RetainPtr<MTLDepthStencilState>&& depthStencil, RetainPtr<MTLRenderPipelineState>&& pipeline, GPUPrimitiveTopology topology)
    442442    : m_depthStencilState(WTFMove(depthStencil))
    443443    , m_platformRenderPipeline(WTFMove(pipeline))
    444     , m_layout(WTFMove(descriptor.layout))
    445     , m_primitiveTopology(descriptor.primitiveTopology)
     444    , m_primitiveTopology(topology)
    446445{
    447446}

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm

    r243091 r243563  
    3838namespace WebCore {
    3939
    40 RefPtr<GPUShaderModule> GPUShaderModule::create(const GPUDevice& device, GPUShaderModuleDescriptor&& descriptor)
     40RefPtr<GPUShaderModule> GPUShaderModule::tryCreate(const GPUDevice& device, const GPUShaderModuleDescriptor& descriptor)
    4141{
    4242    if (!device.platformDevice()) {
Note: See TracChangeset for help on using the changeset viewer.