diff --git a/gfx/wr/webrender_api/src/api.rs b/gfx/wr/webrender_api/src/api.rs
index 146f703ac7da..6c9c796a8216 100644
--- a/gfx/wr/webrender_api/src/api.rs
+++ b/gfx/wr/webrender_api/src/api.rs
@@ -13,12 +13,13 @@ use std::os::raw::c_void;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::u32;
-use {BuiltDisplayList, BuiltDisplayListDescriptor, ColorF, DeviceIntPoint, DeviceIntRect};
-use {DeviceIntSize, ExternalScrollId, FontInstanceKey, FontInstanceOptions};
-use {FontInstancePlatformOptions, FontKey, FontVariation, GlyphDimensions, GlyphIndex, ImageData};
-use {ImageDescriptor, ItemTag, LayoutPoint, LayoutSize, LayoutTransform, LayoutVector2D};
-use {BlobDirtyRect, ImageDirtyRect, ImageKey, BlobImageKey, BlobImageData};
-use {NativeFontHandle, WorldPoint};
+
+use {display_item as di, font};
+use color::ColorF;
+use display_list::{BuiltDisplayList, BuiltDisplayListDescriptor};
+use image::{BlobImageData, BlobImageKey, ImageData, ImageDescriptor, ImageKey};
+use units::*;
+
 
 pub type TileSize = u16;
 /// Documents are rendered in the ascending order of their associated layer values.
@@ -33,9 +34,9 @@ pub enum ResourceUpdate {
     DeleteImage(ImageKey),
     SetBlobImageVisibleArea(BlobImageKey, DeviceIntRect),
     AddFont(AddFont),
-    DeleteFont(FontKey),
+    DeleteFont(font::FontKey),
     AddFontInstance(AddFontInstance),
-    DeleteFontInstance(FontInstanceKey),
+    DeleteFontInstance(font::FontInstanceKey),
 }
 
 /// A Transaction is a group of commands to apply atomically to a document.
@@ -224,7 +225,7 @@ impl Transaction {
     pub fn scroll_node_with_id(
         &mut self,
         origin: LayoutPoint,
-        id: ExternalScrollId,
+        id: di::ExternalScrollId,
         clamp: ScrollClamping,
     ) {
         self.frame_ops.push(FrameMsg::ScrollNodeWithId(origin, id, clamp));
@@ -380,28 +381,28 @@ impl Transaction {
         self.resource_updates.push(ResourceUpdate::SetBlobImageVisibleArea(key, area))
     }
 
-    pub fn add_raw_font(&mut self, key: FontKey, bytes: Vec<u8>, index: u32) {
+    pub fn add_raw_font(&mut self, key: font::FontKey, bytes: Vec<u8>, index: u32) {
         self.resource_updates
             .push(ResourceUpdate::AddFont(AddFont::Raw(key, bytes, index)));
     }
 
-    pub fn add_native_font(&mut self, key: FontKey, native_handle: NativeFontHandle) {
+    pub fn add_native_font(&mut self, key: font::FontKey, native_handle: font::NativeFontHandle) {
         self.resource_updates
             .push(ResourceUpdate::AddFont(AddFont::Native(key, native_handle)));
     }
 
-    pub fn delete_font(&mut self, key: FontKey) {
+    pub fn delete_font(&mut self, key: font::FontKey) {
         self.resource_updates.push(ResourceUpdate::DeleteFont(key));
     }
 
     pub fn add_font_instance(
         &mut self,
-        key: FontInstanceKey,
-        font_key: FontKey,
+        key: font::FontInstanceKey,
+        font_key: font::FontKey,
         glyph_size: Au,
-        options: Option<FontInstanceOptions>,
-        platform_options: Option<FontInstancePlatformOptions>,
-        variations: Vec<FontVariation>,
+        options: Option<font::FontInstanceOptions>,
+        platform_options: Option<font::FontInstancePlatformOptions>,
+        variations: Vec<font::FontVariation>,
     ) {
         self.resource_updates
             .push(ResourceUpdate::AddFontInstance(AddFontInstance {
@@ -414,7 +415,7 @@ impl Transaction {
             }));
     }
 
-    pub fn delete_font_instance(&mut self, key: FontInstanceKey) {
+    pub fn delete_font_instance(&mut self, key: font::FontInstanceKey) {
         self.resource_updates.push(ResourceUpdate::DeleteFontInstance(key));
     }
 
@@ -529,11 +530,11 @@ pub struct UpdateBlobImage {
 #[derive(Clone, Deserialize, Serialize)]
 pub enum AddFont {
     Raw(
-        FontKey,
+        font::FontKey,
         #[serde(with = "serde_bytes")] Vec<u8>,
         u32
     ),
-    Native(FontKey, NativeFontHandle),
+    Native(font::FontKey, font::NativeFontHandle),
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
@@ -542,7 +543,7 @@ pub struct HitTestItem {
     pub pipeline: PipelineId,
 
     /// The tag of the hit display item.
-    pub tag: ItemTag,
+    pub tag: di::ItemTag,
 
     /// The hit point in the coordinate space of the "viewport" of the display item. The
     /// viewport is the scroll node formed by the root reference frame of the display item's
@@ -569,12 +570,12 @@ bitflags! {
 
 #[derive(Clone, Deserialize, Serialize)]
 pub struct AddFontInstance {
-    pub key: FontInstanceKey,
-    pub font_key: FontKey,
+    pub key: font::FontInstanceKey,
+    pub font_key: font::FontKey,
     pub glyph_size: Au,
-    pub options: Option<FontInstanceOptions>,
-    pub platform_options: Option<FontInstancePlatformOptions>,
-    pub variations: Vec<FontVariation>,
+    pub options: Option<font::FontInstanceOptions>,
+    pub platform_options: Option<font::FontInstancePlatformOptions>,
+    pub variations: Vec<font::FontVariation>,
 }
 
 // Frame messages affect building the scene.
@@ -608,7 +609,7 @@ pub enum FrameMsg {
     SetPan(DeviceIntPoint),
     EnableFrameOutput(PipelineId, bool),
     Scroll(ScrollLocation, WorldPoint),
-    ScrollNodeWithId(LayoutPoint, ExternalScrollId, ScrollClamping),
+    ScrollNodeWithId(LayoutPoint, di::ExternalScrollId, ScrollClamping),
     GetScrollNodeState(MsgSender<Vec<ScrollNodeState>>),
     UpdateDynamicProperties(DynamicProperties),
     AppendDynamicProperties(DynamicProperties),
@@ -715,12 +716,12 @@ pub enum ApiMsg {
     UpdateResources(Vec<ResourceUpdate>),
     /// Gets the glyph dimensions
     GetGlyphDimensions(
-        FontInstanceKey,
-        Vec<GlyphIndex>,
-        MsgSender<Vec<Option<GlyphDimensions>>>,
+        font::FontInstanceKey,
+        Vec<font::GlyphIndex>,
+        MsgSender<Vec<Option<font::GlyphDimensions>>>,
     ),
     /// Gets the glyph indices from a string
-    GetGlyphIndices(FontKey, String, MsgSender<Vec<Option<u32>>>),
+    GetGlyphIndices(font::FontKey, String, MsgSender<Vec<Option<u32>>>),
     /// Adds a new document namespace.
     CloneApi(MsgSender<IdNamespace>),
     /// Adds a new document namespace.
@@ -1059,14 +1060,14 @@ impl RenderApi {
         self.api_sender.send(msg).unwrap();
     }
 
-    pub fn generate_font_key(&self) -> FontKey {
+    pub fn generate_font_key(&self) -> font::FontKey {
         let new_id = self.next_unique_id();
-        FontKey::new(self.namespace_id, new_id)
+        font::FontKey::new(self.namespace_id, new_id)
     }
 
-    pub fn generate_font_instance_key(&self) -> FontInstanceKey {
+    pub fn generate_font_instance_key(&self) -> font::FontInstanceKey {
         let new_id = self.next_unique_id();
-        FontInstanceKey::new(self.namespace_id, new_id)
+        font::FontInstanceKey::new(self.namespace_id, new_id)
     }
 
     /// Gets the dimensions for the supplied glyph keys
@@ -1076,9 +1077,9 @@ impl RenderApi {
     /// This means that glyph dimensions e.g. for spaces (' ') will mostly be None.
     pub fn get_glyph_dimensions(
         &self,
-        font: FontInstanceKey,
-        glyph_indices: Vec<GlyphIndex>,
-    ) -> Vec<Option<GlyphDimensions>> {
+        font: font::FontInstanceKey,
+        glyph_indices: Vec<font::GlyphIndex>,
+    ) -> Vec<Option<font::GlyphDimensions>> {
         let (tx, rx) = channel::msg_channel().unwrap();
         let msg = ApiMsg::GetGlyphDimensions(font, glyph_indices, tx);
         self.api_sender.send(msg).unwrap();
@@ -1087,7 +1088,7 @@ impl RenderApi {
 
     /// Gets the glyph indices for the supplied string. These
     /// can be used to construct GlyphKeys.
-    pub fn get_glyph_indices(&self, font_key: FontKey, text: &str) -> Vec<Option<u32>> {
+    pub fn get_glyph_indices(&self, font_key: font::FontKey, text: &str) -> Vec<Option<u32>> {
         let (tx, rx) = channel::msg_channel().unwrap();
         let msg = ApiMsg::GetGlyphIndices(font_key, text.to_string(), tx);
         self.api_sender.send(msg).unwrap();
@@ -1292,7 +1293,7 @@ impl Drop for RenderApi {
 
 #[derive(Clone, Deserialize, Serialize)]
 pub struct ScrollNodeState {
-    pub id: ExternalScrollId,
+    pub id: di::ExternalScrollId,
     pub scroll_offset: LayoutVector2D,
 }
 
@@ -1312,7 +1313,7 @@ pub struct ZoomFactor(f32);
 
 impl ZoomFactor {
     /// Construct a new zoom factor.
-    pub fn new(scale: f32) -> ZoomFactor {
+    pub fn new(scale: f32) -> Self {
         ZoomFactor(scale)
     }
 
diff --git a/gfx/wr/webrender_api/src/display_item.rs b/gfx/wr/webrender_api/src/display_item.rs
index 457c5377c2c8..0e88c1e0bc4c 100644
--- a/gfx/wr/webrender_api/src/display_item.rs
+++ b/gfx/wr/webrender_api/src/display_item.rs
@@ -2,14 +2,14 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#[cfg(any(feature = "serialize", feature = "deserialize"))]
-use GlyphInstance;
 use euclid::{SideOffsets2D, TypedRect};
 use std::ops::Not;
-use {ColorF, FontInstanceKey, GlyphOptions, ImageKey, LayoutPixel, LayoutPoint};
-use {LayoutRect, LayoutSize, LayoutTransform, LayoutVector2D, PipelineId, PropertyBinding};
-use LayoutSideOffsets;
-use image::ColorDepth;
+
+use font;
+use api::{PipelineId, PropertyBinding};
+use color::ColorF;
+use image::{ColorDepth, ImageKey};
+use units::*;
 
 // Maximum blur radius.
 // Taken from nsCSSRendering.cpp in Gecko.
@@ -143,7 +143,7 @@ pub enum CompletelySpecificDisplayItem {
     Rectangle(RectangleDisplayItem),
     ClearRectangle,
     Line(LineDisplayItem),
-    Text(TextDisplayItem, Vec<GlyphInstance>),
+    Text(TextDisplayItem, Vec<font::GlyphInstance>),
     Image(ImageDisplayItem),
     YuvImage(YuvImageDisplayItem),
     Border(BorderDisplayItem),
@@ -264,10 +264,10 @@ pub enum LineStyle {
 
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
 pub struct TextDisplayItem {
-    pub font_key: FontInstanceKey,
+    pub font_key: font::FontInstanceKey,
     pub color: ColorF,
-    pub glyph_options: Option<GlyphOptions>,
-} // IMPLICIT: glyphs: Vec<GlyphInstance>
+    pub glyph_options: Option<font::GlyphOptions>,
+} // IMPLICIT: glyphs: Vec<font::GlyphInstance>
 
 #[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
 pub struct NormalBorder {
diff --git a/gfx/wr/webrender_api/src/display_list.rs b/gfx/wr/webrender_api/src/display_list.rs
index 955d4f28d2c0..717ad18bcfe8 100644
--- a/gfx/wr/webrender_api/src/display_list.rs
+++ b/gfx/wr/webrender_api/src/display_list.rs
@@ -14,19 +14,15 @@ use std::marker::PhantomData;
 use std::ops::Range;
 use std::{io, mem, ptr, slice};
 use time::precise_time_ns;
-use {AlphaType, BorderDetails, BorderDisplayItem, BorderRadius, BoxShadowClipMode, CacheMarkerDisplayItem};
-use {BoxShadowDisplayItem, ClipChainId, ClipChainItem, ClipDisplayItem, ClipId};
-use {ColorF, ComplexClipRegion, DisplayItem, ExtendMode, ExternalScrollId, FilterOp};
-use {FontInstanceKey, GlyphInstance, GlyphOptions, RasterSpace, Gradient, GradientBuilder};
-use {GradientDisplayItem, GradientStop, IframeDisplayItem, ImageDisplayItem, ImageKey, ImageMask};
-use {ImageRendering, LayoutPoint, LayoutPrimitiveInfo, LayoutRect, LayoutSideOffsets, LayoutSize};
-use {LayoutTransform, LayoutVector2D, LineDisplayItem, LineOrientation, LineStyle, MixBlendMode};
-use {PipelineId, PropertyBinding, ReferenceFrameDisplayListItem};
-use {PushStackingContextDisplayItem, RadialGradient, RadialGradientDisplayItem};
-use {RectangleDisplayItem, ReferenceFrame, ReferenceFrameKind, ScrollFrameDisplayItem, ScrollSensitivity};
-use {SerializedDisplayItem, Shadow, SpaceAndClipInfo, SpatialId, SpecificDisplayItem};
-use {StackingContext, StickyFrameDisplayItem, StickyOffsetBounds};
-use {TextDisplayItem, TransformStyle, YuvColorSpace, YuvData, YuvImageDisplayItem, ColorDepth};
+
+use display_item as di;
+use api::{PipelineId, PropertyBinding};
+use gradient_builder::GradientBuilder;
+use color::ColorF;
+use font::{FontInstanceKey, GlyphInstance, GlyphOptions};
+use image::{ColorDepth, ImageKey};
+use units::*;
+
 
 // We don't want to push a long text-run. If a text-run is too long, split it into several parts.
 // This needs to be set to (renderer::MAX_VERTEX_TEXTURE_WIDTH - VECS_PER_TEXT_RUN) * 2
@@ -95,12 +91,12 @@ pub struct BuiltDisplayListDescriptor {
 pub struct BuiltDisplayListIter<'a> {
     list: &'a BuiltDisplayList,
     data: &'a [u8],
-    cur_item: DisplayItem,
-    cur_stops: ItemRange<GradientStop>,
+    cur_item: di::DisplayItem,
+    cur_stops: ItemRange<di::GradientStop>,
     cur_glyphs: ItemRange<GlyphInstance>,
-    cur_filters: ItemRange<FilterOp>,
-    cur_clip_chain_items: ItemRange<ClipId>,
-    cur_complex_clip: (ItemRange<ComplexClipRegion>, usize),
+    cur_filters: ItemRange<di::FilterOp>,
+    cur_clip_chain_items: ItemRange<di::ClipId>,
+    cur_complex_clip: (ItemRange<di::ComplexClipRegion>, usize),
     peeking: Peek,
 }
 
@@ -210,11 +206,11 @@ impl<'a> BuiltDisplayListIter<'a> {
         BuiltDisplayListIter {
             list,
             data,
-            cur_item: DisplayItem {
+            cur_item: di::DisplayItem {
                 // Dummy data, will be overwritten by `next`
-                item: SpecificDisplayItem::PopStackingContext,
-                layout: LayoutPrimitiveInfo::new(LayoutRect::zero()),
-                space_and_clip: SpaceAndClipInfo::root_scroll(PipelineId::dummy())
+                item: di::SpecificDisplayItem::PopStackingContext,
+                layout: di::LayoutPrimitiveInfo::new(LayoutRect::zero()),
+                space_and_clip: di::SpaceAndClipInfo::root_scroll(PipelineId::dummy())
             },
             cur_stops: ItemRange::default(),
             cur_glyphs: ItemRange::default(),
@@ -278,16 +274,16 @@ impl<'a> BuiltDisplayListIter<'a> {
 
         match self.cur_item.item {
             SetGradientStops => {
-                self.cur_stops = skip_slice::<GradientStop>(self.list, &mut self.data).0;
+                self.cur_stops = skip_slice::<di::GradientStop>(self.list, &mut self.data).0;
             }
             ClipChain(_) => {
-                self.cur_clip_chain_items = skip_slice::<ClipId>(self.list, &mut self.data).0;
+                self.cur_clip_chain_items = skip_slice::<di::ClipId>(self.list, &mut self.data).0;
             }
             Clip(_) | ScrollFrame(_) => {
-                self.cur_complex_clip = self.skip_slice::<ComplexClipRegion>()
+                self.cur_complex_clip = self.skip_slice::<di::ComplexClipRegion>()
             }
             Text(_) => self.cur_glyphs = self.skip_slice::<GlyphInstance>().0,
-            PushStackingContext(_) => self.cur_filters = self.skip_slice::<FilterOp>().0,
+            PushStackingContext(_) => self.cur_filters = self.skip_slice::<di::FilterOp>().0,
             _ => { /* do nothing */ }
         }
 
@@ -304,9 +300,9 @@ impl<'a> BuiltDisplayListIter<'a> {
 
     pub fn starting_stacking_context(
         &mut self,
-    ) -> Option<(StackingContext, LayoutRect, ItemRange<FilterOp>)> {
+    ) -> Option<(di::StackingContext, LayoutRect, ItemRange<di::FilterOp>)> {
         self.next().and_then(|item| match *item.item() {
-            SpecificDisplayItem::PushStackingContext(ref specific_item) => Some((
+            di::SpecificDisplayItem::PushStackingContext(ref specific_item) => Some((
                 specific_item.stacking_context,
                 item.rect(),
                 item.filters(),
@@ -319,9 +315,9 @@ impl<'a> BuiltDisplayListIter<'a> {
         let mut depth = 0;
         while let Some(item) = self.next() {
             match *item.item() {
-                SpecificDisplayItem::PushStackingContext(..) => depth += 1,
-                SpecificDisplayItem::PopStackingContext if depth == 0 => return,
-                SpecificDisplayItem::PopStackingContext => depth -= 1,
+                di::SpecificDisplayItem::PushStackingContext(..) => depth += 1,
+                di::SpecificDisplayItem::PopStackingContext if depth == 0 => return,
+                di::SpecificDisplayItem::PopStackingContext => depth -= 1,
                 _ => {}
             }
             debug_assert!(depth >= 0);
@@ -330,7 +326,7 @@ impl<'a> BuiltDisplayListIter<'a> {
 
     pub fn current_stacking_context_empty(&mut self) -> bool {
         match self.peek() {
-            Some(item) => *item.item() == SpecificDisplayItem::PopStackingContext,
+            Some(item) => *item.item() == di::SpecificDisplayItem::PopStackingContext,
             None => true,
         }
     }
@@ -347,7 +343,7 @@ impl<'a> BuiltDisplayListIter<'a> {
 
 // Some of these might just become ItemRanges
 impl<'a, 'b> DisplayItemRef<'a, 'b> {
-    pub fn display_item(&self) -> &DisplayItem {
+    pub fn display_item(&self) -> &di::DisplayItem {
         &self.iter.cur_item
     }
 
@@ -355,9 +351,9 @@ impl<'a, 'b> DisplayItemRef<'a, 'b> {
         self.iter.cur_item.layout.rect
     }
 
-    pub fn get_layout_primitive_info(&self, offset: &LayoutVector2D) -> LayoutPrimitiveInfo {
+    pub fn get_layout_primitive_info(&self, offset: &LayoutVector2D) -> di::LayoutPrimitiveInfo {
         let layout = self.iter.cur_item.layout;
-        LayoutPrimitiveInfo {
+        di::LayoutPrimitiveInfo {
             rect: layout.rect.translate(offset),
             clip_rect: layout.clip_rect.translate(offset),
             is_backface_visible: layout.is_backface_visible,
@@ -369,19 +365,19 @@ impl<'a, 'b> DisplayItemRef<'a, 'b> {
         &self.iter.cur_item.layout.clip_rect
     }
 
-    pub fn space_and_clip_info(&self) -> &SpaceAndClipInfo {
+    pub fn space_and_clip_info(&self) -> &di::SpaceAndClipInfo {
         &self.iter.cur_item.space_and_clip
     }
 
-    pub fn item(&self) -> &SpecificDisplayItem {
+    pub fn item(&self) -> &di::SpecificDisplayItem {
         &self.iter.cur_item.item
     }
 
-    pub fn complex_clip(&self) -> (ItemRange<ComplexClipRegion>, usize) {
+    pub fn complex_clip(&self) -> (ItemRange<di::ComplexClipRegion>, usize) {
         self.iter.cur_complex_clip
     }
 
-    pub fn gradient_stops(&self) -> ItemRange<GradientStop> {
+    pub fn gradient_stops(&self) -> ItemRange<di::GradientStop> {
         self.iter.cur_stops
     }
 
@@ -389,11 +385,11 @@ impl<'a, 'b> DisplayItemRef<'a, 'b> {
         self.iter.cur_glyphs
     }
 
-    pub fn filters(&self) -> ItemRange<FilterOp> {
+    pub fn filters(&self) -> ItemRange<di::FilterOp> {
         self.iter.cur_filters
     }
 
-    pub fn clip_chain_items(&self) -> ItemRange<ClipId> {
+    pub fn clip_chain_items(&self) -> ItemRange<di::ClipId> {
         self.iter.cur_clip_chain_items
     }
 
@@ -462,47 +458,47 @@ impl Serialize for BuiltDisplayList {
             let display_item = item.display_item();
             let serial_di = GenericDisplayItem {
                 item: match display_item.item {
-                    SpecificDisplayItem::Clip(v) => Clip(
+                    di::SpecificDisplayItem::Clip(v) => Clip(
                         v,
                         item.iter.list.get(item.iter.cur_complex_clip.0).collect()
                     ),
-                    SpecificDisplayItem::ClipChain(v) => ClipChain(
+                    di::SpecificDisplayItem::ClipChain(v) => ClipChain(
                         v,
                         item.iter.list.get(item.iter.cur_clip_chain_items).collect(),
                     ),
-                    SpecificDisplayItem::ScrollFrame(v) => ScrollFrame(
+                    di::SpecificDisplayItem::ScrollFrame(v) => ScrollFrame(
                         v,
                         item.iter.list.get(item.iter.cur_complex_clip.0).collect()
                     ),
-                    SpecificDisplayItem::StickyFrame(v) => StickyFrame(v),
-                    SpecificDisplayItem::Rectangle(v) => Rectangle(v),
-                    SpecificDisplayItem::ClearRectangle => ClearRectangle,
-                    SpecificDisplayItem::Line(v) => Line(v),
-                    SpecificDisplayItem::Text(v) => Text(
+                    di::SpecificDisplayItem::StickyFrame(v) => StickyFrame(v),
+                    di::SpecificDisplayItem::Rectangle(v) => Rectangle(v),
+                    di::SpecificDisplayItem::ClearRectangle => ClearRectangle,
+                    di::SpecificDisplayItem::Line(v) => Line(v),
+                    di::SpecificDisplayItem::Text(v) => Text(
                         v,
                         item.iter.list.get(item.iter.cur_glyphs).collect()
                     ),
-                    SpecificDisplayItem::Image(v) => Image(v),
-                    SpecificDisplayItem::YuvImage(v) => YuvImage(v),
-                    SpecificDisplayItem::Border(v) => Border(v),
-                    SpecificDisplayItem::BoxShadow(v) => BoxShadow(v),
-                    SpecificDisplayItem::Gradient(v) => Gradient(v),
-                    SpecificDisplayItem::RadialGradient(v) => RadialGradient(v),
-                    SpecificDisplayItem::Iframe(v) => Iframe(v),
-                    SpecificDisplayItem::PushReferenceFrame(v) => PushReferenceFrame(v),
-                    SpecificDisplayItem::PopReferenceFrame => PopReferenceFrame,
-                    SpecificDisplayItem::PushStackingContext(v) => PushStackingContext(
+                    di::SpecificDisplayItem::Image(v) => Image(v),
+                    di::SpecificDisplayItem::YuvImage(v) => YuvImage(v),
+                    di::SpecificDisplayItem::Border(v) => Border(v),
+                    di::SpecificDisplayItem::BoxShadow(v) => BoxShadow(v),
+                    di::SpecificDisplayItem::Gradient(v) => Gradient(v),
+                    di::SpecificDisplayItem::RadialGradient(v) => RadialGradient(v),
+                    di::SpecificDisplayItem::Iframe(v) => Iframe(v),
+                    di::SpecificDisplayItem::PushReferenceFrame(v) => PushReferenceFrame(v),
+                    di::SpecificDisplayItem::PopReferenceFrame => PopReferenceFrame,
+                    di::SpecificDisplayItem::PushStackingContext(v) => PushStackingContext(
                         v,
                         item.iter.list.get(item.iter.cur_filters).collect()
                     ),
-                    SpecificDisplayItem::PopStackingContext => PopStackingContext,
-                    SpecificDisplayItem::SetGradientStops => SetGradientStops(
+                    di::SpecificDisplayItem::PopStackingContext => PopStackingContext,
+                    di::SpecificDisplayItem::SetGradientStops => SetGradientStops(
                         item.iter.list.get(item.iter.cur_stops).collect()
                     ),
-                    SpecificDisplayItem::PushShadow(v) => PushShadow(v),
-                    SpecificDisplayItem::PopAllShadows => PopAllShadows,
-                    SpecificDisplayItem::PushCacheMarker(m) => PushCacheMarker(m),
-                    SpecificDisplayItem::PopCacheMarker => PopCacheMarker,
+                    di::SpecificDisplayItem::PushShadow(v) => PushShadow(v),
+                    di::SpecificDisplayItem::PopAllShadows => PopAllShadows,
+                    di::SpecificDisplayItem::PushCacheMarker(m) => PushCacheMarker(m),
+                    di::SpecificDisplayItem::PopCacheMarker => PopCacheMarker,
                 },
                 layout: display_item.layout,
                 space_and_clip: display_item.space_and_clip,
@@ -534,63 +530,63 @@ impl<'de> Deserialize<'de> for BuiltDisplayList {
         let mut total_clip_nodes = FIRST_CLIP_NODE_INDEX;
         let mut total_spatial_nodes = FIRST_SPATIAL_NODE_INDEX;
         for complete in list {
-            let item = DisplayItem {
+            let item = di::DisplayItem {
                 item: match complete.item {
                     Clip(specific_item, complex_clips) => {
                         total_clip_nodes += 1;
                         DisplayListBuilder::push_iter_impl(&mut temp, complex_clips);
-                        SpecificDisplayItem::Clip(specific_item)
+                        di::SpecificDisplayItem::Clip(specific_item)
                     },
                     ClipChain(specific_item, clip_chain_ids) => {
                         DisplayListBuilder::push_iter_impl(&mut temp, clip_chain_ids);
-                        SpecificDisplayItem::ClipChain(specific_item)
+                        di::SpecificDisplayItem::ClipChain(specific_item)
                     }
                     ScrollFrame(specific_item, complex_clips) => {
                         total_spatial_nodes += 1;
                         total_clip_nodes += 1;
                         DisplayListBuilder::push_iter_impl(&mut temp, complex_clips);
-                        SpecificDisplayItem::ScrollFrame(specific_item)
+                        di::SpecificDisplayItem::ScrollFrame(specific_item)
                     }
                     StickyFrame(specific_item) => {
                         total_spatial_nodes += 1;
-                        SpecificDisplayItem::StickyFrame(specific_item)
+                        di::SpecificDisplayItem::StickyFrame(specific_item)
                     }
-                    Rectangle(specific_item) => SpecificDisplayItem::Rectangle(specific_item),
-                    ClearRectangle => SpecificDisplayItem::ClearRectangle,
-                    Line(specific_item) => SpecificDisplayItem::Line(specific_item),
+                    Rectangle(specific_item) => di::SpecificDisplayItem::Rectangle(specific_item),
+                    ClearRectangle => di::SpecificDisplayItem::ClearRectangle,
+                    Line(specific_item) => di::SpecificDisplayItem::Line(specific_item),
                     Text(specific_item, glyphs) => {
                         DisplayListBuilder::push_iter_impl(&mut temp, glyphs);
-                        SpecificDisplayItem::Text(specific_item)
+                        di::SpecificDisplayItem::Text(specific_item)
                     },
-                    Image(specific_item) => SpecificDisplayItem::Image(specific_item),
-                    YuvImage(specific_item) => SpecificDisplayItem::YuvImage(specific_item),
-                    Border(specific_item) => SpecificDisplayItem::Border(specific_item),
-                    BoxShadow(specific_item) => SpecificDisplayItem::BoxShadow(specific_item),
-                    Gradient(specific_item) => SpecificDisplayItem::Gradient(specific_item),
+                    Image(specific_item) => di::SpecificDisplayItem::Image(specific_item),
+                    YuvImage(specific_item) => di::SpecificDisplayItem::YuvImage(specific_item),
+                    Border(specific_item) => di::SpecificDisplayItem::Border(specific_item),
+                    BoxShadow(specific_item) => di::SpecificDisplayItem::BoxShadow(specific_item),
+                    Gradient(specific_item) => di::SpecificDisplayItem::Gradient(specific_item),
                     RadialGradient(specific_item) =>
-                        SpecificDisplayItem::RadialGradient(specific_item),
+                        di::SpecificDisplayItem::RadialGradient(specific_item),
                     Iframe(specific_item) => {
                         total_clip_nodes += 1;
-                        SpecificDisplayItem::Iframe(specific_item)
+                        di::SpecificDisplayItem::Iframe(specific_item)
                     }
                     PushReferenceFrame(v) => {
                         total_spatial_nodes += 1;
-                        SpecificDisplayItem::PushReferenceFrame(v)
+                        di::SpecificDisplayItem::PushReferenceFrame(v)
                     }
-                    PopReferenceFrame => SpecificDisplayItem::PopReferenceFrame,
+                    PopReferenceFrame => di::SpecificDisplayItem::PopReferenceFrame,
                     PushStackingContext(specific_item, filters) => {
                         DisplayListBuilder::push_iter_impl(&mut temp, filters);
-                        SpecificDisplayItem::PushStackingContext(specific_item)
+                        di::SpecificDisplayItem::PushStackingContext(specific_item)
                     },
-                    PopStackingContext => SpecificDisplayItem::PopStackingContext,
+                    PopStackingContext => di::SpecificDisplayItem::PopStackingContext,
                     SetGradientStops(stops) => {
                         DisplayListBuilder::push_iter_impl(&mut temp, stops);
-                        SpecificDisplayItem::SetGradientStops
+                        di::SpecificDisplayItem::SetGradientStops
                     },
-                    PushShadow(specific_item) => SpecificDisplayItem::PushShadow(specific_item),
-                    PopAllShadows => SpecificDisplayItem::PopAllShadows,
-                    PushCacheMarker(marker) => SpecificDisplayItem::PushCacheMarker(marker),
-                    PopCacheMarker => SpecificDisplayItem::PopCacheMarker,
+                    PushShadow(specific_item) => di::SpecificDisplayItem::PushShadow(specific_item),
+                    PopAllShadows => di::SpecificDisplayItem::PopAllShadows,
+                    PushCacheMarker(marker) => di::SpecificDisplayItem::PushCacheMarker(marker),
+                    PopCacheMarker => di::SpecificDisplayItem::PopCacheMarker,
                 },
                 layout: complete.layout,
                 space_and_clip: complete.space_and_clip,
@@ -964,13 +960,13 @@ impl DisplayListBuilder {
     #[inline]
     pub fn push_item(
         &mut self,
-        item: &SpecificDisplayItem,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        item: &di::SpecificDisplayItem,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
     ) {
         serialize_fast(
             &mut self.data,
-            SerializedDisplayItem {
+            di::SerializedDisplayItem {
                 item,
                 layout,
                 space_and_clip,
@@ -979,12 +975,12 @@ impl DisplayListBuilder {
     }
 
     #[inline]
-    fn push_new_empty_item(&mut self, item: &SpecificDisplayItem) {
+    fn push_new_empty_item(&mut self, item: &di::SpecificDisplayItem) {
         let pipeline_id = self.pipeline_id;
         self.push_item(
             item,
-            &LayoutPrimitiveInfo::new(LayoutRect::zero()),
-            &SpaceAndClipInfo::root_scroll(pipeline_id),
+            &di::LayoutPrimitiveInfo::new(LayoutRect::zero()),
+            &di::SpaceAndClipInfo::root_scroll(pipeline_id),
         )
     }
 
@@ -1035,32 +1031,32 @@ impl DisplayListBuilder {
 
     pub fn push_rect(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
         color: ColorF,
     ) {
-        let item = SpecificDisplayItem::Rectangle(RectangleDisplayItem { color });
+        let item = di::SpecificDisplayItem::Rectangle(di::RectangleDisplayItem { color });
         self.push_item(&item, layout, space_and_clip);
     }
 
     pub fn push_clear_rect(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
     ) {
-        self.push_item(&SpecificDisplayItem::ClearRectangle, layout, space_and_clip);
+        self.push_item(&di::SpecificDisplayItem::ClearRectangle, layout, space_and_clip);
     }
 
     pub fn push_line(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
         wavy_line_thickness: f32,
-        orientation: LineOrientation,
+        orientation: di::LineOrientation,
         color: &ColorF,
-        style: LineStyle,
+        style: di::LineStyle,
     ) {
-        let item = SpecificDisplayItem::Line(LineDisplayItem {
+        let item = di::SpecificDisplayItem::Line(di::LineDisplayItem {
             wavy_line_thickness,
             orientation,
             color: *color,
@@ -1072,16 +1068,16 @@ impl DisplayListBuilder {
 
     pub fn push_image(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
         stretch_size: LayoutSize,
         tile_spacing: LayoutSize,
-        image_rendering: ImageRendering,
-        alpha_type: AlphaType,
+        image_rendering: di::ImageRendering,
+        alpha_type: di::AlphaType,
         key: ImageKey,
         color: ColorF,
     ) {
-        let item = SpecificDisplayItem::Image(ImageDisplayItem {
+        let item = di::SpecificDisplayItem::Image(di::ImageDisplayItem {
             image_key: key,
             stretch_size,
             tile_spacing,
@@ -1096,14 +1092,14 @@ impl DisplayListBuilder {
     /// Push a yuv image. All planar data in yuv image should use the same buffer type.
     pub fn push_yuv_image(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
-        yuv_data: YuvData,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
+        yuv_data: di::YuvData,
         color_depth: ColorDepth,
-        color_space: YuvColorSpace,
-        image_rendering: ImageRendering,
+        color_space: di::YuvColorSpace,
+        image_rendering: di::ImageRendering,
     ) {
-        let item = SpecificDisplayItem::YuvImage(YuvImageDisplayItem {
+        let item = di::SpecificDisplayItem::YuvImage(di::YuvImageDisplayItem {
             yuv_data,
             color_depth,
             color_space,
@@ -1114,14 +1110,14 @@ impl DisplayListBuilder {
 
     pub fn push_text(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
         glyphs: &[GlyphInstance],
         font_key: FontInstanceKey,
         color: ColorF,
         glyph_options: Option<GlyphOptions>,
     ) {
-        let item = SpecificDisplayItem::Text(TextDisplayItem {
+        let item = di::SpecificDisplayItem::Text(di::TextDisplayItem {
             color,
             font_key,
             glyph_options,
@@ -1139,9 +1135,9 @@ impl DisplayListBuilder {
         &mut self,
         start_point: LayoutPoint,
         end_point: LayoutPoint,
-        stops: Vec<GradientStop>,
-        extend_mode: ExtendMode,
-    ) -> Gradient {
+        stops: Vec<di::GradientStop>,
+        extend_mode: di::ExtendMode,
+    ) -> di::Gradient {
         let mut builder = GradientBuilder::with_stops(stops);
         let gradient = builder.gradient(start_point, end_point, extend_mode);
         self.push_stops(builder.stops());
@@ -1154,9 +1150,9 @@ impl DisplayListBuilder {
         &mut self,
         center: LayoutPoint,
         radius: LayoutSize,
-        stops: Vec<GradientStop>,
-        extend_mode: ExtendMode,
-    ) -> RadialGradient {
+        stops: Vec<di::GradientStop>,
+        extend_mode: di::ExtendMode,
+    ) -> di::RadialGradient {
         let mut builder = GradientBuilder::with_stops(stops);
         let gradient = builder.radial_gradient(center, radius, extend_mode);
         self.push_stops(builder.stops());
@@ -1165,29 +1161,29 @@ impl DisplayListBuilder {
 
     pub fn push_border(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
         widths: LayoutSideOffsets,
-        details: BorderDetails,
+        details: di::BorderDetails,
     ) {
-        let item = SpecificDisplayItem::Border(BorderDisplayItem { details, widths });
+        let item = di::SpecificDisplayItem::Border(di::BorderDisplayItem { details, widths });
 
         self.push_item(&item, layout, space_and_clip);
     }
 
     pub fn push_box_shadow(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
         box_bounds: LayoutRect,
         offset: LayoutVector2D,
         color: ColorF,
         blur_radius: f32,
         spread_radius: f32,
-        border_radius: BorderRadius,
-        clip_mode: BoxShadowClipMode,
+        border_radius: di::BorderRadius,
+        clip_mode: di::BoxShadowClipMode,
     ) {
-        let item = SpecificDisplayItem::BoxShadow(BoxShadowDisplayItem {
+        let item = di::SpecificDisplayItem::BoxShadow(di::BoxShadowDisplayItem {
             box_bounds,
             offset,
             color,
@@ -1216,13 +1212,13 @@ impl DisplayListBuilder {
     /// The gradient is only visible within the local clip.
     pub fn push_gradient(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
-        gradient: Gradient,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
+        gradient: di::Gradient,
         tile_size: LayoutSize,
         tile_spacing: LayoutSize,
     ) {
-        let item = SpecificDisplayItem::Gradient(GradientDisplayItem {
+        let item = di::SpecificDisplayItem::Gradient(di::GradientDisplayItem {
             gradient,
             tile_size,
             tile_spacing,
@@ -1236,13 +1232,13 @@ impl DisplayListBuilder {
     /// See [`push_gradient`](#method.push_gradient) for explanation.
     pub fn push_radial_gradient(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
-        gradient: RadialGradient,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
+        gradient: di::RadialGradient,
         tile_size: LayoutSize,
         tile_spacing: LayoutSize,
     ) {
-        let item = SpecificDisplayItem::RadialGradient(RadialGradientDisplayItem {
+        let item = di::SpecificDisplayItem::RadialGradient(di::RadialGradientDisplayItem {
             gradient,
             tile_size,
             tile_spacing,
@@ -1254,15 +1250,15 @@ impl DisplayListBuilder {
     pub fn push_reference_frame(
         &mut self,
         rect: &LayoutRect,
-        parent: SpatialId,
-        transform_style: TransformStyle,
+        parent: di::SpatialId,
+        transform_style: di::TransformStyle,
         transform: PropertyBinding<LayoutTransform>,
-        kind: ReferenceFrameKind,
-    ) -> SpatialId {
+        kind: di::ReferenceFrameKind,
+    ) -> di::SpatialId {
         let id = self.generate_spatial_index();
 
-        let item = SpecificDisplayItem::PushReferenceFrame(ReferenceFrameDisplayListItem {
-            reference_frame: ReferenceFrame {
+        let item = di::SpecificDisplayItem::PushReferenceFrame(di::ReferenceFrameDisplayListItem {
+            reference_frame: di::ReferenceFrame {
                 transform_style,
                 transform,
                 kind,
@@ -1270,16 +1266,16 @@ impl DisplayListBuilder {
             },
         });
 
-        let layout = LayoutPrimitiveInfo::new(*rect);
-        self.push_item(&item, &layout, &SpaceAndClipInfo {
+        let layout = di::LayoutPrimitiveInfo::new(*rect);
+        self.push_item(&item, &layout, &di::SpaceAndClipInfo {
             spatial_id: parent,
-            clip_id: ClipId::invalid(),
+            clip_id: di::ClipId::invalid(),
         });
         id
     }
 
     pub fn push_cache_marker(&mut self) {
-        self.push_new_empty_item(&SpecificDisplayItem::PushCacheMarker(CacheMarkerDisplayItem {
+        self.push_new_empty_item(&di::SpecificDisplayItem::PushCacheMarker(di::CacheMarkerDisplayItem {
             // The display item itself is empty for now while we experiment with
             // the API. In future it may contain extra information, such as details
             // on whether the surface is known to be opaque and/or a background color
@@ -1288,26 +1284,26 @@ impl DisplayListBuilder {
     }
 
     pub fn pop_cache_marker(&mut self) {
-        self.push_new_empty_item(&SpecificDisplayItem::PopCacheMarker);
+        self.push_new_empty_item(&di::SpecificDisplayItem::PopCacheMarker);
     }
 
     pub fn pop_reference_frame(&mut self) {
-        self.push_new_empty_item(&SpecificDisplayItem::PopReferenceFrame);
+        self.push_new_empty_item(&di::SpecificDisplayItem::PopReferenceFrame);
     }
 
     pub fn push_stacking_context(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        spatial_id: SpatialId,
-        clip_id: Option<ClipId>,
-        transform_style: TransformStyle,
-        mix_blend_mode: MixBlendMode,
-        filters: &[FilterOp],
-        raster_space: RasterSpace,
+        layout: &di::LayoutPrimitiveInfo,
+        spatial_id: di::SpatialId,
+        clip_id: Option<di::ClipId>,
+        transform_style: di::TransformStyle,
+        mix_blend_mode: di::MixBlendMode,
+        filters: &[di::FilterOp],
+        raster_space: di::RasterSpace,
         cache_tiles: bool,
     ) {
-        let item = SpecificDisplayItem::PushStackingContext(PushStackingContextDisplayItem {
-            stacking_context: StackingContext {
+        let item = di::SpecificDisplayItem::PushStackingContext(di::PushStackingContextDisplayItem {
+            stacking_context: di::StackingContext {
                 transform_style,
                 mix_blend_mode,
                 clip_id,
@@ -1316,9 +1312,9 @@ impl DisplayListBuilder {
             },
         });
 
-        self.push_item(&item, layout, &SpaceAndClipInfo {
+        self.push_item(&item, layout, &di::SpaceAndClipInfo {
             spatial_id,
-            clip_id: ClipId::invalid(),
+            clip_id: di::ClipId::invalid(),
         });
         self.push_iter(filters);
     }
@@ -1326,8 +1322,8 @@ impl DisplayListBuilder {
     /// Helper for examples/ code.
     pub fn push_simple_stacking_context(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        spatial_id: SpatialId,
+        layout: &di::LayoutPrimitiveInfo,
+        spatial_id: di::SpatialId,
     ) {
         self.push_simple_stacking_context_with_filters(layout, spatial_id, &[]);
     }
@@ -1335,66 +1331,66 @@ impl DisplayListBuilder {
     /// Helper for examples/ code.
     pub fn push_simple_stacking_context_with_filters(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        spatial_id: SpatialId,
-        filters: &[FilterOp],
+        layout: &di::LayoutPrimitiveInfo,
+        spatial_id: di::SpatialId,
+        filters: &[di::FilterOp],
     ) {
         self.push_stacking_context(
             layout,
             spatial_id,
             None,
-            TransformStyle::Flat,
-            MixBlendMode::Normal,
+            di::TransformStyle::Flat,
+            di::MixBlendMode::Normal,
             filters,
-            RasterSpace::Screen,
+            di::RasterSpace::Screen,
             /* cache_tiles = */ false,
         );
     }
 
     pub fn pop_stacking_context(&mut self) {
-        self.push_new_empty_item(&SpecificDisplayItem::PopStackingContext);
+        self.push_new_empty_item(&di::SpecificDisplayItem::PopStackingContext);
     }
 
-    pub fn push_stops(&mut self, stops: &[GradientStop]) {
+    pub fn push_stops(&mut self, stops: &[di::GradientStop]) {
         if stops.is_empty() {
             return;
         }
-        self.push_new_empty_item(&SpecificDisplayItem::SetGradientStops);
+        self.push_new_empty_item(&di::SpecificDisplayItem::SetGradientStops);
         self.push_iter(stops);
     }
 
-    fn generate_clip_index(&mut self) -> ClipId {
+    fn generate_clip_index(&mut self) -> di::ClipId {
         self.next_clip_index += 1;
-        ClipId::Clip(self.next_clip_index - 1, self.pipeline_id)
+        di::ClipId::Clip(self.next_clip_index - 1, self.pipeline_id)
     }
 
-    fn generate_spatial_index(&mut self) -> SpatialId {
+    fn generate_spatial_index(&mut self) -> di::SpatialId {
         self.next_spatial_index += 1;
-        SpatialId::new(self.next_spatial_index - 1, self.pipeline_id)
+        di::SpatialId::new(self.next_spatial_index - 1, self.pipeline_id)
     }
 
-    fn generate_clip_chain_id(&mut self) -> ClipChainId {
+    fn generate_clip_chain_id(&mut self) -> di::ClipChainId {
         self.next_clip_chain_id += 1;
-        ClipChainId(self.next_clip_chain_id - 1, self.pipeline_id)
+        di::ClipChainId(self.next_clip_chain_id - 1, self.pipeline_id)
     }
 
     pub fn define_scroll_frame<I>(
         &mut self,
-        parent_space_and_clip: &SpaceAndClipInfo,
-        external_id: Option<ExternalScrollId>,
+        parent_space_and_clip: &di::SpaceAndClipInfo,
+        external_id: Option<di::ExternalScrollId>,
         content_rect: LayoutRect,
         clip_rect: LayoutRect,
         complex_clips: I,
-        image_mask: Option<ImageMask>,
-        scroll_sensitivity: ScrollSensitivity,
-    ) -> SpaceAndClipInfo
+        image_mask: Option<di::ImageMask>,
+        scroll_sensitivity: di::ScrollSensitivity,
+    ) -> di::SpaceAndClipInfo
     where
-        I: IntoIterator<Item = ComplexClipRegion>,
+        I: IntoIterator<Item = di::ComplexClipRegion>,
         I::IntoIter: ExactSizeIterator + Clone,
     {
         let clip_id = self.generate_clip_index();
         let scroll_frame_id = self.generate_spatial_index();
-        let item = SpecificDisplayItem::ScrollFrame(ScrollFrameDisplayItem {
+        let item = di::SpecificDisplayItem::ScrollFrame(di::ScrollFrameDisplayItem {
             clip_id,
             scroll_frame_id,
             external_id,
@@ -1404,12 +1400,12 @@ impl DisplayListBuilder {
 
         self.push_item(
             &item,
-            &LayoutPrimitiveInfo::with_clip_rect(content_rect, clip_rect),
+            &di::LayoutPrimitiveInfo::with_clip_rect(content_rect, clip_rect),
             parent_space_and_clip,
         );
         self.push_iter(complex_clips);
 
-        SpaceAndClipInfo {
+        di::SpaceAndClipInfo {
             spatial_id: scroll_frame_id,
             clip_id,
         }
@@ -1417,39 +1413,39 @@ impl DisplayListBuilder {
 
     pub fn define_clip_chain<I>(
         &mut self,
-        parent: Option<ClipChainId>,
+        parent: Option<di::ClipChainId>,
         clips: I,
-    ) -> ClipChainId
+    ) -> di::ClipChainId
     where
-        I: IntoIterator<Item = ClipId>,
+        I: IntoIterator<Item = di::ClipId>,
         I::IntoIter: ExactSizeIterator + Clone,
     {
         let id = self.generate_clip_chain_id();
-        self.push_new_empty_item(&SpecificDisplayItem::ClipChain(ClipChainItem { id, parent }));
+        self.push_new_empty_item(&di::SpecificDisplayItem::ClipChain(di::ClipChainItem { id, parent }));
         self.push_iter(clips);
         id
     }
 
     pub fn define_clip<I>(
         &mut self,
-        parent_space_and_clip: &SpaceAndClipInfo,
+        parent_space_and_clip: &di::SpaceAndClipInfo,
         clip_rect: LayoutRect,
         complex_clips: I,
-        image_mask: Option<ImageMask>,
-    ) -> ClipId
+        image_mask: Option<di::ImageMask>,
+    ) -> di::ClipId
     where
-        I: IntoIterator<Item = ComplexClipRegion>,
+        I: IntoIterator<Item = di::ComplexClipRegion>,
         I::IntoIter: ExactSizeIterator + Clone,
     {
         let id = self.generate_clip_index();
-        let item = SpecificDisplayItem::Clip(ClipDisplayItem {
+        let item = di::SpecificDisplayItem::Clip(di::ClipDisplayItem {
             id,
             image_mask,
         });
 
         self.push_item(
             &item,
-            &LayoutPrimitiveInfo::new(clip_rect),
+            &di::LayoutPrimitiveInfo::new(clip_rect),
             parent_space_and_clip,
         );
         self.push_iter(complex_clips);
@@ -1458,15 +1454,15 @@ impl DisplayListBuilder {
 
     pub fn define_sticky_frame(
         &mut self,
-        parent_spatial_id: SpatialId,
+        parent_spatial_id: di::SpatialId,
         frame_rect: LayoutRect,
         margins: SideOffsets2D<Option<f32>>,
-        vertical_offset_bounds: StickyOffsetBounds,
-        horizontal_offset_bounds: StickyOffsetBounds,
+        vertical_offset_bounds: di::StickyOffsetBounds,
+        horizontal_offset_bounds: di::StickyOffsetBounds,
         previously_applied_offset: LayoutVector2D,
-    ) -> SpatialId {
+    ) -> di::SpatialId {
         let id = self.generate_spatial_index();
-        let item = SpecificDisplayItem::StickyFrame(StickyFrameDisplayItem {
+        let item = di::SpecificDisplayItem::StickyFrame(di::StickyFrameDisplayItem {
             id,
             margins,
             vertical_offset_bounds,
@@ -1476,10 +1472,10 @@ impl DisplayListBuilder {
 
         self.push_item(
             &item,
-            &LayoutPrimitiveInfo::new(frame_rect),
-            &SpaceAndClipInfo {
+            &di::LayoutPrimitiveInfo::new(frame_rect),
+            &di::SpaceAndClipInfo {
                 spatial_id: parent_spatial_id,
-                clip_id: ClipId::invalid(),
+                clip_id: di::ClipId::invalid(),
             },
         );
         id
@@ -1487,12 +1483,12 @@ impl DisplayListBuilder {
 
     pub fn push_iframe(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
         pipeline_id: PipelineId,
         ignore_missing_pipeline: bool
     ) {
-        let item = SpecificDisplayItem::Iframe(IframeDisplayItem {
+        let item = di::SpecificDisplayItem::Iframe(di::IframeDisplayItem {
             pipeline_id,
             ignore_missing_pipeline,
         });
@@ -1501,15 +1497,15 @@ impl DisplayListBuilder {
 
     pub fn push_shadow(
         &mut self,
-        layout: &LayoutPrimitiveInfo,
-        space_and_clip: &SpaceAndClipInfo,
-        shadow: Shadow,
+        layout: &di::LayoutPrimitiveInfo,
+        space_and_clip: &di::SpaceAndClipInfo,
+        shadow: di::Shadow,
     ) {
-        self.push_item(&SpecificDisplayItem::PushShadow(shadow), layout, space_and_clip);
+        self.push_item(&di::SpecificDisplayItem::PushShadow(shadow), layout, space_and_clip);
     }
 
     pub fn pop_all_shadows(&mut self) {
-        self.push_new_empty_item(&SpecificDisplayItem::PopAllShadows);
+        self.push_new_empty_item(&di::SpecificDisplayItem::PopAllShadows);
     }
 
     pub fn finalize(self) -> (PipelineId, LayoutSize, BuiltDisplayList) {
diff --git a/gfx/wr/webrender_api/src/font.rs b/gfx/wr/webrender_api/src/font.rs
index f5469ed904fb..557420b41840 100644
--- a/gfx/wr/webrender_api/src/font.rs
+++ b/gfx/wr/webrender_api/src/font.rs
@@ -16,7 +16,10 @@ use std::hash::{Hash, Hasher};
 #[cfg(not(target_os = "macos"))]
 use std::path::PathBuf;
 use std::sync::Arc;
-use {ColorU, IdNamespace, LayoutPoint};
+
+use api::IdNamespace;
+use color::ColorU;
+use units::LayoutPoint;
 
 
 #[cfg(not(target_os = "macos"))]
diff --git a/gfx/wr/webrender_api/src/gradient_builder.rs b/gfx/wr/webrender_api/src/gradient_builder.rs
index 8b9e61d16d11..ef4ab9f8bb07 100644
--- a/gfx/wr/webrender_api/src/gradient_builder.rs
+++ b/gfx/wr/webrender_api/src/gradient_builder.rs
@@ -2,41 +2,42 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use {ExtendMode, Gradient, GradientStop, LayoutPoint, LayoutSize, RadialGradient};
+use display_item as di;
+use units::*;
 
 
 /// Construct a gradient to be used in display lists.
 ///
 /// Each gradient needs at least two stops.
 pub struct GradientBuilder {
-    stops: Vec<GradientStop>,
+    stops: Vec<di::GradientStop>,
 }
 
 impl GradientBuilder {
     /// Create a new gradient builder.
-    pub fn new() -> GradientBuilder {
+    pub fn new() -> Self {
         GradientBuilder {
             stops: Vec::new(),
         }
     }
 
     /// Create a gradient builder with a list of stops.
-    pub fn with_stops(stops: Vec<GradientStop>) -> GradientBuilder {
+    pub fn with_stops(stops: Vec<di::GradientStop>) -> GradientBuilder {
         GradientBuilder { stops }
     }
 
     /// Push an additional stop for the gradient.
-    pub fn push(&mut self, stop: GradientStop) {
+    pub fn push(&mut self, stop: di::GradientStop) {
         self.stops.push(stop);
     }
 
     /// Get a reference to the list of stops.
-    pub fn stops(&self) -> &[GradientStop] {
+    pub fn stops(&self) -> &[di::GradientStop] {
         self.stops.as_ref()
     }
 
     /// Return the gradient stops vector.
-    pub fn into_stops(self) -> Vec<GradientStop> {
+    pub fn into_stops(self) -> Vec<di::GradientStop> {
         self.stops
     }
 
@@ -45,12 +46,12 @@ impl GradientBuilder {
         &mut self,
         start_point: LayoutPoint,
         end_point: LayoutPoint,
-        extend_mode: ExtendMode,
-    ) -> Gradient {
+        extend_mode: di::ExtendMode,
+    ) -> di::Gradient {
         let (start_offset, end_offset) = self.normalize(extend_mode);
         let start_to_end = end_point - start_point;
 
-        Gradient {
+        di::Gradient {
             start_point: start_point + start_to_end * start_offset,
             end_point: start_point + start_to_end * end_offset,
             extend_mode,
@@ -65,8 +66,8 @@ impl GradientBuilder {
         &mut self,
         center: LayoutPoint,
         radius: LayoutSize,
-        extend_mode: ExtendMode,
-    ) -> RadialGradient {
+        extend_mode: di::ExtendMode,
+    ) -> di::RadialGradient {
         if radius.width <= 0.0 || radius.height <= 0.0 {
             // The shader cannot handle a non positive radius. So
             // reuse the stops vector and construct an equivalent
@@ -74,10 +75,10 @@ impl GradientBuilder {
             let last_color = self.stops.last().unwrap().color;
 
             self.stops.clear();
-            self.stops.push(GradientStop { offset: 0.0, color: last_color, });
-            self.stops.push(GradientStop { offset: 1.0, color: last_color, });
+            self.stops.push(di::GradientStop { offset: 0.0, color: last_color, });
+            self.stops.push(di::GradientStop { offset: 1.0, color: last_color, });
 
-            return RadialGradient {
+            return di::RadialGradient {
                 center,
                 radius: LayoutSize::new(1.0, 1.0),
                 start_offset: 0.0,
@@ -89,7 +90,7 @@ impl GradientBuilder {
         let (start_offset, end_offset) =
             self.normalize(extend_mode);
 
-        RadialGradient {
+        di::RadialGradient {
             center,
             radius,
             start_offset,
@@ -105,7 +106,7 @@ impl GradientBuilder {
     /// of the gradient line to where stop[0] and the end of the gradient line
     /// to stop[n-1]. this function adjusts the stops in place, and returns
     /// the amount to adjust the gradient line start and stop.
-    fn normalize(&mut self, extend_mode: ExtendMode) -> (f32, f32) {
+    fn normalize(&mut self, extend_mode: di::ExtendMode) -> (f32, f32) {
         let stops = &mut self.stops;
         assert!(stops.len() >= 2);
 
@@ -129,26 +130,26 @@ impl GradientBuilder {
             stops.clear();
 
             match extend_mode {
-                ExtendMode::Clamp => {
+                di::ExtendMode::Clamp => {
                     // This gradient is two colors split at the offset of the stops,
                     // so create a gradient with two colors split at 0.5 and adjust
                     // the gradient line so 0.5 is at the offset of the stops
-                    stops.push(GradientStop { color: first.color, offset: 0.0, });
-                    stops.push(GradientStop { color: first.color, offset: 0.5, });
-                    stops.push(GradientStop { color: last.color, offset: 0.5, });
-                    stops.push(GradientStop { color: last.color, offset: 1.0, });
+                    stops.push(di::GradientStop { color: first.color, offset: 0.0, });
+                    stops.push(di::GradientStop { color: first.color, offset: 0.5, });
+                    stops.push(di::GradientStop { color: last.color, offset: 0.5, });
+                    stops.push(di::GradientStop { color: last.color, offset: 1.0, });
 
                     let offset = last.offset;
 
                     (offset - 0.5, offset + 0.5)
                 }
-                ExtendMode::Repeat => {
+                di::ExtendMode::Repeat => {
                     // A repeating gradient with stops that are all in the same
                     // position should just display the last color. I believe the
                     // spec says that it should be the average color of the gradient,
                     // but this matches what Gecko and Blink does
-                    stops.push(GradientStop { color: last.color, offset: 0.0, });
-                    stops.push(GradientStop { color: last.color, offset: 1.0, });
+                    stops.push(di::GradientStop { color: last.color, offset: 0.0, });
+                    stops.push(di::GradientStop { color: last.color, offset: 1.0, });
 
                     (0.0, 1.0)
                 }
diff --git a/gfx/wr/webrender_api/src/image.rs b/gfx/wr/webrender_api/src/image.rs
index 6ce0401a1e68..711d9ccddaf4 100644
--- a/gfx/wr/webrender_api/src/image.rs
+++ b/gfx/wr/webrender_api/src/image.rs
@@ -4,14 +4,13 @@
 
 #![deny(missing_docs)]
 
-extern crate serde_bytes;
-
-use font::{FontInstanceKey, FontInstanceData, FontKey, FontTemplate};
-use std::sync::Arc;
-use {DeviceIntPoint, DeviceIntRect, DeviceIntSize, LayoutIntRect};
-use {BlobDirtyRect, IdNamespace, TileOffset, TileSize};
 use euclid::{size2, TypedRect, num::Zero};
 use std::ops::{Add, Sub};
+use std::sync::Arc;
+
+use api::{IdNamespace, TileSize};
+use font::{FontInstanceKey, FontInstanceData, FontKey, FontTemplate};
+use units::*;
 
 /// An opaque identifier describing an image registered with WebRender.
 /// This is used as a handle to reference images, and is used as the
diff --git a/gfx/wr/webrender_api/src/units.rs b/gfx/wr/webrender_api/src/units.rs
index fd9c6f1bc919..642a0b70a3ae 100644
--- a/gfx/wr/webrender_api/src/units.rs
+++ b/gfx/wr/webrender_api/src/units.rs
@@ -16,7 +16,8 @@ use app_units::Au;
 use euclid::{Length, TypedRect, TypedScale, TypedSize2D, TypedTransform3D, TypedTranslation2D};
 use euclid::{TypedPoint2D, TypedPoint3D, TypedVector2D, TypedVector3D, TypedSideOffsets2D};
 use euclid::HomogeneousVector;
-use DirtyRect;
+
+use image::DirtyRect;
 
 /// Geometry in the coordinate system of the render target (screen or intermediate
 /// surface) in physical pixels.