canvas: Remove all the canvas layerization infrastructure

It was never complete, and with webrender as a backend the way we render
WebGL contexts has changed a bit.

This should remove quite a bit of overhead.

components/layout/context.rs

@@ -8,7 +8,6 @@
 #![allow(unsafe_code)]
 
 use app_units::Au;
-use canvas_traits::CanvasMsg;
 use euclid::Rect;
 use fnv::FnvHasher;
 use gfx::display_list::WebRenderImageInfo;
@@ -16,7 +15,7 @@ use gfx::font_cache_thread::FontCacheThread;
 use gfx::font_context::FontContext;
 use gfx_traits::LayerId;
 use heapsize::HeapSizeOf;
-use ipc_channel::ipc::{self, IpcSender, IpcSharedMemory};
+use ipc_channel::ipc::{self, IpcSharedMemory};
 use net_traits::image::base::Image;
 use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheThread, ImageResponse, ImageState};
 use net_traits::image_cache_thread::{ImageOrMetadataAvailable, UsePlaceholder};
@@ -24,7 +23,6 @@ use std::cell::{RefCell, RefMut};
 use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 use std::rc::Rc;
-use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 use style::context::{LocalStyleContext, StyleContext};
 use style::matching::{ApplicableDeclarationsCache, StyleSharingCandidateCache};
@@ -95,9 +93,6 @@ pub struct SharedLayoutContext {
     /// The URL.
     pub url: Url,
 
-    /// A channel to send canvas renderers to paint thread, in order to correctly paint the layers
-    pub canvas_layers_sender: Mutex<Sender<(LayerId, IpcSender<CanvasMsg>)>>,
-
     /// The visible rects for each layer, as reported to us by the compositor.
     pub visible_rects: Arc<HashMap<LayerId, Rect<Au>, BuildHasherDefault<FnvHasher>>>,
 

components/layout/display_list_builder.rs

@@ -1197,13 +1197,7 @@ impl FragmentDisplayListBuilding for Fragment {
                             let (sender, receiver) = ipc::channel().unwrap();
                             ipc_renderer.send(CanvasMsg::FromLayout(
                                 FromLayoutMsg::SendData(sender))).unwrap();
-                            let data = receiver.recv().unwrap();
-
-                            // Propagate the layer and the renderer to the paint task.
-                            state.layout_context.shared.canvas_layers_sender.lock().unwrap().send(
-                                (layer_id, (*ipc_renderer).clone())).unwrap();
-
-                            data
+                            receiver.recv().unwrap()
                         },
                         None => CanvasData::Pixels(CanvasPixelData {
                             image_data: IpcSharedMemory::from_byte(0xFFu8, width * height * 4),

components/layout/layout_thread.rs

@@ -10,7 +10,6 @@
 use animation;
 use app_units::Au;
 use azure::azure::AzColor;
-use canvas_traits::CanvasMsg;
 use construct::ConstructionResult;
 use context::{LayoutContext, SharedLayoutContext, heap_size_of_local_context};
 use display_list_builder::ToGfxColor;
@@ -186,11 +185,6 @@ pub struct LayoutThread {
     /// Is this the first reflow in this LayoutThread?
     first_reflow: bool,
 
-    /// To receive a canvas renderer associated to a layer, this message is propagated
-    /// to the paint chan
-    canvas_layers_receiver: Receiver<(LayerId, IpcSender<CanvasMsg>)>,
-    canvas_layers_sender: Sender<(LayerId, IpcSender<CanvasMsg>)>,
-
     /// The workers that we use for parallel operation.
     parallel_traversal: Option<WorkQueue<SharedLayoutContext, WorkQueueData>>,
 
@@ -406,7 +400,6 @@ impl LayoutThread {
 
         // Create the channel on which new animations can be sent.
         let (new_animations_sender, new_animations_receiver) = channel();
-        let (canvas_layers_sender, canvas_layers_receiver) = channel();
 
         // Proxy IPC messages from the pipeline to the layout thread.
         let pipeline_receiver = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(pipeline_port);
@@ -449,8 +442,6 @@ impl LayoutThread {
             image_cache_sender: ImageCacheChan(ipc_image_cache_sender),
             font_cache_receiver: font_cache_receiver,
             font_cache_sender: ipc_font_cache_sender,
-            canvas_layers_receiver: canvas_layers_receiver,
-            canvas_layers_sender: canvas_layers_sender,
             parallel_traversal: parallel_traversal,
             generation: 0,
             new_animations_sender: new_animations_sender,
@@ -521,7 +512,6 @@ impl LayoutThread {
             image_cache_thread: self.image_cache_thread.clone(),
             image_cache_sender: Mutex::new(self.image_cache_sender.clone()),
             font_cache_thread: Mutex::new(self.font_cache_thread.clone()),
-            canvas_layers_sender: Mutex::new(self.canvas_layers_sender.clone()),
             url: (*url).clone(),
             visible_rects: self.visible_rects.clone(),
             webrender_image_cache: self.webrender_image_cache.clone(),
@@ -1148,12 +1138,6 @@ impl LayoutThread {
             self.root_flow = self.try_get_layout_root(node);
         }
 
-        // Send new canvas renderers to the paint thread
-        while let Ok((layer_id, renderer)) = self.canvas_layers_receiver.try_recv() {
-            // Just send if there's an actual renderer
-            self.paint_chan.send(LayoutToPaintMsg::CanvasLayer(layer_id, renderer)).unwrap();
-        }
-
         // Perform post-style recalculation layout passes.
         self.perform_post_style_recalc_layout_passes(&data.reflow_info,
                                                      &mut rw_data,

components/layout/traversal.rs

@@ -15,7 +15,7 @@ use flow::{self, Flow, CAN_BE_FRAGMENTED};
 use gfx::display_list::OpaqueNode;
 use incremental::{BUBBLE_ISIZES, REFLOW, REFLOW_OUT_OF_FLOW, REPAINT, RestyleDamage};
 use std::mem;
-use style::context::{StyleContext, ReflowGoal};
+use style::context::StyleContext;
 use style::matching::MatchMethods;
 use style::traversal::{DomTraversalContext, STYLE_BLOOM};
 use style::traversal::{put_thread_local_bloom_filter, recalc_style_at};