Register invalid resources separately

1 files changed, 163 insertions, 132 deletions

diff --git a/components/script/dom/gpudevice.rs b/components/script/dom/gpudevice.rs
index 9e3e6d4976d..5044fc8f3dd 100644
--- a/components/script/dom/gpudevice.rs
+++ b/components/script/dom/gpudevice.rs
@@ -293,15 +293,12 @@ impl GPUDeviceMethods for GPUDevice {
 
     /// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createbuffer
     fn CreateBuffer(&self, descriptor: &GPUBufferDescriptor) -> DomRoot<GPUBuffer> {
-        let wgpu_descriptor = wgt::BufferDescriptor {
+        let desc = wgt::BufferUsage::from_bits(descriptor.usage).map(|usg| wgt::BufferDescriptor {
             label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
             size: descriptor.size,
-            usage: match wgt::BufferUsage::from_bits(descriptor.usage) {
-                Some(u) => u,
-                None => wgt::BufferUsage::empty(),
-            },
+            usage: usg,
             mapped_at_creation: descriptor.mappedAtCreation,
-        };
+        });
         let id = self
             .global()
             .wgpu_id_hub()
@@ -309,6 +306,13 @@ impl GPUDeviceMethods for GPUDevice {
             .create_buffer_id(self.device.0.backend());
 
         let scope_id = self.use_current_scope();
+        if desc.is_none() {
+            self.handle_server_msg(
+                scope_id,
+                WebGPUOpResult::ValidationError(String::from("Invalid GPUBufferUsage")),
+            );
+        }
+
         self.channel
             .0
             .send((
@@ -316,7 +320,7 @@ impl GPUDeviceMethods for GPUDevice {
                 WebGPURequest::CreateBuffer {
                     device_id: self.device.0,
                     buffer_id: id,
-                    descriptor: wgpu_descriptor,
+                    descriptor: desc,
                 },
             ))
             .expect("Failed to create WebGPU buffer");
@@ -357,13 +361,17 @@ impl GPUDeviceMethods for GPUDevice {
         &self,
         descriptor: &GPUBindGroupLayoutDescriptor,
     ) -> DomRoot<GPUBindGroupLayout> {
+        let mut valid = true;
         let entries = descriptor
             .entries
             .iter()
             .map(|bind| {
                 let visibility = match wgt::ShaderStage::from_bits(bind.visibility) {
                     Some(visibility) => visibility,
-                    None => wgt::ShaderStage::from_bits(0).unwrap(),
+                    None => {
+                        valid = false;
+                        wgt::ShaderStage::empty()
+                    },
                 };
                 let ty = match bind.type_ {
                     GPUBindingType::Uniform_buffer => wgt::BindingType::UniformBuffer {
@@ -435,13 +443,21 @@ impl GPUDeviceMethods for GPUDevice {
 
         let scope_id = self.use_current_scope();
 
-        let desc = wgt::BindGroupLayoutDescriptor {
-            label: descriptor
-                .parent
-                .label
-                .as_ref()
-                .map(|s| Cow::Owned(s.to_string())),
-            entries: Cow::Owned(entries),
+        let desc = if valid {
+            Some(wgt::BindGroupLayoutDescriptor {
+                label: descriptor
+                    .parent
+                    .label
+                    .as_ref()
+                    .map(|s| Cow::Owned(s.to_string())),
+                entries: Cow::Owned(entries),
+            })
+        } else {
+            self.handle_server_msg(
+                scope_id,
+                WebGPUOpResult::ValidationError(String::from("Invalid GPUShaderStage")),
+            );
+            None
         };
 
         let bind_group_layout_id = self
@@ -695,22 +711,20 @@ impl GPUDeviceMethods for GPUDevice {
     /// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createtexture
     fn CreateTexture(&self, descriptor: &GPUTextureDescriptor) -> DomRoot<GPUTexture> {
         let size = convert_texture_size_to_dict(&descriptor.size);
-        let desc = wgt::TextureDescriptor {
-            label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
-            size: convert_texture_size_to_wgt(&size),
-            mip_level_count: descriptor.mipLevelCount,
-            sample_count: descriptor.sampleCount,
-            dimension: match descriptor.dimension {
-                GPUTextureDimension::_1d => wgt::TextureDimension::D1,
-                GPUTextureDimension::_2d => wgt::TextureDimension::D2,
-                GPUTextureDimension::_3d => wgt::TextureDimension::D3,
-            },
-            format: convert_texture_format(descriptor.format),
-            usage: match wgt::TextureUsage::from_bits(descriptor.usage) {
-                Some(t) => t,
-                None => wgt::TextureUsage::empty(),
-            },
-        };
+        let desc =
+            wgt::TextureUsage::from_bits(descriptor.usage).map(|usg| wgt::TextureDescriptor {
+                label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
+                size: convert_texture_size_to_wgt(&size),
+                mip_level_count: descriptor.mipLevelCount,
+                sample_count: descriptor.sampleCount,
+                dimension: match descriptor.dimension {
+                    GPUTextureDimension::_1d => wgt::TextureDimension::D1,
+                    GPUTextureDimension::_2d => wgt::TextureDimension::D2,
+                    GPUTextureDimension::_3d => wgt::TextureDimension::D3,
+                },
+                format: convert_texture_format(descriptor.format),
+                usage: usg,
+            });
 
         let texture_id = self
             .global()
@@ -719,7 +733,12 @@ impl GPUDeviceMethods for GPUDevice {
             .create_texture_id(self.device.0.backend());
 
         let scope_id = self.use_current_scope();
-
+        if desc.is_none() {
+            self.handle_server_msg(
+                scope_id,
+                WebGPUOpResult::ValidationError(String::from("Invalid GPUTextureUsage")),
+            );
+        }
         self.channel
             .0
             .send((
@@ -803,110 +822,124 @@ impl GPUDeviceMethods for GPUDevice {
     ) -> DomRoot<GPURenderPipeline> {
         let ref rs_desc = descriptor.rasterizationState;
         let ref vs_desc = descriptor.vertexState;
+        let scope_id = self.use_current_scope();
+        let mut valid = true;
+        let color_states = Cow::Owned(
+            descriptor
+                .colorStates
+                .iter()
+                .map(|state| wgt::ColorStateDescriptor {
+                    format: convert_texture_format(state.format),
+                    alpha_blend: convert_blend_descriptor(&state.alphaBlend),
+                    color_blend: convert_blend_descriptor(&state.colorBlend),
+                    write_mask: match wgt::ColorWrite::from_bits(state.writeMask) {
+                        Some(mask) => mask,
+                        None => {
+                            valid = false;
+                            wgt::ColorWrite::empty()
+                        },
+                    },
+                })
+                .collect::<Vec<_>>(),
+        );
 
-        let desc = wgpu_pipe::RenderPipelineDescriptor {
-            layout: descriptor.parent.layout.id().0,
-            vertex_stage: wgpu_pipe::ProgrammableStageDescriptor {
-                module: descriptor.vertexStage.module.id().0,
-                entry_point: Cow::Owned(descriptor.vertexStage.entryPoint.to_string()),
-            },
-            fragment_stage: descriptor.fragmentStage.as_ref().map(|stage| {
-                wgpu_pipe::ProgrammableStageDescriptor {
-                    module: stage.module.id().0,
-                    entry_point: Cow::Owned(stage.entryPoint.to_string()),
-                }
-            }),
-            rasterization_state: Some(wgt::RasterizationStateDescriptor {
-                front_face: match rs_desc.frontFace {
-                    GPUFrontFace::Ccw => wgt::FrontFace::Ccw,
-                    GPUFrontFace::Cw => wgt::FrontFace::Cw,
+        let desc = if valid {
+            Some(wgpu_pipe::RenderPipelineDescriptor {
+                layout: descriptor.parent.layout.id().0,
+                vertex_stage: wgpu_pipe::ProgrammableStageDescriptor {
+                    module: descriptor.vertexStage.module.id().0,
+                    entry_point: Cow::Owned(descriptor.vertexStage.entryPoint.to_string()),
                 },
-                cull_mode: match rs_desc.cullMode {
-                    GPUCullMode::None => wgt::CullMode::None,
-                    GPUCullMode::Front => wgt::CullMode::Front,
-                    GPUCullMode::Back => wgt::CullMode::Back,
+                fragment_stage: descriptor.fragmentStage.as_ref().map(|stage| {
+                    wgpu_pipe::ProgrammableStageDescriptor {
+                        module: stage.module.id().0,
+                        entry_point: Cow::Owned(stage.entryPoint.to_string()),
+                    }
+                }),
+                rasterization_state: Some(wgt::RasterizationStateDescriptor {
+                    front_face: match rs_desc.frontFace {
+                        GPUFrontFace::Ccw => wgt::FrontFace::Ccw,
+                        GPUFrontFace::Cw => wgt::FrontFace::Cw,
+                    },
+                    cull_mode: match rs_desc.cullMode {
+                        GPUCullMode::None => wgt::CullMode::None,
+                        GPUCullMode::Front => wgt::CullMode::Front,
+                        GPUCullMode::Back => wgt::CullMode::Back,
+                    },
+                    clamp_depth: rs_desc.clampDepth,
+                    depth_bias: rs_desc.depthBias,
+                    depth_bias_slope_scale: *rs_desc.depthBiasSlopeScale,
+                    depth_bias_clamp: *rs_desc.depthBiasClamp,
+                }),
+                primitive_topology: match descriptor.primitiveTopology {
+                    GPUPrimitiveTopology::Point_list => wgt::PrimitiveTopology::PointList,
+                    GPUPrimitiveTopology::Line_list => wgt::PrimitiveTopology::LineList,
+                    GPUPrimitiveTopology::Line_strip => wgt::PrimitiveTopology::LineStrip,
+                    GPUPrimitiveTopology::Triangle_list => wgt::PrimitiveTopology::TriangleList,
+                    GPUPrimitiveTopology::Triangle_strip => wgt::PrimitiveTopology::TriangleStrip,
                 },
-                clamp_depth: rs_desc.clampDepth,
-                depth_bias: rs_desc.depthBias,
-                depth_bias_slope_scale: *rs_desc.depthBiasSlopeScale,
-                depth_bias_clamp: *rs_desc.depthBiasClamp,
-            }),
-            primitive_topology: match descriptor.primitiveTopology {
-                GPUPrimitiveTopology::Point_list => wgt::PrimitiveTopology::PointList,
-                GPUPrimitiveTopology::Line_list => wgt::PrimitiveTopology::LineList,
-                GPUPrimitiveTopology::Line_strip => wgt::PrimitiveTopology::LineStrip,
-                GPUPrimitiveTopology::Triangle_list => wgt::PrimitiveTopology::TriangleList,
-                GPUPrimitiveTopology::Triangle_strip => wgt::PrimitiveTopology::TriangleStrip,
-            },
-            color_states: Cow::Owned(
-                descriptor
-                    .colorStates
-                    .iter()
-                    .map(|state| wgt::ColorStateDescriptor {
-                        format: convert_texture_format(state.format),
-                        alpha_blend: convert_blend_descriptor(&state.alphaBlend),
-                        color_blend: convert_blend_descriptor(&state.colorBlend),
-                        write_mask: match wgt::ColorWrite::from_bits(state.writeMask) {
-                            Some(mask) => mask,
-                            None => wgt::ColorWrite::empty(),
+                color_states,
+                depth_stencil_state: descriptor.depthStencilState.as_ref().map(|dss_desc| {
+                    wgt::DepthStencilStateDescriptor {
+                        format: convert_texture_format(dss_desc.format),
+                        depth_write_enabled: dss_desc.depthWriteEnabled,
+                        depth_compare: convert_compare_function(dss_desc.depthCompare),
+                        stencil_front: wgt::StencilStateFaceDescriptor {
+                            compare: convert_compare_function(dss_desc.stencilFront.compare),
+                            fail_op: convert_stencil_op(dss_desc.stencilFront.failOp),
+                            depth_fail_op: convert_stencil_op(dss_desc.stencilFront.depthFailOp),
+                            pass_op: convert_stencil_op(dss_desc.stencilFront.passOp),
                         },
-                    })
-                    .collect::<Vec<_>>(),
-            ),
-            depth_stencil_state: descriptor.depthStencilState.as_ref().map(|dss_desc| {
-                wgt::DepthStencilStateDescriptor {
-                    format: convert_texture_format(dss_desc.format),
-                    depth_write_enabled: dss_desc.depthWriteEnabled,
-                    depth_compare: convert_compare_function(dss_desc.depthCompare),
-                    stencil_front: wgt::StencilStateFaceDescriptor {
-                        compare: convert_compare_function(dss_desc.stencilFront.compare),
-                        fail_op: convert_stencil_op(dss_desc.stencilFront.failOp),
-                        depth_fail_op: convert_stencil_op(dss_desc.stencilFront.depthFailOp),
-                        pass_op: convert_stencil_op(dss_desc.stencilFront.passOp),
-                    },
-                    stencil_back: wgt::StencilStateFaceDescriptor {
-                        compare: convert_compare_function(dss_desc.stencilBack.compare),
-                        fail_op: convert_stencil_op(dss_desc.stencilBack.failOp),
-                        depth_fail_op: convert_stencil_op(dss_desc.stencilBack.depthFailOp),
-                        pass_op: convert_stencil_op(dss_desc.stencilBack.passOp),
+                        stencil_back: wgt::StencilStateFaceDescriptor {
+                            compare: convert_compare_function(dss_desc.stencilBack.compare),
+                            fail_op: convert_stencil_op(dss_desc.stencilBack.failOp),
+                            depth_fail_op: convert_stencil_op(dss_desc.stencilBack.depthFailOp),
+                            pass_op: convert_stencil_op(dss_desc.stencilBack.passOp),
+                        },
+                        stencil_read_mask: dss_desc.stencilReadMask,
+                        stencil_write_mask: dss_desc.stencilWriteMask,
+                    }
+                }),
+                vertex_state: wgt::VertexStateDescriptor {
+                    index_format: match vs_desc.indexFormat {
+                        GPUIndexFormat::Uint16 => wgt::IndexFormat::Uint16,
+                        GPUIndexFormat::Uint32 => wgt::IndexFormat::Uint32,
                     },
-                    stencil_read_mask: dss_desc.stencilReadMask,
-                    stencil_write_mask: dss_desc.stencilWriteMask,
-                }
-            }),
-            vertex_state: wgt::VertexStateDescriptor {
-                index_format: match vs_desc.indexFormat {
-                    GPUIndexFormat::Uint16 => wgt::IndexFormat::Uint16,
-                    GPUIndexFormat::Uint32 => wgt::IndexFormat::Uint32,
+                    vertex_buffers: Cow::Owned(
+                        vs_desc
+                            .vertexBuffers
+                            .iter()
+                            .map(|buffer| wgt::VertexBufferDescriptor {
+                                stride: buffer.arrayStride,
+                                step_mode: match buffer.stepMode {
+                                    GPUInputStepMode::Vertex => wgt::InputStepMode::Vertex,
+                                    GPUInputStepMode::Instance => wgt::InputStepMode::Instance,
+                                },
+                                attributes: Cow::Owned(
+                                    buffer
+                                        .attributes
+                                        .iter()
+                                        .map(|att| wgt::VertexAttributeDescriptor {
+                                            format: convert_vertex_format(att.format),
+                                            offset: att.offset,
+                                            shader_location: att.shaderLocation,
+                                        })
+                                        .collect::<Vec<_>>(),
+                                ),
+                            })
+                            .collect::<Vec<_>>(),
+                    ),
                 },
-                vertex_buffers: Cow::Owned(
-                    vs_desc
-                        .vertexBuffers
-                        .iter()
-                        .map(|buffer| wgt::VertexBufferDescriptor {
-                            stride: buffer.arrayStride,
-                            step_mode: match buffer.stepMode {
-                                GPUInputStepMode::Vertex => wgt::InputStepMode::Vertex,
-                                GPUInputStepMode::Instance => wgt::InputStepMode::Instance,
-                            },
-                            attributes: Cow::Owned(
-                                buffer
-                                    .attributes
-                                    .iter()
-                                    .map(|att| wgt::VertexAttributeDescriptor {
-                                        format: convert_vertex_format(att.format),
-                                        offset: att.offset,
-                                        shader_location: att.shaderLocation,
-                                    })
-                                    .collect::<Vec<_>>(),
-                            ),
-                        })
-                        .collect::<Vec<_>>(),
-                ),
-            },
-            sample_count: descriptor.sampleCount,
-            sample_mask: descriptor.sampleMask,
-            alpha_to_coverage_enabled: descriptor.alphaToCoverageEnabled,
+                sample_count: descriptor.sampleCount,
+                sample_mask: descriptor.sampleMask,
+                alpha_to_coverage_enabled: descriptor.alphaToCoverageEnabled,
+            })
+        } else {
+            self.handle_server_msg(
+                scope_id,
+                WebGPUOpResult::ValidationError(String::from("Invalid GPUColorWriteFlags")),
+            );
+            None
         };
 
         let render_pipeline_id = self
@@ -915,8 +948,6 @@ impl GPUDeviceMethods for GPUDevice {
             .lock()
             .create_render_pipeline_id(self.device.0.backend());
 
-        let scope_id = self.use_current_scope();
-
         self.channel
             .0
             .send((