From 0e8667946496b3a0a3d7c18f28c33371001a2de5 Mon Sep 17 00:00:00 2001
From: Bryan Bell <bryan.w.bell@gmail.com>
Date: Thu, 28 Aug 2014 15:02:23 -0700
Subject: [PATCH] Store one RenderState per-pipeline in the Compositor

This can later be used to decide whether the entire pipeline is ready
for rendering.
---
 components/compositing/compositor.rs      | 13 ++++++++++---
 components/compositing/compositor_task.rs |  6 +++---
 components/gfx/render_task.rs             |  5 ++---
 components/msg/compositor_msg.rs          |  2 +-
 4 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/components/compositing/compositor.rs b/components/compositing/compositor.rs
index e098de519bb..da3ac32b189 100644
--- a/components/compositing/compositor.rs
+++ b/components/compositing/compositor.rs
@@ -104,6 +104,9 @@ pub struct IOCompositor {
     /// Current display/reflow status of each pipeline.
     ready_states: HashMap<PipelineId, ReadyState>,
 
+    /// Current render status of each pipeline.
+    render_states: HashMap<PipelineId, RenderState>,
+
     /// Whether the page being rendered has loaded completely.
     /// Differs from ReadyState because we can finish loading (ready)
     /// many times for a single page.
@@ -167,6 +170,7 @@ impl IOCompositor {
             zoom_action: false,
             zoom_time: 0f64,
             ready_states: HashMap::new(),
+            render_states: HashMap::new(),
             load_complete: false,
             constellation_chan: constellation_chan,
             time_profiler_chan: time_profiler_chan,
@@ -280,8 +284,8 @@ impl IOCompositor {
                     self.change_ready_state(pipeline_id, ready_state);
                 }
 
-                (Ok(ChangeRenderState(render_state)), NotShuttingDown) => {
-                    self.change_render_state(render_state);
+                (Ok(ChangeRenderState(pipeline_id, render_state)), NotShuttingDown) => {
+                    self.change_render_state(pipeline_id, render_state);
                 }
 
                 (Ok(RenderMsgDiscarded), NotShuttingDown) => {
@@ -348,7 +352,10 @@ impl IOCompositor {
 
     }
 
-    fn change_render_state(&mut self, render_state: RenderState) {
+    fn change_render_state(&mut self, pipeline_id: PipelineId, render_state: RenderState) {
+        self.render_states.insert_or_update_with(pipeline_id,
+                                                 render_state,
+                                                 |_key, value| *value = render_state);
         self.window.set_render_state(render_state);
         if render_state == IdleRenderState {
             self.composite_ready = true;
diff --git a/components/compositing/compositor_task.rs b/components/compositing/compositor_task.rs
index dd98381ee3b..0f63b11d4b0 100644
--- a/components/compositing/compositor_task.rs
+++ b/components/compositing/compositor_task.rs
@@ -126,8 +126,8 @@ impl RenderListener for CompositorChan {
         self.chan.send(RenderMsgDiscarded);
     }
 
-    fn set_render_state(&self, render_state: RenderState) {
-        self.chan.send(ChangeRenderState(render_state))
+    fn set_render_state(&self, pipeline_id: PipelineId, render_state: RenderState) {
+        self.chan.send(ChangeRenderState(pipeline_id, render_state))
     }
 }
 
@@ -176,7 +176,7 @@ pub enum Msg {
     /// Alerts the compositor to the current status of page loading.
     ChangeReadyState(PipelineId, ReadyState),
     /// Alerts the compositor to the current status of rendering.
-    ChangeRenderState(RenderState),
+    ChangeRenderState(PipelineId, RenderState),
     /// Alerts the compositor that the RenderMsg has been discarded.
     RenderMsgDiscarded,
     /// Sets the channel to the current layout and render tasks, along with their id
diff --git a/components/gfx/render_task.rs b/components/gfx/render_task.rs
index 2d7b8b5e2d7..8c41d8d1d26 100644
--- a/components/gfx/render_task.rs
+++ b/components/gfx/render_task.rs
@@ -234,9 +234,8 @@ impl<C:RenderListener + Send> RenderTask<C> {
                         continue;
                     }
 
-                    self.compositor.set_render_state(RenderingRenderState);
-
                     let mut replies = Vec::new();
+                    self.compositor.set_render_state(self.id, RenderingRenderState);
                     for RenderRequest { buffer_requests, scale, layer_id, epoch }
                           in requests.move_iter() {
                         if self.epoch == epoch {
@@ -246,7 +245,7 @@ impl<C:RenderListener + Send> RenderTask<C> {
                         }
                     }
 
-                    self.compositor.set_render_state(IdleRenderState);
+                    self.compositor.set_render_state(self.id, IdleRenderState);
 
                     debug!("render_task: returning surfaces");
                     self.compositor.paint(self.id, self.epoch, replies);
diff --git a/components/msg/compositor_msg.rs b/components/msg/compositor_msg.rs
index 650c7fae71a..30a882c2f0a 100644
--- a/components/msg/compositor_msg.rs
+++ b/components/msg/compositor_msg.rs
@@ -101,7 +101,7 @@ pub trait RenderListener {
              replies: Vec<(LayerId, Box<LayerBufferSet>)>);
 
     fn render_msg_discarded(&self);
-    fn set_render_state(&self, render_state: RenderState);
+    fn set_render_state(&self, PipelineId, RenderState);
 }
 
 /// The interface used by the script task to tell the compositor to update its ready state,