diff --git a/components/layout/display_list/builder.rs b/components/layout/display_list/builder.rs
index 9d5f1e100ab..0be8183e2a7 100644
--- a/components/layout/display_list/builder.rs
+++ b/components/layout/display_list/builder.rs
@@ -1571,6 +1571,11 @@ impl Fragment {
             return;
         }
 
+        // If this fragment takes up no space, we don't need to build any display items for it.
+        if self.has_non_invertible_transform() {
+            return;
+        }
+
         debug!(
             "Fragment::build_display_list at rel={:?}, abs={:?}: {:?}",
             self.border_box, stacking_relative_border_box, self
@@ -2376,6 +2381,11 @@ impl BlockFlow {
         state: &mut StackingContextCollectionState,
         flags: StackingContextCollectionFlags,
     ) {
+        // This block flow produces no stacking contexts if it takes up no space.
+        if self.has_non_invertible_transform() {
+            return;
+        }
+
         let mut preserved_state = SavedStackingContextCollectionState::new(state);
 
         let stacking_context_type = self.stacking_context_type(flags);
diff --git a/components/layout/display_list/items.rs b/components/layout/display_list/items.rs
index 27b4ec1fa88..4800abe7e53 100644
--- a/components/layout/display_list/items.rs
+++ b/components/layout/display_list/items.rs
@@ -217,6 +217,12 @@ impl StackingContext {
         parent_clipping_and_scrolling: ClippingAndScrolling,
         established_reference_frame: Option<ClipScrollNodeIndex>,
     ) -> StackingContext {
+        if let Some(ref t) = transform {
+            // These are used as scale values by webrender, and it can't handle
+            // divisors of 0 when scaling.
+            assert_ne!(t.m11, 0.);
+            assert_ne!(t.m22, 0.);
+        }
         StackingContext {
             id,
             context_type,
diff --git a/components/layout/flow.rs b/components/layout/flow.rs
index c2d01b7f9f9..acea20ad4d4 100644
--- a/components/layout/flow.rs
+++ b/components/layout/flow.rs
@@ -273,6 +273,22 @@ pub trait Flow: HasBaseFlow + fmt::Debug + Sync + Send + 'static {
         might_have_floats_in_or_out
     }
 
+    fn has_non_invertible_transform(&self) -> bool {
+        if !self.class().is_block_like() ||
+            self.as_block()
+                .fragment
+                .style
+                .get_box()
+                .transform
+                .0
+                .is_empty()
+        {
+            return false;
+        }
+
+        self.as_block().fragment.has_non_invertible_transform()
+    }
+
     fn get_overflow_in_parent_coordinates(&self) -> Overflow {
         // FIXME(#2795): Get the real container size.
         let container_size = Size2D::zero();
@@ -1160,7 +1176,9 @@ impl BaseFlow {
         state: &mut StackingContextCollectionState,
     ) {
         for kid in self.children.iter_mut() {
-            kid.collect_stacking_contexts(state);
+            if !kid.has_non_invertible_transform() {
+                kid.collect_stacking_contexts(state);
+            }
         }
     }
 
diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs
index 062db9c0a7e..10c0fb072cc 100644
--- a/components/layout/fragment.rs
+++ b/components/layout/fragment.rs
@@ -2730,6 +2730,12 @@ impl Fragment {
             self.style().get_box().perspective != Perspective::None
     }
 
+    /// Returns true if this fragment has a transform applied that causes it to take up no space.
+    pub fn has_non_invertible_transform(&self) -> bool {
+        self.transform_matrix(&Rect::default())
+            .map_or(false, |matrix| !matrix.is_invertible())
+    }
+
     /// Returns true if this fragment establishes a new stacking context and false otherwise.
     pub fn establishes_stacking_context(&self) -> bool {
         // Text fragments shouldn't create stacking contexts.
diff --git a/components/layout/inline.rs b/components/layout/inline.rs
index dfdb20e309b..ee9980c4f1a 100644
--- a/components/layout/inline.rs
+++ b/components/layout/inline.rs
@@ -1871,6 +1871,11 @@ impl Flow for InlineFlow {
         let previous_cb_clipping_and_scrolling = state.containing_block_clipping_and_scrolling;
 
         for fragment in self.fragments.fragments.iter_mut() {
+            // If a particular fragment would establish a stacking context but has a transform
+            // applied that causes it to take up no space, we can skip it entirely.
+            if fragment.has_non_invertible_transform() {
+                continue;
+            }
             state.containing_block_clipping_and_scrolling = previous_cb_clipping_and_scrolling;
 
             let abspos_containing_block = fragment.style.get_box().position != Position::Static;
diff --git a/components/layout/traversal.rs b/components/layout/traversal.rs
index 88a6514433b..5c66004bc1a 100644
--- a/components/layout/traversal.rs
+++ b/components/layout/traversal.rs
@@ -346,6 +346,10 @@ pub struct BuildDisplayList<'a> {
 impl<'a> BuildDisplayList<'a> {
     #[inline]
     pub fn traverse(&mut self, flow: &mut dyn Flow) {
+        if flow.has_non_invertible_transform() {
+            return;
+        }
+
         let parent_stacking_context_id = self.state.current_stacking_context_id;
         self.state.current_stacking_context_id = flow.base().stacking_context_id;