api: unify error handling

Make error infrastructure more backend agnostic and let backends
just forward the os errors opaquely.

src/platform_impl/web/event_loop/window_target.rs

@@ -11,7 +11,7 @@ use super::event::DeviceId;
 use super::runner::{EventWrapper, WeakShared};
 use super::window::WindowId;
 use super::{backend, runner, EventLoopProxy};
-use crate::error::{ExternalError, NotSupportedError};
+use crate::error::{NotSupportedError, RequestError};
 use crate::event::{
     DeviceId as RootDeviceId, ElementState, Event, FingerId as RootFingerId, KeyEvent, Touch,
     TouchPhase, WindowEvent,
@@ -606,7 +606,10 @@ impl ActiveEventLoop {
     }
 
     pub(crate) fn has_multiple_screens(&self) -> Result<bool, NotSupportedError> {
-        self.runner.monitor().is_extended().ok_or(NotSupportedError::new())
+        self.runner
+            .monitor()
+            .is_extended()
+            .ok_or(NotSupportedError::new("has_multiple_screens is not supported"))
     }
 
     pub(crate) fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture {
@@ -631,7 +634,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_window(
         &self,
         window_attributes: crate::window::WindowAttributes,
-    ) -> Result<Box<dyn crate::window::Window>, crate::error::OsError> {
+    ) -> Result<Box<dyn crate::window::Window>, RequestError> {
         let window = Window::new(self, window_attributes)?;
         Ok(Box::new(window))
     }
@@ -639,7 +642,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_custom_cursor(
         &self,
         source: CustomCursorSource,
-    ) -> Result<RootCustomCursor, ExternalError> {
+    ) -> Result<RootCustomCursor, RequestError> {
         Ok(RootCustomCursor { inner: CustomCursor::new(self, source.inner) })
     }
 

src/platform_impl/web/mod.rs

@@ -37,7 +37,6 @@ pub(crate) use cursor::{
     CustomCursorSource as PlatformCustomCursorSource,
 };
 
-pub use self::error::OsError;
 pub use self::event::{DeviceId, FingerId};
 pub(crate) use self::event_loop::{
     ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,

src/platform_impl/web/web_sys/canvas.rs

@@ -22,10 +22,10 @@ use super::media_query_handle::MediaQueryListHandle;
 use super::pointer::PointerHandler;
 use super::{event, fullscreen, ButtonsState, ResizeScaleHandle};
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::error::OsError as RootOE;
+use crate::error::RequestError;
 use crate::event::{Force, MouseButton, MouseScrollDelta, SurfaceSizeWriter};
 use crate::keyboard::{Key, KeyLocation, ModifiersState, PhysicalKey};
-use crate::platform_impl::{Fullscreen, OsError};
+use crate::platform_impl::Fullscreen;
 use crate::window::{WindowAttributes, WindowId as RootWindowId};
 
 #[allow(dead_code)]
@@ -83,13 +83,13 @@ impl Canvas {
         navigator: Navigator,
         document: Document,
         attr: WindowAttributes,
-    ) -> Result<Self, RootOE> {
+    ) -> Result<Self, RequestError> {
         let canvas = match attr.platform_specific.canvas.map(Arc::try_unwrap) {
             Some(Ok(canvas)) => canvas.into_inner(main_thread),
             Some(Err(canvas)) => canvas.get(main_thread).clone(),
             None => document
                 .create_element("canvas")
-                .map_err(|_| os_error!(OsError("Failed to create canvas element".to_owned())))?
+                .map_err(|_| os_error!("Failed to create canvas element"))?
                 .unchecked_into(),
         };
 
@@ -109,7 +109,7 @@ impl Canvas {
         if attr.platform_specific.focusable {
             canvas
                 .set_attribute("tabindex", "0")
-                .map_err(|_| os_error!(OsError("Failed to set a tabindex".to_owned())))?;
+                .map_err(|_| os_error!("Failed to set a tabindex"))?;
         }
 
         let style = Style::new(&window, &canvas);

src/platform_impl/web/window.rs

@@ -9,7 +9,7 @@ use super::monitor::MonitorHandler;
 use super::r#async::Dispatcher;
 use super::{backend, lock, ActiveEventLoop};
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{ExternalError, NotSupportedError, OsError as RootOE};
+use crate::error::{NotSupportedError, RequestError};
 use crate::icon::Icon;
 use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::window::{
@@ -31,7 +31,10 @@ pub struct Inner {
 }
 
 impl Window {
-    pub(crate) fn new(target: &ActiveEventLoop, attr: WindowAttributes) -> Result<Self, RootOE> {
+    pub(crate) fn new(
+        target: &ActiveEventLoop,
+        attr: WindowAttributes,
+    ) -> Result<Self, RequestError> {
         let id = target.generate_id();
 
         let window = target.runner.window();
@@ -106,13 +109,13 @@ impl RootWindow for Window {
         // Not supported
     }
 
-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
         // Note: the canvas element has no window decorations, so this is equal to `outer_position`.
         self.outer_position()
     }
 
-    fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        self.inner.queue(|inner| Ok(inner.canvas.position().to_physical(inner.scale_factor())))
+    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        Ok(self.inner.queue(|inner| inner.canvas.position().to_physical(inner.scale_factor())))
     }
 
     fn set_outer_position(&self, position: Position) {
@@ -315,12 +318,12 @@ impl RootWindow for Window {
         self.inner.dispatch(move |inner| inner.canvas.cursor.set_cursor(cursor))
     }
 
-    fn set_cursor_position(&self, _: Position) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    fn set_cursor_position(&self, _: Position) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_position is not supported").into())
     }
 
-    fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
-        self.inner.queue(|inner| {
+    fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError> {
+        Ok(self.inner.queue(|inner| {
             match mode {
                 CursorGrabMode::None => inner.canvas.document().exit_pointer_lock(),
                 CursorGrabMode::Locked => lock::request_pointer_lock(
@@ -329,30 +332,30 @@ impl RootWindow for Window {
                     inner.canvas.raw(),
                 ),
                 CursorGrabMode::Confined => {
-                    return Err(ExternalError::NotSupported(NotSupportedError::new()))
+                    return Err(NotSupportedError::new("confined cursor mode is not supported"))
                 },
             }
 
             Ok(())
-        })
+        })?)
     }
 
     fn set_cursor_visible(&self, visible: bool) {
         self.inner.dispatch(move |inner| inner.canvas.cursor.set_cursor_visible(visible))
     }
 
-    fn drag_window(&self) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    fn drag_window(&self) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("drag_window is not supported").into())
     }
 
-    fn drag_resize_window(&self, _: ResizeDirection) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    fn drag_resize_window(&self, _: ResizeDirection) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("drag_resize_window is not supported").into())
     }
 
     fn show_window_menu(&self, _: Position) {}
 
-    fn set_cursor_hittest(&self, _: bool) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    fn set_cursor_hittest(&self, _: bool) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_hittest is not supported").into())
     }
 
     fn current_monitor(&self) -> Option<RootMonitorHandle> {