From 43d1601016e03fe83fe9b8a526357de1d5fc4122 Mon Sep 17 00:00:00 2001
From: Samson <16504129+sagudev@users.noreply.github.com>
Date: Tue, 29 Oct 2024 19:42:07 +0100
Subject: [PATCH] Only send mapping back on unmap when MapMode = WRITE (#34054)

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
---
 components/script/dom/gpubuffer.rs     | 15 +++++++++------
 components/webgpu/ipc_messages/recv.rs |  8 +++-----
 components/webgpu/wgpu_thread.rs       | 20 ++++++++------------
 3 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/components/script/dom/gpubuffer.rs b/components/script/dom/gpubuffer.rs
index 7cd56c9741c..0cae783d653 100644
--- a/components/script/dom/gpubuffer.rs
+++ b/components/script/dom/gpubuffer.rs
@@ -205,10 +205,15 @@ impl GPUBufferMethods for GPUBuffer {
         // Step 5&7
         if let Err(e) = self.channel.0.send(WebGPURequest::UnmapBuffer {
             buffer_id: self.id().0,
-            array_buffer: IpcSharedMemory::from_bytes(mapping.data.data()),
-            write_back: mapping.mode >= GPUMapModeConstants::WRITE,
-            offset: mapping.range.start,
-            size: mapping.range.end - mapping.range.start,
+            mapping: if mapping.mode >= GPUMapModeConstants::WRITE {
+                Some(Mapping {
+                    data: IpcSharedMemory::from_bytes(mapping.data.data()),
+                    range: mapping.range.clone(),
+                    mode: HostMap::Write,
+                })
+            } else {
+                None
+            },
         }) {
             warn!("Failed to send Buffer unmap ({:?}) ({})", self.buffer.0, e);
         }
@@ -249,8 +254,6 @@ impl GPUBufferMethods for GPUBuffer {
         // Step 4
         *self.pending_map.borrow_mut() = Some(promise.clone());
         // Step 5
-
-        // This should be bitflags in wgpu-core
         let host_map = match mode {
             GPUMapModeConstants::READ => HostMap::Read,
             GPUMapModeConstants::WRITE => HostMap::Write,
diff --git a/components/webgpu/ipc_messages/recv.rs b/components/webgpu/ipc_messages/recv.rs
index bc907c497a1..bb478ad571d 100644
--- a/components/webgpu/ipc_messages/recv.rs
+++ b/components/webgpu/ipc_messages/recv.rs
@@ -32,7 +32,7 @@ pub use {wgpu_core as wgc, wgpu_types as wgt};
 use crate::identity::*;
 use crate::render_commands::RenderCommand;
 use crate::swapchain::WebGPUContextId;
-use crate::{Error, ErrorFilter, WebGPUResponse, PRESENTATION_BUFFER_COUNT};
+use crate::{Error, ErrorFilter, Mapping, WebGPUResponse, PRESENTATION_BUFFER_COUNT};
 
 #[derive(Clone, Copy, Debug, Deserialize, Serialize)]
 pub struct ContextConfiguration {
@@ -276,10 +276,8 @@ pub enum WebGPURequest {
     },
     UnmapBuffer {
         buffer_id: id::BufferId,
-        array_buffer: IpcSharedMemory,
-        write_back: bool,
-        offset: u64,
-        size: u64,
+        /// Return back mapping for writeback
+        mapping: Option<Mapping>,
     },
     WriteBuffer {
         device_id: id::DeviceId,
diff --git a/components/webgpu/wgpu_thread.rs b/components/webgpu/wgpu_thread.rs
index 70ecb79d8e2..3b1e43d6392 100644
--- a/components/webgpu/wgpu_thread.rs
+++ b/components/webgpu/wgpu_thread.rs
@@ -995,25 +995,21 @@ impl WGPU {
                         };
                         self.maybe_dispatch_error(device_id, result.err());
                     },
-                    WebGPURequest::UnmapBuffer {
-                        buffer_id,
-                        array_buffer,
-                        write_back,
-                        offset,
-                        size,
-                    } => {
+                    WebGPURequest::UnmapBuffer { buffer_id, mapping } => {
                         let global = &self.global;
-                        if write_back {
-                            if let Ok((slice_pointer, range_size)) =
-                                global.buffer_get_mapped_range(buffer_id, offset, Some(size))
-                            {
+                        if let Some(mapping) = mapping {
+                            if let Ok((slice_pointer, range_size)) = global.buffer_get_mapped_range(
+                                buffer_id,
+                                mapping.range.start,
+                                Some(mapping.range.end - mapping.range.start),
+                            ) {
                                 unsafe {
                                     slice::from_raw_parts_mut(
                                         slice_pointer.as_ptr(),
                                         range_size as usize,
                                     )
                                 }
-                                .copy_from_slice(&array_buffer);
+                                .copy_from_slice(&mapping.data);
                             }
                         }
                         // Ignore result because this operation always succeed from user perspective