gfx: remove GfxFramebuffer::take_render_ops

src/backends/metal/video.rs

@@ -923,7 +923,7 @@ impl MetalConnector {
         match &direct_scanout_data {
             None => {
                 let sf = buffer_fb
-                    .perform_render_pass(pass)
+                    .perform_render_pass(&pass)
                     .map_err(MetalError::RenderFrame)?;
                 sync_file = buffer.copy_to_dev(sf)?;
                 fb = buffer.drm.clone();

src/gfx_api.rs

@@ -256,13 +256,11 @@ pub enum ResetStatus {
 }
 
 pub trait GfxFramebuffer: Debug {
-    fn take_render_ops(&self) -> Vec<GfxApiOpt>;
-
     fn physical_size(&self) -> (i32, i32);
 
     fn render(
         &self,
-        ops: Vec<GfxApiOpt>,
+        ops: &[GfxApiOpt],
         clear: Option<&Color>,
     ) -> Result<Option<SyncFile>, GfxError>;
 
@@ -286,8 +284,7 @@ impl dyn GfxFramebuffer {
     }
 
     pub fn clear_with(&self, r: f32, g: f32, b: f32, a: f32) -> Result<Option<SyncFile>, GfxError> {
-        let ops = self.take_render_ops();
+        self.render(&[], Some(&Color { r, g, b, a }))
-        self.render(ops, Some(&Color { r, g, b, a }))
     }
 
     pub fn logical_size(&self, transform: Transform) -> (i32, i32) {
@@ -320,7 +317,7 @@ impl dyn GfxFramebuffer {
         x: i32,
         y: i32,
     ) -> Result<Option<SyncFile>, GfxError> {
-        let mut ops = self.take_render_ops();
+        let mut ops = vec![];
         let scale = Scale::from_int(1);
         let mut renderer = self.renderer_base(&mut ops, scale, Transform::None);
         renderer.render_texture(
@@ -337,7 +334,7 @@ impl dyn GfxFramebuffer {
             release_sync,
         );
         let clear = self.format().has_alpha.then_some(&Color::TRANSPARENT);
-        self.render(ops, clear)
+        self.render(&ops, clear)
     }
 
     pub fn render_custom(
@@ -346,10 +343,10 @@ impl dyn GfxFramebuffer {
         clear: Option<&Color>,
         f: &mut dyn FnMut(&mut RendererBase),
     ) -> Result<Option<SyncFile>, GfxError> {
-        let mut ops = self.take_render_ops();
+        let mut ops = vec![];
         let mut renderer = self.renderer_base(&mut ops, scale, Transform::None);
         f(&mut renderer);
-        self.render(ops, clear)
+        self.render(&ops, clear)
     }
 
     pub fn create_render_pass(
@@ -365,7 +362,7 @@ impl dyn GfxFramebuffer {
         transform: Transform,
         visualizer: Option<&DamageVisualizer>,
     ) -> GfxRenderPass {
-        let mut ops = self.take_render_ops();
+        let mut ops = vec![];
         let mut renderer = Renderer {
             base: self.renderer_base(&mut ops, scale, transform),
             state,
@@ -430,8 +427,8 @@ impl dyn GfxFramebuffer {
         }
     }
 
-    pub fn perform_render_pass(&self, pass: GfxRenderPass) -> Result<Option<SyncFile>, GfxError> {
+    pub fn perform_render_pass(&self, pass: &GfxRenderPass) -> Result<Option<SyncFile>, GfxError> {
-        self.render(pass.ops, pass.clear.as_ref())
+        self.render(&pass.ops, pass.clear.as_ref())
     }
 
     pub fn render_output(
@@ -480,7 +477,7 @@ impl dyn GfxFramebuffer {
             transform,
             None,
         );
-        self.perform_render_pass(pass)
+        self.perform_render_pass(&pass)
     }
 
     pub fn render_hardware_cursor(
@@ -490,7 +487,7 @@ impl dyn GfxFramebuffer {
         scale: Scale,
         transform: Transform,
     ) -> Result<Option<SyncFile>, GfxError> {
-        let mut ops = self.take_render_ops();
+        let mut ops = vec![];
         let mut renderer = Renderer {
             base: self.renderer_base(&mut ops, scale, transform),
             state,
@@ -502,7 +499,7 @@ impl dyn GfxFramebuffer {
             },
         };
         cursor.render_hardware_cursor(&mut renderer);
-        self.render(ops, Some(&Color::TRANSPARENT))
+        self.render(&ops, Some(&Color::TRANSPARENT))
     }
 }
 

src/gfx_apis/gl/renderer/context.rs

@@ -4,8 +4,8 @@ use {
         cpu_worker::CpuWorker,
         format::{Format, XRGB8888},
         gfx_api::{
-            AsyncShmGfxTexture, BufferResvUser, GfxApiOpt, GfxContext, GfxError, GfxFormat,
+            AsyncShmGfxTexture, BufferResvUser, GfxContext, GfxError, GfxFormat, GfxFramebuffer,
-            GfxFramebuffer, GfxImage, ResetStatus, ShmGfxTexture,
+            GfxImage, ResetStatus, ShmGfxTexture,
         },
         gfx_apis::gl::{
             egl::{context::EglContext, display::EglDisplay, image::EglImage},
@@ -84,7 +84,6 @@ pub(in crate::gfx_apis::gl) struct GlRenderContext {
     pub(crate) fill_prog_pos: GLint,
     pub(crate) fill_prog_color: GLint,
 
-    pub(crate) gfx_ops: RefCell<Vec<GfxApiOpt>>,
     pub(in crate::gfx_apis::gl) gl_state: RefCell<GfxGlState>,
 
     pub(in crate::gfx_apis::gl) buffer_resv_user: BufferResvUser,
@@ -169,7 +168,6 @@ impl GlRenderContext {
             fill_prog_color: fill_prog.get_uniform_location(c"color"),
             fill_prog,
 
-            gfx_ops: Default::default(),
             gl_state: Default::default(),
 
             buffer_resv_user: Default::default(),

src/gfx_apis/gl/renderer/framebuffer.rs

@@ -17,7 +17,6 @@ use {
     std::{
         cell::Cell,
         fmt::{Debug, Formatter},
-        mem,
         rc::Rc,
     },
 };
@@ -70,11 +69,11 @@ impl Framebuffer {
 
     pub fn render(
         &self,
-        mut ops: Vec<GfxApiOpt>,
+        ops: &[GfxApiOpt],
         clear: Option<&Color>,
     ) -> Result<Option<SyncFile>, RenderError> {
         let gles = self.ctx.ctx.dpy.gles;
-        let res = self.ctx.ctx.with_current(|| {
+        self.ctx.ctx.with_current(|| {
             unsafe {
                 (gles.glBindFramebuffer)(GL_FRAMEBUFFER, self.gl.fbo);
                 (gles.glViewport)(0, 0, self.gl.width, self.gl.height);
@@ -84,32 +83,25 @@ impl Framebuffer {
                 }
                 (gles.glBlendFunc)(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
             }
-            let fd = run_ops(self, &ops);
+            let fd = run_ops(self, ops);
             if fd.is_none() {
                 unsafe {
                     (gles.glFlush)();
                 }
             }
             Ok(fd)
-        });
+        })
-        ops.clear();
-        *self.ctx.gfx_ops.borrow_mut() = ops;
-        res
     }
 }
 
 impl GfxFramebuffer for Framebuffer {
-    fn take_render_ops(&self) -> Vec<GfxApiOpt> {
-        mem::take(&mut *self.ctx.gfx_ops.borrow_mut())
-    }
-
     fn physical_size(&self) -> (i32, i32) {
         (self.gl.width, self.gl.height)
     }
 
     fn render(
         &self,
-        ops: Vec<GfxApiOpt>,
+        ops: &[GfxApiOpt],
         clear: Option<&Color>,
     ) -> Result<Option<SyncFile>, GfxError> {
         self.render(ops, clear).map_err(|e| e.into())

src/gfx_apis/vulkan/image.rs

@@ -13,7 +13,7 @@ use {
         },
         rect::Region,
         theme::Color,
-        utils::{clonecell::CloneCell, on_drop::OnDrop},
+        utils::on_drop::OnDrop,
         video::dmabuf::{DmaBuf, PlaneVec},
     },
     ash::vk::{
@@ -59,7 +59,6 @@ pub struct VulkanImage {
     pub(super) is_undefined: Cell<bool>,
     pub(super) contents_are_undefined: Cell<bool>,
     pub(super) ty: VulkanImageMemory,
-    pub(super) render_ops: CloneCell<Vec<GfxApiOpt>>,
     pub(super) bridge: Option<VulkanFramebufferBridge>,
 }
 
@@ -378,7 +377,6 @@ impl VulkanDmaBufImageTemplate {
             width: self.width,
             height: self.height,
             stride: 0,
-            render_ops: Default::default(),
             ty: VulkanImageMemory::DmaBuf(VulkanDmaBufImage {
                 template: self.clone(),
                 mems: device_memories,
@@ -461,21 +459,17 @@ impl Debug for VulkanImage {
 }
 
 impl GfxFramebuffer for VulkanImage {
-    fn take_render_ops(&self) -> Vec<GfxApiOpt> {
-        self.render_ops.take()
-    }
-
     fn physical_size(&self) -> (i32, i32) {
         (self.width as _, self.height as _)
     }
 
     fn render(
         &self,
-        ops: Vec<GfxApiOpt>,
+        ops: &[GfxApiOpt],
         clear: Option<&Color>,
     ) -> Result<Option<SyncFile>, GfxError> {
         self.renderer
-            .execute(self, &ops, clear)
+            .execute(self, ops, clear)
             .map_err(|e| e.into())
     }
 

src/gfx_apis/vulkan/shm_image.rs

@@ -730,7 +730,6 @@ impl VulkanRenderer {
             is_undefined: Cell::new(true),
             contents_are_undefined: Cell::new(true),
             ty: VulkanImageMemory::Internal(shm),
-            render_ops: Default::default(),
             bridge: None,
         });
         let shm = match &img.ty {

src/it/test_gfx_api.rs

@@ -404,10 +404,6 @@ impl GfxImage for TestGfxImage {
 }
 
 impl GfxFramebuffer for TestGfxFb {
-    fn take_render_ops(&self) -> Vec<GfxApiOpt> {
-        vec![]
-    }
-
     fn physical_size(&self) -> (i32, i32) {
         match &*self.img {
             TestGfxImage::Shm(v) => (v.width, v.height),
@@ -417,7 +413,7 @@ impl GfxFramebuffer for TestGfxFb {
 
     fn render(
         &self,
-        ops: Vec<GfxApiOpt>,
+        ops: &[GfxApiOpt],
         clear: Option<&Color>,
     ) -> Result<Option<SyncFile>, GfxError> {
         let fb_points = |width: i32, height: i32, rect: &FramebufferRect| {

src/state.rs

@@ -905,7 +905,7 @@ impl State {
         size: Option<(i32, i32)>,
         transform: Transform,
     ) -> Result<Option<SyncFile>, GfxError> {
-        let mut ops = target.take_render_ops();
+        let mut ops = vec![];
         let mut renderer = Renderer {
             base: target.renderer_base(&mut ops, Scale::from_int(1), Transform::None),
             state: self,
@@ -943,7 +943,7 @@ impl State {
                 }
             }
         }
-        target.render(ops, Some(&Color::SOLID_BLACK))
+        target.render(&ops, Some(&Color::SOLID_BLACK))
     }
 
     fn have_hardware_cursor(&self) -> bool {