diff --git a/src/components/gfx/render_task.rs b/src/components/gfx/render_task.rs
index fcc21acce51..5e327441aaa 100644
--- a/src/components/gfx/render_task.rs
+++ b/src/components/gfx/render_task.rs
@@ -31,12 +31,28 @@ pub struct RenderLayer {
 
 pub enum Msg {
     RenderMsg(RenderLayer),
-    ReRenderMsg(~[(Rect<uint>, Rect<f32>)], f32),
+    ReRenderMsg(~[BufferRequest], f32),
     PaintPermissionGranted,
     PaintPermissionRevoked,
     ExitMsg(Chan<()>),
 }
 
+/// A request from the compositor to the renderer for tiles that need to be (re)displayed.
+pub struct BufferRequest {
+    // The rect in pixels that will be drawn to the screen
+    screen_rect: Rect<uint>,
+    
+    // The rect in page coordinates that this tile represents
+    page_rect: Rect<f32>,
+}
+
+pub fn BufferRequest(screen_rect: Rect<uint>, page_rect: Rect<f32>) -> BufferRequest {
+    BufferRequest {
+        screen_rect: screen_rect,
+        page_rect: page_rect,
+    }
+}
+
 #[deriving(Clone)]
 pub struct RenderChan {
     chan: SharedChan<Msg>,
@@ -145,7 +161,7 @@ impl<C: RenderListener + Send> RenderTask<C> {
         }
     }
 
-    fn render(&mut self, tiles: ~[(Rect<uint>, Rect<f32>)], scale: f32) {
+    fn render(&mut self, tiles: ~[BufferRequest], scale: f32) {
         let render_layer;
         match self.render_layer {
             Some(ref r_layer) => {
@@ -162,18 +178,17 @@ impl<C: RenderListener + Send> RenderTask<C> {
 
             // Divide up the layer into tiles.
             do time::profile(time::RenderingPrepBuffCategory, self.profiler_chan.clone()) {
-                for tiles.each |tile_rects| {
-                    let (screen_rect, page_rect) = *tile_rects;
-                    let width = screen_rect.size.width;
-                    let height = screen_rect.size.height;
+                for tiles.each |tile| {
+                    let width = tile.screen_rect.size.width;
+                    let height = tile.screen_rect.size.height;
                     
                     let buffer = LayerBuffer {
                         draw_target: DrawTarget::new_with_fbo(self.opts.render_backend,
                                                               self.share_gl_context,
                                                               Size2D(width as i32, height as i32),
                                                               B8G8R8A8),
-                        rect: page_rect,
-                        screen_pos: screen_rect,
+                        rect: tile.page_rect,
+                        screen_pos: tile.screen_rect,
                         resolution: scale,
                         stride: (width * 4) as uint
                     };
diff --git a/src/components/main/compositing/mod.rs b/src/components/main/compositing/mod.rs
index 24f95b1b23a..50139134523 100644
--- a/src/components/main/compositing/mod.rs
+++ b/src/components/main/compositing/mod.rs
@@ -14,7 +14,7 @@ use servo_msg::compositor_msg::{RenderListener, LayerBuffer, LayerBufferSet, Ren
 use servo_msg::compositor_msg::{ReadyState, ScriptListener};
 use servo_msg::constellation_msg::{CompositorAck, ConstellationChan};
 use servo_msg::constellation_msg;
-use gfx::render_task::{RenderChan, ReRenderMsg};
+use gfx::render_task::{RenderChan, ReRenderMsg, BufferRequest};
 
 use azure::azure_hl::{DataSourceSurface, DrawTarget, SourceSurfaceMethods, current_gl_context};
 use azure::azure::AzGLContext;
@@ -261,7 +261,7 @@ impl CompositorTask {
                             // TODO: clamp tiles to page bounds
                             // TODO: add null buffer/checkerboard tile to stop a flood of requests
                             debug!("requesting tile: (%?, %?): %?", x, y, tile_size);
-                            tile_request.push((tile_screen_pos, tile_page_pos));
+                            tile_request.push(BufferRequest(tile_screen_pos, tile_page_pos));
                             
                             x += tile_size;
                         }
@@ -517,6 +517,9 @@ impl CompositorTask {
             
             root_layer.common.set_transform(scroll_transform);
             
+            // FIXME: ask_for_tiles() should be called here, but currently this sends a flood of requests
+            // to the renderer, which slows the application dramatically. Instead, ask_for_tiles() is only
+            // called on a click event.
 //            ask_for_tiles();
 
             *recomposite = true;
@@ -557,6 +560,10 @@ impl CompositorTask {
                                                       window_size.height as f32 / -2f32,
                                                       0.0);
             root_layer.common.set_transform(zoom_transform);
+
+            // FIXME: ask_for_tiles() should be called here, but currently this sends a flood of requests
+            // to the renderer, which slows the application dramatically. Instead, ask_for_tiles() is only
+            // called on a click event.
 //            ask_for_tiles();
             
             *recomposite = true;