Implement GPUBuffer.getMappedRange()

components/constellation/constellation.rs

@@ -2769,13 +2769,6 @@ where
             warn!("Exit Canvas Paint thread failed ({})", e);
         }
 
-        if let Some(webgl_threads) = self.webgl_threads.as_ref() {
-            debug!("Exiting WebGL thread.");
-            if let Err(e) = webgl_threads.exit() {
-                warn!("Exit WebGL Thread failed ({})", e);
-            }
-        }
-
         debug!("Exiting WebGPU threads.");
         let receivers = self
             .browsing_context_group_set
@@ -2800,6 +2793,13 @@ where
             }
         }
 
+        if let Some(webgl_threads) = self.webgl_threads.as_ref() {
+            debug!("Exiting WebGL thread.");
+            if let Err(e) = webgl_threads.exit() {
+                warn!("Exit WebGL Thread failed ({})", e);
+            }
+        }
+
         debug!("Exiting GLPlayer thread.");
         if let Some(glplayer_threads) = self.glplayer_threads.as_ref() {
             if let Err(e) = glplayer_threads.exit() {

components/script/dom/gpubuffer.rs

@@ -2,32 +2,35 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::dom::bindings::cell::DomRefCell;
+use crate::dom::bindings::cell::{DomRefCell, RefCell};
 use crate::dom::bindings::codegen::Bindings::GPUBufferBinding::{GPUBufferMethods, GPUSize64};
 use crate::dom::bindings::codegen::Bindings::GPUMapModeBinding::GPUMapModeConstants;
-use crate::dom::bindings::error::Error;
+use crate::dom::bindings::error::{Error, Fallible};
 use crate::dom::bindings::reflector::DomObject;
 use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
 use crate::dom::bindings::root::DomRoot;
 use crate::dom::bindings::str::DOMString;
-use crate::dom::bindings::trace::RootedTraceableBox;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::gpu::{response_async, AsyncWGPUListener};
 use crate::dom::promise::Promise;
 use crate::realms::InRealm;
+use crate::script_runtime::JSContext;
 use dom_struct::dom_struct;
+use js::jsapi::DetachArrayBuffer;
+use js::jsapi::NewExternalArrayBuffer;
 use js::jsapi::{Heap, JSObject};
-use js::jsval::UndefinedValue;
-use js::rust::jsapi_wrapped::{DetachArrayBuffer, IsPromiseObject, RejectPromise};
-use js::typedarray::{ArrayBuffer, CreateWith};
 use std::cell::Cell;
+use std::ffi::c_void;
 use std::ops::Range;
-use std::ptr;
+use std::ptr::NonNull;
 use std::rc::Rc;
 use webgpu::{
     wgpu::device::HostMap, WebGPU, WebGPUBuffer, WebGPUDevice, WebGPURequest, WebGPUResponse,
 };
 
+const RANGE_OFFSET_ALIGN_MASK: u64 = 8;
+const RANGE_SIZE_ALIGN_MASK: u64 = 4;
+
 // https://gpuweb.github.io/gpuweb/#buffer-state
 #[derive(Clone, Copy, MallocSizeOf, PartialEq)]
 pub enum GPUBufferState {
@@ -49,8 +52,13 @@ pub struct GPUBuffer {
     device: WebGPUDevice,
     valid: Cell<bool>,
     #[ignore_malloc_size_of = "defined in mozjs"]
-    mapping: RootedTraceableBox<Heap<*mut JSObject>>,
+    mapping: Rc<RefCell<Option<Vec<u8>>>>,
-    mapping_range: DomRefCell<Range<u64>>,
+    mapping_range: DomRefCell<Option<Range<u64>>>,
+    mapped_ranges: DomRefCell<Option<Vec<Range<u64>>>>,
+    #[ignore_malloc_size_of = "defined in mozjs"]
+    js_buffers: DomRefCell<Option<Vec<Box<Heap<*mut JSObject>>>>>,
+    #[ignore_malloc_size_of = "defined in mozjs"]
+    map_promise: DomRefCell<Option<Rc<Promise>>>,
     size: GPUSize64,
     map_mode: Cell<Option<u32>>,
 }
@@ -63,7 +71,7 @@ impl GPUBuffer {
         state: GPUBufferState,
         size: GPUSize64,
         valid: bool,
-        mapping: RootedTraceableBox<Heap<*mut JSObject>>,
+        mapping: Rc<RefCell<Option<Vec<u8>>>>,
         mapping_range: Range<u64>,
     ) -> Self {
         Self {
@@ -75,8 +83,11 @@ impl GPUBuffer {
             device,
             buffer,
             mapping,
+            mapped_ranges: DomRefCell::new(None),
+            js_buffers: DomRefCell::new(None),
+            map_promise: DomRefCell::new(None),
             size,
-            mapping_range: DomRefCell::new(mapping_range),
+            mapping_range: DomRefCell::new(Some(mapping_range)),
             map_mode: Cell::new(None),
         }
     }
@@ -90,7 +101,7 @@ impl GPUBuffer {
         state: GPUBufferState,
         size: GPUSize64,
         valid: bool,
-        mapping: RootedTraceableBox<Heap<*mut JSObject>>,
+        mapping: Rc<RefCell<Option<Vec<u8>>>>,
         mapping_range: Range<u64>,
     ) -> DomRoot<Self> {
         reflect_dom_object(
@@ -142,51 +153,34 @@ impl GPUBufferMethods for GPUBuffer {
             },
             // Step 3
             GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => {
-                match ArrayBuffer::from(self.mapping.get()) {
+                if let Err(e) = self.channel.0.send(WebGPURequest::UnmapBuffer {
-                    Ok(array_buffer) => {
-                        // Step 3.2
-                        self.channel
-                            .0
-                            .send(WebGPURequest::UnmapBuffer {
                     buffer_id: self.id().0,
-                                array_buffer: array_buffer.to_vec(),
+                    array_buffer: self.mapping.borrow().as_ref().unwrap().clone(),
                     is_map_read: self.map_mode.get() == Some(GPUMapModeConstants::READ),
-                                offset: self.mapping_range.borrow().start,
+                    offset: self.mapping_range.borrow().as_ref().unwrap().start,
-                                size: self.mapping_range.borrow().end -
+                    size: self.mapping_range.borrow().as_ref().unwrap().end -
-                                    self.mapping_range.borrow().start,
+                        self.mapping_range.borrow().as_ref().unwrap().start,
-                            })
+                }) {
-                            .unwrap();
+                    warn!("Failed to send Buffer unmap ({:?}) ({})", self.buffer.0, e);
-                        // Step 3.3
-                        unsafe {
-                            DetachArrayBuffer(*cx, self.mapping.handle());
                 }
-                    },
+                // Step 3.3
-                    Err(_) => {
+                let mut bufs = self.js_buffers.borrow_mut().take().unwrap();
-                        warn!(
+                bufs.drain(..).for_each(|obj| unsafe {
-                            "Could not find ArrayBuffer of Mapped buffer ({:?})",
+                    DetachArrayBuffer(*cx, obj.handle());
-                            self.buffer.0
+                });
-                        );
+                *self.mapped_ranges.borrow_mut() = None;
-                    },
+                *self.mapping.borrow_mut() = None;
-                };
             },
             // Step 2
-            GPUBufferState::MappingPending => unsafe {
+            GPUBufferState::MappingPending => {
-                if IsPromiseObject(self.mapping.handle()) {
+                let promise = self.map_promise.borrow_mut().take().unwrap();
-                    let err = Error::Operation;
+                promise.reject_error(Error::Operation);
-                    rooted!(in(*cx) let mut undef = UndefinedValue());
-                    err.to_jsval(*cx, &self.global(), undef.handle_mut());
-                    RejectPromise(*cx, self.mapping.handle(), undef.handle());
-                } else {
-                    warn!("No promise object for pending mapping found");
-                }
             },
         };
-        // Step 3.3
-        self.mapping.set(ptr::null_mut());
         // Step 4
         self.state.set(GPUBufferState::Unmapped);
         self.map_mode.set(None);
-        *self.mapping_range.borrow_mut() = 0..0;
+        *self.mapping_range.borrow_mut() = None;
     }
 
     /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-destroy
@@ -213,7 +207,13 @@ impl GPUBufferMethods for GPUBuffer {
 
     #[allow(unsafe_code)]
     /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapasync-offset-size
-    fn MapAsync(&self, mode: u32, offset: u64, size: u64, comp: InRealm) -> Rc<Promise> {
+    fn MapAsync(
+        &self,
+        mode: u32,
+        offset: GPUSize64,
+        size: GPUSize64,
+        comp: InRealm,
+    ) -> Rc<Promise> {
         let promise = Promise::new_in_current_realm(&self.global(), comp);
         let map_range = if size == 0 {
             offset..self.size
@@ -237,7 +237,6 @@ impl GPUBufferMethods for GPUBuffer {
             promise.reject_error(Error::Abort);
             return promise;
         }
-        self.mapping.set(*promise.promise_obj());
 
         let sender = response_async(&promise, self);
         if let Err(e) = self.channel.0.send(WebGPURequest::BufferMapAsync {
@@ -256,10 +255,72 @@ impl GPUBufferMethods for GPUBuffer {
 
         self.state.set(GPUBufferState::MappingPending);
         self.map_mode.set(Some(mode));
-        *self.mapping_range.borrow_mut() = map_range;
+        *self.mapping_range.borrow_mut() = Some(map_range);
+        *self.map_promise.borrow_mut() = Some(promise.clone());
         promise
     }
 
+    /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-getmappedrange
+    #[allow(unsafe_code)]
+    fn GetMappedRange(
+        &self,
+        cx: JSContext,
+        offset: GPUSize64,
+        size: GPUSize64,
+    ) -> Fallible<NonNull<JSObject>> {
+        if self.mapped_ranges.borrow().is_none() {
+            *self.mapped_ranges.borrow_mut() = Some(Vec::new());
+        }
+        if self.js_buffers.borrow().is_none() {
+            *self.js_buffers.borrow_mut() = Some(Vec::new());
+        }
+        let act_size = if size == 0 { self.size - offset } else { size };
+        let mut valid = match self.state.get() {
+            GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => true,
+            _ => false,
+        };
+        valid &= offset % RANGE_OFFSET_ALIGN_MASK == 0 &&
+            act_size % RANGE_SIZE_ALIGN_MASK == 0 &&
+            offset >= self.mapping_range.borrow().as_ref().unwrap().start &&
+            offset + act_size <= self.mapping_range.borrow().as_ref().unwrap().end;
+        valid &= self
+            .mapped_ranges
+            .borrow()
+            .as_ref()
+            .unwrap()
+            .iter()
+            .all(|range| range.start > offset + act_size || range.end < offset);
+        if !valid {
+            return Err(Error::Operation);
+        }
+
+        unsafe extern "C" fn free_func(_contents: *mut c_void, free_user_data: *mut c_void) {
+            let _ = Rc::from_raw(free_user_data as _);
+        }
+
+        let array_buffer = unsafe {
+            NewExternalArrayBuffer(
+                *cx,
+                act_size as usize,
+                self.mapping.borrow_mut().as_mut().unwrap()
+                    [offset as usize..(offset + act_size) as usize]
+                    .as_mut_ptr() as _,
+                Some(free_func),
+                Rc::into_raw(self.mapping.clone()) as _,
+            )
+        };
+        self.mapped_ranges
+            .borrow_mut()
+            .as_mut()
+            .map(|v| v.push(offset..offset + act_size));
+        self.js_buffers
+            .borrow_mut()
+            .as_mut()
+            .map(|a| a.push(Heap::boxed(array_buffer)));
+
+        Ok(NonNull::new(array_buffer).unwrap())
+    }
+
     /// https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label
     fn GetLabel(&self) -> Option<DOMString> {
         self.label.borrow().clone()
@@ -276,21 +337,8 @@ impl AsyncWGPUListener for GPUBuffer {
     fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>) {
         match response {
             WebGPUResponse::BufferMapAsync(bytes) => {
-                let cx = self.global().get_cx();
+                *self.mapping.borrow_mut() = Some(bytes);
-                rooted!(in(*cx) let mut array_buffer = ptr::null_mut::<JSObject>());
+                promise.resolve_native(&());
-                match unsafe {
-                    ArrayBuffer::create(*cx, CreateWith::Slice(&bytes), array_buffer.handle_mut())
-                } {
-                    Ok(_) => promise.resolve_native(&()),
-                    Err(()) => {
-                        warn!(
-                            "Failed to create ArrayBuffer for buffer({:?})",
-                            self.buffer.0
-                        );
-                        promise.reject_error(Error::Operation);
-                    },
-                }
-                self.mapping.set(array_buffer.get());
                 self.state.set(GPUBufferState::Mapped);
             },
             _ => {
@@ -298,6 +346,7 @@ impl AsyncWGPUListener for GPUBuffer {
                 promise.reject_error(Error::Operation);
             },
         }
+        *self.map_promise.borrow_mut() = None;
         if let Err(e) = self
             .channel
             .0

components/script/dom/gpudevice.rs

@@ -4,7 +4,7 @@
 
 #![allow(unsafe_code)]
 
-use crate::dom::bindings::cell::DomRefCell;
+use crate::dom::bindings::cell::{DomRefCell, RefCell};
 use crate::dom::bindings::codegen::Bindings::GPUBindGroupBinding::{
     GPUBindGroupDescriptor, GPUBindingResource,
 };
@@ -54,8 +54,8 @@ use crate::script_runtime::JSContext as SafeJSContext;
 use arrayvec::ArrayVec;
 use dom_struct::dom_struct;
 use js::jsapi::{Heap, JSObject};
-use js::typedarray::{ArrayBuffer, CreateWith};
+use std::ptr::NonNull;
-use std::ptr::{self, NonNull};
+use std::rc::Rc;
 use webgpu::wgpu::binding_model::BufferBinding;
 use webgpu::{self, wgt, WebGPU, WebGPUBindings, WebGPURequest};
 
@@ -177,24 +177,16 @@ impl GPUDeviceMethods for GPUDevice {
             .expect("Failed to create WebGPU buffer");
 
         let buffer = webgpu::WebGPUBuffer(id);
-        let mapping = RootedTraceableBox::new(Heap::default());
+        let mapping;
         let state;
         let mapping_range;
         if descriptor.mappedAtCreation {
-            let cx = self.global().get_cx();
+            let buf_data = vec![0u8; descriptor.size as usize];
-            rooted!(in(*cx) let mut array_buffer = ptr::null_mut::<JSObject>());
+            mapping = Rc::new(RefCell::new(Some(buf_data)));
-            unsafe {
-                assert!(ArrayBuffer::create(
-                    *cx,
-                    CreateWith::Length(descriptor.size as u32),
-                    array_buffer.handle_mut(),
-                )
-                .is_ok());
-            }
-            mapping.set(array_buffer.get());
             state = GPUBufferState::MappedAtCreation;
             mapping_range = 0..descriptor.size;
         } else {
+            mapping = Rc::new(RefCell::new(None));
             state = GPUBufferState::Unmapped;
             mapping_range = 0..0;
         }

components/script/dom/webidls/GPUBuffer.webidl

@@ -6,7 +6,7 @@
 [Exposed=(Window, DedicatedWorker), Serializable, Pref="dom.webgpu.enabled"]
 interface GPUBuffer {
     Promise<void> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size = 0);
-    //ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size = 0);
+    [Throws] ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size = 0);
     void unmap();
 
     void destroy();