Move Cef Handler into the cef module

Author: TrueDoctor

desktop/src/app.rs

@@ -6,7 +6,6 @@ use std::sync::Arc;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 use std::time::Instant;
-use tracing::instrument::WithSubscriber;
 use winit::application::ApplicationHandler;
 use winit::dpi::PhysicalSize;
 use winit::event::StartCause;

desktop/src/cef.rs

@@ -1,12 +1,16 @@
-use crate::FrameBuffer;
-use std::time::Instant;
+use crate::{CustomEvent, FrameBuffer};
+use std::{
+	sync::{Arc, Mutex, mpsc::Receiver},
+	time::Instant,
+};
 
 mod context;
 mod input;
 mod internal;
 mod scheme_handler;
 
 pub(crate) use context::{Context, InitError, Initialized, Setup, SetupError};
+use winit::event_loop::EventLoopProxy;
 
 pub(crate) trait CefEventHandler: Clone {
 	fn window_size(&self) -> WindowSize;
@@ -27,3 +31,50 @@ impl WindowSize {
 		Self { width, height }
 	}
 }
+
+#[derive(Clone)]
+pub(crate) struct CefHandler {
+	window_size_receiver: Arc<Mutex<WindowSizeReceiver>>,
+	event_loop_proxy: EventLoopProxy<CustomEvent>,
+}
+struct WindowSizeReceiver {
+	receiver: Receiver<WindowSize>,
+	window_size: WindowSize,
+}
+impl WindowSizeReceiver {
+	fn new(window_size_receiver: Receiver<WindowSize>) -> Self {
+		Self {
+			window_size: WindowSize { width: 1, height: 1 },
+			receiver: window_size_receiver,
+		}
+	}
+}
+impl CefHandler {
+	pub(crate) fn new(window_size_receiver: Receiver<WindowSize>, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
+		Self {
+			window_size_receiver: Arc::new(Mutex::new(WindowSizeReceiver::new(window_size_receiver))),
+			event_loop_proxy,
+		}
+	}
+}
+
+impl CefEventHandler for CefHandler {
+	fn window_size(&self) -> WindowSize {
+		let Ok(mut guard) = self.window_size_receiver.lock() else {
+			tracing::error!("Failed to lock window_size_receiver");
+			return WindowSize::new(1, 1);
+		};
+		let WindowSizeReceiver { receiver, window_size } = &mut *guard;
+		for new_window_size in receiver.try_iter() {
+			*window_size = new_window_size;
+		}
+		*window_size
+	}
+	fn draw(&self, frame_buffer: FrameBuffer) {
+		let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate(frame_buffer));
+	}
+
+	fn schedule_cef_message_loop_work(&self, scheduled_time: std::time::Instant) {
+		let _ = self.event_loop_proxy.send_event(CustomEvent::ScheduleBrowserWork(scheduled_time));
+	}
+}

desktop/src/main.rs

@@ -1,11 +1,9 @@
 use std::fmt::Debug;
 use std::process::exit;
-use std::sync::mpsc::Receiver;
-use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
 use tracing_subscriber::EnvFilter;
-use winit::event_loop::{EventLoop, EventLoopProxy};
+use winit::event_loop::EventLoop;
 
 mod cef;
 use cef::{Setup, WindowSize};
@@ -22,53 +20,6 @@ pub(crate) enum CustomEvent {
 	ScheduleBrowserWork(Instant),
 }
 
-#[derive(Clone)]
-struct CefHandler {
-	window_size_receiver: Arc<Mutex<WindowSizeReceiver>>,
-	event_loop_proxy: EventLoopProxy<CustomEvent>,
-}
-struct WindowSizeReceiver {
-	receiver: Receiver<WindowSize>,
-	window_size: WindowSize,
-}
-impl WindowSizeReceiver {
-	fn new(window_size_receiver: Receiver<WindowSize>) -> Self {
-		Self {
-			window_size: WindowSize { width: 1, height: 1 },
-			receiver: window_size_receiver,
-		}
-	}
-}
-impl CefHandler {
-	fn new(window_size_receiver: Receiver<WindowSize>, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
-		Self {
-			window_size_receiver: Arc::new(Mutex::new(WindowSizeReceiver::new(window_size_receiver))),
-			event_loop_proxy,
-		}
-	}
-}
-
-impl cef::CefEventHandler for CefHandler {
-	fn window_size(&self) -> cef::WindowSize {
-		let Ok(mut guard) = self.window_size_receiver.lock() else {
-			tracing::error!("Failed to lock window_size_receiver");
-			return cef::WindowSize::new(1, 1);
-		};
-		let WindowSizeReceiver { receiver, window_size } = &mut *guard;
-		for new_window_size in receiver.try_iter() {
-			*window_size = new_window_size;
-		}
-		*window_size
-	}
-	fn draw(&self, frame_buffer: FrameBuffer) {
-		let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate(frame_buffer));
-	}
-
-	fn schedule_cef_message_loop_work(&self, scheduled_time: std::time::Instant) {
-		let _ = self.event_loop_proxy.send_event(CustomEvent::ScheduleBrowserWork(scheduled_time));
-	}
-}
-
 fn main() {
 	tracing_subscriber::fmt().with_env_filter(EnvFilter::from_default_env()).init();
 
@@ -85,7 +36,7 @@ fn main() {
 
 	let (send, recv) = std::sync::mpsc::channel();
 
-	let cef_context = match cef_context.init(CefHandler::new(recv, event_loop.create_proxy())) {
+	let cef_context = match cef_context.init(cef::CefHandler::new(recv, event_loop.create_proxy())) {
 		Ok(c) => c,
 		Err(cef::InitError::InitializationFailed) => {
 			tracing::error!("Cef initialization failed");

desktop/src/render.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use thiserror::Error;
-use wgpu::PollType;
 use winit::window::Window;
 
 pub(crate) struct FrameBuffer {
@@ -215,7 +214,7 @@ impl GraphicsState {
 
 		let fb = FrameBuffer::new(initial_data, width, height)
 			.map_err(|e| {
-				panic!("Failed to create initial FrameBuffer: {}", e);
+				panic!("Failed to create initial FrameBuffer: {e}");
 			})
 			.unwrap();
 
@@ -224,10 +223,6 @@ impl GraphicsState {
 		graphics_state
 	}
 
-	pub(crate) fn poll(&self) {
-		let _ = self.device.poll(PollType::Poll);
-	}
-
 	pub(crate) fn update_texture(&mut self, frame_buffer: &FrameBuffer) {
 		let data = frame_buffer.buffer();
 		let width = frame_buffer.width() as u32;