diff --git a/components/layout/block.rs b/components/layout/block.rs
index 2dbcd4f91e5..6db30de9bec 100644
--- a/components/layout/block.rs
+++ b/components/layout/block.rs
@@ -46,7 +46,7 @@ use gfx::display_list::{ClippingRegion, StackingContext};
 use gfx_traits::ScrollRootId;
 use gfx_traits::print_tree::PrintTree;
 use layout_debug;
-use model::{CollapsibleMargins, IntrinsicISizes, MarginCollapseInfo, MaybeAuto};
+use model::{AdjoiningMargins, CollapsibleMargins, IntrinsicISizes, MarginCollapseInfo, MaybeAuto};
 use model::{specified, specified_or_none};
 use sequential;
 use serde::{Serialize, Serializer};
@@ -1887,6 +1887,14 @@ impl Flow for BlockFlow {
             self.fragment.assign_replaced_block_size_if_necessary();
             if !self.base.flags.contains(IS_ABSOLUTELY_POSITIONED) {
                 self.base.position.size.block = self.fragment.border_box.size.block;
+                let mut block_start = AdjoiningMargins::from_margin(self.fragment.margin.block_start);
+                let block_end = AdjoiningMargins::from_margin(self.fragment.margin.block_end);
+                if self.fragment.border_box.size.block == Au(0) {
+                    block_start.union(block_end);
+                    self.base.collapsible_margins = CollapsibleMargins::CollapseThrough(block_start);
+                } else {
+                    self.base.collapsible_margins = CollapsibleMargins::Collapse(block_start, block_end);
+                }
                 self.base.restyle_damage.remove(REFLOW_OUT_OF_FLOW | REFLOW);
                 self.fragment.restyle_damage.remove(REFLOW_OUT_OF_FLOW | REFLOW);
             }
diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs
index 0c34a147655..60b1ecedc19 100644
--- a/components/layout/display_list_builder.rs
+++ b/components/layout/display_list_builder.rs
@@ -1489,57 +1489,51 @@ impl FragmentDisplayListBuilding for Fragment {
                 }
             }
             SpecificFragmentInfo::Canvas(ref canvas_fragment_info) => {
-                let width = canvas_fragment_info.replaced_image_fragment_info
-                    .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);
-                if width > 0 && height > 0 {
-                    let computed_width = canvas_fragment_info.canvas_inline_size().to_px();
-                    let computed_height = canvas_fragment_info.canvas_block_size().to_px();
+                let computed_width = canvas_fragment_info.dom_width.to_px();
+                let computed_height = canvas_fragment_info.dom_height.to_px();
 
-                    let canvas_data = match canvas_fragment_info.ipc_renderer {
-                        Some(ref ipc_renderer) => {
-                            let ipc_renderer = ipc_renderer.lock().unwrap();
-                            let (sender, receiver) = ipc::channel().unwrap();
-                            ipc_renderer.send(CanvasMsg::FromLayout(
-                                FromLayoutMsg::SendData(sender))).unwrap();
-                            receiver.recv().unwrap()
-                        },
-                        None => return,
-                    };
+                let canvas_data = match canvas_fragment_info.ipc_renderer {
+                    Some(ref ipc_renderer) => {
+                        let ipc_renderer = ipc_renderer.lock().unwrap();
+                        let (sender, receiver) = ipc::channel().unwrap();
+                        ipc_renderer.send(CanvasMsg::FromLayout(
+                            FromLayoutMsg::SendData(sender))).unwrap();
+                        receiver.recv().unwrap()
+                    },
+                    None => return,
+                };
 
-                    let base = state.create_base_display_item(
-                        &stacking_relative_content_box,
-                        clip,
-                        self.node,
-                        self.style.get_cursor(Cursor::Default),
-                        DisplayListSection::Content);
-                    let display_item = match canvas_data {
-                        CanvasData::Image(canvas_data) => {
-                            DisplayItem::Image(box ImageDisplayItem {
-                                base: base,
-                                webrender_image: WebRenderImageInfo {
-                                    width: computed_width as u32,
-                                    height: computed_height as u32,
-                                    format: PixelFormat::RGBA8,
-                                    key: Some(canvas_data.image_key),
-                                },
-                                image_data: None,
-                                stretch_size: stacking_relative_content_box.size,
-                                tile_spacing: Size2D::zero(),
-                                image_rendering: image_rendering::T::auto,
-                            })
-                        }
-                        CanvasData::WebGL(context_id) => {
-                            DisplayItem::WebGL(box WebGLDisplayItem {
-                                base: base,
-                                context_id: context_id,
-                            })
-                        }
-                    };
+                let base = state.create_base_display_item(
+                    &stacking_relative_content_box,
+                    clip,
+                    self.node,
+                    self.style.get_cursor(Cursor::Default),
+                    DisplayListSection::Content);
+                let display_item = match canvas_data {
+                    CanvasData::Image(canvas_data) => {
+                        DisplayItem::Image(box ImageDisplayItem {
+                            base: base,
+                            webrender_image: WebRenderImageInfo {
+                                width: computed_width as u32,
+                                height: computed_height as u32,
+                                format: PixelFormat::RGBA8,
+                                key: Some(canvas_data.image_key),
+                            },
+                            image_data: None,
+                            stretch_size: stacking_relative_content_box.size,
+                            tile_spacing: Size2D::zero(),
+                            image_rendering: image_rendering::T::auto,
+                        })
+                    }
+                    CanvasData::WebGL(context_id) => {
+                        DisplayItem::WebGL(box WebGLDisplayItem {
+                            base: base,
+                            context_id: context_id,
+                        })
+                    }
+                };
 
-                    state.add_display_item(display_item);
-                }
+                state.add_display_item(display_item);
             }
             SpecificFragmentInfo::UnscannedText(_) => {
                 panic!("Shouldn't see unscanned fragments here.")
diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs
index 593acfb8cd8..e5d86e78ed5 100644
--- a/components/layout/fragment.rs
+++ b/components/layout/fragment.rs
@@ -1990,10 +1990,10 @@ impl Fragment {
             SpecificFragmentInfo::Canvas(_) | SpecificFragmentInfo::Iframe(_) |
             SpecificFragmentInfo::Image(_) | SpecificFragmentInfo::Svg(_) |
             SpecificFragmentInfo::Generic | SpecificFragmentInfo::GeneratedContent(_) => {
-                let ascent = self.border_box.size.block + self.margin.block_start;
+                let ascent = self.border_box.size.block + self.margin.block_end;
                 InlineMetrics {
-                    space_above_baseline: ascent,
-                    space_below_baseline: self.margin.block_end,
+                    space_above_baseline: ascent + self.margin.block_start,
+                    space_below_baseline: Au(0),
                     ascent: ascent,
                 }
             }