script: Make most of 2D canvas and WebGL run over IPC.

To actually make the multiprocess communication work, we'll need to
reroute the task creation to the pipeline or the compositor. But this
works as a first step.

components/layout/Cargo.toml

@@ -55,6 +55,10 @@ git = "https://github.com/servo/rust-selectors"
 [dependencies.clock_ticks]
 git = "https://github.com/tomaka/clock_ticks"
 
+[dependencies.cssparser]
+version = "0.3"
+features = [ "serde-serialization" ]
+
 [dependencies.ipc-channel]
 git = "https://github.com/pcwalton/ipc-channel"
 
@@ -66,7 +70,6 @@ url = "0.2.36"
 bitflags = "0.3"
 rustc-serialize = "0.3"
 libc = "0.1"
-cssparser = "0.3.1"
 smallvec = "0.1"
 string_cache = "0.1"
 string_cache_plugin = "0.1"

components/layout/context.rs

@@ -15,6 +15,7 @@ use euclid::{Rect, Size2D};
 use gfx::display_list::OpaqueNode;
 use gfx::font_cache_task::FontCacheTask;
 use gfx::font_context::FontContext;
+use ipc_channel::ipc::IpcSender;
 use msg::constellation_msg::ConstellationChan;
 use net_traits::image::base::Image;
 use net_traits::image_cache_task::{ImageCacheChan, ImageCacheTask, ImageResponse, ImageState};
@@ -24,7 +25,7 @@ use std::cell::{RefCell, RefMut};
 use std::collections::HashMap;
 use std::collections::hash_state::DefaultState;
 use std::rc::Rc;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::sync::mpsc::{channel, Sender};
 use style::selector_matching::Stylist;
 use url::Url;
@@ -120,7 +121,7 @@ pub struct SharedLayoutContext {
     pub new_animations_sender: Sender<Animation>,
 
     /// A channel to send canvas renderers to paint task, in order to correctly paint the layers
-    pub canvas_layers_sender: Sender<(LayerId, Option<Arc<Mutex<Sender<CanvasMsg>>>>)>,
+    pub canvas_layers_sender: 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>, DefaultState<FnvHasher>>>,

components/layout/display_list_builder.rs

@@ -21,6 +21,7 @@ use list_item::ListItemFlow;
 use model::{self, MaybeAuto, ToGfxMatrix, ToAu};
 use table_cell::CollapsedBordersForCell;
 
+use canvas_traits::{CanvasMsg, FromLayoutMsg};
 use euclid::{Point2D, Point3D, Rect, Size2D, SideOffsets2D};
 use euclid::Matrix4;
 use gfx_traits::color;
@@ -32,7 +33,7 @@ use gfx::display_list::{GradientStop, ImageDisplayItem, LineDisplayItem};
 use gfx::display_list::{OpaqueNode, SolidColorDisplayItem};
 use gfx::display_list::{StackingContext, TextDisplayItem, TextOrientation};
 use gfx::paint_task::{PaintLayer, THREAD_TINT_COLORS};
-use ipc_channel::ipc::IpcSharedMemory;
+use ipc_channel::ipc::{self, IpcSharedMemory};
 use msg::compositor_msg::{ScrollPolicy, LayerId};
 use msg::constellation_msg::ConstellationChan;
 use msg::constellation_msg::Msg as ConstellationMsg;
@@ -41,6 +42,7 @@ use net_traits::image::base::{Image, PixelFormat};
 use std::cmp;
 use std::default::Default;
 use std::sync::Arc;
+use std::sync::mpsc::channel;
 use std::f32;
 use style::computed_values::filter::Filter;
 use style::computed_values::{background_attachment, background_clip, background_origin,
@@ -60,9 +62,6 @@ use util::geometry::{Au, ZERO_POINT};
 use util::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize, WritingMode};
 use util::opts;
 
-use canvas_traits::{CanvasMsg, CanvasCommonMsg};
-use std::sync::mpsc::channel;
-
 /// A possible `PaintLayer` for an stacking context
 pub enum StackingContextLayer {
     Existing(PaintLayer),
@@ -1099,11 +1098,11 @@ impl FragmentDisplayListBuilding for Fragment {
                     .computed_inline_size.map_or(0, |w| w.to_px() as usize);
                 let height = canvas_fragment_info.replaced_image_fragment_info
                     .computed_block_size.map_or(0, |h| h.to_px() as usize);
-                let (sender, receiver) = channel::<IpcSharedMemory>();
-                let canvas_data = match canvas_fragment_info.renderer {
-                    Some(ref renderer) =>  {
-                        renderer.lock().unwrap().send(CanvasMsg::Common(
-                                CanvasCommonMsg::SendPixelContents(sender))).unwrap();
+                let (sender, receiver) = ipc::channel::<IpcSharedMemory>().unwrap();
+                let canvas_data = match canvas_fragment_info.ipc_renderer {
+                    Some(ref ipc_renderer) =>  {
+                        ipc_renderer.lock().unwrap().send(CanvasMsg::FromLayout(
+                                FromLayoutMsg::SendPixelContents(sender))).unwrap();
                         receiver.recv().unwrap()
                     },
                     None => IpcSharedMemory::from_byte(0xFFu8, width * height * 4),
@@ -1248,8 +1247,11 @@ impl FragmentDisplayListBuilding for Fragment {
         // task
         if let SpecificFragmentInfo::Canvas(ref fragment_info) = self.specific {
             let layer_id = layer.as_ref().unwrap().id;
-            layout_context.shared.canvas_layers_sender
-                .send((layer_id, fragment_info.renderer.clone())).unwrap();
+            if let Some(ref ipc_renderer) = fragment_info.ipc_renderer {
+                layout_context.shared
+                              .canvas_layers_sender
+                              .send((layer_id, (*ipc_renderer.lock().unwrap()).clone())).unwrap();
+            }
         }
 
         let transform_style = self.style().get_used_transform_style();

components/layout/fragment.rs

@@ -24,6 +24,7 @@ use euclid::{Point2D, Rect, Size2D};
 use gfx::display_list::{BLUR_INFLATION_FACTOR, OpaqueNode};
 use gfx::text::glyph::CharIndex;
 use gfx::text::text_run::{TextRun, TextRunSlice};
+use ipc_channel::ipc::IpcSender;
 use msg::constellation_msg::{ConstellationChan, Msg, PipelineId, SubpageId};
 use net_traits::image::base::Image;
 use net_traits::image_cache_task::UsePlaceholder;
@@ -32,7 +33,6 @@ use std::borrow::ToOwned;
 use std::cmp::{max, min};
 use std::collections::LinkedList;
 use std::fmt;
-use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex};
 use string_cache::Atom;
 use style::computed_values::content::ContentItem;
@@ -291,7 +291,8 @@ impl InlineAbsoluteFragmentInfo {
 #[derive(Clone)]
 pub struct CanvasFragmentInfo {
     pub replaced_image_fragment_info: ReplacedImageFragmentInfo,
-    pub renderer: Option<Arc<Mutex<Sender<CanvasMsg>>>>,
+    pub renderer_id: Option<usize>,
+    pub ipc_renderer: Option<Arc<Mutex<IpcSender<CanvasMsg>>>>,
 }
 
 impl CanvasFragmentInfo {
@@ -300,7 +301,9 @@ impl CanvasFragmentInfo {
             replaced_image_fragment_info: ReplacedImageFragmentInfo::new(node,
                 Some(Au::from_px(node.canvas_width() as i32)),
                 Some(Au::from_px(node.canvas_height() as i32))),
-            renderer: node.renderer().map(|rec| Arc::new(Mutex::new(rec))),
+            renderer_id: node.canvas_renderer_id(),
+            ipc_renderer: node.canvas_ipc_renderer()
+                              .map(|renderer| Arc::new(Mutex::new(renderer))),
         }
     }
 

components/layout/layout_task.rs

@@ -39,7 +39,7 @@ use gfx::display_list::StackingContext;
 use gfx::font_cache_task::FontCacheTask;
 use gfx::paint_task::Msg as PaintMsg;
 use gfx::paint_task::{PaintChan, PaintLayer};
-use ipc_channel::ipc::{self, IpcReceiver};
+use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use ipc_channel::router::ROUTER;
 use layout_traits::LayoutTaskFactory;
 use log;
@@ -197,8 +197,8 @@ pub struct LayoutTask {
 
     /// To receive a canvas renderer associated to a layer, this message is propagated
     /// to the paint chan
-    pub canvas_layers_receiver: Receiver<(LayerId, Option<Arc<Mutex<Sender<CanvasMsg>>>>)>,
-    pub canvas_layers_sender: Sender<(LayerId, Option<Arc<Mutex<Sender<CanvasMsg>>>>)>,
+    pub canvas_layers_receiver: Receiver<(LayerId, IpcSender<CanvasMsg>)>,
+    pub canvas_layers_sender: Sender<(LayerId, IpcSender<CanvasMsg>)>,
 
     /// A mutex to allow for fast, read-only RPC of layout's internal data
     /// structures, while still letting the LayoutTask modify them.
@@ -1030,9 +1030,7 @@ impl LayoutTask {
         // Send new canvas renderers to the paint task
         while let Ok((layer_id, renderer)) = self.canvas_layers_receiver.try_recv() {
             // Just send if there's an actual renderer
-            if let Some(renderer) = renderer {
-                self.paint_chan.send(PaintMsg::CanvasLayer(layer_id, renderer));
-            }
+            self.paint_chan.send(PaintMsg::CanvasLayer(layer_id, renderer));
         }
 
         // Perform post-style recalculation layout passes.

components/layout/wrapper.rs

@@ -38,6 +38,7 @@ use data::{LayoutDataFlags, LayoutDataWrapper, PrivateLayoutData};
 use opaque_node::OpaqueNodeMethods;
 
 use gfx::display_list::OpaqueNode;
+use ipc_channel::ipc::IpcSender;
 use script::dom::attr::AttrValue;
 use script::dom::bindings::codegen::InheritTypes::{CharacterDataCast, ElementCast};
 use script::dom::bindings::codegen::InheritTypes::{HTMLIFrameElementCast, HTMLCanvasElementCast};
@@ -63,7 +64,6 @@ use std::borrow::ToOwned;
 use std::cell::{Ref, RefMut};
 use std::marker::PhantomData;
 use std::mem;
-use std::sync::mpsc::Sender;
 use string_cache::{Atom, Namespace};
 use style::computed_values::content::ContentItem;
 use style::computed_values::{content, display, white_space};
@@ -904,10 +904,17 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
         }
     }
 
-    pub fn renderer(&self) -> Option<Sender<CanvasMsg>> {
+    pub fn canvas_renderer_id(&self) -> Option<usize> {
         unsafe {
             let canvas_element = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
-            canvas_element.and_then(|elem| elem.get_renderer())
+            canvas_element.and_then(|elem| elem.get_renderer_id())
+        }
+    }
+
+    pub fn canvas_ipc_renderer(&self) -> Option<IpcSender<CanvasMsg>> {
+        unsafe {
+            let canvas_element = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
+            canvas_element.and_then(|elem| elem.get_ipc_renderer())
         }
     }