Chances of crash using wgpu backend

[wormtql]

I write a minimal example, but even with the minimal code relating only imgui, glfw and webgpu, it still exhibits crashes when resizing window.
The code example are here
and you can find the related imgui/glfw/webgpu version here

Most of the code follows the cpp egpu tutorial, and the official wgpu-imgui example(especially the logic to handle window resizing)
The code runs fine if I just left it run and don't do any resizing, but there are chances of crash when I frequently resize the window.

The error message:

thread '<unnamed>' panicked at 'Error in wgpuQueueSubmit: Validation Error

Caused by:
    Parent device is lost
', src\lib.rs:495:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

And there are chances the error message is something like "surface timeout"

for convenience, I paste the related code there

// simple_imgui_instance.cpp (main)
#include <instance/SimpleInstance.h>

using namespace frieren_application;

int main() {
    SimpleInstance instance{};

    instance.run();

    return 0;
}

// SimpleInstance.h
#ifndef FRIEREN_SIMPLEINSTANCE_H
#define FRIEREN_SIMPLEINSTANCE_H

#include <webgpu/webgpu.hpp>
#include <GLFW/glfw3.h>
#include <glfw3webgpu.h>

using namespace std;

namespace frieren_application {
    class SimpleInstance {
    private:
        WGPUInstance instance;
        WGPUSurface surface;
        WGPUAdapter adapter;
        WGPUDevice device;
        WGPUQueue queue;
        WGPUSwapChain swap_chain;
        WGPUSwapChainDescriptor swap_chain_desc{};
        GLFWwindow* window;
        int window_width;
        int window_height;

        void create_wgpu_context();

        void create_imgui_context();

        void draw_imgui(WGPUTextureView texture_view);
    public:
        explicit SimpleInstance();

        void run();
    };
}

#endif //FRIEREN_SIMPLEINSTANCE_H

// SimpleInstance.cpp
#include "SimpleInstance.h"

#include <GLFW/glfw3.h>
#include <glfw3webgpu.h>

#include <imgui.h>
#include <imgui_internal.h>
#include <backends/imgui_impl_wgpu.h>
#include <backends/imgui_impl_glfw.h>
#include <common/wgpu_common_function.h>

namespace frieren_application {
    void SimpleInstance::create_wgpu_context() {
        WGPUInstanceDescriptor instance_desc{};
        instance_desc.nextInChain = nullptr;

        this->instance = wgpuCreateInstance(&instance_desc);
        if (!instance) {
            std::cerr << "Could not initialize WebGPU!" << std::endl;
            assert(false);
        }
        std::cout << "WGPU instance: " << instance << std::endl;

        glfwInit();
        glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
        this->window = glfwCreateWindow(640, 480, "WebGPU Window", nullptr, nullptr);
        this->window_width = 640;
        this->window_height = 480;
        if (!window) {
            std::cerr << "Could not open window!" << std::endl;
            glfwTerminate();
            assert(false);
        }

        this->surface = glfwGetWGPUSurface(instance, window);

        WGPURequestAdapterOptions adapterOpts{};
        adapterOpts.nextInChain = nullptr;
        adapterOpts.compatibleSurface = surface;
        this->adapter = WGPUCommonFunction::request_adapter(adapterOpts, instance);

        WGPUDeviceDescriptor device_desc{};
        device_desc.nextInChain = nullptr;
        device_desc.label = "My Device";
        device_desc.requiredFeaturesCount = 0;
        device_desc.requiredLimits = nullptr;
        device_desc.defaultQueue.nextInChain = nullptr;
        device_desc.defaultQueue.label = "The default queue";
        this->device = WGPUCommonFunction::request_device(device_desc, adapter);

        auto onDeviceError = [](WGPUErrorType type, char const *message, void *) {
            std::cout << "Uncaptured device error: type" << type;
            if (message) std::cout << " (" << message << ")";
            std::cout << std::endl;
        };
        wgpuDeviceSetUncapturedErrorCallback(device, onDeviceError, nullptr);

        WGPUCommonFunction::inspect_device(device);

        this->queue = wgpuDeviceGetQueue(device);

        auto onQueueWorkDone = [](WGPUQueueWorkDoneStatus status, void *) {
            std::cout << "Queued work finished with status: " << status << std::endl;
        };
        wgpuQueueOnSubmittedWorkDone(queue, onQueueWorkDone, nullptr);

        WGPUSwapChainDescriptor swap_chain_desc{};
        swap_chain_desc.nextInChain = nullptr;
        swap_chain_desc.width = 640;
        swap_chain_desc.height = 480;
        WGPUTextureFormat swapChainFormat = wgpuSurfaceGetPreferredFormat(surface, adapter);

        cout << "swap chain format: " << swapChainFormat << endl;
        swap_chain_desc.format = swapChainFormat;
        swap_chain_desc.usage = WGPUTextureUsage_RenderAttachment;
        swap_chain_desc.presentMode = WGPUPresentMode_Fifo;
        this->swap_chain_desc = swap_chain_desc;

        this->swap_chain = wgpuDeviceCreateSwapChain(device, surface, &swap_chain_desc);
    }

    SimpleInstance::SimpleInstance() {
        // create wgpu related context
        create_wgpu_context();

        // setup imgui states
        create_imgui_context();
    }

    void SimpleInstance::run() {
        while (!glfwWindowShouldClose(window)) {
            ImGuiIO& io = ImGui::GetIO();
            glfwPollEvents();

            int width, height;
            glfwGetFramebufferSize(this->window, &width, &height);

            if (width != swap_chain_desc.width || height != swap_chain_desc.height) {
                ImGui_ImplWGPU_InvalidateDeviceObjects();
                if (swap_chain) {
                    wgpuSwapChainRelease(swap_chain);
                }
                cout << "(" << width << ", " << height << ")" << endl;
                swap_chain_desc.width = width;
                swap_chain_desc.height = height;
                swap_chain = wgpuDeviceCreateSwapChain(device, surface, &swap_chain_desc);
                ImGui_ImplWGPU_CreateDeviceObjects();
            }

            WGPUTextureView next_texture = wgpuSwapChainGetCurrentTextureView(swap_chain);
            if (!next_texture) {
                std::cerr << "Cannot acquire next swap chain texture" << std::endl;
                continue;
            }

            // render UI
            ImGui_ImplWGPU_NewFrame();
            ImGui_ImplGlfw_NewFrame();
            ImGui::NewFrame();
            ImGui::Begin("SampleWindow");
            ImGui::Text("123");
            ImGui::End();
            ImGui::Render();
            draw_imgui(next_texture);

            wgpuTextureViewRelease(next_texture);
            wgpuSwapChainPresent(swap_chain);
        }
    }

    void SimpleInstance::draw_imgui(WGPUTextureView texture_view) {
        WGPURenderPassColorAttachment color_attachments{};
        color_attachments.loadOp = WGPULoadOp_Load;
        color_attachments.storeOp = WGPUStoreOp_Store;
        color_attachments.view = texture_view;
        WGPURenderPassDescriptor render_pass_desc{};
        render_pass_desc.colorAttachmentCount = 1;
        render_pass_desc.colorAttachments = &color_attachments;
        render_pass_desc.depthStencilAttachment = nullptr;
        render_pass_desc.label = "Draw ImGui Render Pass";

        WGPUCommandEncoderDescriptor enc_desc{};
        enc_desc.label = "Draw ImGui";
        WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(this->device, &enc_desc);

        WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(encoder, &render_pass_desc);
        ImGui_ImplWGPU_RenderDrawData(ImGui::GetDrawData(), pass);
        wgpuRenderPassEncoderEnd(pass);

        WGPUCommandBufferDescriptor cmd_buffer_desc{};
        WGPUCommandBuffer cmd_buffer = wgpuCommandEncoderFinish(encoder, &cmd_buffer_desc);

        wgpuQueueSubmit(this->queue, 1, &cmd_buffer);

        wgpuCommandBufferRelease(cmd_buffer);
        wgpuRenderPassEncoderRelease(pass);
        wgpuCommandEncoderRelease(encoder);
    }

    void SimpleInstance::create_imgui_context() {
        IMGUI_CHECKVERSION();
        ImGui::CreateContext();
        ImGuiIO& io = ImGui::GetIO();
        (void) io;
        io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
        io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
        io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;

        io.IniFilename = nullptr;

        ImGui::StyleColorsDark();

        ImGui_ImplGlfw_InitForOther(this->window, true);
        ImGui_ImplWGPU_Init(this->device, 3, this->swap_chain_desc.format, WGPUTextureFormat_Undefined);
    }
}

// wgpu_common_function.cpp (the header file is trivial, so ignored here)
#include "wgpu_common_function.h"
#include <vector>

using namespace std;

namespace frieren_application {
    void WGPUCommonFunction::inspect_adapter(WGPUAdapter adapter) {
        std::vector<WGPUFeatureName> features;

        size_t featureCount = wgpuAdapterEnumerateFeatures(adapter, nullptr);

        features.resize(featureCount);

        wgpuAdapterEnumerateFeatures(adapter, features.data());

        std::cout << "Adapter features:" << std::endl;
        for (auto f : features) {
            std::cout << " - " << f << std::endl;
        }

        WGPUSupportedLimits limits = {};
        limits.nextInChain = nullptr;
        bool success = wgpuAdapterGetLimits(adapter, &limits);
        if (success) {
            std::cout << "Adapter limits:" << std::endl;
            std::cout << " - maxTextureDimension1D: " << limits.limits.maxTextureDimension1D << std::endl;
            std::cout << " - maxTextureDimension2D: " << limits.limits.maxTextureDimension2D << std::endl;
            std::cout << " - maxTextureDimension3D: " << limits.limits.maxTextureDimension3D << std::endl;
            std::cout << " - maxTextureArrayLayers: " << limits.limits.maxTextureArrayLayers << std::endl;
            std::cout << " - maxBindGroups: " << limits.limits.maxBindGroups << std::endl;
            std::cout << " - maxDynamicUniformBuffersPerPipelineLayout: " << limits.limits.maxDynamicUniformBuffersPerPipelineLayout << std::endl;
            std::cout << " - maxDynamicStorageBuffersPerPipelineLayout: " << limits.limits.maxDynamicStorageBuffersPerPipelineLayout << std::endl;
            std::cout << " - maxSampledTexturesPerShaderStage: " << limits.limits.maxSampledTexturesPerShaderStage << std::endl;
            std::cout << " - maxSamplersPerShaderStage: " << limits.limits.maxSamplersPerShaderStage << std::endl;
            std::cout << " - maxStorageBuffersPerShaderStage: " << limits.limits.maxStorageBuffersPerShaderStage << std::endl;
            std::cout << " - maxStorageTexturesPerShaderStage: " << limits.limits.maxStorageTexturesPerShaderStage << std::endl;
            std::cout << " - maxUniformBuffersPerShaderStage: " << limits.limits.maxUniformBuffersPerShaderStage << std::endl;
            std::cout << " - maxUniformBufferBindingSize: " << limits.limits.maxUniformBufferBindingSize << std::endl;
            std::cout << " - maxStorageBufferBindingSize: " << limits.limits.maxStorageBufferBindingSize << std::endl;
            std::cout << " - minUniformBufferOffsetAlignment: " << limits.limits.minUniformBufferOffsetAlignment << std::endl;
            std::cout << " - minStorageBufferOffsetAlignment: " << limits.limits.minStorageBufferOffsetAlignment << std::endl;
            std::cout << " - maxVertexBuffers: " << limits.limits.maxVertexBuffers << std::endl;
            std::cout << " - maxVertexAttributes: " << limits.limits.maxVertexAttributes << std::endl;
            std::cout << " - maxVertexBufferArrayStride: " << limits.limits.maxVertexBufferArrayStride << std::endl;
            std::cout << " - maxInterStageShaderComponents: " << limits.limits.maxInterStageShaderComponents << std::endl;
            std::cout << " - maxComputeWorkgroupStorageSize: " << limits.limits.maxComputeWorkgroupStorageSize << std::endl;
            std::cout << " - maxComputeInvocationsPerWorkgroup: " << limits.limits.maxComputeInvocationsPerWorkgroup << std::endl;
            std::cout << " - maxComputeWorkgroupSizeX: " << limits.limits.maxComputeWorkgroupSizeX << std::endl;
            std::cout << " - maxComputeWorkgroupSizeY: " << limits.limits.maxComputeWorkgroupSizeY << std::endl;
            std::cout << " - maxComputeWorkgroupSizeZ: " << limits.limits.maxComputeWorkgroupSizeZ << std::endl;
            std::cout << " - maxComputeWorkgroupsPerDimension: " << limits.limits.maxComputeWorkgroupsPerDimension << std::endl;
        }

        WGPUAdapterProperties properties = {};
        properties.nextInChain = nullptr;
        wgpuAdapterGetProperties(adapter, &properties);
        std::cout << "Adapter properties:" << std::endl;
        std::cout << " - vendorID: " << properties.vendorID << std::endl;
        std::cout << " - deviceID: " << properties.deviceID << std::endl;
        std::cout << " - name: " << properties.name << std::endl;
        if (properties.driverDescription) {
            std::cout << " - driverDescription: " << properties.driverDescription << std::endl;
        }
        std::cout << " - adapterType: " << properties.adapterType << std::endl;
        std::cout << " - backendType: " << properties.backendType << std::endl;
    }

    WGPUDevice WGPUCommonFunction::request_device(const WGPUDeviceDescriptor &desc, WGPUAdapter adapter) {
        struct UserData {
            WGPUDevice device = nullptr;
            bool requestEnded = false;
        };
        UserData userData;

        auto onDeviceRequestEnded = [] (WGPURequestDeviceStatus status, WGPUDevice device, char const* message, void* pUserData) {
            UserData& userData = *reinterpret_cast<UserData*>(pUserData);
            if (status == WGPURequestDeviceStatus_Success) {
                userData.device = device;
            } else {
                std::cout << "Could not get WebGPU device: " << message << std::endl;
            }
            userData.requestEnded = true;
        };

        wgpuAdapterRequestDevice(adapter, &desc, onDeviceRequestEnded, (void*) &userData);

        assert(userData.requestEnded);

        return userData.device;
    }

    WGPUAdapter WGPUCommonFunction::request_adapter(const WGPURequestAdapterOptions &options, WGPUInstance instance) {
        struct UserData {
            WGPUAdapter adapter = nullptr;
            bool requestEnded = false;
        };

        UserData userData;

        auto onAdapterRequestEnded = [] (WGPURequestAdapterStatus status, WGPUAdapter adapter, char const* message, void* pUserData) {
            UserData& userData = *reinterpret_cast<UserData*>(pUserData);
            if (status == WGPURequestAdapterStatus_Success) {
                userData.adapter = adapter;
            } else {
                std::cout << "Could not get WebGPU adapter: " << message << std::endl;
            }
            userData.requestEnded = true;
        };

        wgpuInstanceRequestAdapter(instance, &options, onAdapterRequestEnded, (void*) &userData);

        assert(userData.requestEnded);

        return userData.adapter;
    }

    void WGPUCommonFunction::inspect_device(WGPUDevice device) {
        std::vector<WGPUFeatureName> features;
        size_t featureCount = wgpuDeviceEnumerateFeatures(device, nullptr);
        features.resize(featureCount);
        wgpuDeviceEnumerateFeatures(device, features.data());

        std::cout << "Device features:" << std::endl;
        for (auto f : features) {
            std::cout << " - " << f << std::endl;
        }

        WGPUSupportedLimits limits = {};
        limits.nextInChain = nullptr;
        bool success = wgpuDeviceGetLimits(device, &limits);
        if (success) {
            std::cout << "Device limits:" << std::endl;
            std::cout << " - maxTextureDimension1D: " << limits.limits.maxTextureDimension1D << std::endl;
            std::cout << " - maxTextureDimension2D: " << limits.limits.maxTextureDimension2D << std::endl;
            std::cout << " - maxTextureDimension3D: " << limits.limits.maxTextureDimension3D << std::endl;
            std::cout << " - maxTextureArrayLayers: " << limits.limits.maxTextureArrayLayers << std::endl;
            std::cout << " - maxBindGroups: " << limits.limits.maxBindGroups << std::endl;
            std::cout << " - maxDynamicUniformBuffersPerPipelineLayout: " << limits.limits.maxDynamicUniformBuffersPerPipelineLayout << std::endl;
            std::cout << " - maxDynamicStorageBuffersPerPipelineLayout: " << limits.limits.maxDynamicStorageBuffersPerPipelineLayout << std::endl;
            std::cout << " - maxSampledTexturesPerShaderStage: " << limits.limits.maxSampledTexturesPerShaderStage << std::endl;
            std::cout << " - maxSamplersPerShaderStage: " << limits.limits.maxSamplersPerShaderStage << std::endl;
            std::cout << " - maxStorageBuffersPerShaderStage: " << limits.limits.maxStorageBuffersPerShaderStage << std::endl;
            std::cout << " - maxStorageTexturesPerShaderStage: " << limits.limits.maxStorageTexturesPerShaderStage << std::endl;
            std::cout << " - maxUniformBuffersPerShaderStage: " << limits.limits.maxUniformBuffersPerShaderStage << std::endl;
            std::cout << " - maxUniformBufferBindingSize: " << limits.limits.maxUniformBufferBindingSize << std::endl;
            std::cout << " - maxStorageBufferBindingSize: " << limits.limits.maxStorageBufferBindingSize << std::endl;
            std::cout << " - minUniformBufferOffsetAlignment: " << limits.limits.minUniformBufferOffsetAlignment << std::endl;
            std::cout << " - minStorageBufferOffsetAlignment: " << limits.limits.minStorageBufferOffsetAlignment << std::endl;
            std::cout << " - maxVertexBuffers: " << limits.limits.maxVertexBuffers << std::endl;
            std::cout << " - maxVertexAttributes: " << limits.limits.maxVertexAttributes << std::endl;
            std::cout << " - maxVertexBufferArrayStride: " << limits.limits.maxVertexBufferArrayStride << std::endl;
            std::cout << " - maxInterStageShaderComponents: " << limits.limits.maxInterStageShaderComponents << std::endl;
            std::cout << " - maxComputeWorkgroupStorageSize: " << limits.limits.maxComputeWorkgroupStorageSize << std::endl;
            std::cout << " - maxComputeInvocationsPerWorkgroup: " << limits.limits.maxComputeInvocationsPerWorkgroup << std::endl;
            std::cout << " - maxComputeWorkgroupSizeX: " << limits.limits.maxComputeWorkgroupSizeX << std::endl;
            std::cout << " - maxComputeWorkgroupSizeY: " << limits.limits.maxComputeWorkgroupSizeY << std::endl;
            std::cout << " - maxComputeWorkgroupSizeZ: " << limits.limits.maxComputeWorkgroupSizeZ << std::endl;
            std::cout << " - maxComputeWorkgroupsPerDimension: " << limits.limits.maxComputeWorkgroupsPerDimension << std::endl;
        }
    }
}