rutabaga_gfx: RutabagaFenceData --> RutabagaFence

It's a little bit less wordy.

BUG=b:150239451
TEST=none

Change-Id: Ia25ac6b3db77ce8e9b074273967294909fb56e87
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/3173067
Reviewed-by: Dennis Kempin <denniskempin@google.com>
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>
Tested-by: kokoro <noreply+kokoro@google.com>
Commit-Queue: Gurchetan Singh <gurchetansingh@chromium.org>

devices/src/virtio/gpu/mod.rs

@@ -721,13 +721,13 @@ impl Frontend {
                     // The only possible current value for hdr info.
                     info = ctrl_hdr.info.to_native();
 
-                    let fence_data = RutabagaFenceData {
+                    let fence = RutabagaFence {
                         flags,
                         fence_id,
                         ctx_id,
                         ring_idx: info,
                     };
-                    gpu_response = match self.virtio_gpu.create_fence(fence_data) {
+                    gpu_response = match self.virtio_gpu.create_fence(fence) {
                         Ok(_) => gpu_response,
                         Err(fence_resp) => {
                             warn!("create_fence {} -> {:?}", fence_id, fence_resp);

devices/src/virtio/gpu/virtio_gpu.rs

@@ -17,7 +17,7 @@ use data_model::VolatileSlice;
 
 use gpu_display::*;
 use rutabaga_gfx::{
-    ResourceCreate3D, ResourceCreateBlob, Rutabaga, RutabagaBuilder, RutabagaFenceData,
+    ResourceCreate3D, ResourceCreateBlob, Rutabaga, RutabagaBuilder, RutabagaFence,
     RutabagaFenceHandler, RutabagaIovec, Transfer3D,
 };
 
@@ -551,15 +551,15 @@ impl VirtioGpu {
         self.rutabaga.force_ctx_0()
     }
 
-    /// Creates a fence with the RutabagaFenceData that can be used to determine when the previous
+    /// Creates a fence with the RutabagaFence that can be used to determine when the previous
     /// command completed.
-    pub fn create_fence(&mut self, rutabaga_fence_data: RutabagaFenceData) -> VirtioGpuResult {
-        self.rutabaga.create_fence(rutabaga_fence_data)?;
+    pub fn create_fence(&mut self, rutabaga_fence: RutabagaFence) -> VirtioGpuResult {
+        self.rutabaga.create_fence(rutabaga_fence)?;
         Ok(OkNoData)
     }
 
-    /// Returns an array of RutabagaFenceData, describing completed fences.
-    pub fn fence_poll(&mut self) -> Vec<RutabagaFenceData> {
+    /// Returns an array of RutabagaFence, describing completed fences.
+    pub fn fence_poll(&mut self) -> Vec<RutabagaFence> {
         self.rutabaga.poll()
     }
 

rutabaga_gfx/src/cross_domain/cross_domain.rs

@@ -52,7 +52,7 @@ enum CrossDomainItem {
 }
 
 enum CrossDomainJob {
-    HandleFence(RutabagaFenceData),
+    HandleFence(RutabagaFence),
     AddReadPipe(u32),
 }
 
@@ -318,7 +318,7 @@ impl CrossDomainWorker {
     // boolean value indicating whether the worker thread should be stopped is returned.
     fn handle_fence(
         &mut self,
-        fence: RutabagaFenceData,
+        fence: RutabagaFence,
         resample_evt: &Event,
         receive_buf: &mut Vec<u8>,
     ) -> RutabagaResult<bool> {
@@ -903,12 +903,12 @@ impl RutabagaContext for CrossDomainContext {
         self.context_resources.lock().remove(&resource.resource_id);
     }
 
-    fn context_create_fence(&mut self, fence_data: RutabagaFenceData) -> RutabagaResult<()> {
-        match fence_data.ring_idx {
-            CROSS_DOMAIN_QUERY_RING => self.fence_handler.call(fence_data),
+    fn context_create_fence(&mut self, fence: RutabagaFence) -> RutabagaResult<()> {
+        match fence.ring_idx {
+            CROSS_DOMAIN_QUERY_RING => self.fence_handler.call(fence),
             CROSS_DOMAIN_CHANNEL_RING => {
                 if let Some(state) = &self.state {
-                    state.add_job(CrossDomainJob::HandleFence(fence_data));
+                    state.add_job(CrossDomainJob::HandleFence(fence));
                 }
             }
             _ => return Err(RutabagaError::SpecViolation),

rutabaga_gfx/src/gfxstream.rs

@@ -244,13 +244,11 @@ impl RutabagaComponent for Gfxstream {
         Vec::new()
     }
 
-    fn create_fence(&mut self, fence_data: RutabagaFenceData) -> RutabagaResult<()> {
-        let ret = unsafe {
-            pipe_virgl_renderer_create_fence(fence_data.fence_id as i32, fence_data.ctx_id)
-        };
+    fn create_fence(&mut self, fence: RutabagaFence) -> RutabagaResult<()> {
+        let ret = unsafe { pipe_virgl_renderer_create_fence(fence.fence_id as i32, fence.ctx_id) };
         // This can be moved to the cookie once gfxstream directly calls the
         // write_fence callback in pipe_virgl_renderer_create_fence
-        self.fence_handler.call(fence_data);
+        self.fence_handler.call(fence);
         ret_to_res(ret)
     }
 

rutabaga_gfx/src/renderer_utils.rs

@@ -10,7 +10,7 @@ use std::rc::Rc;
 
 use crate::generated::virgl_renderer_bindings::__va_list_tag;
 use crate::rutabaga_utils::{
-    RutabagaError, RutabagaFenceData, RutabagaFenceHandler, RutabagaResult, RUTABAGA_FLAG_FENCE,
+    RutabagaError, RutabagaFence, RutabagaFenceHandler, RutabagaResult, RUTABAGA_FLAG_FENCE,
 };
 
 #[repr(C)]
@@ -60,7 +60,7 @@ impl FenceState {
         if latest_fence > self.latest_fence {
             self.latest_fence = latest_fence;
             if let Some(handler) = &self.handler {
-                handler.call(RutabagaFenceData {
+                handler.call(RutabagaFence {
                     flags: RUTABAGA_FLAG_FENCE,
                     fence_id: latest_fence as u64,
                     ctx_id: 0,

rutabaga_gfx/src/rutabaga_2d.rs

@@ -143,9 +143,9 @@ impl Rutabaga2D {
 }
 
 impl RutabagaComponent for Rutabaga2D {
-    fn create_fence(&mut self, fence_data: RutabagaFenceData) -> RutabagaResult<()> {
-        self.latest_created_fence_id = fence_data.fence_id as u32;
-        self.fence_handler.call(fence_data);
+    fn create_fence(&mut self, fence: RutabagaFence) -> RutabagaResult<()> {
+        self.latest_created_fence_id = fence.fence_id as u32;
+        self.fence_handler.call(fence);
         Ok(())
     }
 

rutabaga_gfx/src/rutabaga_core.rs

@@ -67,7 +67,7 @@ pub trait RutabagaComponent {
 
     /// Implementations must create a fence that represents the completion of prior work.  This is
     /// required for synchronization with the guest kernel.
-    fn create_fence(&mut self, _fence_data: RutabagaFenceData) -> RutabagaResult<()> {
+    fn create_fence(&mut self, _fence: RutabagaFence) -> RutabagaResult<()> {
         Err(RutabagaError::Unsupported)
     }
 
@@ -181,15 +181,15 @@ pub trait RutabagaContext {
     /// Implementations must stop using `resource` in this context's command stream.
     fn detach(&mut self, _resource: &RutabagaResource);
 
-    /// Implementations must create a fence on specified `ring_idx` in `fence_data`.  This
+    /// Implementations must create a fence on specified `ring_idx` in `fence`.  This
     /// allows for multiple syncrhonizations timelines per RutabagaContext.
-    fn context_create_fence(&mut self, _fence_data: RutabagaFenceData) -> RutabagaResult<()> {
+    fn context_create_fence(&mut self, _fence: RutabagaFence) -> RutabagaResult<()> {
         Err(RutabagaError::Unsupported)
     }
 
     /// Implementations must return an array of fences that have completed.  This will be used by
     /// the cross-domain context for asynchronous Tx/Rx.
-    fn context_poll(&mut self) -> Option<Vec<RutabagaFenceData>> {
+    fn context_poll(&mut self) -> Option<Vec<RutabagaFence>> {
         None
     }
 }
@@ -275,33 +275,33 @@ impl Rutabaga {
         }
     }
 
-    /// Creates a fence with the given `fence_data`.
+    /// Creates a fence with the given `fence`.
     /// If the flags include RUTABAGA_FLAG_INFO_RING_IDX, then the fence is created on a
     /// specific timeline on the specific context.
-    pub fn create_fence(&mut self, fence_data: RutabagaFenceData) -> RutabagaResult<()> {
-        if fence_data.flags & RUTABAGA_FLAG_INFO_RING_IDX != 0 {
+    pub fn create_fence(&mut self, fence: RutabagaFence) -> RutabagaResult<()> {
+        if fence.flags & RUTABAGA_FLAG_INFO_RING_IDX != 0 {
             let ctx = self
                 .contexts
-                .get_mut(&fence_data.ctx_id)
+                .get_mut(&fence.ctx_id)
                 .ok_or(RutabagaError::InvalidContextId)?;
 
-            ctx.context_create_fence(fence_data)?;
+            ctx.context_create_fence(fence)?;
         } else {
             let component = self
                 .components
                 .get_mut(&self.default_component)
                 .ok_or(RutabagaError::InvalidComponent)?;
 
-            component.create_fence(fence_data)?;
+            component.create_fence(fence)?;
         }
 
         Ok(())
     }
 
-    /// Polls all rutabaga components and contexts, and returns a vector of RutabagaFenceData
+    /// Polls all rutabaga components and contexts, and returns a vector of RutabagaFence
     /// describing which fences have completed.
-    pub fn poll(&mut self) -> Vec<RutabagaFenceData> {
-        let mut completed_fences: Vec<RutabagaFenceData> = Vec::new();
+    pub fn poll(&mut self) -> Vec<RutabagaFence> {
+        let mut completed_fences: Vec<RutabagaFence> = Vec::new();
         // Poll the default component -- this the global timeline which does not take into account
         // `ctx_id` or `ring_idx`.  This path exists for OpenGL legacy reasons and 2D mode.
         let component = self
@@ -311,7 +311,7 @@ impl Rutabaga {
             .unwrap();
 
         let global_fence_id = component.poll();
-        completed_fences.push(RutabagaFenceData {
+        completed_fences.push(RutabagaFence {
             flags: RUTABAGA_FLAG_FENCE,
             fence_id: global_fence_id as u64,
             ctx_id: 0,

rutabaga_gfx/src/rutabaga_utils.rs

@@ -97,7 +97,7 @@ pub const RUTABAGA_FLAG_INFO_RING_IDX: u32 = 1 << 1;
 
 /// Convenience struct for Rutabaga fences
 #[derive(Copy, Clone)]
-pub struct RutabagaFenceData {
+pub struct RutabagaFence {
     pub flags: u32,
     pub fence_id: u64,
     pub ctx_id: u32,
@@ -521,7 +521,7 @@ impl RutabagaHandle {
 
 /// Trait for fence completion handlers
 pub trait RutabagaFenceCallback: Send {
-    fn call(&self, data: RutabagaFenceData);
+    fn call(&self, data: RutabagaFence);
     fn clone_box(&self) -> RutabagaFenceHandler;
 }
 
@@ -542,7 +542,7 @@ pub struct RutabagaFenceClosure<T> {
 
 impl<T> RutabagaFenceClosure<T>
 where
-    T: Fn(RutabagaFenceData) + Clone + Send + 'static,
+    T: Fn(RutabagaFence) + Clone + Send + 'static,
 {
     pub fn new(closure: T) -> RutabagaFenceHandler {
         Box::new(RutabagaFenceClosure { closure })
@@ -551,9 +551,9 @@ where
 
 impl<T> RutabagaFenceCallback for RutabagaFenceClosure<T>
 where
-    T: Fn(RutabagaFenceData) + Clone + Send + 'static,
+    T: Fn(RutabagaFence) + Clone + Send + 'static,
 {
-    fn call(&self, data: RutabagaFenceData) {
+    fn call(&self, data: RutabagaFence) {
         (self.closure)(data)
     }
 

rutabaga_gfx/src/virgl_renderer.rs

@@ -310,9 +310,8 @@ impl RutabagaComponent for VirglRenderer {
         unsafe { virgl_renderer_force_ctx_0() };
     }
 
-    fn create_fence(&mut self, fence_data: RutabagaFenceData) -> RutabagaResult<()> {
-        let ret =
-            unsafe { virgl_renderer_create_fence(fence_data.fence_id as i32, fence_data.ctx_id) };
+    fn create_fence(&mut self, fence: RutabagaFence) -> RutabagaResult<()> {
+        let ret = unsafe { virgl_renderer_create_fence(fence.fence_id as i32, fence.ctx_id) };
         ret_to_res(ret)
     }