Simplified a bit the wasi-web crate by removing VMMemory

lib/wasi-web/src/pool.rs

@@ -29,14 +29,14 @@ use wasm_bindgen::{prelude::*, JsCast};
 use wasm_bindgen_futures::JsFuture;
 use wasmer_wasix::{
     runtime::SpawnType,
-    wasmer::{vm::VMMemory, MemoryType, Module, Store, WASM_MAX_PAGES},
+    wasmer::{AsJs, Memory, MemoryType, Module, Store, WASM_MAX_PAGES},
     VirtualTaskManager, WasiThreadError,
 };
 use web_sys::{DedicatedWorkerGlobalScope, WorkerOptions, WorkerType};
 use xterm_js_rs::Terminal;
 
 use super::{common::*, interval::*};
-use crate::runtime::{build_memory_internal, WebTaskManager};
+use crate::runtime::WebTaskManager;
 
 pub type BoxRun<'a> = Box<dyn FnOnce() + Send + 'a>;
 
@@ -54,7 +54,7 @@ enum WasmRunType {
 #[derivative(Debug)]
 struct WasmRunCommand {
     #[derivative(Debug = "ignore")]
-    run: Box<dyn FnOnce(Store, Module, Option<VMMemory>) + Send + 'static>,
+    run: Box<dyn FnOnce(Store, Module, Option<Memory>) + Send + 'static>,
     ty: WasmRunType,
     store: Store,
     module_bytes: Bytes,
@@ -269,7 +269,7 @@ impl WebThreadPool {
 
     pub fn spawn_wasm(
         &self,
-        run: impl FnOnce(Store, Module, Option<VMMemory>) + Send + 'static,
+        run: impl FnOnce(Store, Module, Option<Memory>) + Send + 'static,
         wasm_store: Store,
         wasm_module: Module,
         spawn_type: SpawnType,
@@ -279,9 +279,8 @@ impl WebThreadPool {
             SpawnType::Create => WasmRunType::Create,
             SpawnType::CreateWithType(mem) => WasmRunType::CreateWithMemory(mem.ty),
             SpawnType::NewThread(memory) => {
-                let (mem, ty) = memory.clone().into();
+                wasm_memory = memory.as_jsvalue(&wasm_store);
-                wasm_memory = mem;
+                WasmRunType::Existing(memory.ty(&wasm_store))
-                WasmRunType::Existing(ty)
             }
         };
 
@@ -566,7 +565,7 @@ pub fn wasm_entry_point(ctx_ptr: u32, wasm_module: JsValue, wasm_memory: JsValue
     let run_callback = (*ctx).cmd.run;
 
     // Compile the web assembly module
-    let wasm_store = ctx.cmd.store;
+    let mut wasm_store = ctx.cmd.store;
     let wasm_module = match wasm_module.dyn_into::<js_sys::WebAssembly::Module>() {
         Ok(a) => a,
         Err(err) => {
@@ -583,17 +582,18 @@ pub fn wasm_entry_point(ctx_ptr: u32, wasm_module: JsValue, wasm_memory: JsValue
     let wasm_memory = match ctx.memory {
         WasmRunMemory::WithoutMemory => None,
         WasmRunMemory::WithMemory(wasm_memory_type) => {
-            let wasm_memory = match wasm_memory.dyn_into::<js_sys::WebAssembly::Memory>() {
+            let wasm_memory =
-                Ok(a) => a,
+                match Memory::from_jsvalue(&mut wasm_store, &wasm_memory_type, &wasm_memory) {
-                Err(err) => {
+                    Ok(a) => a,
-                    error!(
+                    Err(err) => {
-                        "Failed to receive memory for module - {}",
+                        // error!(
-                        err.as_string().unwrap_or_else(|| format!("{:?}", err))
+                        //     "Failed to receive memory for module - {}",
-                    );
+                        //     err.as_string().unwrap_or_else(|| format!("{:?}", err))
-                    return;
+                        // );
-                }
+                        return;
-            };
+                    }
-            Some(VMMemory::new(wasm_memory, wasm_memory_type))
+                };
+            Some(wasm_memory)
         }
     };
 
@@ -610,7 +610,7 @@ pub fn wasm_entry_point(ctx_ptr: u32, wasm_module: JsValue, wasm_memory: JsValue
 pub fn worker_schedule_task(task_ptr: u32, wasm_module: JsValue, mut wasm_memory: JsValue) {
     // Grab the task that passes us the rust variables
     let task = task_ptr as *mut WasmRunCommand;
-    let task = unsafe { Box::from_raw(task) };
+    let mut task = unsafe { Box::from_raw(task) };
 
     let mut opts = WorkerOptions::new();
     opts.type_(WorkerType::Module);
@@ -647,13 +647,14 @@ pub fn worker_schedule_task(task_ptr: u32, wasm_module: JsValue, mut wasm_memory
             }
 
             if wasm_memory.is_null() {
-                wasm_memory = match build_memory_internal(ty) {
+                let memory = match Memory::new(&mut task.store, ty.clone()) {
-                    Ok(m) => JsValue::from(m),
+                    Ok(a) => a,
                     Err(err) => {
                         error!("Failed to create WASM memory - {}", err);
                         return;
                     }
                 };
+                wasm_memory = memory.as_jsvalue(&task.store);
             }
 
             let ctx = WasmRunContext {

lib/wasi-web/src/runtime.rs

@@ -20,7 +20,7 @@ use wasmer_wasix::{
     http::{DynHttpClient, HttpRequest, HttpResponse},
     os::{TtyBridge, TtyOptions},
     runtime::SpawnType,
-    wasmer::{vm::VMMemory, MemoryType, Module, Store},
+    wasmer::{Memory, MemoryType, Module, Store, StoreMut},
     VirtualFile, VirtualNetworking, VirtualTaskManager, WasiRuntime, WasiThreadError, WasiTtyState,
 };
 use web_sys::WebGl2RenderingContext;
@@ -100,39 +100,29 @@ impl<'g> Drop for WebRuntimeGuard<'g> {
     fn drop(&mut self) {}
 }
 
-pub fn build_memory_internal(ty: MemoryType) -> Result<VMMemory, WasiThreadError> {
-    let descriptor = js_sys::Object::new();
-    js_sys::Reflect::set(&descriptor, &"initial".into(), &ty.minimum.0.into()).unwrap();
-    //let min = 100u32.max(ty.minimum.0);
-    //js_sys::Reflect::set(&descriptor, &"initial".into(), &min.into()).unwrap();
-    if let Some(max) = ty.maximum {
-        js_sys::Reflect::set(&descriptor, &"maximum".into(), &max.0.into()).unwrap();
-    }
-    js_sys::Reflect::set(&descriptor, &"shared".into(), &ty.shared.into()).unwrap();
-
-    match js_sys::WebAssembly::Memory::new(&descriptor) {
-        Ok(a) => Ok(VMMemory::new(a, ty)),
-        Err(err) => {
-            error!(
-                "WebAssembly failed to create the memory - {}",
-                err.as_string().unwrap_or_else(|| format!("{:?}", err))
-            );
-            return Err(WasiThreadError::MemoryCreateFailed);
-        }
-    }
-}
-
 #[async_trait::async_trait]
 #[allow(unused_variables)]
 impl VirtualTaskManager for WebTaskManager {
     /// Build a new Webassembly memory.
     ///
     /// May return `None` if the memory can just be auto-constructed.
-    fn build_memory(&self, spawn_type: SpawnType) -> Result<Option<VMMemory>, WasiThreadError> {
+    fn build_memory(
+        &self,
+        mut store: &mut StoreMut,
+        spawn_type: SpawnType,
+    ) -> Result<Option<Memory>, WasiThreadError> {
         match spawn_type {
-            SpawnType::Create => Ok(None),
+            SpawnType::CreateWithType(mut mem) => {
-            SpawnType::CreateWithType(mem) => build_memory_internal(mem.ty).map(|a| Some(a)),
+                mem.ty.shared = true;
+                Memory::new(&mut store, mem.ty)
+                    .map_err(|err| {
+                        tracing::error!("could not create memory: {err}");
+                        WasiThreadError::MemoryCreateFailed
+                    })
+                    .map(Some)
+            }
             SpawnType::NewThread(mem) => Ok(Some(mem)),
+            SpawnType::Create => Ok(None),
         }
     }
 
@@ -191,7 +181,7 @@ impl VirtualTaskManager for WebTaskManager {
     /// It is ok for this task to block execution and any async futures within its scope
     fn task_wasm(
         &self,
-        task: Box<dyn FnOnce(Store, Module, Option<VMMemory>) + Send + 'static>,
+        task: Box<dyn FnOnce(Store, Module, Option<Memory>) + Send + 'static>,
         store: Store,
         module: Module,
         spawn_type: SpawnType,