Kernel: Separate GenericFramebufferConsole implementation

The GenericFramebufferConsoleImpl class implements the logic without
taking into account any other details such as synchronization. The
GenericFramebufferConsole class then is a simple wrapper around
GenericFramebufferConsoleImpl that takes care of synchronization.

This allows us to re-use this implementation with e.g. different
synchronization schemes.

Kernel/Graphics/Console/GenericFramebufferConsole.cpp

@@ -200,31 +200,30 @@ static inline BGRColor convert_standard_color_to_bgr_color(Console::Color color)
     }
 }
 
-size_t GenericFramebufferConsole::bytes_per_base_glyph() const
+size_t GenericFramebufferConsoleImpl::bytes_per_base_glyph() const
 {
     // FIXME: We assume we have 32 bit bpp framebuffer.
     return 8 * 32;
 }
-size_t GenericFramebufferConsole::chars_per_line() const
+size_t GenericFramebufferConsoleImpl::chars_per_line() const
 {
     return width() / bytes_per_base_glyph();
 }
 
-void GenericFramebufferConsole::set_cursor(size_t, size_t)
+void GenericFramebufferConsoleImpl::set_cursor(size_t, size_t)
 {
 }
 
-void GenericFramebufferConsole::hide_cursor()
+void GenericFramebufferConsoleImpl::hide_cursor()
 {
 }
 
-void GenericFramebufferConsole::show_cursor()
+void GenericFramebufferConsoleImpl::show_cursor()
 {
 }
 
-void GenericFramebufferConsole::clear(size_t x, size_t y, size_t length)
+void GenericFramebufferConsoleImpl::clear(size_t x, size_t y, size_t length)
 {
-    SpinlockLocker lock(m_lock);
     if (x == 0 && length == max_column()) {
         // if we need to clear the entire row, just clean it with quick memset :)
         auto* offset_in_framebuffer = (u32*)&framebuffer_data()[x * sizeof(u32) * 8 + y * 8 * sizeof(u32) * width()];
@@ -251,9 +250,8 @@ void GenericFramebufferConsole::clear(size_t x, size_t y, size_t length)
     }
 }
 
-void GenericFramebufferConsole::clear_glyph(size_t x, size_t y)
+void GenericFramebufferConsoleImpl::clear_glyph(size_t x, size_t y)
 {
-    VERIFY(m_lock.is_locked());
     auto* offset_in_framebuffer = (u32*)&framebuffer_data()[x * sizeof(u32) * 8 + y * 8 * sizeof(u32) * width()];
     for (size_t current_x = 0; current_x < 8; current_x++) {
         memset(offset_in_framebuffer, 0, 8 * sizeof(u32));
@@ -262,21 +260,19 @@ void GenericFramebufferConsole::clear_glyph(size_t x, size_t y)
     flush(8 * x, 8 * y, 8, 8);
 }
 
-void GenericFramebufferConsole::enable()
+void GenericFramebufferConsoleImpl::enable()
 {
-    SpinlockLocker lock(m_lock);
     memset(framebuffer_data(), 0, height() * width() * sizeof(u32));
     m_enabled.store(true);
 }
-void GenericFramebufferConsole::disable()
+
+void GenericFramebufferConsoleImpl::disable()
 {
-    SpinlockLocker lock(m_lock);
     m_enabled.store(false);
 }
 
-void GenericFramebufferConsole::write(size_t x, size_t y, char ch, Color background, Color foreground, bool critical)
+void GenericFramebufferConsoleImpl::write(size_t x, size_t y, char ch, Color background, Color foreground, bool critical)
 {
-    SpinlockLocker lock(m_lock);
     if (!m_enabled.load())
         return;
 
@@ -323,14 +319,44 @@ void GenericFramebufferConsole::write(size_t x, size_t y, char ch, Color backgro
     }
 }
 
-void GenericFramebufferConsole::write(size_t x, size_t y, char ch, bool critical)
+void GenericFramebufferConsoleImpl::write(size_t x, size_t y, char ch, bool critical)
 {
     write(x, y, ch, m_default_background_color, m_default_foreground_color, critical);
 }
 
-void GenericFramebufferConsole::write(char ch, bool critical)
+void GenericFramebufferConsoleImpl::write(char ch, bool critical)
 {
     write(m_x, m_y, ch, m_default_background_color, m_default_foreground_color, critical);
 }
 
+void GenericFramebufferConsole::clear(size_t x, size_t y, size_t length)
+{
+    SpinlockLocker lock(m_lock);
+    GenericFramebufferConsoleImpl::clear(x, y, length);
+}
+
+void GenericFramebufferConsole::clear_glyph(size_t x, size_t y)
+{
+    VERIFY(m_lock.is_locked());
+    GenericFramebufferConsoleImpl::clear_glyph(x, y);
+}
+
+void GenericFramebufferConsole::enable()
+{
+    SpinlockLocker lock(m_lock);
+    GenericFramebufferConsoleImpl::enable();
+}
+
+void GenericFramebufferConsole::disable()
+{
+    SpinlockLocker lock(m_lock);
+    GenericFramebufferConsoleImpl::disable();
+}
+
+void GenericFramebufferConsole::write(size_t x, size_t y, char ch, Color background, Color foreground, bool critical)
+{
+    SpinlockLocker lock(m_lock);
+    GenericFramebufferConsoleImpl::write(x, y, ch, background, foreground, critical);
+}
+
 }

Kernel/Graphics/Console/GenericFramebufferConsole.h

@@ -13,7 +13,7 @@
 
 namespace Kernel::Graphics {
 
-class GenericFramebufferConsole : public Console {
+class GenericFramebufferConsoleImpl : public Console {
 public:
     virtual size_t bytes_per_base_glyph() const override;
     virtual size_t chars_per_line() const override;
@@ -39,14 +39,33 @@ public:
     virtual void set_resolution(size_t width, size_t height, size_t pitch) = 0;
 
 protected:
-    GenericFramebufferConsole(size_t width, size_t height, size_t pitch)
+    GenericFramebufferConsoleImpl(size_t width, size_t height, size_t pitch)
         : Console(width, height)
         , m_pitch(pitch)
     {
     }
     virtual u8* framebuffer_data() = 0;
-    void clear_glyph(size_t x, size_t y);
+    virtual void clear_glyph(size_t x, size_t y);
     size_t m_pitch;
+};
+
+class GenericFramebufferConsole : public GenericFramebufferConsoleImpl {
+public:
+    virtual void clear(size_t x, size_t y, size_t length) override;
+    virtual void write(size_t x, size_t y, char ch, Color background, Color foreground, bool critical = false) override;
+
+    virtual void enable() override;
+    virtual void disable() override;
+
+protected:
+    GenericFramebufferConsole(size_t width, size_t height, size_t pitch)
+        : GenericFramebufferConsoleImpl(width, height, pitch)
+    {
+    }
+
+    virtual void clear_glyph(size_t x, size_t y) override;
+
     mutable Spinlock m_lock;
 };
+
 }