Disable local feature of webgpu-native

components/script/dom/gpu.rs

@@ -132,16 +132,14 @@ impl GPUMethods for GPU {
             None => wgpu::PowerPreference::Default,
         };
 
-        let options = wgpu::RequestAdapterOptions {
-            power_preference,
-            backends: wgpu::BackendBit::PRIMARY,
-        };
-
         match self.get_wgpu_thread() {
             Some(thread) => {
                 thread
                     .0
-                    .send(WebGPURequest::RequestAdapter(sender, options))
+                    .send(WebGPURequest::RequestAdapter(
+                        sender,
+                        wgpu::RequestAdapterOptions { power_preference },
+                    ))
                     .unwrap();
             },
             None => promise.reject_error(Error::Type("No WebGPU thread...".to_owned())),

components/webgpu/Cargo.toml

@@ -15,4 +15,4 @@ embedder_traits = {path = "../embedder_traits"}
 ipc-channel = "0.12"
 serde = "1.0"
 servo_config = {path = "../config"}
-wgpu-native = { version = "0.4.0", features = ["serde","local"] }
+wgpu-native = { version = "0.4.0", features = ["serde"] }

components/webgpu/lib.rs

@@ -4,10 +4,13 @@
 
 #[macro_use]
 extern crate serde;
+#[macro_use]
+pub extern crate wgpu_native as wgpu;
 
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use servo_config::pref;
-pub use wgpu_native as wgpu;
+use wgpu::adapter_get_info;
+use wgpu::TypedId;
 
 #[derive(Debug, Deserialize, Serialize)]
 pub enum WebGPUResponse {
@@ -52,6 +55,7 @@ impl WebGPUThread {
 
 struct WebGPU {
     receiver: IpcReceiver<WebGPURequest>,
+    global: wgpu::Global,
     adapters: Vec<WebGPUAdapter>,
     // Track invalid adapters https://gpuweb.github.io/gpuweb/#invalid
     _invalid_adapters: Vec<WebGPUAdapter>,
@@ -61,25 +65,50 @@ impl WebGPU {
     fn new(receiver: IpcReceiver<WebGPURequest>) -> Self {
         WebGPU {
             receiver,
+            global: wgpu::Global::new("webgpu-native"),
             adapters: Vec::new(),
             _invalid_adapters: Vec::new(),
         }
     }
 
-    fn run(&mut self) {
+    fn deinit(self) {
+        self.global.delete()
+    }
+
+    fn run(mut self) {
         while let Ok(msg) = self.receiver.recv() {
             match msg {
                 WebGPURequest::RequestAdapter(sender, options) => {
-                    let id = wgpu::wgpu_request_adapter(Some(&options));
-                    let adapter = WebGPUAdapter(id);
+                    let adapter_id = match wgpu::request_adapter(
+                        &self.global,
+                        &options,
+                        &[
+                            wgpu::Id::zip(0, 0, wgpu::Backend::Vulkan),
+                            wgpu::Id::zip(0, 0, wgpu::Backend::Metal),
+                            wgpu::Id::zip(0, 0, wgpu::Backend::Dx12),
+                        ],
+                    ) {
+                        Some(id) => id,
+                        None => {
+                            sender
+                                .send(Err("Failed to get webgpu adapter".to_string()))
+                                .expect("Failed to send response");
+                            return;
+                        },
+                    };
+                    let adapter = WebGPUAdapter(adapter_id);
                     self.adapters.push(adapter);
-                    let info = wgpu::wgpu_adapter_get_info(id);
+                    let info =
+                        gfx_select!(adapter_id => adapter_get_info(&self.global, adapter_id));
                     sender
                         .send(Ok(WebGPUResponse::RequestAdapter(info.name, adapter)))
                         .expect("Failed to send response");
                 },
                 WebGPURequest::RequestDevice => {},
-                WebGPURequest::Exit => return,
+                WebGPURequest::Exit => {
+                    self.deinit();
+                    return;
+                },
             }
         }
     }