Rename ReRenderMsg to RenderMsg

ReRenderMsg is also used for rendering the first time, so the name is
confusing.

src/components/compositing/compositor.rs

@@ -6,7 +6,7 @@ use compositor_data::{CompositorData, DoesntWantScrollEvents, WantsScrollEvents}
 use compositor_task::{Msg, CompositorTask, Exit, ChangeReadyState, SetIds, LayerProperties};
 use compositor_task::{GetGraphicsMetadata, CreateOrUpdateRootLayer, CreateOrUpdateDescendantLayer};
 use compositor_task::{SetLayerClipRect, Paint, ScrollFragmentPoint, LoadComplete};
-use compositor_task::{ShutdownComplete, ChangeRenderState, ReRenderMsgDiscarded};
+use compositor_task::{ShutdownComplete, ChangeRenderState, RenderMsgDiscarded};
 use constellation::SendableFrameTree;
 use events;
 use pipeline::CompositionPipeline;
@@ -26,7 +26,7 @@ use geom::point::{Point2D, TypedPoint2D};
 use geom::rect::Rect;
 use geom::size::TypedSize2D;
 use geom::scale_factor::ScaleFactor;
-use gfx::render_task::{RenderChan, ReRenderMsg, ReRenderRequest, UnusedBufferMsg};
+use gfx::render_task::{RenderChan, RenderMsg, RenderRequest, UnusedBufferMsg};
 use layers::layers::{BufferRequest, Layer, LayerBufferSet};
 use layers::rendergl;
 use layers::rendergl::RenderContext;
@@ -90,8 +90,8 @@ pub struct IOCompositor {
     /// Tracks whether we need to re-composite a page.
     recomposite: bool,
 
-    /// Tracks outstanding ReRenderMsg's sent to the render tasks.
+    /// Tracks outstanding render_msg's sent to the render tasks.
-    outstanding_rerendermsgs: uint,
+    outstanding_render_msgs: uint,
 
     /// Tracks whether the zoom action has happend recently.
     zoom_action: bool,
@@ -170,7 +170,7 @@ impl IOCompositor {
             time_profiler_chan: time_profiler_chan,
             memory_profiler_chan: memory_profiler_chan,
             fragment_point: None,
-            outstanding_rerendermsgs: 0,
+            outstanding_render_msgs: 0,
         }
     }
 
@@ -282,8 +282,8 @@ impl IOCompositor {
                     self.change_render_state(render_state);
                 }
 
-                (Ok(ReRenderMsgDiscarded), NotShuttingDown) => {
+                (Ok(RenderMsgDiscarded), NotShuttingDown) => {
-                    self.remove_outstanding_rerendermsg();
+                    self.remove_outstanding_render_msg();
                 }
 
                 (Ok(SetIds(frame_tree, response_chan, new_constellation_chan)), _) => {
@@ -312,7 +312,7 @@ impl IOCompositor {
                     for (layer_id, new_layer_buffer_set) in replies.move_iter() {
                         self.paint(pipeline_id, layer_id, new_layer_buffer_set, epoch);
                     }
-                    self.remove_outstanding_rerendermsg();
+                    self.remove_outstanding_render_msg();
                 }
 
                 (Ok(ScrollFragmentPoint(pipeline_id, layer_id, point)), NotShuttingDown) => {
@@ -338,30 +338,30 @@ impl IOCompositor {
         }
     }
 
-    fn has_rerendermsg_tracking(&self) -> bool {
+    fn has_render_msg_tracking(&self) -> bool {
-        // only track ReRenderMsg's if the compositor outputs to a file.
+        // only track RenderMsg's if the compositor outputs to a file.
         self.opts.output_file.is_some()
     }
 
-    fn has_outstanding_rerendermsgs(&self) -> bool {
+    fn has_outstanding_render_msgs(&self) -> bool {
-        self.has_rerendermsg_tracking() && self.outstanding_rerendermsgs > 0
+        self.has_render_msg_tracking() && self.outstanding_render_msgs > 0
     }
 
-    fn add_outstanding_rerendermsg(&mut self, count: uint) {
+    fn add_outstanding_render_msg(&mut self, count: uint) {
-        // return early if not tracking ReRenderMsg's
+        // return early if not tracking render_msg's
-        if !self.has_rerendermsg_tracking() {
+        if !self.has_render_msg_tracking() {
             return;
         }
-        debug!("add_outstanding_rerendermsg {}", self.outstanding_rerendermsgs);
+        debug!("add_outstanding_render_msg {}", self.outstanding_render_msgs);
-        self.outstanding_rerendermsgs += count;
+        self.outstanding_render_msgs += count;
     }
 
-    fn remove_outstanding_rerendermsg(&mut self) {
+    fn remove_outstanding_render_msg(&mut self) {
-        if !self.has_rerendermsg_tracking() {
+        if !self.has_render_msg_tracking() {
             return;
         }
-        if self.outstanding_rerendermsgs > 0 {
+        if self.outstanding_render_msgs > 0 {
-            self.outstanding_rerendermsgs -= 1;
+            self.outstanding_render_msgs -= 1;
         } else {
             debug!("too many rerender msgs completed");
         }
@@ -806,10 +806,10 @@ impl IOCompositor {
                                                         requests: Vec<(Rc<Layer<CompositorData>>,
                                                                        Vec<BufferRequest>)>) ->
                                                         HashMap<PipelineId, (RenderChan,
-                                                                             Vec<ReRenderRequest>)> {
+                                                                             Vec<RenderRequest>)> {
         let scale = self.device_pixels_per_page_px();
         let mut results:
-            HashMap<PipelineId, (RenderChan, Vec<ReRenderRequest>)> = HashMap::new();
+            HashMap<PipelineId, (RenderChan, Vec<RenderRequest>)> = HashMap::new();
 
         for (layer, mut layer_requests) in requests.move_iter() {
             let pipeline_id = layer.extra_data.borrow().pipeline.id;
@@ -823,7 +823,7 @@ impl IOCompositor {
                 request.page_rect = request.page_rect / scale.get();
             }
 
-            vec.push(ReRenderRequest {
+            vec.push(RenderRequest {
                 buffer_requests: layer_requests,
                 scale: scale.get(),
                 layer_id: layer.extra_data.borrow().id,
@@ -867,13 +867,13 @@ impl IOCompositor {
         let pipeline_requests =
             self.convert_buffer_requests_to_pipeline_requests_map(layers_and_requests);
 
-        let mut num_rerendermsgs_sent = 0;
+        let mut num_render_msgs_sent = 0;
         for (_pipeline_id, (chan, requests)) in pipeline_requests.move_iter() {
-            num_rerendermsgs_sent += 1;
+            num_render_msgs_sent += 1;
-            let _ = chan.send_opt(ReRenderMsg(requests));
+            let _ = chan.send_opt(RenderMsg(requests));
         }
 
-        self.add_outstanding_rerendermsg(num_rerendermsgs_sent);
+        self.add_outstanding_render_msg(num_render_msgs_sent);
     }
 
     fn composite(&mut self) {
@@ -897,7 +897,7 @@ impl IOCompositor {
         // Render to PNG. We must read from the back buffer (ie, before
         // self.window.present()) as OpenGL ES 2 does not have glReadBuffer().
         if self.load_complete && self.ready_state == FinishedLoading
-            && self.opts.output_file.is_some() && !self.has_outstanding_rerendermsgs() {
+            && self.opts.output_file.is_some() && !self.has_outstanding_render_msgs() {
             let (width, height) = (self.window_size.width.get(), self.window_size.height.get());
             let path = from_str::<Path>(self.opts.output_file.get_ref().as_slice()).unwrap();
             let mut pixels = gl2::read_pixels(0, 0,

src/components/compositing/compositor_task.rs

@@ -122,8 +122,8 @@ impl RenderListener for CompositorChan {
         }
     }
 
-    fn rerendermsg_discarded(&self) {
+    fn render_msg_discarded(&self) {
-        self.chan.send(ReRenderMsgDiscarded);
+        self.chan.send(RenderMsgDiscarded);
     }
 
     fn set_layer_clip_rect(&self,
@@ -188,8 +188,8 @@ pub enum Msg {
     ChangeReadyState(ReadyState),
     /// Alerts the compositor to the current status of rendering.
     ChangeRenderState(RenderState),
-    /// Alerts the compositor that the ReRenderMsg has been discarded.
+    /// Alerts the compositor that the RenderMsg has been discarded.
-    ReRenderMsgDiscarded,
+    RenderMsgDiscarded,
     /// Sets the channel to the current layout and render tasks, along with their id
     SetIds(SendableFrameTree, Sender<()>, ConstellationChan),
     /// The load of a page for a given URL has completed.

src/components/compositing/headless.rs

@@ -5,7 +5,7 @@
 use compositor_task::{Msg, Exit, ChangeReadyState, SetIds};
 use compositor_task::{GetGraphicsMetadata, CreateOrUpdateRootLayer, CreateOrUpdateDescendantLayer};
 use compositor_task::{SetLayerClipRect, Paint, ScrollFragmentPoint, LoadComplete};
-use compositor_task::{ShutdownComplete, ChangeRenderState, ReRenderMsgDiscarded};
+use compositor_task::{ShutdownComplete, ChangeRenderState, RenderMsgDiscarded};
 
 use geom::scale_factor::ScaleFactor;
 use geom::size::TypedSize2D;
@@ -92,7 +92,7 @@ impl NullCompositor {
                 CreateOrUpdateDescendantLayer(..) |
                 SetLayerClipRect(..) | Paint(..) |
                 ChangeReadyState(..) | ChangeRenderState(..) | ScrollFragmentPoint(..) |
-                LoadComplete(..) | ReRenderMsgDiscarded(..) => ()
+                LoadComplete(..) | RenderMsgDiscarded(..) => ()
             }
         }
     }

src/components/gfx/render_task.rs

@@ -50,7 +50,7 @@ pub struct RenderLayer {
     pub scroll_policy: ScrollPolicy,
 }
 
-pub struct ReRenderRequest {
+pub struct RenderRequest {
     pub buffer_requests: Vec<BufferRequest>,
     pub scale: f32,
     pub layer_id: LayerId,
@@ -59,7 +59,7 @@ pub struct ReRenderRequest {
 
 pub enum Msg {
     RenderInitMsg(SmallVec1<RenderLayer>),
-    ReRenderMsg(Vec<ReRenderRequest>),
+    RenderMsg(Vec<RenderRequest>),
     UnusedBufferMsg(Vec<Box<LayerBuffer>>),
     PaintPermissionGranted,
     PaintPermissionRevoked,
@@ -237,19 +237,19 @@ impl<C:RenderListener + Send> RenderTask<C> {
                                       self.epoch,
                                       self.render_layers.as_slice());
                 }
-                ReRenderMsg(requests) => {
+                RenderMsg(requests) => {
                     if !self.paint_permission {
                         debug!("render_task: render ready msg");
                         let ConstellationChan(ref mut c) = self.constellation_chan;
                         c.send(RendererReadyMsg(self.id));
-                        self.compositor.rerendermsg_discarded();
+                        self.compositor.render_msg_discarded();
                         continue;
                     }
 
                     self.compositor.set_render_state(RenderingRenderState);
 
                     let mut replies = Vec::new();
-                    for ReRenderRequest { buffer_requests, scale, layer_id, epoch }
+                    for RenderRequest { buffer_requests, scale, layer_id, epoch }
                           in requests.move_iter() {
                         if self.epoch == epoch {
                             self.render(&mut replies, buffer_requests, scale, layer_id);

src/components/msg/compositor_msg.rs

@@ -105,7 +105,7 @@ pub trait RenderListener {
              epoch: Epoch,
              replies: Vec<(LayerId, Box<LayerBufferSet>)>);
 
-    fn rerendermsg_discarded(&self);
+    fn render_msg_discarded(&self);
     fn set_render_state(&self, render_state: RenderState);
 }