graphics/fbbootlogd: Merge Display into FbbbootlogScheme

graphics/fbbootlogd/src/display.rs

@@ -1,62 +0,0 @@
-use std::io;
-
-use graphics_ipc::v1::{Damage, V1GraphicsHandle};
-use inputd::ConsumerHandle;
-
-fn display_fd_map(display_handle: V1GraphicsHandle) -> io::Result<DisplayMap> {
-    let display_map = display_handle.map_display()?;
-    Ok(DisplayMap {
-        display_handle,
-        inner: display_map,
-    })
-}
-
-pub struct DisplayMap {
-    display_handle: V1GraphicsHandle,
-    pub inner: graphics_ipc::v1::DisplayMap,
-}
-
-pub struct Display {
-    pub input_handle: ConsumerHandle,
-    pub map: Option<DisplayMap>,
-}
-
-impl Display {
-    pub fn open_first_vt() -> io::Result<Self> {
-        let mut display = Self {
-            input_handle: ConsumerHandle::new_vt()?,
-            map: None,
-        };
-
-        display.handle_handoff();
-
-        Ok(display)
-    }
-
-    pub fn handle_handoff(&mut self) {
-        let new_display_handle = match self.input_handle.open_display() {
-            Ok(display) => V1GraphicsHandle::from_file(display).unwrap(),
-            Err(err) => {
-                eprintln!("fbbootlogd: No display present yet: {err}");
-                return;
-            }
-        };
-
-        match display_fd_map(new_display_handle) {
-            Ok(ok) => {
-                self.map = Some(ok);
-
-                eprintln!("fbbootlogd: mapped display");
-            }
-            Err(err) => {
-                eprintln!("fbbootlogd: failed to open display: {}", err);
-            }
-        }
-    }
-
-    pub fn sync_rects(&mut self, sync_rects: Vec<Damage>) {
-        if let Some(map) = &self.map {
-            map.display_handle.sync_rects(&sync_rects).unwrap();
-        }
-    }
-}

graphics/fbbootlogd/src/main.rs

@@ -17,7 +17,6 @@ use redox_scheme::{RequestKind, SignalBehavior, Socket};
 
 use crate::scheme::FbbootlogScheme;
 
-mod display;
 mod scheme;
 
 fn main() {
@@ -48,7 +47,7 @@ fn inner(daemon: redox_daemon::Daemon) -> ! {
 
     event_queue
         .subscribe(
-            scheme.display.input_handle.event_handle().as_raw_fd() as usize,
+            scheme.input_handle.event_handle().as_raw_fd() as usize,
             Source::Input,
             event::EventFlags::READ,
         )
@@ -93,7 +92,6 @@ fn inner(daemon: redox_daemon::Daemon) -> ! {
                 let mut events = [Event::new(); 16];
                 loop {
                     match scheme
-                        .display
                         .input_handle
                         .read_events(&mut events)
                         .expect("fbbootlogd: error while reading events")
@@ -102,7 +100,7 @@ fn inner(daemon: redox_daemon::Daemon) -> ! {
                         ConsumerHandleEvent::Events(_) => {}
                         ConsumerHandleEvent::Handoff => {
                             eprintln!("fbbootlogd: handoff requested");
-                            scheme.display.handle_handoff();
+                            scheme.handle_handoff();
                         }
                     }
                 }

graphics/fbbootlogd/src/scheme.rs

@@ -1,20 +1,55 @@
 use std::collections::VecDeque;
 
+use graphics_ipc::v1::V1GraphicsHandle;
+use inputd::ConsumerHandle;
 use redox_scheme::Scheme;
 use syscall::{Error, Result, EINVAL, ENOENT};
 
-use crate::display::Display;
+pub struct DisplayMap {
+    display_handle: V1GraphicsHandle,
+    inner: graphics_ipc::v1::DisplayMap,
+}
 
 pub struct FbbootlogScheme {
-    pub display: Display,
+    pub input_handle: ConsumerHandle,
+    display_map: Option<DisplayMap>,
     text_screen: console_draw::TextScreen,
 }
 
 impl FbbootlogScheme {
     pub fn new() -> FbbootlogScheme {
-        FbbootlogScheme {
-            display: Display::open_first_vt().expect("Failed to open display for vt"),
+        let mut scheme = FbbootlogScheme {
+            input_handle: ConsumerHandle::new_vt().expect("fbbootlogd: Failed to open vt"),
+            display_map: None,
             text_screen: console_draw::TextScreen::new(),
+        };
+
+        scheme.handle_handoff();
+
+        scheme
+    }
+
+    pub fn handle_handoff(&mut self) {
+        let new_display_handle = match self.input_handle.open_display() {
+            Ok(display) => V1GraphicsHandle::from_file(display).unwrap(),
+            Err(err) => {
+                eprintln!("fbbootlogd: No display present yet: {err}");
+                return;
+            }
+        };
+
+        match new_display_handle.map_display() {
+            Ok(display_map) => {
+                self.display_map = Some(DisplayMap {
+                    display_handle: new_display_handle,
+                    inner: display_map,
+                });
+
+                eprintln!("fbbootlogd: mapped display");
+            }
+            Err(err) => {
+                eprintln!("fbbootlogd: failed to open display: {}", err);
+            }
         }
     }
 }
@@ -55,7 +90,7 @@ impl Scheme for FbbootlogScheme {
     }
 
     fn write(&mut self, _id: usize, buf: &[u8], _offset: u64, _fcntl_flags: u32) -> Result<usize> {
-        if let Some(map) = &mut self.display.map {
+        if let Some(map) = &mut self.display_map {
             let damage = self.text_screen.write(
                 &mut console_draw::DisplayMap {
                     offscreen: map.inner.ptr_mut(),
@@ -66,7 +101,9 @@ impl Scheme for FbbootlogScheme {
                 &mut VecDeque::new(),
             );
 
-            self.display.sync_rects(damage);
+            if let Some(map) = &self.display_map {
+                map.display_handle.sync_rects(&damage).unwrap();
+            }
         }
 
         Ok(buf.len())