Make Surface#configure and Surface#get_current_texture non-fatal

examples/src/framework.rs

@@ -226,6 +226,7 @@ impl SurfaceWrapper {
                 // If the surface is outdated, or was lost, reconfigure it.
                 wgpu::SurfaceError::Outdated
                 | wgpu::SurfaceError::Lost
+                | wgpu::SurfaceError::Other
                 // If OutOfMemory happens, reconfiguring may not help, but we might as well try
                 | wgpu::SurfaceError::OutOfMemory,
             ) => {

wgpu-types/src/lib.rs

@@ -5626,6 +5626,8 @@ pub enum SurfaceStatus {
     Outdated,
     /// The surface under the swap chain is lost.
     Lost,
+    /// The surface status is not known.
+    Unknown,
 }
 
 /// Nanosecond timestamp used by the presentation engine.

wgpu/src/api/surface.rs

@@ -115,6 +115,7 @@ impl Surface<'_> {
             SurfaceStatus::Timeout => return Err(SurfaceError::Timeout),
             SurfaceStatus::Outdated => return Err(SurfaceError::Outdated),
             SurfaceStatus::Lost => return Err(SurfaceError::Lost),
+            SurfaceStatus::Unknown => return Err(SurfaceError::Other),
         };
 
         let guard = self.config.lock();

wgpu/src/api/surface_texture.rs

@@ -67,6 +67,8 @@ pub enum SurfaceError {
     Lost,
     /// There is no more memory left to allocate a new frame.
     OutOfMemory,
+    /// Acquiring a texture failed for an unknown reason
+    Other,
 }
 static_assertions::assert_impl_all!(SurfaceError: Send, Sync);
 
@@ -77,6 +79,7 @@ impl fmt::Display for SurfaceError {
             Self::Outdated => "The underlying surface has changed, and therefore the swap chain must be updated",
             Self::Lost =>  "The swap chain has been lost and needs to be recreated",
             Self::OutOfMemory => "There is no more memory left to allocate a new frame",
+            Self::Other => "Acquiring a texture failed for an unknown reason"
         })
     }
 }

wgpu/src/backend/wgpu_core.rs

@@ -441,6 +441,9 @@ pub struct Surface {
     /// Configured device is needed to know which backend
     /// code to execute when acquiring a new frame.
     configured_device: Mutex<Option<wgc::id::DeviceId>>,
+    /// The error sink with which to report errors.
+    /// `None` if the surface has not been configured.
+    error_sink: Mutex<Option<ErrorSink>>,
 }
 
 #[derive(Debug)]
@@ -572,6 +575,7 @@ impl crate::Context for ContextWgpuCore {
         Ok(Surface {
             id,
             configured_device: Mutex::default(),
+            error_sink: Mutex::default(),
         })
     }
 
@@ -707,9 +711,10 @@ impl crate::Context for ContextWgpuCore {
             .0
             .surface_configure(surface_data.id, device_data.id, config);
         if let Some(e) = error {
-            self.handle_error_fatal(e, "Surface::configure");
+            self.handle_error_nolabel(&device_data.error_sink, e, "Surface::configure");
         } else {
             *surface_data.configured_device.lock() = Some(device_data.id);
+            *surface_data.error_sink.lock() = Some(device_data.error_sink.clone());
         }
     }
 
@@ -736,7 +741,19 @@ impl crate::Context for ContextWgpuCore {
                     },
                 )
             }
-            Err(err) => self.handle_error_fatal(err, "Surface::get_current_texture_view"),
+            Err(err) => match surface_data.error_sink.lock().as_ref() {
+                Some(error_sink) => {
+                    self.handle_error_nolabel(error_sink, err, "Surface::get_current_texture_view");
+                    (
+                        None,
+                        SurfaceStatus::Unknown,
+                        SurfaceOutputDetail {
+                            surface_id: surface_data.id,
+                        },
+                    )
+                }
+                None => self.handle_error_fatal(err, "Surface::get_current_texture_view"),
+            },
         }
     }