follow core guidelines and be more const correct

jstkdng · jstkdng · commit 9e680f7d993a · 2023-09-19T00:06:45.000-05:00
diff --git a/include/util/egl.hpp b/include/util/egl.hpp
@@ -35,14 +35,12 @@ class EGLUtil
     EGLUtil(EGLenum platform, T* native_display, const EGLAttrib* attrib = nullptr);
     ~EGLUtil();
 
-    void get_texture_from_image(const Image& image, GLuint texture);
-
-    auto create_surface(V* native_window) -> EGLSurface;
-    auto create_context(EGLSurface surface) -> EGLContext;
-
-    void run_contained(EGLSurface surface, EGLContext context, const std::function<void()>& func);
-    void make_current(EGLSurface surface, EGLContext context);
-    void restore();
+    void get_texture_from_image(const Image& image, GLuint texture) const;
+    void run_contained(EGLSurface surface, EGLContext context, const std::function<void()>& func) const;
+    void make_current(EGLSurface surface, EGLContext context) const;
+    void restore() const;
+    [[nodiscard]] auto create_surface(V* native_window) const -> EGLSurface;
+    [[nodiscard]] auto create_context(EGLSurface surface) const -> EGLContext;
 
     EGLDisplay display;
 
diff --git a/src/canvas/wayland/config/wayfire.hpp b/src/canvas/wayland/config/wayfire.hpp
@@ -36,7 +36,7 @@ class WayfireSocket : public WaylandConfig
 private:
     [[nodiscard]] auto request(std::string_view method, const nlohmann::json& data = {}) const -> nlohmann::json;
 
-    const UnixSocket socket;
+    UnixSocket socket;
     std::shared_ptr<spdlog::logger> logger;
 };
 
diff --git a/src/canvas/wayland/wayland.cpp b/src/canvas/wayland/wayland.cpp
@@ -147,15 +147,15 @@ void WaylandCanvas::add_image(const std::string& identifier, std::unique_ptr<Ima
 #ifdef ENABLE_OPENGL
     if (egl_available) {
         try {
-            window = std::make_shared<WaylandEglWindow>(compositor, xdg_base, *egl, std::move(new_image), config, xdg_agg);
+            window = std::make_shared<WaylandEglWindow>(compositor, xdg_base, egl.get(), std::move(new_image), config, &xdg_agg);
         } catch (const std::runtime_error& err) {
             return;
         }
     } else {
-        window = std::make_shared<WaylandShmWindow>(compositor, wl_shm, xdg_base, std::move(new_image), config, xdg_agg);
+        window = std::make_shared<WaylandShmWindow>(compositor, wl_shm, xdg_base, std::move(new_image), config, &xdg_agg);
     }
 #else
-    window = std::make_shared<WaylandShmWindow>(compositor, wl_shm, xdg_base, std::move(new_image), config, xdg_agg);
+    window = std::make_shared<WaylandShmWindow>(compositor, wl_shm, xdg_base, std::move(new_image), config, &xdg_agg);
 #endif
     window->finish_init();
     windows.insert_or_assign(identifier, std::move(window));
diff --git a/src/canvas/wayland/window/waylandegl.cpp b/src/canvas/wayland/window/waylandegl.cpp
@@ -34,8 +34,8 @@ constexpr struct wl_callback_listener frame_listener_egl = {
 };
 
 WaylandEglWindow::WaylandEglWindow(struct wl_compositor *compositor, struct xdg_wm_base *xdg_base,
-        EGLUtil<struct wl_display, struct wl_egl_window>& egl, std::unique_ptr<Image> new_image,
-        std::shared_ptr<WaylandConfig> new_config, struct XdgStructAgg& xdg_agg):
+        const EGLUtil<struct wl_display, struct wl_egl_window>* egl, std::unique_ptr<Image> new_image,
+        std::shared_ptr<WaylandConfig> new_config, struct XdgStructAgg* xdg_agg):
 compositor(compositor),
 xdg_base(xdg_base),
 surface(wl_compositor_create_surface(compositor)),
@@ -62,38 +62,38 @@ WaylandEglWindow::~WaylandEglWindow()
 
 void WaylandEglWindow::opengl_cleanup()
 {
-    egl.run_contained(egl_context, egl_surface, [this] {
+    egl->run_contained(egl_context, egl_surface, [this] {
         glDeleteTextures(1, &texture);
         glDeleteFramebuffers(1, &fbo);
     });
-    eglDestroySurface(egl.display, egl_surface);
-    eglDestroyContext(egl.display, egl_context);
+    eglDestroySurface(egl->display, egl_surface);
+    eglDestroyContext(egl->display, egl_context);
 }
 
 void WaylandEglWindow::finish_init()
 {
     auto xdg = std::make_unique<XdgStruct>();
     xdg->ptr = weak_from_this();
     this_ptr = xdg.get();
-    xdg_agg.ptrs.push_back(std::move(xdg));
+    xdg_agg->ptrs.push_back(std::move(xdg));
     setup_listeners();
     visible = true;
 }
 
 void WaylandEglWindow::opengl_setup()
 {
-    egl_surface = egl.create_surface(egl_window);
+    egl_surface = egl->create_surface(egl_window);
     if (egl_surface == EGL_NO_SURFACE) {
         throw std::runtime_error("");
     }
 
-    egl_context = egl.create_context(egl_surface);
+    egl_context = egl->create_context(egl_surface);
     if (egl_context == EGL_NO_CONTEXT) {
         throw std::runtime_error("");
     }
 
-    egl.run_contained(egl_surface, egl_context, [this] {
-        eglSwapInterval(egl.display, 0);
+    egl->run_contained(egl_surface, egl_context, [this] {
+        eglSwapInterval(egl->display, 0);
         glGenFramebuffers(1, &fbo);
         glGenTextures(1, &texture);
     });
@@ -151,15 +151,15 @@ void WaylandEglWindow::draw()
 void WaylandEglWindow::load_framebuffer()
 {
     std::scoped_lock lock {egl_mutex};
-    egl.run_contained(egl_surface, egl_context, [this] {
-        egl.get_texture_from_image(*image, texture);
+    egl->run_contained(egl_surface, egl_context, [this] {
+        egl->get_texture_from_image(*image, texture);
         glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
         glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                 GL_TEXTURE_2D, texture, 0);
         glBlitFramebuffer(0, 0, image->width(), image->height(), 0, 0, image->width(), image->height(),
                       GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
-        eglSwapBuffers(egl.display, egl_surface);
+        eglSwapBuffers(egl->display, egl_surface);
     });
 }
 
diff --git a/src/canvas/wayland/window/waylandegl.hpp b/src/canvas/wayland/window/waylandegl.hpp
@@ -35,8 +35,8 @@ class WaylandEglWindow :
 {
 public:
     WaylandEglWindow(struct wl_compositor *compositor, struct xdg_wm_base *xdg_base,
-            EGLUtil<struct wl_display, struct wl_egl_window>& egl, std::unique_ptr<Image> new_image,
-            std::shared_ptr<WaylandConfig> new_config, struct XdgStructAgg& xdg_agg);
+            const EGLUtil<struct wl_display, struct wl_egl_window>* egl, std::unique_ptr<Image> new_image,
+            std::shared_ptr<WaylandConfig> new_config, struct XdgStructAgg* xdg_agg);
     ~WaylandEglWindow() override;
     static void xdg_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial);
     static void wl_surface_frame_done(void *data, struct wl_callback *callback, uint32_t time);
@@ -64,7 +64,7 @@ class WaylandEglWindow :
     EGLContext egl_context;
 
     struct wl_egl_window *egl_window = nullptr;
-    EGLUtil<struct wl_display, struct wl_egl_window>& egl;
+    const EGLUtil<struct wl_display, struct wl_egl_window>* egl;
 
     GLuint texture;
     GLuint fbo;
@@ -74,7 +74,7 @@ class WaylandEglWindow :
 
     std::string appid;
     void* this_ptr;
-    struct XdgStructAgg& xdg_agg;
+    struct XdgStructAgg* xdg_agg;
     bool visible = false;
 
     void move_window();
diff --git a/src/canvas/wayland/window/waylandshm.cpp b/src/canvas/wayland/window/waylandshm.cpp
@@ -36,7 +36,7 @@ constexpr struct wl_callback_listener frame_listener = {
 
 WaylandShmWindow::WaylandShmWindow(struct wl_compositor *compositor,
         struct wl_shm *wl_shm, struct xdg_wm_base *xdg_base, std::unique_ptr<Image> new_image,
-        std::shared_ptr<WaylandConfig> new_config, struct XdgStructAgg& xdg_agg):
+        std::shared_ptr<WaylandConfig> new_config, struct XdgStructAgg* xdg_agg):
 compositor(compositor),
 xdg_base(xdg_base),
 surface(wl_compositor_create_surface(compositor)),
@@ -57,7 +57,7 @@ void WaylandShmWindow::finish_init()
     auto xdg = std::make_unique<XdgStruct>();
     xdg->ptr = weak_from_this();
     this_ptr = xdg.get();
-    xdg_agg.ptrs.push_back(std::move(xdg));
+    xdg_agg->ptrs.push_back(std::move(xdg));
     setup_listeners();
     visible = true;
 }
diff --git a/src/canvas/wayland/window/waylandshm.hpp b/src/canvas/wayland/window/waylandshm.hpp
@@ -36,7 +36,7 @@ class WaylandShmWindow :
 public:
     WaylandShmWindow(struct wl_compositor *compositor, struct wl_shm *wl_shm,
             struct xdg_wm_base *xdg_base, std::unique_ptr<Image> new_image,
-            std::shared_ptr<WaylandConfig> new_config, struct XdgStructAgg& xdg_agg);
+            std::shared_ptr<WaylandConfig> new_config, struct XdgStructAgg* xdg_agg);
     ~WaylandShmWindow() override;
     static void xdg_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial);
     static void wl_surface_frame_done(void *data, struct wl_callback *callback, uint32_t time);
@@ -64,7 +64,7 @@ class WaylandShmWindow :
     std::string appid;
     std::shared_ptr<WaylandConfig> config;
 
-    XdgStructAgg& xdg_agg;
+    struct XdgStructAgg* xdg_agg;
     void* this_ptr;
 
     void move_window();
diff --git a/src/canvas/x11/window/x11egl.cpp b/src/canvas/x11/window/x11egl.cpp
@@ -25,7 +25,7 @@
 #include <gsl/gsl>
 
 X11EGLWindow::X11EGLWindow(xcb_connection_t* connection, xcb_screen_t* screen,
-            xcb_window_t windowid, xcb_window_t parentid, EGLUtil<xcb_connection_t, xcb_window_t>& egl,
+            xcb_window_t windowid, xcb_window_t parentid, const EGLUtil<xcb_connection_t, xcb_window_t>* egl,
             std::shared_ptr<Image> new_image):
 connection(connection),
 screen(screen),
@@ -41,12 +41,12 @@ egl(egl)
 
 X11EGLWindow::~X11EGLWindow()
 {
-    egl.run_contained(egl_surface, egl_context, [this] {
+    egl->run_contained(egl_surface, egl_context, [this] {
         glDeleteTextures(1, &texture);
         glDeleteFramebuffers(1, &fbo);
     });
-    eglDestroySurface(egl.display, egl_surface);
-    eglDestroyContext(egl.display, egl_context);
+    eglDestroySurface(egl->display, egl_surface);
+    eglDestroyContext(egl->display, egl_context);
 
     xcb_destroy_window(connection, windowid);
     xcb_flush(connection);
@@ -79,17 +79,17 @@ void X11EGLWindow::create()
 
 void X11EGLWindow::opengl_setup()
 {
-    egl_surface = egl.create_surface(&windowid);
+    egl_surface = egl->create_surface(&windowid);
     if (egl_surface == EGL_NO_SURFACE) {
         throw std::runtime_error("");
     }
 
-    egl_context = egl.create_context(egl_surface);
+    egl_context = egl->create_context(egl_surface);
     if (egl_context == EGL_NO_CONTEXT) {
         throw std::runtime_error("");
     }
 
-    egl.run_contained(egl_surface, egl_context, [this] {
+    egl->run_contained(egl_surface, egl_context, [this] {
         glGenFramebuffers(1, &fbo);
         glGenTextures(1, &texture);
     });
@@ -98,18 +98,18 @@ void X11EGLWindow::opengl_setup()
 void X11EGLWindow::draw()
 {
     const std::scoped_lock lock {egl_mutex};
-    egl.run_contained(egl_surface, egl_context, [this] {
+    egl->run_contained(egl_surface, egl_context, [this] {
         glBlitFramebuffer(0, 0, image->width(), image->height(), 0, 0, image->width(), image->height(),
                       GL_COLOR_BUFFER_BIT, GL_NEAREST);
-        eglSwapBuffers(egl.display, egl_surface);
+        eglSwapBuffers(egl->display, egl_surface);
     });
 }
 
 void X11EGLWindow::generate_frame()
 {
     const std::scoped_lock lock {egl_mutex};
-    egl.run_contained(egl_surface, egl_context, [this] {
-        egl.get_texture_from_image(*image, texture);
+    egl->run_contained(egl_surface, egl_context, [this] {
+        egl->get_texture_from_image(*image, texture);
         glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
         glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                 GL_TEXTURE_2D, texture, 0);
diff --git a/src/canvas/x11/window/x11egl.hpp b/src/canvas/x11/window/x11egl.hpp
@@ -32,7 +32,7 @@ class X11EGLWindow : public Window
 {
 public:
     X11EGLWindow(xcb_connection_t* connection, xcb_screen_t* screen,
-            xcb_window_t windowid, xcb_window_t parentid, EGLUtil<xcb_connection_t, xcb_window_t>& egl,
+            xcb_window_t windowid, xcb_window_t parentid, const EGLUtil<xcb_connection_t, xcb_window_t>* egl,
             std::shared_ptr<Image> new_image);
     ~X11EGLWindow() override;
 
@@ -47,7 +47,7 @@ class X11EGLWindow : public Window
     xcb_window_t windowid;
     xcb_window_t parentid;
     std::shared_ptr<Image> image;
-    EGLUtil<xcb_connection_t, xcb_window_t>& egl;
+    const EGLUtil<xcb_connection_t, xcb_window_t>* egl;
 
     GLuint texture;
     GLuint fbo;
diff --git a/src/canvas/x11/x11.cpp b/src/canvas/x11/x11.cpp
@@ -189,7 +189,7 @@ void X11Canvas::add_image(const std::string& identifier, std::unique_ptr<Image>
 #ifdef ENABLE_OPENGL
         if (egl_available) {
             try {
-                window = std::make_shared<X11EGLWindow>(connection, screen, window_id, parent, *egl, image);
+                window = std::make_shared<X11EGLWindow>(connection, screen, window_id, parent, egl.get(), image);
             } catch (const std::runtime_error& err) {
                 return;
             }
diff --git a/src/util/egl.cpp b/src/util/egl.cpp
@@ -140,7 +140,7 @@ auto EGLUtil<T, V>::error_to_string() const -> std::string_view
 }
 
 template <class T, class V>
-auto EGLUtil<T, V>::create_context(EGLSurface surface) -> EGLContext
+auto EGLUtil<T, V>::create_context(EGLSurface surface) const -> EGLContext
 {
     EGLContext context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attrs.data());
     if (context == EGL_NO_CONTEXT) {
@@ -160,7 +160,7 @@ auto EGLUtil<T, V>::create_context(EGLSurface surface) -> EGLContext
 }
 
 template <class T, class V>
-auto EGLUtil<T, V>::create_surface(V* native_window) -> EGLSurface
+auto EGLUtil<T, V>::create_surface(V* native_window) const -> EGLSurface
 {
     EGLSurface surface = eglCreatePlatformWindowSurface(display, config, native_window, nullptr);
     if (surface == EGL_NO_SURFACE) {
@@ -171,27 +171,27 @@ auto EGLUtil<T, V>::create_surface(V* native_window) -> EGLSurface
 }
 
 template <class T, class V>
-void EGLUtil<T, V>::make_current(EGLSurface surface, EGLContext context)
+void EGLUtil<T, V>::make_current(EGLSurface surface, EGLContext context) const
 {
     eglMakeCurrent(display, surface, surface, context);
 }
 
 template <class T, class V>
-void EGLUtil<T, V>::restore()
+void EGLUtil<T, V>::restore() const
 {
     eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 }
 
 template <class T, class V>
-void EGLUtil<T, V>::run_contained(EGLSurface surface, EGLContext context, const std::function<void()>& func)
+void EGLUtil<T, V>::run_contained(EGLSurface surface, EGLContext context, const std::function<void()>& func) const
 {
     make_current(surface, context);
     func();
     restore();
 }
 
 template <class T, class V>
-void EGLUtil<T, V>::get_texture_from_image(const Image& image, GLuint texture)
+void EGLUtil<T, V>::get_texture_from_image(const Image& image, GLuint texture) const
 {
     glBindTexture(GL_TEXTURE_2D, texture);
 

Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ void X11Canvas::add_image(const std::string& identifier, std::unique_ptr<Image>`
`189`	`189`	`#ifdef ENABLE_OPENGL`
`190`	`190`	`if (egl_available) {`
`191`	`191`	`try {`
`192`		`- window = std::make_shared<X11EGLWindow>(connection, screen, window_id, parent, *egl, image);`
	`192`	`+ window = std::make_shared<X11EGLWindow>(connection, screen, window_id, parent, egl.get(), image);`
`193`	`193`	`} catch (const std::runtime_error& err) {`
`194`	`194`	`return;`
`195`	`195`	`}`
Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ auto EGLUtil<T, V>::error_to_string() const -> std::string_view`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`template <class T, class V>`
`143`		`-auto EGLUtil<T, V>::create_context(EGLSurface surface) -> EGLContext`
	`143`	`+auto EGLUtil<T, V>::create_context(EGLSurface surface) const -> EGLContext`
`144`	`144`	`{`
`145`	`145`	`EGLContext context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attrs.data());`
`146`	`146`	`if (context == EGL_NO_CONTEXT) {`
`@@ -160,7 +160,7 @@ auto EGLUtil<T, V>::create_context(EGLSurface surface) -> EGLContext`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`template <class T, class V>`
`163`		`-auto EGLUtil<T, V>::create_surface(V* native_window) -> EGLSurface`
	`163`	`+auto EGLUtil<T, V>::create_surface(V* native_window) const -> EGLSurface`
`164`	`164`	`{`
`165`	`165`	`EGLSurface surface = eglCreatePlatformWindowSurface(display, config, native_window, nullptr);`
`166`	`166`	`if (surface == EGL_NO_SURFACE) {`
`@@ -171,27 +171,27 @@ auto EGLUtil<T, V>::create_surface(V* native_window) -> EGLSurface`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`template <class T, class V>`
`174`		`-void EGLUtil<T, V>::make_current(EGLSurface surface, EGLContext context)`
	`174`	`+void EGLUtil<T, V>::make_current(EGLSurface surface, EGLContext context) const`
`175`	`175`	`{`
`176`	`176`	`eglMakeCurrent(display, surface, surface, context);`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`template <class T, class V>`
`180`		`-void EGLUtil<T, V>::restore()`
	`180`	`+void EGLUtil<T, V>::restore() const`
`181`	`181`	`{`
`182`	`182`	`eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`template <class T, class V>`
`186`		`-void EGLUtil<T, V>::run_contained(EGLSurface surface, EGLContext context, const std::function<void()>& func)`
	`186`	`+void EGLUtil<T, V>::run_contained(EGLSurface surface, EGLContext context, const std::function<void()>& func) const`
`187`	`187`	`{`
`188`	`188`	`make_current(surface, context);`
`189`	`189`	`func();`
`190`	`190`	`restore();`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`template <class T, class V>`
`194`		`-void EGLUtil<T, V>::get_texture_from_image(const Image& image, GLuint texture)`
	`194`	`+void EGLUtil<T, V>::get_texture_from_image(const Image& image, GLuint texture) const`
`195`	`195`	`{`
`196`	`196`	`glBindTexture(GL_TEXTURE_2D, texture);`
`197`	`197`