Auto merge of #27173 - kunalmohan:gpu-queue-write, r=kvark

Implement GPUQueue write methods and update wgpu-core

<!-- Please describe your changes on the following line: -->
Implements `GPUQueue.writeBuffer` and `GPUQueue.writeTexture`.

r?@kvark

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `___` with appropriate data: -->
- [X] `./mach build -d` does not report any errors
- [X] `./mach test-tidy` does not report any errors
- [ ] These changes fix #___ (GitHub issue number if applicable)

<!-- Either: -->
- [ ] There are tests for these changes OR
- [ ] These changes do not require tests because ___

<!-- Also, please make sure that "Allow edits from maintainers" checkbox is checked, so that we can help you if you get stuck somewhere along the way.-->

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->

components/script/dom/gpuadapter.rs

@@ -81,7 +81,7 @@ impl GPUAdapterMethods for GPUAdapter {
         let promise = Promise::new_in_current_realm(&self.global(), comp);
         let sender = response_async(&promise, self);
         let desc = wgt::DeviceDescriptor {
-            extensions: wgt::Extensions::empty(),
+            features: wgt::Features::empty(),
             limits: wgt::Limits {
                 max_bind_groups: descriptor.limits.maxBindGroups,
                 ..Default::default()

components/script/dom/gpudevice.rs

@@ -874,7 +874,7 @@ pub fn convert_texture_view_dimension(
     }
 }
 
-fn convert_texture_size_to_dict(size: &GPUExtent3D) -> GPUExtent3DDict {
+pub fn convert_texture_size_to_dict(size: &GPUExtent3D) -> GPUExtent3DDict {
     match *size {
         GPUExtent3D::GPUExtent3DDict(ref dict) => GPUExtent3DDict {
             width: dict.width,
@@ -889,7 +889,7 @@ fn convert_texture_size_to_dict(size: &GPUExtent3D) -> GPUExtent3DDict {
     }
 }
 
-fn convert_texture_size_to_wgt(size: &GPUExtent3DDict) -> wgt::Extent3d {
+pub fn convert_texture_size_to_wgt(size: &GPUExtent3DDict) -> wgt::Extent3d {
     wgt::Extent3d {
         width: size.width,
         height: size.height,

components/script/dom/gpuqueue.rs

@@ -3,15 +3,24 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use crate::dom::bindings::cell::DomRefCell;
+use crate::dom::bindings::codegen::Bindings::GPUBufferBinding::GPUSize64;
 use crate::dom::bindings::codegen::Bindings::GPUQueueBinding::GPUQueueMethods;
+use crate::dom::bindings::codegen::Bindings::GPUTextureBinding::{
+    GPUExtent3D, GPUOrigin3D, GPUTextureCopyView, GPUTextureDataLayout,
+};
+use crate::dom::bindings::error::{Error, Fallible};
 use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
 use crate::dom::bindings::root::DomRoot;
 use crate::dom::bindings::str::DOMString;
 use crate::dom::globalscope::GlobalScope;
-use crate::dom::gpubuffer::GPUBufferState;
+use crate::dom::gpubuffer::{GPUBuffer, GPUBufferState};
 use crate::dom::gpucommandbuffer::GPUCommandBuffer;
+use crate::dom::gpudevice::{convert_texture_size_to_dict, convert_texture_size_to_wgt};
 use dom_struct::dom_struct;
-use webgpu::{WebGPU, WebGPUQueue, WebGPURequest};
+use ipc_channel::ipc::IpcSharedMemory;
+use js::rust::CustomAutoRooterGuard;
+use js::typedarray::ArrayBuffer;
+use webgpu::{wgpu::command as wgpu_com, wgt, WebGPU, WebGPUQueue, WebGPURequest};
 
 #[dom_struct]
 pub struct GPUQueue {
@@ -69,4 +78,105 @@ impl GPUQueueMethods for GPUQueue {
             })
             .unwrap();
     }
+
+    /// https://gpuweb.github.io/gpuweb/#dom-gpuqueue-writebuffer
+    #[allow(unsafe_code)]
+    fn WriteBuffer(
+        &self,
+        buffer: &GPUBuffer,
+        buffer_offset: GPUSize64,
+        data: CustomAutoRooterGuard<ArrayBuffer>,
+        data_offset: GPUSize64,
+        size: Option<GPUSize64>,
+    ) -> Fallible<()> {
+        let bytes = data.to_vec();
+        let content_size = if let Some(s) = size {
+            s
+        } else {
+            bytes.len() as GPUSize64 - data_offset
+        };
+        let valid = data_offset + content_size <= bytes.len() as u64 &&
+            buffer.state() == GPUBufferState::Unmapped &&
+            content_size % wgt::COPY_BUFFER_ALIGNMENT == 0 &&
+            buffer_offset % wgt::COPY_BUFFER_ALIGNMENT == 0 &&
+            buffer.is_valid();
+
+        if !valid {
+            return Err(Error::Operation);
+        }
+
+        let final_data = IpcSharedMemory::from_bytes(
+            &bytes[data_offset as usize..(data_offset + content_size) as usize],
+        );
+        if let Err(e) = self.channel.0.send(WebGPURequest::WriteBuffer {
+            queue_id: self.queue.0,
+            buffer_id: buffer.id().0,
+            buffer_offset,
+            data: final_data,
+        }) {
+            warn!("Failed to send WriteBuffer({:?}) ({})", buffer.id(), e);
+            return Err(Error::Operation);
+        }
+
+        Ok(())
+    }
+
+    /// https://gpuweb.github.io/gpuweb/#dom-gpuqueue-writetexture
+    fn WriteTexture(
+        &self,
+        destination: &GPUTextureCopyView,
+        data: CustomAutoRooterGuard<ArrayBuffer>,
+        data_layout: &GPUTextureDataLayout,
+        size: GPUExtent3D,
+    ) -> Fallible<()> {
+        let bytes = data.to_vec();
+        let valid = data_layout.offset <= data.len() as u64 && destination.texture.is_valid();
+
+        if !valid {
+            return Err(Error::Operation);
+        }
+
+        let texture_cv = wgpu_com::TextureCopyView {
+            texture: destination.texture.id().0,
+            mip_level: destination.mipLevel,
+            origin: match destination.origin {
+                GPUOrigin3D::RangeEnforcedUnsignedLongSequence(ref v) => wgt::Origin3d {
+                    x: v[0],
+                    y: v[1],
+                    z: v[2],
+                },
+                GPUOrigin3D::GPUOrigin3DDict(ref d) => wgt::Origin3d {
+                    x: d.x,
+                    y: d.y,
+                    z: d.z,
+                },
+            },
+        };
+
+        let texture_layout = wgt::TextureDataLayout {
+            offset: data_layout.offset as wgt::BufferAddress,
+            bytes_per_row: data_layout.bytesPerRow,
+            rows_per_image: data_layout.rowsPerImage,
+        };
+
+        let write_size = convert_texture_size_to_wgt(&convert_texture_size_to_dict(&size));
+        let final_data = IpcSharedMemory::from_bytes(&bytes);
+
+        if let Err(e) = self.channel.0.send(WebGPURequest::WriteTexture {
+            queue_id: self.queue.0,
+            texture_cv,
+            data_layout: texture_layout,
+            size: write_size,
+            data: final_data,
+        }) {
+            warn!(
+                "Failed to send WriteTexture({:?}) ({})",
+                destination.texture.id().0,
+                e
+            );
+            return Err(Error::Operation);
+        }
+
+        Ok(())
+    }
 }

components/script/dom/gputexture.rs

@@ -107,6 +107,10 @@ impl GPUTexture {
     pub fn id(&self) -> WebGPUTexture {
         self.texture
     }
+
+    pub fn is_valid(&self) -> bool {
+        self.valid.get()
+    }
 }
 
 impl GPUTextureMethods for GPUTexture {

components/script/dom/webidls/GPUBuffer.webidl

@@ -20,5 +20,3 @@ dictionary GPUBufferDescriptor : GPUObjectDescriptorBase {
 };
 
 typedef unsigned long long GPUSize64;
-
-typedef sequence<any> GPUMappedBuffer;

components/script/dom/webidls/GPUQueue.webidl

@@ -7,12 +7,25 @@
 interface GPUQueue {
     void submit(sequence<GPUCommandBuffer> commandBuffers);
 
-    // GPUFence createFence(optional GPUFenceDescriptor descriptor = {});
-    // void signal(GPUFence fence, unsigned long long signalValue);
+    //GPUFence createFence(optional GPUFenceDescriptor descriptor = {});
+    //void signal(GPUFence fence, GPUFenceValue signalValue);
 
-    // void copyImageBitmapToTexture(
-    //     GPUImageBitmapCopyView source,
-    //     GPUTextureCopyView destination,
-    //     GPUExtent3D copySize);
+    [Throws] void writeBuffer(
+        GPUBuffer buffer,
+        GPUSize64 bufferOffset,
+        /*[AllowShared]*/ ArrayBuffer data,
+        optional GPUSize64 dataOffset = 0,
+        optional GPUSize64 size);
+
+    [Throws] void writeTexture(
+      GPUTextureCopyView destination,
+      /*[AllowShared]*/ ArrayBuffer data,
+      GPUTextureDataLayout dataLayout,
+      GPUExtent3D size);
+
+    //void copyImageBitmapToTexture(
+    //    GPUImageBitmapCopyView source,
+    //    GPUTextureCopyView destination,
+    //    GPUExtent3D copySize);
 };
 GPUQueue includes GPUObjectBase;

components/script/dom/webidls/GPUTexture.webidl

@@ -92,3 +92,22 @@ dictionary GPUExtent3DDict {
 };
 typedef [EnforceRange] unsigned long GPUIntegerCoordinate;
 typedef (sequence<GPUIntegerCoordinate> or GPUExtent3DDict) GPUExtent3D;
+
+dictionary GPUTextureCopyView {
+    required GPUTexture texture;
+    GPUIntegerCoordinate mipLevel = 0;
+    GPUOrigin3D origin = {};
+};
+
+dictionary GPUTextureDataLayout {
+    GPUSize64 offset = 0;
+    required GPUSize32 bytesPerRow;
+    GPUSize32 rowsPerImage = 0;
+};
+
+dictionary GPUOrigin3DDict {
+    GPUIntegerCoordinate x = 0;
+    GPUIntegerCoordinate y = 0;
+    GPUIntegerCoordinate z = 0;
+};
+typedef (sequence<GPUIntegerCoordinate> or GPUOrigin3DDict) GPUOrigin3D;