diff --git a/components/compositing/compositor.rs b/components/compositing/compositor.rs index d5a0474ca30..44015c8012c 100644 --- a/components/compositing/compositor.rs +++ b/components/compositing/compositor.rs @@ -97,8 +97,8 @@ pub struct IOCompositor { /// the compositor. shutdown_state: ShutdownState, - /// Tracks outstanding render_msg's sent to the paint tasks. - outstanding_render_msgs: uint, + /// Tracks outstanding paint_msg's sent to the paint tasks. + outstanding_paint_msgs: uint, /// Tracks the last composite time. last_composite_time: u64, @@ -173,8 +173,8 @@ impl IOCompositor { -> IOCompositor { // Create an initial layer tree. // - // TODO: There should be no initial layer tree until the renderer creates one from the - // display list. This is only here because we don't have that logic in the renderer yet. + // TODO: There should be no initial layer tree until the painter creates one from the + // display list. This is only here because we don't have that logic in the painter yet. let window_size = window.framebuffer_size(); let hidpi_factor = window.hidpi_factor(); let context = CompositorTask::create_graphics_context(&window.native_metadata()); @@ -207,7 +207,7 @@ impl IOCompositor { time_profiler_chan: time_profiler_chan, memory_profiler_chan: memory_profiler_chan, fragment_point: None, - outstanding_render_msgs: 0, + outstanding_paint_msgs: 0, last_composite_time: 0, } } @@ -263,7 +263,7 @@ impl IOCompositor { } (PaintMsgDiscarded, NotShuttingDown) => { - self.remove_outstanding_render_msg(); + self.remove_outstanding_paint_msg(); } (SetIds(frame_tree, response_chan, new_constellation_chan), NotShuttingDown) => { @@ -298,7 +298,7 @@ impl IOCompositor { for (layer_id, new_layer_buffer_set) in replies.into_iter() { self.paint(pipeline_id, layer_id, new_layer_buffer_set, epoch); } - self.remove_outstanding_render_msg(); + self.remove_outstanding_paint_msg(); } (ScrollFragmentPoint(pipeline_id, layer_id, point), NotShuttingDown) => { @@ -308,14 +308,14 @@ impl IOCompositor { (LoadComplete(..), NotShuttingDown) => { self.got_load_complete_message = true; - // If we're rendering in headless mode, schedule a recomposite. + // If we're painting in headless mode, schedule a recomposite. if opts::get().output_file.is_some() { self.composite_if_necessary(); } } (ScrollTimeout(timestamp), NotShuttingDown) => { - debug!("scroll timeout, drawing unrendered content!"); + debug!("scroll timeout, drawing unpainted content!"); match self.composition_request { CompositeOnScrollTimeout(this_timestamp) if timestamp == this_timestamp => { self.composition_request = CompositeNow @@ -344,7 +344,7 @@ impl IOCompositor { } self.window.set_ready_state(self.get_earliest_pipeline_ready_state()); - // If we're rendering in headless mode, schedule a recomposite. + // If we're painting in headless mode, schedule a recomposite. if opts::get().output_file.is_some() { self.composite_if_necessary() } @@ -378,32 +378,32 @@ impl IOCompositor { return self.paint_states.values().all(|&value| value == IdlePaintState); } - fn has_render_msg_tracking(&self) -> bool { + fn has_paint_msg_tracking(&self) -> bool { // only track PaintMsg's if the compositor outputs to a file. opts::get().output_file.is_some() } - fn has_outstanding_render_msgs(&self) -> bool { - self.has_render_msg_tracking() && self.outstanding_render_msgs > 0 + fn has_outstanding_paint_msgs(&self) -> bool { + self.has_paint_msg_tracking() && self.outstanding_paint_msgs > 0 } - fn add_outstanding_render_msg(&mut self, count: uint) { - // return early if not tracking render_msg's - if !self.has_render_msg_tracking() { + fn add_outstanding_paint_msg(&mut self, count: uint) { + // return early if not tracking paint_msg's + if !self.has_paint_msg_tracking() { return; } - debug!("add_outstanding_render_msg {}", self.outstanding_render_msgs); - self.outstanding_render_msgs += count; + debug!("add_outstanding_paint_msg {}", self.outstanding_paint_msgs); + self.outstanding_paint_msgs += count; } - fn remove_outstanding_render_msg(&mut self) { - if !self.has_render_msg_tracking() { + fn remove_outstanding_paint_msg(&mut self) { + if !self.has_paint_msg_tracking() { return; } - if self.outstanding_render_msgs > 0 { - self.outstanding_render_msgs -= 1; + if self.outstanding_paint_msgs > 0 { + self.outstanding_paint_msgs -= 1; } else { - debug!("too many rerender msgs completed"); + debug!("too many repaint msgs completed"); } } @@ -483,7 +483,7 @@ impl IOCompositor { opts::get().tile_size); // Add the first child / base layer to the front of the child list, so that - // child iframe layers are rendered on top of the base layer. These iframe + // child iframe layers are painted on top of the base layer. These iframe // layers were added previously when creating the layer tree skeleton in // create_frame_tree_root_layers. root_layer.children().insert(0, first_child); @@ -604,7 +604,7 @@ impl IOCompositor { } None => { // FIXME: This may potentially be triggered by a race condition where a - // buffers are being rendered but the layer is removed before rendering + // buffers are being painted but the layer is removed before painting // completes. panic!("compositor given paint command for non-existent layer"); } @@ -856,7 +856,7 @@ impl IOCompositor { } }; - // All the BufferRequests are in layer/device coordinates, but the render task + // All the BufferRequests are in layer/device coordinates, but the paint task // wants to know the page coordinates. We scale them before sending them. for request in layer_requests.iter_mut() { request.page_rect = request.page_rect / scale.get(); @@ -925,17 +925,17 @@ impl IOCompositor { let pipeline_requests = self.convert_buffer_requests_to_pipeline_requests_map(layers_and_requests); - let mut num_render_msgs_sent = 0; + let mut num_paint_msgs_sent = 0; for (_pipeline_id, (chan, requests)) in pipeline_requests.into_iter() { - num_render_msgs_sent += 1; + num_paint_msgs_sent += 1; let _ = chan.send_opt(PaintMsg(requests)); } - self.add_outstanding_render_msg(num_render_msgs_sent); + self.add_outstanding_paint_msg(num_paint_msgs_sent); true } - fn is_ready_to_render_image_output(&self) -> bool { + fn is_ready_to_paint_image_output(&self) -> bool { if !self.got_load_complete_message { return false; } @@ -944,7 +944,7 @@ impl IOCompositor { return false; } - if self.has_outstanding_render_msgs() { + if self.has_outstanding_paint_msgs() { return false; } @@ -961,7 +961,7 @@ impl IOCompositor { fn composite(&mut self) { let output_image = opts::get().output_file.is_some() && - self.is_ready_to_render_image_output(); + self.is_ready_to_paint_image_output(); let mut framebuffer_ids = vec!(); let mut texture_ids = vec!(); @@ -992,7 +992,7 @@ impl IOCompositor { origin: Zero::zero(), size: self.window_size.as_f32(), }; - // Render the scene. + // paint the scene. match self.scene.root { Some(ref layer) => { rendergl::render_scene(layer.clone(), self.context, &self.scene); diff --git a/components/compositing/compositor_layer.rs b/components/compositing/compositor_layer.rs index 38b9aea80dc..804ebb8625a 100644 --- a/components/compositing/compositor_layer.rs +++ b/components/compositing/compositor_layer.rs @@ -75,19 +75,19 @@ pub trait CompositorLayer { fn add_buffers(&self, new_buffers: Box, epoch: Epoch) -> bool; - /// Destroys all layer tiles, sending the buffers back to the renderer to be destroyed or + /// Destroys all layer tiles, sending the buffers back to the painter to be destroyed or /// reused. fn clear(&self); /// Destroys tiles for this layer and all descendent layers, sending the buffers back to the - /// renderer to be destroyed or reused. + /// painter to be destroyed or reused. fn clear_all_tiles(&self); /// Destroys all tiles of all layers, including children, *without* sending them back to the - /// renderer. You must call this only when the render task is destined to be going down; + /// painter. You must call this only when the paint task is destined to be going down; /// otherwise, you will leak tiles. /// - /// This is used during shutdown, when we know the render task is going away. + /// This is used during shutdown, when we know the paint task is going away. fn forget_all_tiles(&self); /// Move the layer's descendants that don't want scroll events and scroll by a relative @@ -217,8 +217,8 @@ impl CompositorLayer for Layer { let mut buffers = self.collect_buffers(); if !buffers.is_empty() { - // We have no way of knowing without a race whether the render task is even up and - // running, but mark the buffers as not leaking. If the render task died, then the + // We have no way of knowing without a race whether the paint task is even up and + // running, but mark the buffers as not leaking. If the paint task died, then the // buffers are going to be cleaned up. for buffer in buffers.iter_mut() { buffer.mark_wont_leak() @@ -229,7 +229,7 @@ impl CompositorLayer for Layer { } /// Destroys tiles for this layer and all descendent layers, sending the buffers back to the - /// renderer to be destroyed or reused. + /// painter to be destroyed or reused. fn clear_all_tiles(&self) { self.clear(); for kid in self.children().iter() { @@ -238,10 +238,10 @@ impl CompositorLayer for Layer { } /// Destroys all tiles of all layers, including children, *without* sending them back to the - /// renderer. You must call this only when the render task is destined to be going down; + /// painter. You must call this only when the paint task is destined to be going down; /// otherwise, you will leak tiles. /// - /// This is used during shutdown, when we know the render task is going away. + /// This is used during shutdown, when we know the paint task is going away. fn forget_all_tiles(&self) { let tiles = self.collect_buffers(); for tile in tiles.into_iter() { diff --git a/components/compositing/compositor_task.rs b/components/compositing/compositor_task.rs index abeef153234..89aed5defa0 100644 --- a/components/compositing/compositor_task.rs +++ b/components/compositing/compositor_task.rs @@ -161,7 +161,7 @@ pub enum Msg { /// at the time that we send it an ExitMsg. ShutdownComplete, - /// Requests the compositor's graphics metadata. Graphics metadata is what the renderer needs + /// Requests the compositor's graphics metadata. Graphics metadata is what the painter needs /// to create surfaces that the compositor can see. On Linux this is the X display; on Mac this /// is the pixel format. /// @@ -184,9 +184,9 @@ pub enum Msg { ChangeReadyState(PipelineId, ReadyState), /// Alerts the compositor to the current status of painting. ChangePaintState(PipelineId, PaintState), - /// Alerts the compositor that the RenderMsg has been discarded. + /// Alerts the compositor that the PaintMsg has been discarded. PaintMsgDiscarded, - /// Sets the channel to the current layout and render tasks, along with their id + /// Sets the channel to the current layout and paint tasks, along with their id SetIds(SendableFrameTree, Sender<()>, ConstellationChan), /// Sends an updated version of the frame tree. FrameTreeUpdateMsg(FrameTreeDiff, Sender<()>), diff --git a/components/compositing/constellation.rs b/components/compositing/constellation.rs index 7e3907ebe64..5155801f553 100644 --- a/components/compositing/constellation.rs +++ b/components/compositing/constellation.rs @@ -452,10 +452,10 @@ impl Constellation { debug!("constellation got navigation message"); self.handle_navigate_msg(direction); } - // Notification that rendering has finished and is requesting permission to paint. + // Notification that painting has finished and is requesting permission to paint. PainterReadyMsg(pipeline_id) => { - debug!("constellation got renderer ready message"); - self.handle_renderer_ready_msg(pipeline_id); + debug!("constellation got painter ready message"); + self.handle_painter_ready_msg(pipeline_id); } ResizedWindowMsg(new_size) => { debug!("constellation got window resize message"); @@ -787,8 +787,8 @@ impl Constellation { }); } - fn handle_renderer_ready_msg(&mut self, pipeline_id: PipelineId) { - debug!("Renderer {} ready to send paint msg", pipeline_id); + fn handle_painter_ready_msg(&mut self, pipeline_id: PipelineId) { + debug!("Painter {} ready to send paint msg", pipeline_id); // This message could originate from a pipeline in the navigation context or // from a pending frame. The only time that we will grant paint permission is // when the message originates from a pending frame or the current frame. diff --git a/components/compositing/pipeline.rs b/components/compositing/pipeline.rs index 1f382c42a9d..cf1ebd16f8c 100644 --- a/components/compositing/pipeline.rs +++ b/components/compositing/pipeline.rs @@ -19,7 +19,7 @@ use servo_net::storage_task::StorageTask; use servo_util::time::TimeProfilerChan; use std::rc::Rc; -/// A uniquely-identifiable pipeline of script task, layout task, and render task. +/// A uniquely-identifiable pipeline of script task, layout task, and paint task. pub struct Pipeline { pub id: PipelineId, pub subpage_id: Option, @@ -27,7 +27,7 @@ pub struct Pipeline { pub layout_chan: LayoutControlChan, pub paint_chan: PaintChan, pub layout_shutdown_port: Receiver<()>, - pub render_shutdown_port: Receiver<()>, + pub paint_shutdown_port: Receiver<()>, /// The most recently loaded page pub load_data: LoadData, } @@ -41,7 +41,7 @@ pub struct CompositionPipeline { } impl Pipeline { - /// Starts a render task, layout task, and possibly a script task. + /// Starts a paint task, layout task, and possibly a script task. /// Returns the channels wrapped in a struct. /// If script_pipeline is not None, then subpage_id must also be not None. pub fn create( @@ -60,8 +60,8 @@ impl Pipeline { load_data: LoadData) -> Pipeline { let layout_pair = ScriptTaskFactory::create_layout_channel(None::<&mut STF>); - let (render_port, paint_chan) = PaintChan::new(); - let (render_shutdown_chan, render_shutdown_port) = channel(); + let (paint_port, paint_chan) = PaintChan::new(); + let (paint_shutdown_chan, paint_shutdown_port) = channel(); let (layout_shutdown_chan, layout_shutdown_port) = channel(); let (pipeline_chan, pipeline_port) = channel(); @@ -103,13 +103,13 @@ impl Pipeline { }; PaintTask::create(id, - render_port, + paint_port, compositor_proxy, constellation_chan.clone(), font_cache_task.clone(), failure.clone(), time_profiler_chan.clone(), - render_shutdown_chan); + paint_shutdown_chan); LayoutTaskFactory::create(None::<&mut LTF>, id, @@ -131,7 +131,7 @@ impl Pipeline { LayoutControlChan(pipeline_chan), paint_chan, layout_shutdown_port, - render_shutdown_port, + paint_shutdown_port, load_data) } @@ -141,7 +141,7 @@ impl Pipeline { layout_chan: LayoutControlChan, paint_chan: PaintChan, layout_shutdown_port: Receiver<()>, - render_shutdown_port: Receiver<()>, + paint_shutdown_port: Receiver<()>, load_data: LoadData) -> Pipeline { Pipeline { @@ -151,7 +151,7 @@ impl Pipeline { layout_chan: layout_chan, paint_chan: paint_chan, layout_shutdown_port: layout_shutdown_port, - render_shutdown_port: render_shutdown_port, + paint_shutdown_port: paint_shutdown_port, load_data: load_data, } } @@ -166,20 +166,20 @@ impl Pipeline { } pub fn revoke_paint_permission(&self) { - debug!("pipeline revoking render channel paint permission"); + debug!("pipeline revoking paint channel paint permission"); let _ = self.paint_chan.send_opt(PaintPermissionRevoked); } pub fn exit(&self) { debug!("pipeline {} exiting", self.id); - // Script task handles shutting down layout, and layout handles shutting down the renderer. + // Script task handles shutting down layout, and layout handles shutting down the painter. // For now, if the script task has failed, we give up on clean shutdown. let ScriptControlChan(ref chan) = self.script_chan; if chan.send_opt(ExitPipelineMsg(self.id)).is_ok() { // Wait until all slave tasks have terminated and run destructors // NOTE: We don't wait for script task as we don't always own it - let _ = self.render_shutdown_port.recv_opt(); + let _ = self.paint_shutdown_port.recv_opt(); let _ = self.layout_shutdown_port.recv_opt(); } }