diff --git a/direct-composition/src/main_windows.rs b/direct-composition/src/main_windows.rs
index 899635be96..889b2a359b 100644
--- a/direct-composition/src/main_windows.rs
+++ b/direct-composition/src/main_windows.rs
@@ -131,15 +131,7 @@ impl Rectangle {
         let mut builder = api::DisplayListBuilder::new(pipeline_id, layout_size);
 
         let rect = euclid::TypedRect::new(euclid::TypedPoint2D::zero(), layout_size);
-        builder.push_rect(
-            &api::PrimitiveInfo::with_clip(
-                rect,
-                api::LocalClip::RoundedRect(rect, api::ComplexClipRegion::new(
-                    rect, api::BorderRadius::uniform(20.), api::ClipMode::Clip,
-                ))
-            ),
-            self.color,
-        );
+        builder.push_rect(&api::PrimitiveInfo::new(rect), self.color);
 
         let mut transaction = api::Transaction::new();
         transaction.set_display_list(
diff --git a/webrender/examples/alpha_perf.rs b/webrender/examples/alpha_perf.rs
index 48d978373d..e692690f82 100644
--- a/webrender/examples/alpha_perf.rs
+++ b/webrender/examples/alpha_perf.rs
@@ -29,10 +29,7 @@ impl Example for App {
         _document_id: DocumentId,
     ) {
         let bounds = (0, 0).to(1920, 1080);
-        let info = LayoutPrimitiveInfo {
-            local_clip: LocalClip::Rect(bounds),
-            .. LayoutPrimitiveInfo::new(bounds)
-        };
+        let info = LayoutPrimitiveInfo::new(bounds);
 
         builder.push_stacking_context(
             &info,
diff --git a/webrender/examples/animation.rs b/webrender/examples/animation.rs
index 68270cc31c..3a848c75e0 100644
--- a/webrender/examples/animation.rs
+++ b/webrender/examples/animation.rs
@@ -41,20 +41,12 @@ impl Example for App {
     ) {
         // Create a 200x200 stacking context with an animated transform property.
         let bounds = (0, 0).to(200, 200);
-        let complex_clip = ComplexClipRegion {
-            rect: bounds,
-            radii: BorderRadius::uniform(50.0),
-            mode: ClipMode::Clip,
-        };
-        let info = LayoutPrimitiveInfo {
-            local_clip: LocalClip::RoundedRect(bounds, complex_clip),
-            .. LayoutPrimitiveInfo::new(bounds)
-        };
 
         let filters = vec![
             FilterOp::Opacity(PropertyBinding::Binding(self.opacity_key), self.opacity),
         ];
 
+        let info = LayoutPrimitiveInfo::new(bounds);
         builder.push_stacking_context(
             &info,
             ScrollPolicy::Scrollable,
@@ -65,9 +57,19 @@ impl Example for App {
             filters,
         );
 
+        let complex_clip = ComplexClipRegion {
+            rect: bounds,
+            radii: BorderRadius::uniform(50.0),
+            mode: ClipMode::Clip,
+        };
+        let clip_id = builder.define_clip(bounds, vec![complex_clip], None);
+        builder.push_clip_id(clip_id);
+
         // Fill it with a white rect
         builder.push_rect(&info, ColorF::new(0.0, 1.0, 0.0, 1.0));
 
+        builder.pop_clip_id();
+
         builder.pop_stacking_context();
     }
 
diff --git a/webrender/src/box_shadow.rs b/webrender/src/box_shadow.rs
index e604641bf9..3b3444fcfb 100644
--- a/webrender/src/box_shadow.rs
+++ b/webrender/src/box_shadow.rs
@@ -2,9 +2,8 @@
  * 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 api::{BorderRadius, BoxShadowClipMode, ClipMode, ColorF, ComplexClipRegion};
-use api::{LayerPrimitiveInfo, LayerRect, LayerSize, LayerVector2D, LayoutSize, LocalClip};
-use api::{DeviceIntSize};
+use api::{BorderRadius, BoxShadowClipMode, ClipMode, ColorF, DeviceIntSize, LayerPrimitiveInfo};
+use api::{LayerRect, LayerSize, LayerVector2D, LayoutSize};
 use clip::ClipSource;
 use display_list_flattener::DisplayListFlattener;
 use gpu_cache::GpuCacheHandle;
@@ -113,9 +112,7 @@ impl<'a> DisplayListFlattener<'a> {
             }
 
             let mut clips = Vec::with_capacity(2);
-            clips.push(ClipSource::Rectangle(*prim_info.local_clip.clip_rect()));
-
-            let fast_info = match clip_mode {
+            let (final_prim_rect, clip_radius) = match clip_mode {
                 BoxShadowClipMode::Outset => {
                     if !shadow_rect.is_well_formed_and_nonempty() {
                         return;
@@ -128,17 +125,7 @@ impl<'a> DisplayListFlattener<'a> {
                         ClipMode::ClipOut
                     ));
 
-                    LayerPrimitiveInfo::with_clip(
-                        shadow_rect,
-                        LocalClip::RoundedRect(
-                            shadow_rect,
-                            ComplexClipRegion::new(
-                                shadow_rect,
-                                shadow_radius,
-                                ClipMode::Clip,
-                            ),
-                        ),
-                    )
+                    (shadow_rect, shadow_radius)
                 }
                 BoxShadowClipMode::Inset => {
                     if shadow_rect.is_well_formed_and_nonempty() {
@@ -149,23 +136,15 @@ impl<'a> DisplayListFlattener<'a> {
                         ));
                     }
 
-                    LayerPrimitiveInfo::with_clip(
-                        prim_info.rect,
-                        LocalClip::RoundedRect(
-                            prim_info.rect,
-                            ComplexClipRegion::new(
-                                prim_info.rect,
-                                border_radius,
-                                ClipMode::Clip
-                            ),
-                        ),
-                    )
+                    (prim_info.rect, border_radius)
                 }
             };
 
+            clips.push(ClipSource::new_rounded_rect(final_prim_rect, clip_radius, ClipMode::Clip));
+
             self.add_primitive(
                 clip_and_scroll,
-                &fast_info,
+                &LayerPrimitiveInfo::with_clip_rect(final_prim_rect, prim_info.clip_rect),
                 clips,
                 PrimitiveContainer::Brush(
                     BrushPrimitive::new(BrushKind::Solid {
@@ -222,10 +201,7 @@ impl<'a> DisplayListFlattener<'a> {
 
                     // Outset shadows are expanded by the shadow
                     // region from the original primitive.
-                    LayerPrimitiveInfo::with_clip_rect(
-                        dest_rect,
-                        *prim_info.local_clip.clip_rect()
-                    )
+                    LayerPrimitiveInfo::with_clip_rect(dest_rect, prim_info.clip_rect)
                 }
                 BoxShadowClipMode::Inset => {
                     // If the inner shadow rect contains the prim
diff --git a/webrender/src/clip.rs b/webrender/src/clip.rs
index 68f56ca9fc..e35b8d6dc1 100644
--- a/webrender/src/clip.rs
+++ b/webrender/src/clip.rs
@@ -421,32 +421,11 @@ impl From<LayerRect> for Geometry {
     }
 }
 
-pub trait Contains {
-    fn contains(&self, point: &LayoutPoint) -> bool;
-}
-
-impl Contains for LocalClip {
-    fn contains(&self, point: &LayoutPoint) -> bool {
-        if !self.clip_rect().contains(point) {
-            return false;
-        }
-        match self {
-            &LocalClip::Rect(..) => true,
-            &LocalClip::RoundedRect(_, complex_clip) => complex_clip.contains(point),
-        }
-    }
-}
-
-impl Contains for ComplexClipRegion {
-    fn contains(&self, point: &LayoutPoint) -> bool {
-        rounded_rectangle_contains_point(point, &self.rect, &self.radii)
-    }
-}
-
-pub fn rounded_rectangle_contains_point(point: &LayoutPoint,
-                                        rect: &LayerRect,
-                                        radii: &BorderRadius)
-                                        -> bool {
+pub fn rounded_rectangle_contains_point(
+    point: &LayoutPoint,
+    rect: &LayerRect,
+    radii: &BorderRadius
+) -> bool {
     if !rect.contains(point) {
         return false;
     }
diff --git a/webrender/src/display_list_flattener.rs b/webrender/src/display_list_flattener.rs
index 368ec95fc9..70f8ae8762 100644
--- a/webrender/src/display_list_flattener.rs
+++ b/webrender/src/display_list_flattener.rs
@@ -3,17 +3,16 @@
  * 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 api::{AlphaType, BorderDetails, BorderDisplayItem, BuiltDisplayListIter};
-use api::{ClipAndScrollInfo, ClipId, ColorF, ComplexClipRegion, DeviceIntPoint, DeviceIntRect};
-use api::{DeviceIntSize, DevicePixelScale, DeviceUintRect};
-use api::{DisplayItemRef, Epoch, ExtendMode, ExternalScrollId, FilterOp};
-use api::{FontInstanceKey, FontRenderMode, GlyphInstance, GlyphOptions, GradientStop};
-use api::{IframeDisplayItem, ImageKey, ImageRendering, ItemRange, LayerPoint};
-use api::{LayerPrimitiveInfo, LayerRect, LayerSize, LayerVector2D, LayoutSize, LayoutTransform};
-use api::{LayoutVector2D, LineOrientation, LineStyle, LocalClip, PipelineId};
-use api::{PropertyBinding, RepeatMode, ScrollFrameDisplayItem, ScrollPolicy, ScrollSensitivity};
-use api::{Shadow, SpecificDisplayItem, StackingContext, StickyFrameDisplayItem, TexelRect};
-use api::{TileOffset, TransformStyle, YuvColorSpace, YuvData};
+use api::{AlphaType, BorderDetails, BorderDisplayItem, BuiltDisplayListIter, ClipAndScrollInfo};
+use api::{ClipId, ColorF, ComplexClipRegion, DeviceIntPoint, DeviceIntRect, DeviceIntSize};
+use api::{DevicePixelScale, DeviceUintRect, DisplayItemRef, Epoch, ExtendMode, ExternalScrollId};
+use api::{FilterOp, FontInstanceKey, FontRenderMode, GlyphInstance, GlyphOptions, GradientStop};
+use api::{IframeDisplayItem, ImageKey, ImageRendering, ItemRange, LayerPoint, LayerPrimitiveInfo};
+use api::{LayerRect, LayerSize, LayerVector2D, LayoutRect, LayoutSize, LayoutTransform};
+use api::{LayoutVector2D, LineOrientation, LineStyle, LocalClip, PipelineId, PropertyBinding};
+use api::{RepeatMode, ScrollFrameDisplayItem, ScrollPolicy, ScrollSensitivity, Shadow};
+use api::{SpecificDisplayItem, StackingContext, StickyFrameDisplayItem, TexelRect, TileOffset};
+use api::{TransformStyle, YuvColorSpace, YuvData};
 use app_units::Au;
 use border::ImageBorderSegment;
 use clip::{ClipRegion, ClipSource, ClipSources, ClipStore};
@@ -442,7 +441,7 @@ impl<'a> DisplayListFlattener<'a> {
     ) {
         let complex_clips = self.get_complex_clips(pipeline_id, item.complex_clip().0);
         let clip_region = ClipRegion::create_for_clip_node(
-            *item.local_clip().clip_rect(),
+            *item.clip_rect(),
             complex_clips,
             info.image_mask,
             &reference_frame_relative_offset,
@@ -451,9 +450,7 @@ impl<'a> DisplayListFlattener<'a> {
         // This is useful when calculating scroll extents for the
         // ClipScrollNode::scroll(..) API as well as for properly setting sticky
         // positioning offsets.
-        let frame_rect = item.local_clip()
-            .clip_rect()
-            .translate(&reference_frame_relative_offset);
+        let frame_rect = item.clip_rect().translate(&reference_frame_relative_offset);
         let content_rect = item.rect().translate(&reference_frame_relative_offset);
 
         debug_assert!(info.clip_id != info.scroll_frame_id);
@@ -584,7 +581,7 @@ impl<'a> DisplayListFlattener<'a> {
             info.clip_id,
             clip_and_scroll_ids.scroll_node_id,
             ClipRegion::create_for_clip_node_with_local_clip(
-                &item.local_clip(),
+                &LocalClip::from(*item.clip_rect()),
                 &reference_frame_relative_offset
             ),
         );
@@ -804,7 +801,7 @@ impl<'a> DisplayListFlattener<'a> {
             SpecificDisplayItem::Clip(ref info) => {
                 let complex_clips = self.get_complex_clips(pipeline_id, item.complex_clip().0);
                 let clip_region = ClipRegion::create_for_clip_node(
-                    *item.local_clip().clip_rect(),
+                    *item.clip_rect(),
                     complex_clips,
                     info.image_mask,
                     &reference_frame_relative_offset,
@@ -867,19 +864,9 @@ impl<'a> DisplayListFlattener<'a> {
     pub fn create_primitive(
         &mut self,
         info: &LayerPrimitiveInfo,
-        mut clip_sources: Vec<ClipSource>,
+        clip_sources: Vec<ClipSource>,
         container: PrimitiveContainer,
     ) -> PrimitiveIndex {
-        if let &LocalClip::RoundedRect(main, region) = &info.local_clip {
-            clip_sources.push(ClipSource::Rectangle(main));
-
-            clip_sources.push(ClipSource::new_rounded_rect(
-                region.rect,
-                region.radii,
-                region.mode,
-            ));
-        }
-
         let stacking_context = self.sc_stack.last().expect("bug: no stacking context!");
 
         let clip_sources = if clip_sources.is_empty() {
@@ -890,7 +877,7 @@ impl<'a> DisplayListFlattener<'a> {
 
         let prim_index = self.prim_store.add_primitive(
             &info.rect,
-            &info.local_clip.clip_rect(),
+            &info.clip_rect,
             info.is_backface_visible && stacking_context.is_backface_visible,
             clip_sources,
             info.tag,
@@ -1570,8 +1557,7 @@ impl<'a> DisplayListFlattener<'a> {
             );
             let mut info = info.clone();
             info.rect = info.rect.translate(&shadow_offset);
-            info.local_clip =
-              LocalClip::from(info.local_clip.clip_rect().translate(&shadow_offset));
+            info.clip_rect = info.clip_rect.translate(&shadow_offset);
             let prim_index = self.create_primitive(
                 &info,
                 Vec::new(),
@@ -2164,8 +2150,7 @@ impl<'a> DisplayListFlattener<'a> {
             let rect = info.rect;
             let mut info = info.clone();
             info.rect = rect.translate(&text_prim.offset);
-            info.local_clip =
-              LocalClip::from(info.local_clip.clip_rect().translate(&text_prim.offset));
+            info.clip_rect = info.clip_rect.translate(&text_prim.offset);
             let prim_index = self.create_primitive(
                 &info,
                 Vec::new(),
@@ -2383,7 +2368,9 @@ impl PrimitiveInfoTiler for LayerPrimitiveInfo {
 
         if tile_repeat.width < self.rect.size.width ||
            tile_repeat.height < self.rect.size.height {
-            let local_clip = self.local_clip.clip_by(&self.rect);
+            let clip_rect = self.clip_rect
+                .intersection(&self.rect)
+                .unwrap_or_else(LayoutRect::zero);
             let rect_p0 = self.rect.origin;
             let rect_p1 = self.rect.bottom_right();
 
@@ -2397,7 +2384,7 @@ impl PrimitiveInfoTiler for LayerPrimitiveInfo {
                             LayerPoint::new(x0, y0),
                             tile_size,
                         ),
-                        local_clip,
+                        clip_rect,
                         is_backface_visible: self.is_backface_visible,
                         tag: self.tag,
                     });
diff --git a/webrender/src/hit_test.rs b/webrender/src/hit_test.rs
index e396280060..8e5fb18629 100644
--- a/webrender/src/hit_test.rs
+++ b/webrender/src/hit_test.rs
@@ -3,8 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use api::{BorderRadius, ClipMode, HitTestFlags, HitTestItem, HitTestResult, ItemTag, LayerPoint};
-use api::{LayerPrimitiveInfo, LayerRect, LocalClip, PipelineId, WorldPoint};
-use clip::{ClipSource, ClipStore, Contains, rounded_rectangle_contains_point};
+use api::{LayerPrimitiveInfo, LayerRect, PipelineId, WorldPoint};
+use clip::{ClipSource, ClipStore, rounded_rectangle_contains_point};
 use clip_scroll_node::{ClipScrollNode, NodeType};
 use clip_scroll_tree::{ClipChainIndex, ClipScrollNodeIndex, ClipScrollTree};
 use internal_types::FastHashMap;
@@ -55,7 +55,7 @@ impl HitTestClipChainDescriptor {
 #[derive(Clone)]
 pub struct HitTestingItem {
     rect: LayerRect,
-    clip: LocalClip,
+    clip_rect: LayerRect,
     tag: ItemTag,
 }
 
@@ -63,7 +63,7 @@ impl HitTestingItem {
     pub fn new(tag: ItemTag, info: &LayerPrimitiveInfo) -> HitTestingItem {
         HitTestingItem {
             rect: info.rect,
-            clip: info.local_clip,
+            clip_rect: info.clip_rect,
             tag: tag,
         }
     }
@@ -239,7 +239,8 @@ impl HitTester {
 
             let mut clipped_in = false;
             for item in items.iter().rev() {
-                if !item.rect.contains(&point_in_layer) || !item.clip.contains(&point_in_layer) {
+                if !item.rect.contains(&point_in_layer) ||
+                    !item.clip_rect.contains(&point_in_layer) {
                     continue;
                 }
 
diff --git a/webrender_api/src/display_item.rs b/webrender_api/src/display_item.rs
index b304d25036..920a774526 100644
--- a/webrender_api/src/display_item.rs
+++ b/webrender_api/src/display_item.rs
@@ -64,7 +64,7 @@ pub type DisplayItem = GenericDisplayItem<SpecificDisplayItem>;
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
 pub struct PrimitiveInfo<T> {
     pub rect: TypedRect<f32, T>,
-    pub local_clip: LocalClip,
+    pub clip_rect: TypedRect<f32, T>,
     pub is_backface_visible: bool,
     pub tag: Option<ItemTag>,
 }
@@ -78,13 +78,9 @@ impl LayerPrimitiveInfo {
         rect: TypedRect<f32, LayerPixel>,
         clip_rect: TypedRect<f32, LayerPixel>,
     ) -> Self {
-        Self::with_clip(rect, LocalClip::from(clip_rect))
-    }
-
-    pub fn with_clip(rect: TypedRect<f32, LayerPixel>, clip: LocalClip) -> Self {
         PrimitiveInfo {
-            rect: rect,
-            local_clip: clip,
+            rect,
+            clip_rect,
             is_backface_visible: true,
             tag: None,
         }
diff --git a/webrender_api/src/display_list.rs b/webrender_api/src/display_list.rs
index eb633655dc..e645899e21 100644
--- a/webrender_api/src/display_list.rs
+++ b/webrender_api/src/display_list.rs
@@ -19,8 +19,8 @@ use {ColorF, ComplexClipRegion, DisplayItem, ExtendMode, ExternalScrollId, Filte
 use {FontInstanceKey, GlyphInstance, GlyphOptions, Gradient, GradientDisplayItem, GradientStop};
 use {IframeDisplayItem, ImageDisplayItem, ImageKey, ImageMask, ImageRendering, LayerPrimitiveInfo};
 use {LayoutPoint, LayoutPrimitiveInfo, LayoutRect, LayoutSize, LayoutTransform, LayoutVector2D};
-use {LineDisplayItem, LineOrientation, LineStyle, LocalClip, MixBlendMode, PipelineId};
-use {PropertyBinding, PushStackingContextDisplayItem, RadialGradient, RadialGradientDisplayItem};
+use {LineDisplayItem, LineOrientation, LineStyle, MixBlendMode, PipelineId, PropertyBinding};
+use {PushStackingContextDisplayItem, RadialGradient, RadialGradientDisplayItem};
 use {RectangleDisplayItem, ScrollFrameDisplayItem, ScrollPolicy, ScrollSensitivity, Shadow};
 use {SpecificDisplayItem, StackingContext, StickyFrameDisplayItem, StickyOffsetBounds};
 use {TextDisplayItem, TransformStyle, YuvColorSpace, YuvData, YuvImageDisplayItem};
@@ -336,14 +336,14 @@ impl<'a, 'b> DisplayItemRef<'a, 'b> {
         let info = self.iter.cur_item.info;
         LayerPrimitiveInfo {
             rect: info.rect.translate(&offset),
-            local_clip: info.local_clip.create_with_offset(offset),
+            clip_rect: info.clip_rect.translate(&offset),
             is_backface_visible: info.is_backface_visible,
             tag: info.tag,
         }
     }
 
-    pub fn local_clip(&self) -> &LocalClip {
-        &self.iter.cur_item.info.local_clip
+    pub fn clip_rect(&self) -> &LayoutRect {
+        &self.iter.cur_item.info.clip_rect
     }
 
     pub fn clip_and_scroll(&self) -> ClipAndScrollInfo {
diff --git a/wrench/src/rawtest.rs b/wrench/src/rawtest.rs
index e76dbe687d..1a03b351fc 100644
--- a/wrench/src/rawtest.rs
+++ b/wrench/src/rawtest.rs
@@ -602,13 +602,6 @@ impl<'a> RawtestHarness<'a> {
             )
         };
 
-        // Add a rounded 100x100 rectangle at 200,0.
-        let rect = LayoutRect::new(LayoutPoint::new(200., 0.), LayoutSize::new(100., 100.));
-        let mut info = LayoutPrimitiveInfo::with_clip(
-            rect, LocalClip::RoundedRect(rect, make_rounded_complex_clip(&rect, 20.)));
-        info.tag = Some((0, 3));
-        builder.push_rect(&info, ColorF::new(1.0, 1.0, 1.0, 1.0));
-
 
         // Add a rectangle that is clipped by a rounded rect clip item.
         let rect = LayoutRect::new(LayoutPoint::new(100., 100.), LayoutSize::new(100., 100.));
@@ -687,7 +680,6 @@ impl<'a> RawtestHarness<'a> {
             assert_hit_test(bottom_right, vec![(0, 1)]);
         };
 
-        test_rounded_rectangle(WorldPoint::new(200., 0.), WorldSize::new(100., 100.), (0, 3));
         test_rounded_rectangle(WorldPoint::new(100., 100.), WorldSize::new(100., 100.), (0, 4));
         test_rounded_rectangle(WorldPoint::new(200., 100.), WorldSize::new(100., 100.), (0, 5));
     }
diff --git a/wrench/src/yaml_frame_reader.rs b/wrench/src/yaml_frame_reader.rs
index cd6c095b82..0296854e29 100644
--- a/wrench/src/yaml_frame_reader.rs
+++ b/wrench/src/yaml_frame_reader.rs
@@ -1257,14 +1257,12 @@ impl YamlFrameReader {
         dl.push_iframe(&info, pipeline_id);
     }
 
-    pub fn get_local_clip_for_item(&mut self, yaml: &Yaml, full_clip: LayoutRect) -> LocalClip {
-        let rect = yaml["clip-rect"].as_rect().unwrap_or(full_clip);
+    pub fn get_complex_clip_for_item(&mut self, yaml: &Yaml) -> Option<ComplexClipRegion> {
         let complex_clip = &yaml["complex-clip"];
-        if !complex_clip.is_badvalue() {
-            LocalClip::RoundedRect(rect, self.to_complex_clip_region(complex_clip))
-        } else {
-            LocalClip::from(rect)
+        if complex_clip.is_badvalue() {
+            return None;
         }
+        Some(self.to_complex_clip_region(complex_clip))
     }
 
     pub fn add_display_list_items_from_yaml(
@@ -1317,8 +1315,23 @@ impl YamlFrameReader {
             if let Some(clip_scroll_info) = clip_scroll_info {
                 dl.push_clip_and_scroll_info(clip_scroll_info);
             }
-            let local_clip = self.get_local_clip_for_item(item, full_clip);
-            let mut info = LayoutPrimitiveInfo::with_clip(LayoutRect::zero(), local_clip);
+
+            let complex_clip = self.get_complex_clip_for_item(item);
+            let clip_rect = item["clip-rect"].as_rect().unwrap_or(full_clip);
+
+            let mut pushed_clip = false;
+            if let Some(complex_clip) = complex_clip {
+                match item_type {
+                    "clip" | "clip-chain" | "scroll-frame" => {},
+                    _ => {
+                        let id = dl.define_clip(clip_rect, vec![complex_clip], None);
+                        dl.push_clip_id(id);
+                        pushed_clip = true;
+                    }
+                }
+            }
+
+            let mut info = LayoutPrimitiveInfo::with_clip_rect(LayoutRect::zero(), clip_rect);
             info.is_backface_visible = item["backface-visible"].as_bool().unwrap_or(true);;
             match item_type {
                 "rect" => self.handle_rect(dl, item, &mut info),
@@ -1344,9 +1357,15 @@ impl YamlFrameReader {
                 _ => println!("Skipping unknown item type: {:?}", item),
             }
 
+            if pushed_clip {
+                dl.pop_clip_id();
+
+            }
+
             if clip_scroll_info.is_some() {
                 dl.pop_clip_id();
             }
+
         }
     }
 
@@ -1435,7 +1454,7 @@ impl YamlFrameReader {
             .as_rect()
             .expect("Text shadows require bounds");
         info.rect = rect;
-        info.local_clip = LocalClip::from(rect);
+        info.clip_rect = rect;
         let blur_radius = yaml["blur-radius"].as_f32().unwrap_or(0.0);
         let offset = yaml["offset"].as_vector().unwrap_or(LayoutVector2D::zero());
         let color = yaml["color"].as_colorf().unwrap_or(*BLACK_COLOR);
@@ -1555,7 +1574,7 @@ impl YamlFrameReader {
 
         let filters = yaml["filters"].as_vec_filter_op().unwrap_or(vec![]);
         info.rect = bounds;
-        info.local_clip = LocalClip::from(bounds);
+        info.clip_rect = bounds;
 
         dl.push_stacking_context(
             &info,
diff --git a/wrench/src/yaml_frame_writer.rs b/wrench/src/yaml_frame_writer.rs
index c3959b9aa8..f24c8da810 100644
--- a/wrench/src/yaml_frame_writer.rs
+++ b/wrench/src/yaml_frame_writer.rs
@@ -665,10 +665,7 @@ impl YamlFrameWriter {
             let mut v = new_table();
             rect_node(&mut v, "bounds", &base.rect());
 
-            rect_node(&mut v, "clip-rect", base.local_clip().clip_rect());
-            if let &LocalClip::RoundedRect(_, ref region) = base.local_clip() {
-                yaml_node(&mut v, "complex-clip", self.make_complex_clip_node(region));
-            }
+            rect_node(&mut v, "clip-rect", base.clip_rect());
 
             let clip_and_scroll_yaml = match clip_id_mapper.map_info(&base.clip_and_scroll()) {
                 (scroll_id, Some(clip_id)) => {
@@ -1034,7 +1031,7 @@ impl YamlFrameWriter {
                     str_node(&mut v, "type", "scroll-frame");
                     usize_node(&mut v, "id", clip_id_mapper.add_id(item.scroll_frame_id));
                     size_node(&mut v, "content-size", &base.rect().size);
-                    rect_node(&mut v, "bounds", &base.local_clip().clip_rect());
+                    rect_node(&mut v, "bounds", &base.clip_rect());
 
                     let (complex_clips, complex_clip_count) = base.complex_clip();
                     if let Some(complex) = self.make_complex_clips_node(
@@ -1052,7 +1049,7 @@ impl YamlFrameWriter {
                 StickyFrame(item) => {
                     str_node(&mut v, "type", "sticky-frame");
                     usize_node(&mut v, "id", clip_id_mapper.add_id(item.id));
-                    rect_node(&mut v, "bounds", &base.local_clip().clip_rect());
+                    rect_node(&mut v, "bounds", &base.clip_rect());
 
                     if let Some(margin) = item.margins.top {
                         f32_node(&mut v, "margin-top", margin);