Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-19 14:48:59 +01:00
Code Issues Projects Releases Packages Wiki Activity

render task no longer copies the layer buffer sets before sending paint messages -- uses an ARC instead

Browse source
This commit is contained in:
Tim Kuehn 2013-07-03 16:28:26 -07:00
parent 6ba2f8d535
commit dc8e3cbf9b
3 changed files with 30 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

28
src/components/gfx/render_task.rs
View file

@ -25,6 +25,8 @@ use std::uint;
use servo_util::time::{ProfilerChan, profile};
use servo_util::time;
use extra::arc;
pub struct RenderLayer {
display_list: DisplayList<()>,
size: Size2D<uint>
@ -73,7 +75,7 @@ priv struct RenderTask<C> {
/// Permission to send paint messages to the compositor
paint_permission: bool,
/// Cached copy of last layers rendered
last_paint_msg: Option<(LayerBufferSet, Size2D<uint>)>,
last_paint_msg: Option<(arc::ARC<LayerBufferSet>, Size2D<uint>)>,
}
impl<C: RenderListener + Owned> RenderTask<C> {
@ -83,32 +85,33 @@ impl<C: RenderListener + Owned> RenderTask<C> {
opts: Opts,
constellation_chan: ConstellationChan,
profiler_chan: ProfilerChan) {
let compositor_cell = Cell::new(compositor);
let opts_cell = Cell::new(opts);
let compositor = Cell::new(compositor);
let opts = Cell::new(opts);
let port = Cell::new(port);
let constellation_chan = Cell::new(constellation_chan);
let profiler_chan = Cell::new(profiler_chan);
do spawn {
let compositor = compositor_cell.take();
let compositor = compositor.take();
let share_gl_context = compositor.get_gl_context();
let opts = opts_cell.with_ref(|o| copy *o);
let profiler_chan = profiler_chan.clone();
let profiler_chan_clone = profiler_chan.clone();
let opts = opts.take();
let constellation_chan = constellation_chan.take();
let profiler_chan = profiler_chan.take();
// FIXME: rust/#5967
let mut render_task = RenderTask {
id: id,
port: port.take(),
compositor: compositor,
font_ctx: @mut FontContext::new(opts.render_backend,
font_ctx: @mut FontContext::new(copy opts.render_backend,
false,
profiler_chan),
opts: opts_cell.take(),
profiler_chan: profiler_chan_clone,
profiler_chan.clone()),
opts: opts,
profiler_chan: profiler_chan,
share_gl_context: share_gl_context,
render_layer: None,
constellation_chan: constellation_chan.take(),
constellation_chan: constellation_chan,
paint_permission: false,
last_paint_msg: None,
};
@ -232,6 +235,7 @@ impl<C: RenderListener + Owned> RenderTask<C> {
let layer_buffer_set = LayerBufferSet {
buffers: new_buffers,
};
let layer_buffer_set = arc::ARC(layer_buffer_set);
debug!("render_task: returning surface");
if self.paint_permission {

19
src/components/main/compositing/mod.rs
View file

@ -36,6 +36,7 @@ use servo_util::{time, url};
use servo_util::time::profile;
use servo_util::time::ProfilerChan;
use extra::arc;
pub use windowing;
/// The implementation of the layers-based compositor.
@ -47,28 +48,34 @@ pub struct CompositorChan {
/// Implementation of the abstract `ScriptListener` interface.
impl ScriptListener for CompositorChan {
fn set_ready_state(&self, ready_state: ReadyState) {
let msg = ChangeReadyState(ready_state);
self.chan.send(msg);
}
}
/// Implementation of the abstract `RenderListener` interface.
impl RenderListener for CompositorChan {
fn get_gl_context(&self) -> AzGLContext {
let (port, chan) = comm::stream();
self.chan.send(GetGLContext(chan));
port.recv()
}
fn paint(&self, id: uint, layer_buffer_set: LayerBufferSet, new_size: Size2D<uint>) {
fn paint(&self, id: uint, layer_buffer_set: arc::ARC<LayerBufferSet>, new_size: Size2D<uint>) {
self.chan.send(Paint(id, layer_buffer_set, new_size))
}
fn set_render_state(&self, render_state: RenderState) {
self.chan.send(ChangeRenderState(render_state))
}
}
impl CompositorChan {
pub fn new(chan: Chan<Msg>) -> CompositorChan {
CompositorChan {
chan: SharedChan::new(chan),
@ -86,7 +93,7 @@ pub enum Msg {
/// Requests the compositors GL context.
GetGLContext(Chan<AzGLContext>),
/// Requests that the compositor paint the given layer buffer set for the given page size.
Paint(uint, LayerBufferSet, Size2D<uint>),
Paint(uint, arc::ARC<LayerBufferSet>, Size2D<uint>),
/// Alerts the compositor to the current status of page loading.
ChangeReadyState(ReadyState),
/// Alerts the compositor to the current status of rendering.
@ -277,16 +284,12 @@ impl CompositorTask {
*page_size = Size2D(new_size.width as f32, new_size.height as f32);
let mut new_layer_buffer_set = new_layer_buffer_set;
let new_layer_buffer_set = new_layer_buffer_set.get();
// Iterate over the children of the container layer.
let mut current_layer_child = root_layer.first_child;
// Replace the image layer data with the buffer data. Also compute the page
// size here.
let buffers = util::replace(&mut new_layer_buffer_set.buffers, ~[]);
for buffers.each |buffer| {
for new_layer_buffer_set.buffers.each |buffer| {
let width = buffer.rect.size.width as uint;
let height = buffer.rect.size.height as uint;

6
src/components/msg/compositor_msg.rs
View file

@ -6,7 +6,8 @@ use azure::azure_hl::DrawTarget;
use azure::azure::AzGLContext;
use geom::rect::Rect;
use geom::size::Size2D;
use std::util::NonCopyable;
use extra::arc;
#[deriving(Clone)]
pub struct LayerBuffer {
@ -24,7 +25,6 @@ pub struct LayerBuffer {
/// A set of layer buffers. This is an atomic unit used to switch between the front and back
/// buffers.
#[deriving(Clone)]
pub struct LayerBufferSet {
buffers: ~[LayerBuffer]
}
@ -49,7 +49,7 @@ pub enum ReadyState {
/// submit them to be drawn to the display.
pub trait RenderListener {
fn get_gl_context(&self) -> AzGLContext;
fn paint(&self, id: uint, layer_buffer_set: LayerBufferSet, new_size: Size2D<uint>);
fn paint(&self, id: uint, layer_buffer_set: arc::ARC<LayerBufferSet>, new_size: Size2D<uint>);
fn set_render_state(&self, render_state: RenderState);
}