refactor(web): follow-up to #722 (#747)

Author: RRRadicalEdward

crates/ironrdp-server/src/encoder/fast_path.rs

@@ -1,9 +1,7 @@
 use core::{cmp, fmt};
 
-use ironrdp_pdu::{
-    fast_path::{EncryptionFlags, FastPathHeader, FastPathUpdatePdu, Fragmentation, UpdateCode},
-    Encode, WriteCursor,
-};
+use ironrdp_pdu::fast_path::{EncryptionFlags, FastPathHeader, FastPathUpdatePdu, Fragmentation, UpdateCode};
+use ironrdp_pdu::{Encode, WriteCursor};
 
 // this is the maximum amount of data (not including headers) we can send in a single TS_FP_UPDATE_PDU
 const MAX_FASTPATH_UPDATE_SIZE: usize = 16_374;
@@ -100,9 +98,10 @@ impl UpdateFragmenter {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use ironrdp_core::{decode_cursor, ReadCursor};
 
+    use super::*;
+
     #[test]
     fn test_single_fragment() {
         let data = vec![1, 2, 3, 4];

crates/ironrdp-web/src/clipboard/mod.rs

@@ -137,7 +137,7 @@ impl WasmClipboard {
     pub(crate) fn new(message_proxy: WasmClipboardMessageProxy, js_callbacks: JsClipboardCallbacks) -> Self {
         Self {
             local_clipboard: None,
-            remote_clipboard: ClipboardTransaction::construct(),
+            remote_clipboard: ClipboardTransaction::init(),
             proxy: message_proxy,
             js_callbacks,
 
@@ -505,7 +505,7 @@ impl WasmClipboard {
                 } else {
                     // If no initial clipboard callback was set, send empty format list instead
                     return self.process_event(WasmClipboardBackendMessage::LocalClipboardChanged(
-                        ClipboardTransaction::construct(),
+                        ClipboardTransaction::init(),
                     ));
                 }
             }

crates/ironrdp-web/src/clipboard/transaction.rs

@@ -19,7 +19,7 @@ impl ClipboardTransaction {
 
 #[wasm_bindgen]
 impl ClipboardTransaction {
-    pub fn construct() -> Self {
+    pub fn init() -> Self {
         Self { contents: Vec::new() }
     }
 

crates/ironrdp-web/src/error.rs

@@ -3,7 +3,7 @@ use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 #[derive(Clone, Copy)]
-pub enum RemoteDesktopErrorKind {
+pub enum IronErrorKind {
     /// Catch-all error kind
     General,
     /// Incorrect password used
@@ -19,44 +19,44 @@ pub enum RemoteDesktopErrorKind {
 }
 
 #[wasm_bindgen]
-pub struct RemoteDesktopError {
-    kind: RemoteDesktopErrorKind,
+pub struct IronError {
+    kind: IronErrorKind,
     source: anyhow::Error,
 }
 
-impl RemoteDesktopError {
-    pub fn with_kind(mut self, kind: RemoteDesktopErrorKind) -> Self {
+impl IronError {
+    pub fn with_kind(mut self, kind: IronErrorKind) -> Self {
         self.kind = kind;
         self
     }
 }
 
 #[wasm_bindgen]
-impl RemoteDesktopError {
+impl IronError {
     pub fn backtrace(&self) -> String {
         format!("{:?}", self.source)
     }
 
-    pub fn kind(&self) -> RemoteDesktopErrorKind {
+    pub fn kind(&self) -> IronErrorKind {
         self.kind
     }
 }
 
-impl From<connector::ConnectorError> for RemoteDesktopError {
+impl From<connector::ConnectorError> for IronError {
     fn from(e: connector::ConnectorError) -> Self {
         use sspi::credssp::NStatusCode;
 
         let kind = match e.kind {
             ConnectorErrorKind::Credssp(sspi::Error {
                 nstatus: Some(NStatusCode::WRONG_PASSWORD),
                 ..
-            }) => RemoteDesktopErrorKind::WrongPassword,
+            }) => IronErrorKind::WrongPassword,
             ConnectorErrorKind::Credssp(sspi::Error {
                 nstatus: Some(NStatusCode::LOGON_FAILURE),
                 ..
-            }) => RemoteDesktopErrorKind::LogonFailure,
-            ConnectorErrorKind::AccessDenied => RemoteDesktopErrorKind::AccessDenied,
-            _ => RemoteDesktopErrorKind::General,
+            }) => IronErrorKind::LogonFailure,
+            ConnectorErrorKind::AccessDenied => IronErrorKind::AccessDenied,
+            _ => IronErrorKind::General,
         };
 
         Self {
@@ -66,19 +66,19 @@ impl From<connector::ConnectorError> for RemoteDesktopError {
     }
 }
 
-impl From<ironrdp::session::SessionError> for RemoteDesktopError {
+impl From<ironrdp::session::SessionError> for IronError {
     fn from(e: ironrdp::session::SessionError) -> Self {
         Self {
-            kind: RemoteDesktopErrorKind::General,
+            kind: IronErrorKind::General,
             source: anyhow::Error::new(e),
         }
     }
 }
 
-impl From<anyhow::Error> for RemoteDesktopError {
+impl From<anyhow::Error> for IronError {
     fn from(e: anyhow::Error) -> Self {
         Self {
-            kind: RemoteDesktopErrorKind::General,
+            kind: IronErrorKind::General,
             source: e,
         }
     }

crates/ironrdp-web/src/input.rs

@@ -61,7 +61,7 @@ pub struct InputTransaction(pub(crate) SmallVec<[Operation; 3]>);
 
 #[wasm_bindgen]
 impl InputTransaction {
-    pub fn construct() -> Self {
+    pub fn init() -> Self {
         Self(SmallVec::new())
     }
 

crates/ironrdp-web/src/lib.rs

@@ -69,7 +69,7 @@ pub struct DesktopSize {
 
 #[wasm_bindgen]
 impl DesktopSize {
-    pub fn construct(width: u16, height: u16) -> Self {
+    pub fn init(width: u16, height: u16) -> Self {
         DesktopSize { width, height }
     }
 }

crates/ironrdp-web/src/session.rs

@@ -37,7 +37,7 @@ use web_sys::HtmlCanvasElement;
 
 use crate::canvas::Canvas;
 use crate::clipboard::{ClipboardTransaction, WasmClipboard, WasmClipboardBackend, WasmClipboardBackendMessage};
-use crate::error::{RemoteDesktopError, RemoteDesktopErrorKind};
+use crate::error::{IronError, IronErrorKind};
 use crate::image::extract_partial_image;
 use crate::input::InputTransaction;
 use crate::network_client::WasmNetworkClient;
@@ -103,7 +103,7 @@ impl Default for SessionBuilderInner {
 
 #[wasm_bindgen]
 impl SessionBuilder {
-    pub fn construct() -> SessionBuilder {
+    pub fn init() -> SessionBuilder {
         Self(Rc::new(RefCell::new(SessionBuilderInner::default())))
     }
 
@@ -220,7 +220,7 @@ impl SessionBuilder {
         self.clone()
     }
 
-    pub async fn connect(&self) -> Result<Session, RemoteDesktopError> {
+    pub async fn connect(&self) -> Result<Session, IronError> {
         let (
             username,
             destination,
@@ -295,11 +295,11 @@ impl SessionBuilder {
         loop {
             match ws.state() {
                 websocket::State::Closing | websocket::State::Closed => {
-                    return Err(RemoteDesktopError::from(anyhow::anyhow!(
+                    return Err(IronError::from(anyhow::anyhow!(
                         "failed to connect to {proxy_address} (WebSocket is `{:?}`)",
                         ws.state()
                     ))
-                    .with_kind(RemoteDesktopErrorKind::ProxyConnect));
+                    .with_kind(IronErrorKind::ProxyConnect));
                 }
                 websocket::State::Connecting => {
                     trace!("WebSocket is connecting to proxy at {proxy_address}...");
@@ -417,7 +417,7 @@ pub struct Session {
 
 #[wasm_bindgen]
 impl Session {
-    pub async fn run(&self) -> Result<SessionTerminationInfo, RemoteDesktopError> {
+    pub async fn run(&self) -> Result<SessionTerminationInfo, IronError> {
         let rdp_reader = self
             .rdp_reader
             .borrow_mut()
@@ -712,17 +712,17 @@ impl Session {
         }
     }
 
-    pub fn apply_inputs(&self, transaction: InputTransaction) -> Result<(), RemoteDesktopError> {
+    pub fn apply_inputs(&self, transaction: InputTransaction) -> Result<(), IronError> {
         let inputs = self.input_database.borrow_mut().apply(transaction);
         self.h_send_inputs(inputs)
     }
 
-    pub fn release_all_inputs(&self) -> Result<(), RemoteDesktopError> {
+    pub fn release_all_inputs(&self) -> Result<(), IronError> {
         let inputs = self.input_database.borrow_mut().release_all();
         self.h_send_inputs(inputs)
     }
 
-    fn h_send_inputs(&self, inputs: smallvec::SmallVec<[FastPathInputEvent; 2]>) -> Result<(), RemoteDesktopError> {
+    fn h_send_inputs(&self, inputs: smallvec::SmallVec<[FastPathInputEvent; 2]>) -> Result<(), IronError> {
         if !inputs.is_empty() {
             trace!("Inputs: {inputs:?}");
 
@@ -740,7 +740,7 @@ impl Session {
         num_lock: bool,
         caps_lock: bool,
         kana_lock: bool,
-    ) -> Result<(), RemoteDesktopError> {
+    ) -> Result<(), IronError> {
         use ironrdp::pdu::input::fast_path::FastPathInput;
 
         let event = ironrdp::input::synchronize_event(scroll_lock, num_lock, caps_lock, kana_lock);
@@ -755,15 +755,15 @@ impl Session {
         Ok(())
     }
 
-    pub fn shutdown(&self) -> Result<(), RemoteDesktopError> {
+    pub fn shutdown(&self) -> Result<(), IronError> {
         self.input_events_tx
             .unbounded_send(RdpInputEvent::TerminateSession)
             .context("failed to send terminate session event to writer task")?;
 
         Ok(())
     }
 
-    pub async fn on_clipboard_paste(&self, content: ClipboardTransaction) -> Result<(), RemoteDesktopError> {
+    pub async fn on_clipboard_paste(&self, content: ClipboardTransaction) -> Result<(), IronError> {
         self.input_events_tx
             .unbounded_send(RdpInputEvent::ClipboardBackend(
                 WasmClipboardBackendMessage::LocalClipboardChanged(content),
@@ -773,7 +773,7 @@ impl Session {
         Ok(())
     }
 
-    fn set_cursor_style(&self, style: CursorStyle) -> Result<(), RemoteDesktopError> {
+    fn set_cursor_style(&self, style: CursorStyle) -> Result<(), IronError> {
         let (kind, data, hotspot_x, hotspot_y) = match style {
             CursorStyle::Default => ("default", None, None, None),
             CursorStyle::Hidden => ("hidden", None, None, None),
@@ -824,7 +824,7 @@ impl Session {
         false
     }
 
-    pub fn extension_call(_value: JsValue) -> Result<JsValue, RemoteDesktopError> {
+    pub fn extension_call(_value: JsValue) -> Result<JsValue, IronError> {
         Ok(JsValue::null())
     }
 }
@@ -922,7 +922,7 @@ async fn connect(
         clipboard_backend,
         use_display_control,
     }: ConnectParams,
-) -> Result<(connector::ConnectionResult, WebSocket), RemoteDesktopError> {
+) -> Result<(connector::ConnectionResult, WebSocket), IronError> {
     let mut framed = ironrdp_futures::LocalFuturesFramed::new(ws);
 
     let mut connector = ClientConnector::new(config);
@@ -969,7 +969,7 @@ async fn connect_rdcleanpath<S>(
     destination: String,
     proxy_auth_token: String,
     pcb: Option<String>,
-) -> Result<(ironrdp_futures::Upgraded, Vec<u8>), RemoteDesktopError>
+) -> Result<(ironrdp_futures::Upgraded, Vec<u8>), IronError>
 where
     S: ironrdp_futures::FramedRead + FramedWrite,
 {
@@ -1048,10 +1048,10 @@ where
                     server_addr,
                 } => (x224_connection_response, server_cert_chain, server_addr),
                 ironrdp_rdcleanpath::RDCleanPath::Err(error) => {
-                    return Err(RemoteDesktopError::from(
-                        anyhow::Error::new(error).context("received an RDCleanPath error"),
-                    )
-                    .with_kind(RemoteDesktopErrorKind::RDCleanPath));
+                    return Err(
+                        IronError::from(anyhow::Error::new(error).context("received an RDCleanPath error"))
+                            .with_kind(IronErrorKind::RDCleanPath),
+                    );
                 }
             };
 

web-client/iron-remote-desktop-rdp/src/main.ts

@@ -3,7 +3,7 @@ import init, {
     DesktopSize,
     DeviceEvent,
     InputTransaction,
-    RemoteDesktopError,
+    IronError,
     Session,
     SessionBuilder,
     SessionTerminationInfo,
@@ -17,7 +17,7 @@ export default {
     DesktopSize,
     DeviceEvent,
     InputTransaction,
-    RemoteDesktopError,
+    IronError,
     SessionBuilder,
     ClipboardTransaction,
     ClipboardContent,

web-client/iron-remote-desktop/src/interfaces/ClipboardTransaction.ts

@@ -1,7 +1,7 @@
 import type { ClipboardContent } from './ClipboardContent';
 
 export interface ClipboardTransaction {
-    construct(): ClipboardTransaction;
+    init(): ClipboardTransaction;
     add_content(content: ClipboardContent): void;
     is_empty(): boolean;
     content(): Array<ClipboardContent>;

web-client/iron-remote-desktop/src/interfaces/DesktopSize.ts

@@ -2,5 +2,5 @@
     width: number;
     height: number;
 
-    construct(width: number, height: number): DesktopSize;
+    init(width: number, height: number): DesktopSize;
 }