Merge inbound to mozilla-central. a=merge
authorMargareta Eliza Balazs <ebalazs@mozilla.com>
Fri, 31 Aug 2018 12:23:17 +0300
changeset 434227 ea869706644d3b2354b2438c77671d6e43df5e99
parent 434226 bc7c9760b7d1db79ff9eaefbe17b871a6a50ea65 (current diff)
parent 434224 57f23dc56b70bfb36ef223a87cce2ebc4645a443 (diff)
child 434228 23ac0383d77ecfddb53f46744667f2c7472aaf66
child 434249 2b7a5180b9029914ff6d76e1766088ec55e7dd73
push id68594
push userebalazs@mozilla.com
push dateFri, 31 Aug 2018 09:28:05 +0000
treeherderautoland@23ac0383d77e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone63.0a1
first release with
nightly linux32
ea869706644d / 63.0a1 / 20180831100058 / files
nightly linux64
ea869706644d / 63.0a1 / 20180831100058 / files
nightly mac
ea869706644d / 63.0a1 / 20180831100058 / files
nightly win32
ea869706644d / 63.0a1 / 20180831100058 / files
nightly win64
ea869706644d / 63.0a1 / 20180831100058 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge inbound to mozilla-central. a=merge
testing/web-platform/meta/css/css-transforms/transform3d-preserve3d-011.html.ini
--- a/accessible/generic/Accessible.cpp
+++ b/accessible/generic/Accessible.cpp
@@ -27,17 +27,16 @@
 #include "States.h"
 #include "StyleInfo.h"
 #include "TableAccessible.h"
 #include "TableCellAccessible.h"
 #include "TreeWalker.h"
 #include "XULDocument.h"
 
 #include "nsIDOMXULButtonElement.h"
-#include "nsIDOMXULLabelElement.h"
 #include "nsIDOMXULSelectCntrlEl.h"
 #include "nsIDOMXULSelectCntrlItemEl.h"
 #include "nsINodeList.h"
 #include "nsPIDOMWindow.h"
 
 #include "nsIDocument.h"
 #include "nsIContent.h"
 #include "nsIForm.h"
@@ -818,27 +817,25 @@ Accessible::XULElmName(DocAccessible* aD
       if (!select && aElm->IsElement()) {
         aElm->AsElement()->GetAttribute(NS_LITERAL_STRING("label"), aName);
       }
     }
   }
 
   // CASES #2 and #3 ------ label as a child or <label control="id" ... > </label>
   if (aName.IsEmpty()) {
-    Accessible* labelAcc = nullptr;
+    Accessible* label = nullptr;
     XULLabelIterator iter(aDocument, aElm);
-    while ((labelAcc = iter.Next())) {
-      nsCOMPtr<nsIDOMXULLabelElement> xulLabel =
-        do_QueryInterface(labelAcc->GetContent());
+    while ((label = iter.Next())) {
       // Check if label's value attribute is used
-      if (xulLabel && NS_SUCCEEDED(xulLabel->GetValue(aName)) && aName.IsEmpty()) {
+      label->Elm()->GetAttr(kNameSpaceID_None, nsGkAtoms::value, aName);
+      if (aName.IsEmpty()) {
         // If no value attribute, a non-empty label must contain
         // children that define its text -- possibly using HTML
-        nsTextEquivUtils::
-          AppendTextEquivFromContent(labelAcc, labelAcc->GetContent(), &aName);
+        nsTextEquivUtils::AppendTextEquivFromContent(label, label->Elm(), &aName);
       }
     }
   }
 
   aName.CompressWhitespace();
   if (!aName.IsEmpty())
     return;
 
--- a/accessible/xul/XULElementAccessibles.cpp
+++ b/accessible/xul/XULElementAccessibles.cpp
@@ -15,17 +15,16 @@
 #include "Role.h"
 #include "States.h"
 #include "TextUpdater.h"
 
 #ifdef A11Y_LOG
 #include "Logging.h"
 #endif
 
-#include "nsIDOMXULDescriptionElement.h"
 #include "nsNameSpaceManager.h"
 #include "nsNetUtil.h"
 #include "nsString.h"
 #include "nsTextBoxFrame.h"
 
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
--- a/build/unix/mozconfig.asan
+++ b/build/unix/mozconfig.asan
@@ -1,16 +1,27 @@
 MOZ_AUTOMATION_L10N_CHECK=0
 
-. "$topsrcdir/build/unix/mozconfig.linux"
+. "$topsrcdir/build/mozconfig.common"
+
+# Use Clang as specified in manifest
+export CC="$topsrcdir/clang/bin/clang -fgnu89-inline"
+export CXX="$topsrcdir/clang/bin/clang++"
+export LLVM_SYMBOLIZER="$topsrcdir/clang/bin/llvm-symbolizer"
 
-export LLVM_SYMBOLIZER="$topsrcdir/clang/bin/llvm-symbolizer"
-#
+# Use a newer binutils, if it's there
+if [ -e "$topsrcdir/binutils/bin/ld" ]; then
+    export CC="$CC -B $topsrcdir/binutils/bin"
+    export CXX="$CXX -B $topsrcdir/binutils/bin"
+fi
+
 # Enable ASan specific code and build workarounds
 ac_add_options --enable-address-sanitizer
 
 # Mandatory options required for ASan builds (both on Linux and Mac)
 export MOZ_DEBUG_SYMBOLS=1
 ac_add_options --enable-debug-symbols
 ac_add_options --disable-install-strip
 ac_add_options --disable-jemalloc
 ac_add_options --disable-crashreporter
 ac_add_options --disable-profiling
+
+. "$topsrcdir/build/unix/mozconfig.stdcxx"
--- a/build/unix/mozconfig.lto
+++ b/build/unix/mozconfig.lto
@@ -1,13 +1,24 @@
 MOZ_AUTOMATION_L10N_CHECK=0
 
-. "$topsrcdir/build/unix/mozconfig.linux"
+. "$topsrcdir/build/mozconfig.common"
 
 # Use Clang as specified in manifest
 export AR="$topsrcdir/clang/bin/llvm-ar"
 export NM="$topsrcdir/clang/bin/llvm-nm"
 export RANLIB="$topsrcdir/clang/bin/llvm-ranlib"
 
+export CC="$topsrcdir/clang/bin/clang"
+export CXX="$topsrcdir/clang/bin/clang++"
+
+# Use a newer binutils, if it's there
+if [ -e "$topsrcdir/binutils/bin/ld" ]; then
+    export CC="$CC -B $topsrcdir/binutils/bin"
+    export CXX="$CXX -B $topsrcdir/binutils/bin"
+fi
+
 ac_add_options --enable-lto
 # Until it's either made the default or we figure a way to remove the
 # copy locations that LTO induces in non-PIE executables.
 ac_add_options --enable-pie
+
+. "$topsrcdir/build/unix/mozconfig.stdcxx"
--- a/build/unix/mozconfig.tsan
+++ b/build/unix/mozconfig.tsan
@@ -1,14 +1,23 @@
 MOZ_AUTOMATION_L10N_CHECK=0
 
-. "$topsrcdir/build/unix/mozconfig.linux"
+. "$topsrcdir/build/mozconfig.common"
 
+# Use Clang as specified in manifest
+export CC="$topsrcdir/clang/bin/clang"
+export CXX="$topsrcdir/clang/bin/clang++"
 export LLVM_SYMBOLIZER="$topsrcdir/clang/bin/llvm-symbolizer"
 
+# Use a newer binutils, if it's there
+if [ -e "$topsrcdir/binutils/bin/ld" ]; then
+    export CC="$CC -B $topsrcdir/binutils/bin"
+    export CXX="$CXX -B $topsrcdir/binutils/bin"
+fi
+
 # Enable TSan specific code and build workarounds
 ac_add_options --enable-thread-sanitizer
 
 # The ThreadSanitizer is not compatible with sandboxing
 # (see bug 1182565)
 ac_add_options --disable-sandbox
 
 # These are required by TSan
@@ -16,8 +25,10 @@ ac_add_options --disable-jemalloc
 ac_add_options --disable-crashreporter
 ac_add_options --disable-elf-hack
 ac_add_options --enable-pie
 
 # Keep symbols to symbolize TSan traces
 ac_add_options --disable-install-strip
 # -gline-tables-only results in significantly smaller binaries.
 ac_add_options --enable-debug-symbols="-gline-tables-only"
+
+. "$topsrcdir/build/unix/mozconfig.stdcxx"
--- a/docshell/shistory/nsSHistory.cpp
+++ b/docshell/shistory/nsSHistory.cpp
@@ -722,17 +722,17 @@ nsSHistory::GetEntryAtIndex(int32_t aInd
         NOTIFY_LISTENERS(OnIndexChanged, (mIndex))
       }
     }
   }
   return rv;
 }
 
 /* Get the transaction at a given index */
-nsresult
+NS_IMETHODIMP
 nsSHistory::GetTransactionAtIndex(int32_t aIndex, nsISHTransaction** aResult)
 {
   NS_ENSURE_ARG_POINTER(aResult);
 
   if (aIndex < 0 || aIndex >= Length()) {
     return NS_ERROR_FAILURE;
   }
 
@@ -851,23 +851,21 @@ nsSHistory::PurgeHistory(int32_t aNumEnt
   if (!purgeHistory) {
     // Listener asked us not to purge
     return NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA;
   }
 
   // Remove the first `aNumEntries` entries.
   mTransactions.RemoveElementsAt(0, aNumEntries);
 
+  // Adjust the indices, but don't let them go below -1.
   mIndex -= aNumEntries;
-
-  // Now if we were not at the end of the history, mIndex could have
-  // become far too negative.  If so, just set it to -1.
-  if (mIndex < -1) {
-    mIndex = -1;
-  }
+  mIndex = std::max(mIndex, -1);
+  mRequestedIndex -= aNumEntries;
+  mRequestedIndex = std::max(mRequestedIndex, -1);
 
   NOTIFY_LISTENERS(OnLengthChanged, (Length()));
   NOTIFY_LISTENERS(OnIndexChanged, (mIndex))
 
   if (mRootDocShell) {
     mRootDocShell->HistoryPurged(aNumEntries);
   }
 
--- a/gfx/webrender/src/batch.rs
+++ b/gfx/webrender/src/batch.rs
@@ -1,31 +1,31 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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, ClipMode, DeviceIntRect, DeviceIntSize, DeviceIntPoint};
+use api::{AlphaType, ClipMode, DeviceIntRect, DeviceIntSize};
 use api::{DeviceUintRect, DeviceUintPoint, ExternalImageType, FilterOp, ImageRendering};
-use api::{YuvColorSpace, YuvFormat, WorldPixel};
+use api::{YuvColorSpace, YuvFormat, WorldPixel, WorldRect};
 use clip::{ClipNodeFlags, ClipNodeRange, ClipItem, ClipStore};
 use euclid::vec3;
 use glyph_rasterizer::GlyphFormat;
 use gpu_cache::{GpuCache, GpuCacheHandle, GpuCacheAddress};
 use gpu_types::{BrushFlags, BrushInstance, PrimitiveHeaders};
 use gpu_types::{ClipMaskInstance, SplitCompositeInstance};
 use gpu_types::{PrimitiveInstance, RasterizationSpace, GlyphInstance};
 use gpu_types::{PrimitiveHeader, PrimitiveHeaderIndex, TransformPaletteId, TransformPalette};
 use internal_types::{FastHashMap, SavedTargetIndex, SourceTexture};
 use picture::{PictureCompositeMode, PicturePrimitive, PictureSurface};
 use plane_split::{BspSplitter, Clipper, Polygon, Splitter};
 use prim_store::{BrushKind, BrushPrimitive, BrushSegmentTaskId, DeferredResolve};
 use prim_store::{EdgeAaSegmentMask, ImageSource, PrimitiveIndex};
 use prim_store::{PrimitiveMetadata, PrimitiveRun, VisibleGradientTile};
 use prim_store::{BorderSource, Primitive, PrimitiveDetails};
-use render_task::{RenderTaskAddress, RenderTaskId, RenderTaskKind, RenderTaskTree};
+use render_task::{RenderTaskAddress, RenderTaskId, RenderTaskTree};
 use renderer::{BlendMode, ImageBufferKind, ShaderColorMode};
 use renderer::BLOCKS_PER_UV_RECT;
 use resource_cache::{CacheItem, GlyphFetchResult, ImageRequest, ResourceCache};
 use scene::FilterOpHelpers;
 use std::{f32, i32};
 use tiling::{RenderTargetContext};
 use util::{TransformedRectKind};
 
@@ -120,42 +120,42 @@ impl BatchKey {
 
 #[inline]
 fn textures_compatible(t1: SourceTexture, t2: SourceTexture) -> bool {
     t1 == SourceTexture::Invalid || t2 == SourceTexture::Invalid || t1 == t2
 }
 
 pub struct AlphaBatchList {
     pub batches: Vec<PrimitiveBatch>,
-    pub item_rects: Vec<Vec<DeviceIntRect>>,
+    pub item_rects: Vec<Vec<WorldRect>>,
 }
 
 impl AlphaBatchList {
     fn new() -> Self {
         AlphaBatchList {
             batches: Vec::new(),
             item_rects: Vec::new(),
         }
     }
 
     pub fn get_suitable_batch(
         &mut self,
         key: BatchKey,
-        task_relative_bounding_rect: &DeviceIntRect,
+        bounding_rect: &WorldRect,
     ) -> &mut Vec<PrimitiveInstance> {
         let mut selected_batch_index = None;
 
         match key.blend_mode {
             BlendMode::SubpixelWithBgColor => {
                 'outer_multipass: for (batch_index, batch) in self.batches.iter().enumerate().rev().take(10) {
                     // Some subpixel batches are drawn in two passes. Because of this, we need
                     // to check for overlaps with every batch (which is a bit different
                     // than the normal batching below).
                     for item_rect in &self.item_rects[batch_index] {
-                        if item_rect.intersects(task_relative_bounding_rect) {
+                        if item_rect.intersects(bounding_rect) {
                             break 'outer_multipass;
                         }
                     }
 
                     if batch.key.is_compatible_with(&key) {
                         selected_batch_index = Some(batch_index);
                         break;
                     }
@@ -169,33 +169,33 @@ impl AlphaBatchList {
                     // issues to worry about.
                     if batch.key.is_compatible_with(&key) {
                         selected_batch_index = Some(batch_index);
                         break;
                     }
 
                     // check for intersections
                     for item_rect in &self.item_rects[batch_index] {
-                        if item_rect.intersects(task_relative_bounding_rect) {
+                        if item_rect.intersects(bounding_rect) {
                             break 'outer_default;
                         }
                     }
                 }
             }
         }
 
         if selected_batch_index.is_none() {
             let new_batch = PrimitiveBatch::new(key);
             selected_batch_index = Some(self.batches.len());
             self.batches.push(new_batch);
             self.item_rects.push(Vec::new());
         }
 
         let selected_batch_index = selected_batch_index.unwrap();
-        self.item_rects[selected_batch_index].push(*task_relative_bounding_rect);
+        self.item_rects[selected_batch_index].push(*bounding_rect);
         &mut self.batches[selected_batch_index].instances
     }
 }
 
 pub struct OpaqueBatchList {
     pub pixel_area_threshold_for_new_batch: f32,
     pub batches: Vec<PrimitiveBatch>,
 }
@@ -206,20 +206,20 @@ impl OpaqueBatchList {
             batches: Vec::new(),
             pixel_area_threshold_for_new_batch,
         }
     }
 
     pub fn get_suitable_batch(
         &mut self,
         key: BatchKey,
-        task_relative_bounding_rect: &DeviceIntRect
+        bounding_rect: &WorldRect
     ) -> &mut Vec<PrimitiveInstance> {
         let mut selected_batch_index = None;
-        let item_area = task_relative_bounding_rect.size.to_f32().area();
+        let item_area = bounding_rect.size.area();
 
         // If the area of this primitive is larger than the given threshold,
         // then it is large enough to warrant breaking a batch for. In this
         // case we just see if it can be added to the existing batch or
         // create a new one.
         if item_area > self.pixel_area_threshold_for_new_batch {
             if let Some(batch) = self.batches.last() {
                 if batch.key.is_compatible_with(&key) {
@@ -275,31 +275,31 @@ impl BatchList {
             alpha_batch_list: AlphaBatchList::new(),
             opaque_batch_list: OpaqueBatchList::new(batch_area_threshold),
         }
     }
 
     pub fn get_suitable_batch(
         &mut self,
         key: BatchKey,
-        task_relative_bounding_rect: &DeviceIntRect,
+        bounding_rect: &WorldRect,
     ) -> &mut Vec<PrimitiveInstance> {
         match key.blend_mode {
             BlendMode::None => {
                 self.opaque_batch_list
-                    .get_suitable_batch(key, task_relative_bounding_rect)
+                    .get_suitable_batch(key, bounding_rect)
             }
             BlendMode::Alpha |
             BlendMode::PremultipliedAlpha |
             BlendMode::PremultipliedDestOut |
             BlendMode::SubpixelConstantTextColor(..) |
             BlendMode::SubpixelWithBgColor |
             BlendMode::SubpixelDualSource => {
                 self.alpha_batch_list
-                    .get_suitable_batch(key, task_relative_bounding_rect)
+                    .get_suitable_batch(key, bounding_rect)
             }
         }
     }
 
     // Remove any batches that were added but didn't get any instances
     // added to them.
     fn remove_unused_batches(&mut self) {
         if self.opaque_batch_list
@@ -437,42 +437,31 @@ impl AlphaBatchBuilder {
         ctx: &RenderTargetContext,
         gpu_cache: &mut GpuCache,
         render_tasks: &RenderTaskTree,
         deferred_resolves: &mut Vec<DeferredResolve>,
         prim_headers: &mut PrimitiveHeaders,
     ) {
         let task_address = render_tasks.get_task_address(task_id);
 
-        let task = &render_tasks[task_id];
-        let content_origin = match task.kind {
-            RenderTaskKind::Picture(ref pic_task) => {
-                pic_task.content_origin
-            }
-            _ => {
-                panic!("todo: tidy this up");
-            }
-        };
-
         // Even though most of the time a splitter isn't used or needed,
         // they are cheap to construct so we will always pass one down.
         let mut splitter = BspSplitter::new();
 
         // Add each run in this picture to the batch.
         for run in &pic.runs {
             self.add_run_to_batch(
                 run,
                 ctx,
                 gpu_cache,
                 render_tasks,
                 task_id,
                 task_address,
                 deferred_resolves,
                 &mut splitter,
-                content_origin,
                 prim_headers,
             );
         }
 
         // Flush the accumulated plane splits onto the task tree.
         // Z axis is directed at the screen, `sort` is ascending, and we need back-to-front order.
         for poly in splitter.sort(vec3(0.0, 0.0, 1.0)) {
             let prim_index = PrimitiveIndex(poly.anchor);
@@ -489,17 +478,21 @@ impl AlphaBatchBuilder {
             let gpu_handle = gpu_cache.push_per_frame_blocks(&gpu_blocks);
             let key = BatchKey::new(
                 BatchKind::SplitComposite,
                 BlendMode::PremultipliedAlpha,
                 BatchTextures::no_texture(),
             );
             let pic_metadata = &ctx.prim_store.primitives[prim_index.0].metadata;
             let pic = ctx.prim_store.get_pic(prim_index);
-            let batch = self.batch_list.get_suitable_batch(key, &pic_metadata.screen_rect.as_ref().expect("bug").clipped);
+            let batch = self.batch_list
+                            .get_suitable_batch(
+                                key,
+                                &pic_metadata.clipped_world_rect.as_ref().expect("bug"),
+                            );
 
             let source_task_id = pic
                 .surface
                 .as_ref()
                 .expect("BUG: unexpected surface in splitting")
                 .resolve_render_task_id();
             let source_task_address = render_tasks.get_task_address(source_task_id);
             let gpu_address = gpu_cache.get_address(&gpu_handle);
@@ -523,39 +516,37 @@ impl AlphaBatchBuilder {
         run: &PrimitiveRun,
         ctx: &RenderTargetContext,
         gpu_cache: &mut GpuCache,
         render_tasks: &RenderTaskTree,
         task_id: RenderTaskId,
         task_address: RenderTaskAddress,
         deferred_resolves: &mut Vec<DeferredResolve>,
         splitter: &mut BspSplitter<f64, WorldPixel>,
-        content_origin: DeviceIntPoint,
         prim_headers: &mut PrimitiveHeaders,
     ) {
         for i in 0 .. run.count {
             let prim_index = PrimitiveIndex(run.base_prim_index.0 + i);
             let metadata = &ctx.prim_store.primitives[prim_index.0].metadata;
 
-            if metadata.screen_rect.is_some() {
+            if metadata.clipped_world_rect.is_some() {
                 let transform_id = ctx
                     .transforms
                     .get_id(metadata.spatial_node_index);
 
                 self.add_prim_to_batch(
                     transform_id,
                     prim_index,
                     ctx,
                     gpu_cache,
                     render_tasks,
                     task_id,
                     task_address,
                     deferred_resolves,
                     splitter,
-                    content_origin,
                     prim_headers,
                 );
             }
         }
     }
 
     // Adds a primitive to a batch.
     // It can recursively call itself in some situations, for
@@ -567,37 +558,30 @@ impl AlphaBatchBuilder {
         prim_index: PrimitiveIndex,
         ctx: &RenderTargetContext,
         gpu_cache: &mut GpuCache,
         render_tasks: &RenderTaskTree,
         task_id: RenderTaskId,
         task_address: RenderTaskAddress,
         deferred_resolves: &mut Vec<DeferredResolve>,
         splitter: &mut BspSplitter<f64, WorldPixel>,
-        content_origin: DeviceIntPoint,
         prim_headers: &mut PrimitiveHeaders,
     ) {
         let prim = &ctx.prim_store.primitives[prim_index.0];
         let prim_metadata = &prim.metadata;
         #[cfg(debug_assertions)] //TODO: why is this needed?
         debug_assert_eq!(prim_metadata.prepared_frame_id, render_tasks.frame_id());
 
         // TODO(gw): Calculating this for every primitive is a bit
         //           wasteful. We should probably cache this in
         //           the scroll node...
         let transform_kind = transform_id.transform_kind();
-
-        let screen_rect = prim_metadata.screen_rect.expect("bug");
-        let task_relative_bounding_rect = DeviceIntRect::new(
-            DeviceIntPoint::new(
-                screen_rect.unclipped.origin.x - content_origin.x,
-                screen_rect.unclipped.origin.y - content_origin.y,
-            ),
-            screen_rect.unclipped.size,
-        );
+        let bounding_rect = prim_metadata.clipped_world_rect
+                                         .as_ref()
+                                         .expect("bug");
 
         // If the primitive is internally decomposed into multiple sub-primitives we may not
         // use some of the per-primitive data typically stored in PrimitiveMetadata and get
         // it from each sub-primitive instead.
         let is_multiple_primitives = match prim.details {
             PrimitiveDetails::Brush(ref brush) => {
                 match brush.kind {
                     BrushKind::Image { ref visible_tiles, .. } => !visible_tiles.is_empty(),
@@ -662,22 +646,21 @@ impl AlphaBatchBuilder {
                                         prim_metadata.local_rect.cast(),
                                         transform.m.cast(),
                                         prim_index.0,
                                     ).unwrap();
                                     splitter.add(polygon);
                                 }
                                 TransformedRectKind::Complex => {
                                     let mut clipper = Clipper::new();
-                                    let bounds = (screen_rect.clipped.to_f32() / ctx.device_pixel_scale).to_f64();
                                     let matrix = transform.m.cast();
                                     let results = clipper.clip_transformed(
                                         Polygon::from_rect(prim_metadata.local_rect.cast(), prim_index.0),
                                         &matrix,
-                                        Some(bounds),
+                                        Some(bounding_rect.to_f64()),
                                     );
                                     for poly in results {
                                         splitter.add(poly);
                                     }
                                 }
                             }
 
                             return;
@@ -699,17 +682,17 @@ impl AlphaBatchBuilder {
                                                         ctx.resource_cache,
                                                         gpu_cache,
                                                     );
                                                 let key = BatchKey::new(
                                                     kind,
                                                     non_segmented_blend_mode,
                                                     textures,
                                                 );
-                                                let batch = self.batch_list.get_suitable_batch(key, &task_relative_bounding_rect);
+                                                let batch = self.batch_list.get_suitable_batch(key, bounding_rect);
                                                 let prim_header_index = prim_headers.push(&prim_header, [
                                                     uv_rect_address.as_int(),
                                                     (ShaderColorMode::Image as i32) << 16 |
                                                     RasterizationSpace::Screen as i32,
                                                     0,
                                                 ]);
 
                                                 let instance = BrushInstance {
@@ -804,21 +787,21 @@ impl AlphaBatchBuilder {
                                                 prim_header_index: content_prim_header_index,
                                                 clip_task_address,
                                                 segment_index: 0,
                                                 edge_flags: EdgeAaSegmentMask::empty(),
                                                 brush_flags: BrushFlags::empty(),
                                             };
 
                                             self.batch_list
-                                                .get_suitable_batch(shadow_key, &task_relative_bounding_rect)
+                                                .get_suitable_batch(shadow_key, bounding_rect)
                                                 .push(PrimitiveInstance::from(shadow_instance));
 
                                             self.batch_list
-                                                .get_suitable_batch(content_key, &task_relative_bounding_rect)
+                                                .get_suitable_batch(content_key, bounding_rect)
                                                 .push(PrimitiveInstance::from(content_instance));
                                         }
 
                                         false
                                     }
                                     _ => {
                                         match picture.surface {
                                             Some(ref surface) => {
@@ -878,17 +861,17 @@ impl AlphaBatchBuilder {
                                                 let instance = BrushInstance {
                                                     prim_header_index,
                                                     clip_task_address,
                                                     segment_index: 0,
                                                     edge_flags: EdgeAaSegmentMask::empty(),
                                                     brush_flags: BrushFlags::empty(),
                                                 };
 
-                                                let batch = self.batch_list.get_suitable_batch(key, &task_relative_bounding_rect);
+                                                let batch = self.batch_list.get_suitable_batch(key, bounding_rect);
                                                 batch.push(PrimitiveInstance::from(instance));
                                                 false
                                             }
                                             None => {
                                                 true
                                             }
                                         }
                                     }
@@ -908,17 +891,17 @@ impl AlphaBatchBuilder {
                                             task_id,
                                             source_id: cache_task_id,
                                             backdrop_id,
                                         },
                                     ),
                                     BlendMode::PremultipliedAlpha,
                                     BatchTextures::no_texture(),
                                 );
-                                let batch = self.batch_list.get_suitable_batch(key, &task_relative_bounding_rect);
+                                let batch = self.batch_list.get_suitable_batch(key, bounding_rect);
                                 let backdrop_task_address = render_tasks.get_task_address(backdrop_id);
                                 let source_task_address = render_tasks.get_task_address(cache_task_id);
                                 let prim_header_index = prim_headers.push(&prim_header, [
                                     mode as u32 as i32,
                                     backdrop_task_address.0 as i32,
                                     source_task_address.0 as i32,
                                 ]);
 
@@ -944,17 +927,17 @@ impl AlphaBatchBuilder {
                                 );
                                 let key = BatchKey::new(
                                     kind,
                                     non_segmented_blend_mode,
                                     BatchTextures::render_target_cache(),
                                 );
                                 let batch = self.batch_list.get_suitable_batch(
                                     key,
-                                    &task_relative_bounding_rect
+                                    bounding_rect,
                                 );
 
                                 let uv_rect_address = render_tasks[cache_task_id]
                                     .get_texture_address(gpu_cache)
                                     .as_int();
                                 let prim_header_index = prim_headers.push(&prim_header, [
                                     uv_rect_address,
                                     (ShaderColorMode::Image as i32) << 16 |
@@ -1009,43 +992,43 @@ impl AlphaBatchBuilder {
                                 let prim_header_index = prim_headers.push(&prim_header, user_data);
 
                                 self.add_image_tile_to_batch(
                                     batch_kind,
                                     specified_blend_mode,
                                     textures,
                                     prim_header_index,
                                     clip_task_address,
-                                    &task_relative_bounding_rect,
+                                    bounding_rect,
                                     tile.edge_flags
                                 );
                             }
                         }
                     }
                     BrushKind::LinearGradient { ref stops_handle, ref visible_tiles, .. } if !visible_tiles.is_empty() => {
                         add_gradient_tiles(
                             visible_tiles,
                             stops_handle,
                             BrushBatchKind::LinearGradient,
                             specified_blend_mode,
-                            &task_relative_bounding_rect,
+                            bounding_rect,
                             clip_task_address,
                             gpu_cache,
                             &mut self.batch_list,
                             &prim_header,
                             prim_headers,
                         );
                     }
                     BrushKind::RadialGradient { ref stops_handle, ref visible_tiles, .. } if !visible_tiles.is_empty() => {
                         add_gradient_tiles(
                             visible_tiles,
                             stops_handle,
                             BrushBatchKind::RadialGradient,
                             specified_blend_mode,
-                            &task_relative_bounding_rect,
+                            bounding_rect,
                             clip_task_address,
                             gpu_cache,
                             &mut self.batch_list,
                             &prim_header,
                             prim_headers,
                         );
                     }
                     _ => {
@@ -1053,29 +1036,29 @@ impl AlphaBatchBuilder {
                                 ctx.resource_cache,
                                 gpu_cache,
                                 deferred_resolves,
                                 ctx.prim_store.chase_id == Some(prim_index),
                         ) {
                             let prim_header_index = prim_headers.push(&prim_header, user_data);
                             if cfg!(debug_assertions) && ctx.prim_store.chase_id == Some(prim_index) {
                                 println!("\t{:?} {:?}, task relative bounds {:?}",
-                                    batch_kind, prim_header_index, task_relative_bounding_rect);
+                                    batch_kind, prim_header_index, bounding_rect);
                             }
 
                             self.add_brush_to_batch(
                                 brush,
                                 prim_metadata,
                                 batch_kind,
                                 specified_blend_mode,
                                 non_segmented_blend_mode,
                                 textures,
                                 prim_header_index,
                                 clip_task_address,
-                                &task_relative_bounding_rect,
+                                bounding_rect,
                                 transform_kind,
                                 render_tasks,
                             );
                         }
                     }
                 }
             }
             PrimitiveDetails::TextRun(ref text_cpu) => {
@@ -1147,17 +1130,17 @@ impl AlphaBatchBuilder {
                                     BlendMode::PremultipliedAlpha,
                                     ShaderColorMode::ColorBitmap,
                                 )
                             }
                         };
 
                         let prim_header_index = prim_headers.push(&prim_header, [0; 3]);
                         let key = BatchKey::new(kind, blend_mode, textures);
-                        let batch = batch_list.get_suitable_batch(key, &task_relative_bounding_rect);
+                        let batch = batch_list.get_suitable_batch(key, bounding_rect);
                         let base_instance = GlyphInstance::new(
                             prim_header_index,
                         );
 
                         for glyph in glyphs {
                             batch.push(base_instance.build(
                                 glyph.index_in_text_run,
                                 glyph.uv_rect_address.as_int(),
@@ -1173,47 +1156,47 @@ impl AlphaBatchBuilder {
 
     fn add_image_tile_to_batch(
         &mut self,
         batch_kind: BrushBatchKind,
         blend_mode: BlendMode,
         textures: BatchTextures,
         prim_header_index: PrimitiveHeaderIndex,
         clip_task_address: RenderTaskAddress,
-        task_relative_bounding_rect: &DeviceIntRect,
+        bounding_rect: &WorldRect,
         edge_flags: EdgeAaSegmentMask,
     ) {
         let base_instance = BrushInstance {
             prim_header_index,
             clip_task_address,
             segment_index: 0,
             edge_flags,
             brush_flags: BrushFlags::PERSPECTIVE_INTERPOLATION,
         };
 
         let batch_key = BatchKey {
             blend_mode,
             kind: BatchKind::Brush(batch_kind),
             textures,
         };
-        let batch = self.batch_list.get_suitable_batch(batch_key, task_relative_bounding_rect);
+        let batch = self.batch_list.get_suitable_batch(batch_key, bounding_rect);
         batch.push(PrimitiveInstance::from(base_instance));
     }
 
     fn add_brush_to_batch(
         &mut self,
         brush: &BrushPrimitive,
         prim_metadata: &PrimitiveMetadata,
         batch_kind: BrushBatchKind,
         alpha_blend_mode: BlendMode,
         non_segmented_blend_mode: BlendMode,
         textures: BatchTextures,
         prim_header_index: PrimitiveHeaderIndex,
         clip_task_address: RenderTaskAddress,
-        task_relative_bounding_rect: &DeviceIntRect,
+        bounding_rect: &WorldRect,
         transform_kind: TransformedRectKind,
         render_tasks: &RenderTaskTree,
     ) {
         let base_instance = BrushInstance {
             prim_header_index,
             clip_task_address,
             segment_index: 0,
             edge_flags: EdgeAaSegmentMask::all(),
@@ -1225,28 +1208,28 @@ impl AlphaBatchBuilder {
                 let alpha_batch_key = BatchKey {
                     blend_mode: alpha_blend_mode,
                     kind: BatchKind::Brush(batch_kind),
                     textures,
                 };
 
                 let alpha_batch = self.batch_list.alpha_batch_list.get_suitable_batch(
                     alpha_batch_key,
-                    task_relative_bounding_rect
+                    bounding_rect,
                 );
 
                 let opaque_batch_key = BatchKey {
                     blend_mode: BlendMode::None,
                     kind: BatchKind::Brush(batch_kind),
                     textures,
                 };
 
                 let opaque_batch = self.batch_list.opaque_batch_list.get_suitable_batch(
                     opaque_batch_key,
-                    task_relative_bounding_rect
+                    bounding_rect,
                 );
 
                 for (i, segment) in segment_desc.segments.iter().enumerate() {
                     let is_inner = segment.edge_flags.is_empty();
                     let needs_blending = !prim_metadata.opacity.is_opaque ||
                                          segment.clip_task_id.needs_blending() ||
                                          (!is_inner && transform_kind == TransformedRectKind::Complex);
 
@@ -1273,44 +1256,44 @@ impl AlphaBatchBuilder {
                 }
             }
             None => {
                 let batch_key = BatchKey {
                     blend_mode: non_segmented_blend_mode,
                     kind: BatchKind::Brush(batch_kind),
                     textures,
                 };
-                let batch = self.batch_list.get_suitable_batch(batch_key, task_relative_bounding_rect);
+                let batch = self.batch_list.get_suitable_batch(batch_key, bounding_rect);
                 batch.push(PrimitiveInstance::from(base_instance));
             }
         }
 
         self.batch_list.remove_unused_batches();
     }
 }
 
 fn add_gradient_tiles(
     visible_tiles: &[VisibleGradientTile],
     stops_handle: &GpuCacheHandle,
     kind: BrushBatchKind,
     blend_mode: BlendMode,
-    task_relative_bounding_rect: &DeviceIntRect,
+    bounding_rect: &WorldRect,
     clip_task_address: RenderTaskAddress,
     gpu_cache: &GpuCache,
     batch_list: &mut BatchList,
     base_prim_header: &PrimitiveHeader,
     prim_headers: &mut PrimitiveHeaders,
 ) {
     let batch = batch_list.get_suitable_batch(
         BatchKey {
             blend_mode: blend_mode,
             kind: BatchKind::Brush(kind),
             textures: BatchTextures::no_texture(),
         },
-        task_relative_bounding_rect
+        bounding_rect,
     );
 
     let user_data = [stops_handle.as_int(gpu_cache), 0, 0];
 
     for tile in visible_tiles {
         let prim_header = PrimitiveHeader {
             specific_prim_address: gpu_cache.get_address(&tile.handle),
             local_rect: tile.local_rect,
--- a/gfx/webrender/src/clip.rs
+++ b/gfx/webrender/src/clip.rs
@@ -1,28 +1,27 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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, ClipMode, ComplexClipRegion, DeviceIntRect, DevicePixelScale, ImageMask};
 use api::{ImageRendering, LayoutRect, LayoutSize, LayoutPoint, LayoutVector2D, LocalClip};
-use api::{BoxShadowClipMode, LayoutToWorldScale, LineOrientation, LineStyle};
-use api::{LayoutToWorldTransform, WorldPixel, WorldRect, WorldPoint, WorldSize};
+use api::{BoxShadowClipMode, LayoutToWorldScale, LineOrientation, LineStyle, PicturePixel, WorldPixel};
+use api::{PictureRect, LayoutPixel, WorldPoint, WorldSize, WorldRect, LayoutToWorldTransform};
 use border::{ensure_no_corner_overlap};
 use box_shadow::{BLUR_SAMPLE_SCALE, BoxShadowClipSource, BoxShadowCacheKey};
 use clip_scroll_tree::{ClipScrollTree, CoordinateSystemId, SpatialNodeIndex};
 use ellipse::Ellipse;
 use gpu_cache::{GpuCache, GpuCacheHandle, ToGpuBlocks};
-use gpu_types::BoxShadowStretchMode;
-use plane_split::{Clipper, Polygon};
-use prim_store::{ClipData, ImageMaskData};
+use gpu_types::{BoxShadowStretchMode};
+use prim_store::{ClipData, ImageMaskData, SpaceMapper};
 use render_task::to_cache_size;
 use resource_cache::{ImageRequest, ResourceCache};
 use std::{cmp, u32};
-use util::{extract_inner_rect_safe, pack_as_float, recycle_vec, MaxRect};
+use util::{extract_inner_rect_safe, pack_as_float, project_rect, recycle_vec};
 
 /*
 
  Module Overview
 
  There are a number of data structures involved in the clip module:
 
  ClipStore - Main interface used by other modules.
@@ -317,20 +316,24 @@ pub struct ClipStore {
     clip_node_info: Vec<ClipNodeInfo>,
 }
 
 // A clip chain instance is what gets built for a given clip
 // chain id + local primitive region + positioning node.
 #[derive(Debug)]
 pub struct ClipChainInstance {
     pub clips_range: ClipNodeRange,
+    // Combined clip rect for clips that are in the
+    // same coordinate system as the primitive.
     pub local_clip_rect: LayoutRect,
     pub has_non_root_coord_system: bool,
     pub has_non_local_clips: bool,
-    pub world_clip_rect: WorldRect,
+    // Combined clip rect in picture space (may
+    // be more conservative that local_clip_rect).
+    pub pic_clip_rect: PictureRect,
 }
 
 impl ClipStore {
     pub fn new() -> Self {
         ClipStore {
             clip_nodes: Vec::new(),
             clip_chain_nodes: Vec::new(),
             clip_node_indices: Vec::new(),
@@ -411,23 +414,24 @@ impl ClipStore {
     // The main interface other code uses. Given a local primitive, positioning
     // information, and a clip chain id, build an optimized clip chain instance.
     pub fn build_clip_chain_instance(
         &mut self,
         clip_chain_id: ClipChainId,
         local_prim_rect: LayoutRect,
         local_prim_clip_rect: LayoutRect,
         spatial_node_index: SpatialNodeIndex,
+        prim_to_pic_mapper: &SpaceMapper<LayoutPixel, PicturePixel>,
+        pic_to_world_mapper: &SpaceMapper<PicturePixel, WorldPixel>,
         clip_scroll_tree: &ClipScrollTree,
         gpu_cache: &mut GpuCache,
         resource_cache: &mut ResourceCache,
         device_pixel_scale: DevicePixelScale,
     ) -> Option<ClipChainInstance> {
         let mut local_clip_rect = local_prim_clip_rect;
-        let mut world_clip_rect = WorldRect::max_rect();
         let spatial_nodes = &clip_scroll_tree.spatial_nodes;
 
         // Walk the clip chain to build local rects, and collect the
         // smallest possible local/device clip area.
 
         self.clip_node_info.clear();
         let ref_spatial_node = &spatial_nodes[spatial_node_index.0];
         let mut current_clip_chain_id = clip_chain_id;
@@ -475,29 +479,26 @@ impl ClipStore {
                             }
                             ClipSpaceConversion::Offset(ref offset) => {
                                 let clip_rect = clip_rect.translate(offset);
                                 local_clip_rect = match local_clip_rect.intersection(&clip_rect) {
                                     Some(local_clip_rect) => local_clip_rect,
                                     None => return None,
                                 };
                             }
-                            ClipSpaceConversion::Transform(ref transform) => {
-                                let world_clip_rect_for_item = match project_rect(
-                                    transform,
-                                    &clip_rect,
-                                ) {
-                                    Some(rect) => rect,
-                                    None => return None,
-                                };
-
-                                world_clip_rect = match world_clip_rect.intersection(&world_clip_rect_for_item) {
-                                    Some(world_clip_rect) => world_clip_rect,
-                                    None => return None,
-                                };
+                            ClipSpaceConversion::Transform(..) => {
+                                // TODO(gw): In the future, we can reduce the size
+                                //           of the pic_clip_rect here. To do this,
+                                //           we can use project_rect or the
+                                //           inverse_rect_footprint method, depending
+                                //           on the relationship of the clip, pic
+                                //           and primitive spatial nodes.
+                                //           I have left this for now until we
+                                //           find some good test cases where this
+                                //           would be a worthwhile perf win.
                             }
                         }
                     }
                     self.clip_node_info.push(ClipNodeInfo {
                         conversion,
                         node_index: clip_node_index,
                         has_non_root_coord_system: clip_spatial_node.coordinate_system_id != CoordinateSystemId::root(),
                     })
@@ -507,25 +508,22 @@ impl ClipStore {
             current_clip_chain_id = clip_chain_node.parent_clip_chain_id;
         }
 
         let local_bounding_rect = match local_prim_rect.intersection(&local_clip_rect) {
             Some(rect) => rect,
             None => return None,
         };
 
-        let world_bounding_rect = match project_rect(
-            &ref_spatial_node.world_content_transform.to_transform(),
-            &local_bounding_rect,
-        ) {
-            Some(world_bounding_rect) => world_bounding_rect,
+        let pic_clip_rect = match prim_to_pic_mapper.map(&local_bounding_rect) {
+            Some(pic_bounding_rect) => pic_bounding_rect,
             None => return None,
         };
 
-        let world_clip_rect = match world_clip_rect.intersection(&world_bounding_rect) {
+        let world_clip_rect = match pic_to_world_mapper.map(&pic_clip_rect) {
             Some(world_clip_rect) => world_clip_rect,
             None => return None,
         };
 
         // Now, we've collected all the clip nodes that *potentially* affect this
         // primitive region, and reduced the size of the prim region as much as possible.
 
         // Run through the clip nodes, and see which ones affect this prim region.
@@ -546,17 +544,17 @@ impl ClipStore {
                 ClipSpaceConversion::Offset(offset) => {
                     has_non_local_clips = true;
                     node.item.get_clip_result(&local_bounding_rect.translate(&-offset))
                 }
                 ClipSpaceConversion::Transform(ref transform) => {
                     has_non_local_clips = true;
                     node.item.get_clip_result_complex(
                         transform,
-                        &world_bounding_rect,
+                        &world_clip_rect,
                     )
                 }
             };
 
             match clip_result {
                 ClipResult::Accept => {
                     // Doesn't affect the primitive at all, so skip adding to list
                 }
@@ -604,17 +602,17 @@ impl ClipStore {
         };
 
         // Return a valid clip chain instance
         Some(ClipChainInstance {
             clips_range,
             has_non_root_coord_system,
             has_non_local_clips,
             local_clip_rect,
-            world_clip_rect,
+            pic_clip_rect,
         })
     }
 }
 
 #[derive(Debug)]
 pub struct LineDecorationClipSource {
     rect: LayoutRect,
     style: LineStyle,
@@ -865,17 +863,17 @@ impl ClipItem {
             ClipItem::BoxShadow(..) => None,
             ClipItem::LineDecoration(..) => None,
         }
     }
 
     fn get_clip_result_complex(
         &self,
         transform: &LayoutToWorldTransform,
-        prim_rect: &WorldRect,
+        prim_world_rect: &WorldRect,
     ) -> ClipResult {
         let (clip_rect, inner_rect) = match *self {
             ClipItem::Rectangle(clip_rect, ClipMode::Clip) => {
                 (clip_rect, Some(clip_rect))
             }
             ClipItem::RoundedRectangle(ref clip_rect, ref radius, ClipMode::Clip) => {
                 let inner_clip_rect = extract_inner_rect_safe(clip_rect, radius);
                 (*clip_rect, inner_clip_rect)
@@ -889,27 +887,27 @@ impl ClipItem {
             }
         };
 
         let inner_clip_rect = inner_rect.and_then(|ref inner_rect| {
             project_inner_rect(transform, inner_rect)
         });
 
         if let Some(inner_clip_rect) = inner_clip_rect {
-            if inner_clip_rect.contains_rect(prim_rect) {
+            if inner_clip_rect.contains_rect(prim_world_rect) {
                 return ClipResult::Accept;
             }
         }
 
         let outer_clip_rect = match project_rect(transform, &clip_rect) {
             Some(outer_clip_rect) => outer_clip_rect,
             None => return ClipResult::Partial,
         };
 
-        match outer_clip_rect.intersection(prim_rect) {
+        match outer_clip_rect.intersection(prim_world_rect) {
             Some(..) => {
                 ClipResult::Partial
             }
             None => {
                 ClipResult::Reject
             }
         }
     }
@@ -1062,63 +1060,16 @@ pub fn rounded_rectangle_contains_point(
     if bottom_left_center.x > point.x && bottom_left_center.y < point.y &&
        !Ellipse::new(radii.bottom_left).contains(*point - bottom_left_center.to_vector()) {
         return false;
     }
 
     true
 }
 
-fn project_rect(
-    transform: &LayoutToWorldTransform,
-    rect: &LayoutRect,
-) -> Option<WorldRect> {
-    let homogens = [
-        transform.transform_point2d_homogeneous(&rect.origin),
-        transform.transform_point2d_homogeneous(&rect.top_right()),
-        transform.transform_point2d_homogeneous(&rect.bottom_left()),
-        transform.transform_point2d_homogeneous(&rect.bottom_right()),
-    ];
-
-    // Note: we only do the full frustum collision when the polygon approaches the camera plane.
-    // Otherwise, it will be clamped to the screen bounds anyway.
-    if homogens.iter().any(|h| h.w <= 0.0) {
-        let mut clipper = Clipper::new();
-        clipper.add_frustum(
-            transform,
-            None,
-        );
-
-        let polygon = Polygon::from_rect(*rect, 1);
-        let results = clipper.clip(polygon);
-        if results.is_empty() {
-            return None
-        }
-
-        Some(WorldRect::from_points(results
-            .into_iter()
-            // filter out parts behind the view plane
-            .flat_map(|poly| &poly.points)
-            .map(|p| {
-                let mut homo = transform.transform_point2d_homogeneous(&p.to_2d());
-                homo.w = homo.w.max(0.00000001); // avoid infinite values
-                homo.to_point2d().unwrap()
-            })
-        ))
-    } else {
-        // we just checked for all the points to be in positive hemisphere, so `unwrap` is valid
-        Some(WorldRect::from_points(&[
-            homogens[0].to_point2d().unwrap(),
-            homogens[1].to_point2d().unwrap(),
-            homogens[2].to_point2d().unwrap(),
-            homogens[3].to_point2d().unwrap(),
-        ]))
-    }
-}
-
 pub fn project_inner_rect(
     transform: &LayoutToWorldTransform,
     rect: &LayoutRect,
 ) -> Option<WorldRect> {
     let points = [
         transform.transform_point2d(&rect.origin)?,
         transform.transform_point2d(&rect.top_right())?,
         transform.transform_point2d(&rect.bottom_left())?,
--- a/gfx/webrender/src/display_list_flattener.rs
+++ b/gfx/webrender/src/display_list_flattener.rs
@@ -727,20 +727,17 @@ impl<'a> DisplayListFlattener<'a> {
 
             // Do nothing; these are dummy items for the display list parser
             SpecificDisplayItem::SetGradientStops => {}
 
             SpecificDisplayItem::PopStackingContext | SpecificDisplayItem::PopReferenceFrame => {
                 unreachable!("Should have returned in parent method.")
             }
             SpecificDisplayItem::PushShadow(shadow) => {
-                let mut prim_info = prim_info.clone();
-                prim_info.rect = LayoutRect::zero();
-                self
-                    .push_shadow(shadow, clip_and_scroll, &prim_info);
+                self.push_shadow(shadow, clip_and_scroll);
             }
             SpecificDisplayItem::PopAllShadows => {
                 self.pop_all_shadows();
             }
         }
         None
     }
 
@@ -1009,17 +1006,17 @@ impl<'a> DisplayListFlattener<'a> {
                 true,
             );
 
             let prim = BrushPrimitive::new_picture(picture);
 
             let prim_index = self.prim_store.add_primitive(
                 &LayoutRect::zero(),
                 &max_clip,
-                is_backface_visible,
+                true,
                 clip_chain_id,
                 spatial_node_index,
                 None,
                 PrimitiveContainer::Brush(prim),
             );
 
             let parent_prim_index = *self.picture_stack.last().unwrap();
 
@@ -1059,17 +1056,17 @@ impl<'a> DisplayListFlattener<'a> {
                 None,
                 true,
             );
 
             let src_prim = BrushPrimitive::new_picture(picture);
             let src_prim_index = self.prim_store.add_primitive(
                 &LayoutRect::zero(),
                 &max_clip,
-                is_backface_visible,
+                true,
                 clip_chain_id,
                 spatial_node_index,
                 None,
                 PrimitiveContainer::Brush(src_prim),
             );
 
             let parent_pic = self.prim_store.get_pic_mut(parent_prim_index);
             parent_prim_index = src_prim_index;
@@ -1090,17 +1087,17 @@ impl<'a> DisplayListFlattener<'a> {
                 true,
             );
 
             let src_prim = BrushPrimitive::new_picture(picture);
 
             let src_prim_index = self.prim_store.add_primitive(
                 &LayoutRect::zero(),
                 &max_clip,
-                is_backface_visible,
+                true,
                 clip_chain_id,
                 spatial_node_index,
                 None,
                 PrimitiveContainer::Brush(src_prim),
             );
 
             let parent_pic = self.prim_store.get_pic_mut(parent_prim_index);
             parent_prim_index = src_prim_index;
@@ -1148,17 +1145,17 @@ impl<'a> DisplayListFlattener<'a> {
 
         // Create a brush primitive that draws this picture.
         let sc_prim = BrushPrimitive::new_picture(picture);
 
         // Add the brush to the parent picture.
         let sc_prim_index = self.prim_store.add_primitive(
             &LayoutRect::zero(),
             &max_clip,
-            is_backface_visible,
+            true,
             clip_chain_id,
             spatial_node_index,
             None,
             PrimitiveContainer::Brush(sc_prim),
         );
 
         let parent_pic = self.prim_store.get_pic_mut(parent_prim_index);
         parent_pic.add_primitive(sc_prim_index);
@@ -1358,17 +1355,16 @@ impl<'a> DisplayListFlattener<'a> {
         self.id_to_index_mapper.map_to_parent_clip_chain(new_node_id, &parent_id);
         node_index
     }
 
     pub fn push_shadow(
         &mut self,
         shadow: Shadow,
         clip_and_scroll: ScrollNodeAndClipChain,
-        info: &LayoutPrimitiveInfo,
     ) {
         let pipeline_id = self.sc_stack.last().unwrap().pipeline_id;
         let max_clip = LayoutRect::max_rect();
 
         // Quote from https://drafts.csswg.org/css-backgrounds-3/#shadow-blur
         // "the image that would be generated by applying to the shadow a
         // Gaussian blur with a standard deviation equal to half the blur radius."
         let std_deviation = shadow.blur_radius * 0.5;
@@ -1392,17 +1388,17 @@ impl<'a> DisplayListFlattener<'a> {
             apply_local_clip_rect,
         );
 
         // Create the primitive to draw the shadow picture into the scene.
         let shadow_prim = BrushPrimitive::new_picture(shadow_pic);
         let shadow_prim_index = self.prim_store.add_primitive(
             &LayoutRect::zero(),
             &max_clip,
-            info.is_backface_visible,
+            true,
             clip_and_scroll.clip_chain_id,
             clip_and_scroll.spatial_node_index,
             None,
             PrimitiveContainer::Brush(shadow_prim),
         );
 
         // Add the shadow primitive. This must be done before pushing this
         // picture on to the shadow stack, to avoid infinite recursion!
--- a/gfx/webrender/src/frame_builder.rs
+++ b/gfx/webrender/src/frame_builder.rs
@@ -1,24 +1,24 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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::{ColorF, DeviceIntPoint, DeviceIntRect, DevicePixelScale};
-use api::{DeviceUintPoint, DeviceUintRect, DeviceUintSize, DocumentLayer, FontRenderMode};
-use api::{LayoutPoint, LayoutRect, LayoutSize, PipelineId, WorldPoint};
+use api::{ColorF, DeviceIntPoint, DevicePixelScale, LayoutPixel, PicturePixel};
+use api::{DeviceUintPoint, DeviceUintRect, DeviceUintSize, DocumentLayer, FontRenderMode, PictureRect};
+use api::{LayoutPoint, LayoutRect, LayoutSize, PipelineId, WorldPoint, WorldRect, WorldPixel};
 use clip::{ClipStore};
 use clip_scroll_tree::{ClipScrollTree, SpatialNodeIndex};
 use display_list_flattener::{DisplayListFlattener};
 use gpu_cache::GpuCache;
 use gpu_types::{PrimitiveHeaders, TransformPalette, UvRectKind};
 use hit_test::{HitTester, HitTestingRun};
 use internal_types::{FastHashMap};
 use picture::PictureSurface;
-use prim_store::{PrimitiveIndex, PrimitiveRun, LocalRectBuilder, PrimitiveStore, Transform};
+use prim_store::{PrimitiveIndex, PrimitiveRun, PrimitiveStore, Transform, SpaceMapper};
 use profiler::{FrameProfileCounters, GpuCacheProfileCounters, TextureCacheProfileCounters};
 use render_backend::FrameId;
 use render_task::{RenderTask, RenderTaskId, RenderTaskLocation, RenderTaskTree};
 use resource_cache::{ResourceCache};
 use scene::{ScenePipeline, SceneProperties};
 use spatial_node::SpatialNode;
 use std::f32;
 use std::sync::Arc;
@@ -66,17 +66,17 @@ pub struct FrameBuilder {
     pub scrollbar_prims: Vec<ScrollbarPrimitive>,
 }
 
 pub struct FrameBuildingContext<'a> {
     pub scene_id: u64,
     pub device_pixel_scale: DevicePixelScale,
     pub scene_properties: &'a SceneProperties,
     pub pipelines: &'a FastHashMap<PipelineId, Arc<ScenePipeline>>,
-    pub screen_rect: DeviceIntRect,
+    pub world_rect: WorldRect,
     pub clip_scroll_tree: &'a ClipScrollTree,
     pub transforms: &'a TransformPalette,
     pub max_local_clip: LayoutRect,
 }
 
 pub struct FrameBuildingState<'a> {
     pub render_tasks: &'a mut RenderTaskTree,
     pub profile_counters: &'a mut FrameProfileCounters,
@@ -87,45 +87,62 @@ pub struct FrameBuildingState<'a> {
 }
 
 pub struct PictureContext {
     pub pipeline_id: PipelineId,
     pub prim_runs: Vec<PrimitiveRun>,
     pub apply_local_clip_rect: bool,
     pub inflation_factor: f32,
     pub allow_subpixel_aa: bool,
+    pub has_surface: bool,
 }
 
+#[derive(Debug)]
 pub struct PictureState {
     pub tasks: Vec<RenderTaskId>,
     pub has_non_root_coord_system: bool,
     pub local_rect_changed: bool,
+    pub map_local_to_pic: SpaceMapper<LayoutPixel, PicturePixel>,
+    pub map_pic_to_world: SpaceMapper<PicturePixel, WorldPixel>,
 }
 
 impl PictureState {
-    pub fn new() -> Self {
+    pub fn new(
+        ref_spatial_node_index: SpatialNodeIndex,
+        clip_scroll_tree: &ClipScrollTree,
+    ) -> Self {
+        let map_local_to_pic = SpaceMapper::new(ref_spatial_node_index);
+
+        let mut map_pic_to_world = SpaceMapper::new(SpatialNodeIndex(0));
+        map_pic_to_world.set_target_spatial_node(
+            ref_spatial_node_index,
+            clip_scroll_tree,
+        );
+
         PictureState {
             tasks: Vec::new(),
             has_non_root_coord_system: false,
             local_rect_changed: false,
+            map_local_to_pic,
+            map_pic_to_world,
         }
     }
 }
 
 pub struct PrimitiveContext<'a> {
     pub spatial_node: &'a SpatialNode,
     pub spatial_node_index: SpatialNodeIndex,
-    pub transform: Transform<'a>,
+    pub transform: Transform,
 }
 
 impl<'a> PrimitiveContext<'a> {
     pub fn new(
         spatial_node: &'a SpatialNode,
         spatial_node_index: SpatialNodeIndex,
-        transform: Transform<'a>,
+        transform: Transform,
     ) -> Self {
         PrimitiveContext {
             spatial_node,
             spatial_node_index,
             transform,
         }
     }
 }
@@ -196,22 +213,24 @@ impl FrameBuilder {
         self.prim_store.reset_prim_visibility();
 
         // The root picture is always the first one added.
         let root_prim_index = PrimitiveIndex(0);
         let root_spatial_node_index = clip_scroll_tree.root_reference_frame_index();
 
         const MAX_CLIP_COORD: f32 = 1.0e9;
 
+        let world_rect = (self.screen_rect.to_f32() / device_pixel_scale).round_out();
+
         let frame_context = FrameBuildingContext {
             scene_id: self.scene_id,
             device_pixel_scale,
             scene_properties,
             pipelines,
-            screen_rect: self.screen_rect.to_i32(),
+            world_rect,
             clip_scroll_tree,
             transforms: transform_palette,
             max_local_clip: LayoutRect::new(
                 LayoutPoint::new(-MAX_CLIP_COORD, -MAX_CLIP_COORD),
                 LayoutSize::new(2.0 * MAX_CLIP_COORD, 2.0 * MAX_CLIP_COORD),
             ),
         };
 
@@ -219,43 +238,56 @@ impl FrameBuilder {
             render_tasks,
             profile_counters,
             clip_store: &mut self.clip_store,
             resource_cache,
             gpu_cache,
             special_render_passes,
         };
 
-        let mut pic_state = PictureState::new();
+        let mut pic_state = PictureState::new(
+            root_spatial_node_index,
+            &frame_context.clip_scroll_tree,
+        );
 
         let pic_context = self
             .prim_store
             .get_pic_mut(root_prim_index)
-            .take_context(true);
+            .take_context(
+                true,
+                scene_properties,
+                false,
+            )
+            .unwrap();
 
-        let mut local_rect_builder = LocalRectBuilder::new(
-            root_spatial_node_index,
-        );
+        let mut pic_rect = PictureRect::zero();
 
         self.prim_store.prepare_prim_runs(
             &pic_context,
             &mut pic_state,
             &frame_context,
             &mut frame_state,
-            &mut local_rect_builder,
+            root_spatial_node_index,
+            &mut pic_rect,
         );
 
         let pic = self
             .prim_store
             .get_pic_mut(root_prim_index);
-        pic.restore_context(pic_context, local_rect_builder);
+        pic.restore_context(
+            pic_context,
+            pic_state,
+            Some(pic_rect),
+        );
+
+        let pic_state = pic.take_state();
 
         let root_render_task = RenderTask::new_picture(
-            RenderTaskLocation::Fixed(frame_context.screen_rect),
-            frame_context.screen_rect.size,
+            RenderTaskLocation::Fixed(self.screen_rect.to_i32()),
+            self.screen_rect.size.to_f32(),
             root_prim_index,
             DeviceIntPoint::zero(),
             pic_state.tasks,
             UvRectKind::Rect,
         );
 
         let render_task_id = frame_state.render_tasks.add(root_render_task);
         pic.surface = Some(PictureSurface::RenderTask(render_task_id));
--- a/gfx/webrender/src/gpu_types.rs
+++ b/gfx/webrender/src/gpu_types.rs
@@ -469,17 +469,17 @@ impl TransformPalette {
     pub fn get_transform(
         &self,
         index: SpatialNodeIndex,
     ) -> Transform {
         let data = &self.transforms[index.0 as usize];
         let metadata = &self.metadata[index.0 as usize];
 
         Transform {
-            m: &data.transform,
+            m: data.transform,
             transform_kind: metadata.transform_kind,
             backface_is_visible: data.transform.is_backface_visible(),
         }
     }
 
     pub fn get_transform_by_id(
         &self,
         id: TransformPaletteId,
--- a/gfx/webrender/src/picture.rs
+++ b/gfx/webrender/src/picture.rs
@@ -1,28 +1,28 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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::{DeviceRect, FilterOp, MixBlendMode, PipelineId, PremultipliedColorF};
+use api::{DeviceRect, FilterOp, MixBlendMode, PipelineId, PremultipliedColorF, PictureRect};
 use api::{DeviceIntRect, DeviceIntSize, DevicePoint, LayoutPoint, LayoutRect};
 use api::{DevicePixelScale, PictureIntPoint, PictureIntRect, PictureIntSize};
 use box_shadow::{BLUR_SAMPLE_SCALE};
 use frame_builder::{FrameBuildingContext, FrameBuildingState, PictureState};
 use frame_builder::{PictureContext, PrimitiveContext};
 use gpu_cache::{GpuCacheHandle};
 use gpu_types::UvRectKind;
-use prim_store::{PrimitiveIndex, PrimitiveRun, LocalRectBuilder};
+use prim_store::{PrimitiveIndex, PrimitiveRun};
 use prim_store::{PrimitiveMetadata, Transform};
 use render_task::{ClearMode, RenderTask, RenderTaskCacheEntryHandle};
 use render_task::{RenderTaskCacheKey, RenderTaskCacheKeyKind, RenderTaskId, RenderTaskLocation};
 use scene::{FilterOpHelpers, SceneProperties};
 use std::mem;
 use tiling::RenderTargetKind;
-use util::TransformedRectKind;
+use util::{TransformedRectKind, world_rect_to_device_pixels};
 
 /*
  A picture represents a dynamically rendered image. It consists of:
 
  * A number of primitives that are drawn onto the picture.
  * A composite operation describing how to composite this
    picture into its parent.
  * A configuration describing how to draw the primitives on
@@ -117,16 +117,17 @@ pub struct PictureCacheKey {
 #[derive(Debug)]
 pub struct PicturePrimitive {
     // If this picture is drawn to an intermediate surface,
     // the associated target information.
     pub surface: Option<PictureSurface>,
 
     // List of primitive runs that make up this picture.
     pub runs: Vec<PrimitiveRun>,
+    pub state: Option<PictureState>,
 
     // The pipeline that the primitives on this picture belong to.
     pub pipeline_id: PipelineId,
 
     // If true, apply the local clip rect to primitive drawn
     // in this picture.
     pub apply_local_clip_rect: bool,
 
@@ -151,17 +152,17 @@ pub struct PicturePrimitive {
     // picture.
     pub extra_gpu_data_handle: GpuCacheHandle,
 
     // Unique identifier for this picture.
     pub id: PictureId,
 }
 
 impl PicturePrimitive {
-    pub fn resolve_scene_properties(&mut self, properties: &SceneProperties) -> bool {
+    fn resolve_scene_properties(&mut self, properties: &SceneProperties) -> bool {
         match self.composite_mode {
             Some(PictureCompositeMode::Filter(ref mut filter)) => {
                 match *filter {
                     FilterOp::Opacity(ref binding, ref mut value) => {
                         *value = properties.resolve_float(binding);
                     }
                     _ => {}
                 }
@@ -177,53 +178,82 @@ impl PicturePrimitive {
         composite_mode: Option<PictureCompositeMode>,
         is_in_3d_context: bool,
         pipeline_id: PipelineId,
         frame_output_pipeline_id: Option<PipelineId>,
         apply_local_clip_rect: bool,
     ) -> Self {
         PicturePrimitive {
             runs: Vec::new(),
+            state: None,
             surface: None,
             secondary_render_task_id: None,
             composite_mode,
             is_in_3d_context,
             frame_output_pipeline_id,
             extra_gpu_data_handle: GpuCacheHandle::new(),
             apply_local_clip_rect,
             pipeline_id,
             id,
         }
     }
 
+    pub fn can_draw_directly_to_parent_surface(&self) -> bool {
+        match self.composite_mode {
+            Some(PictureCompositeMode::Filter(filter)) => {
+                filter.is_noop()
+            }
+            Some(PictureCompositeMode::Blit) |
+            Some(PictureCompositeMode::MixBlend(..)) => {
+                false
+            }
+            None => {
+                true
+            }
+        }
+    }
+
     pub fn take_context(
         &mut self,
-        allow_subpixel_aa: bool,
-    ) -> PictureContext {
+        parent_allows_subpixel_aa: bool,
+        scene_properties: &SceneProperties,
+        is_chased: bool,
+    ) -> Option<PictureContext> {
+        if !self.resolve_scene_properties(scene_properties) {
+            if cfg!(debug_assertions) && is_chased {
+                println!("\tculled for carrying an invisible composite filter");
+            }
+
+            return None;
+        }
+
+        // Disallow subpixel AA if an intermediate surface is needed.
         // TODO(lsalzman): allow overriding parent if intermediate surface is opaque
-        let allow_subpixel_aa = allow_subpixel_aa && self.allow_subpixel_aa();
+        let allow_subpixel_aa = parent_allows_subpixel_aa &&
+            self.can_draw_directly_to_parent_surface();
 
         let inflation_factor = match self.composite_mode {
             Some(PictureCompositeMode::Filter(FilterOp::Blur(blur_radius))) => {
                 // The amount of extra space needed for primitives inside
                 // this picture to ensure the visibility check is correct.
                 BLUR_SAMPLE_SCALE * blur_radius
             }
             _ => {
                 0.0
             }
         };
 
-        PictureContext {
+        Some(PictureContext {
             pipeline_id: self.pipeline_id,
             prim_runs: mem::replace(&mut self.runs, Vec::new()),
             apply_local_clip_rect: self.apply_local_clip_rect,
             inflation_factor,
             allow_subpixel_aa,
-        }
+            has_surface: !self.can_draw_directly_to_parent_surface(),
+        })
     }
 
     pub fn add_primitive(
         &mut self,
         prim_index: PrimitiveIndex,
     ) {
         if let Some(ref mut run) = self.runs.last_mut() {
             if run.base_prim_index.0 + run.count == prim_index.0 {
@@ -236,87 +266,100 @@ impl PicturePrimitive {
             base_prim_index: prim_index,
             count: 1,
         });
     }
 
     pub fn restore_context(
         &mut self,
         context: PictureContext,
-        local_rect_builder: LocalRectBuilder,
+        state: PictureState,
+        local_rect: Option<PictureRect>,
     ) -> LayoutRect {
         self.runs = context.prim_runs;
+        self.state = Some(state);
 
-        let local_content_rect = local_rect_builder.local_rect;
+        match local_rect {
+            Some(local_rect) => {
+                let local_content_rect = LayoutRect::from_untyped(&local_rect.to_untyped());
 
-        match self.composite_mode {
-            Some(PictureCompositeMode::Filter(FilterOp::Blur(blur_radius))) => {
-                let inflate_size = (blur_radius * BLUR_SAMPLE_SCALE).ceil();
-                local_content_rect.inflate(inflate_size, inflate_size)
-            }
-            Some(PictureCompositeMode::Filter(FilterOp::DropShadow(_, blur_radius, _))) => {
-                let inflate_size = (blur_radius * BLUR_SAMPLE_SCALE).ceil();
-                local_content_rect.inflate(inflate_size, inflate_size)
+                match self.composite_mode {
+                    Some(PictureCompositeMode::Filter(FilterOp::Blur(blur_radius))) => {
+                        let inflate_size = (blur_radius * BLUR_SAMPLE_SCALE).ceil();
+                        local_content_rect.inflate(inflate_size, inflate_size)
+                    }
+                    Some(PictureCompositeMode::Filter(FilterOp::DropShadow(_, blur_radius, _))) => {
+                        let inflate_size = (blur_radius * BLUR_SAMPLE_SCALE).ceil();
+                        local_content_rect.inflate(inflate_size, inflate_size)
 
-                // TODO(gw): When we support culling rect being separate from
-                //           the task/screen rect, we should include both the
-                //           content and shadow rect here, which will prevent
-                //           drop-shadows from disappearing if the main content
-                //           rect is not visible. Something like:
-                // let shadow_rect = local_content_rect
-                //     .inflate(inflate_size, inflate_size)
-                //     .translate(&offset);
-                // shadow_rect.union(&local_content_rect)
+                        // TODO(gw): When we support culling rect being separate from
+                        //           the task/screen rect, we should include both the
+                        //           content and shadow rect here, which will prevent
+                        //           drop-shadows from disappearing if the main content
+                        //           rect is not visible. Something like:
+                        // let shadow_rect = local_content_rect
+                        //     .inflate(inflate_size, inflate_size)
+                        //     .translate(&offset);
+                        // shadow_rect.union(&local_content_rect)
+                    }
+                    _ => {
+                        local_content_rect
+                    }
+                }
             }
-            _ => {
-                local_content_rect
+            None => {
+                assert!(self.can_draw_directly_to_parent_surface());
+                LayoutRect::zero()
             }
         }
     }
 
-    pub fn can_draw_directly_to_parent_surface(&self) -> bool {
-        match self.composite_mode {
-            Some(PictureCompositeMode::Filter(filter)) => {
-                filter.is_noop()
-            }
-            Some(PictureCompositeMode::Blit) |
-            Some(PictureCompositeMode::MixBlend(..)) => {
-                false
-            }
-            None => {
-                true
-            }
-        }
-    }
-
-    // Disallow subpixel AA if an intermediate surface is needed.
-    fn allow_subpixel_aa(&self) -> bool {
-        self.can_draw_directly_to_parent_surface()
+    pub fn take_state(&mut self) -> PictureState {
+        self.state.take().expect("bug: no state present!")
     }
 
     pub fn prepare_for_render(
         &mut self,
         prim_index: PrimitiveIndex,
         prim_metadata: &mut PrimitiveMetadata,
         prim_context: &PrimitiveContext,
-        mut pic_state_for_children: PictureState,
         pic_state: &mut PictureState,
         frame_context: &FrameBuildingContext,
         frame_state: &mut FrameBuildingState,
     ) {
-        let prim_screen_rect = prim_metadata
-                                .screen_rect
-                                .as_ref()
-                                .expect("bug: trying to draw an off-screen picture!?");
+        let mut pic_state_for_children = self.take_state();
+
         if self.can_draw_directly_to_parent_surface() {
             pic_state.tasks.extend(pic_state_for_children.tasks);
             self.surface = None;
             return;
         }
 
+        let clipped_world_rect = prim_metadata
+                                    .clipped_world_rect
+                                    .as_ref()
+                                    .expect("bug: trying to draw an off-screen picture!?");
+
+        let clipped = world_rect_to_device_pixels(
+            *clipped_world_rect,
+            frame_context.device_pixel_scale,
+        ).to_i32();
+
+        let pic_rect = pic_state.map_local_to_pic
+                                .map(&prim_metadata.local_rect)
+                                .unwrap();
+        let world_rect = pic_state.map_pic_to_world
+                                  .map(&pic_rect)
+                                  .unwrap();
+
+        let unclipped = world_rect_to_device_pixels(
+            world_rect,
+            frame_context.device_pixel_scale,
+        );
+
         // TODO(gw): Almost all of the Picture types below use extra_gpu_cache_data
         //           to store the same type of data. The exception is the filter
         //           with a ColorMatrix, which stores the color matrix here. It's
         //           probably worth tidying this code up to be a bit more consistent.
         //           Perhaps store the color matrix after the common data, even though
         //           it's not used by that shader.
         match self.composite_mode {
             Some(PictureCompositeMode::Filter(FilterOp::Blur(blur_radius))) => {
@@ -326,20 +369,19 @@ impl PicturePrimitive {
                 // The clipped field is the part of the picture that is visible
                 // on screen. The unclipped field is the screen-space rect of
                 // the complete picture, if no screen / clip-chain was applied
                 // (this includes the extra space for blur region). To ensure
                 // that we draw a large enough part of the picture to get correct
                 // blur results, inflate that clipped area by the blur range, and
                 // then intersect with the total screen rect, to minimize the
                 // allocation size.
-                let device_rect = prim_screen_rect
-                    .clipped
+                let device_rect = clipped
                     .inflate(blur_range, blur_range)
-                    .intersection(&prim_screen_rect.unclipped)
+                    .intersection(&unclipped.to_i32())
                     .unwrap();
 
                 let uv_rect_kind = calculate_uv_rect_kind(
                     &prim_metadata.local_rect,
                     &prim_context.transform,
                     &device_rect,
                     frame_context.device_pixel_scale,
                 );
@@ -348,17 +390,17 @@ impl PicturePrimitive {
                 // a complex coordinate system, don't bother caching them (for now).
                 // It's likely that they are animating and caching may not help here
                 // anyway. In the future we should relax this a bit, so that we can
                 // cache tasks with complex coordinate systems if we detect the
                 // relevant transforms haven't changed from frame to frame.
                 let surface = if pic_state_for_children.has_non_root_coord_system {
                     let picture_task = RenderTask::new_picture(
                         RenderTaskLocation::Dynamic(None, device_rect.size),
-                        prim_screen_rect.unclipped.size,
+                        unclipped.size,
                         prim_index,
                         device_rect.origin,
                         pic_state_for_children.tasks,
                         uv_rect_kind,
                     );
 
                     let picture_task_id = frame_state.render_tasks.add(picture_task);
 
@@ -375,47 +417,47 @@ impl PicturePrimitive {
                     pic_state.tasks.push(render_task_id);
 
                     PictureSurface::RenderTask(render_task_id)
                 } else {
                     // Get the relative clipped rect within the overall prim rect, that
                     // forms part of the cache key.
                     let pic_relative_render_rect = PictureIntRect::new(
                         PictureIntPoint::new(
-                            device_rect.origin.x - prim_screen_rect.unclipped.origin.x,
-                            device_rect.origin.y - prim_screen_rect.unclipped.origin.y,
+                            device_rect.origin.x - unclipped.origin.x as i32,
+                            device_rect.origin.y - unclipped.origin.y as i32,
                         ),
                         PictureIntSize::new(
                             device_rect.size.width,
                             device_rect.size.height,
                         ),
                     );
 
                     // Request a render task that will cache the output in the
                     // texture cache.
                     let cache_item = frame_state.resource_cache.request_render_task(
                         RenderTaskCacheKey {
                             size: device_rect.size,
                             kind: RenderTaskCacheKeyKind::Picture(PictureCacheKey {
                                 scene_id: frame_context.scene_id,
                                 picture_id: self.id,
-                                unclipped_size: prim_screen_rect.unclipped.size,
+                                unclipped_size: unclipped.size.to_i32(),
                                 pic_relative_render_rect,
                             }),
                         },
                         frame_state.gpu_cache,
                         frame_state.render_tasks,
                         None,
                         false,
                         |render_tasks| {
                             let child_tasks = mem::replace(&mut pic_state_for_children.tasks, Vec::new());
 
                             let picture_task = RenderTask::new_picture(
                                 RenderTaskLocation::Dynamic(None, device_rect.size),
-                                prim_screen_rect.unclipped.size,
+                                unclipped.size,
                                 prim_index,
                                 device_rect.origin,
                                 child_tasks,
                                 uv_rect_kind,
                             );
 
                             let picture_task_id = render_tasks.add(picture_task);
 
@@ -447,32 +489,31 @@ impl PicturePrimitive {
                 // The clipped field is the part of the picture that is visible
                 // on screen. The unclipped field is the screen-space rect of
                 // the complete picture, if no screen / clip-chain was applied
                 // (this includes the extra space for blur region). To ensure
                 // that we draw a large enough part of the picture to get correct
                 // blur results, inflate that clipped area by the blur range, and
                 // then intersect with the total screen rect, to minimize the
                 // allocation size.
-                let device_rect = prim_screen_rect
-                    .clipped
+                let device_rect = clipped
                     .inflate(blur_range, blur_range)
-                    .intersection(&prim_screen_rect.unclipped)
+                    .intersection(&unclipped.to_i32())
                     .unwrap();
 
                 let uv_rect_kind = calculate_uv_rect_kind(
                     &prim_metadata.local_rect,
                     &prim_context.transform,
                     &device_rect,
                     frame_context.device_pixel_scale,
                 );
 
                 let mut picture_task = RenderTask::new_picture(
                     RenderTaskLocation::Dynamic(None, device_rect.size),
-                    prim_screen_rect.unclipped.size,
+                    unclipped.size,
                     prim_index,
                     device_rect.origin,
                     pic_state_for_children.tasks,
                     uv_rect_kind,
                 );
                 picture_task.mark_for_saving();
 
                 let picture_task_id = frame_state.render_tasks.add(picture_task);
@@ -526,31 +567,31 @@ impl PicturePrimitive {
                     request.push(shadow_rect);
                     request.push([0.0, 0.0, 0.0, 0.0]);
                 }
             }
             Some(PictureCompositeMode::MixBlend(..)) => {
                 let uv_rect_kind = calculate_uv_rect_kind(
                     &prim_metadata.local_rect,
                     &prim_context.transform,
-                    &prim_screen_rect.clipped,
+                    &clipped,
                     frame_context.device_pixel_scale,
                 );
 
                 let picture_task = RenderTask::new_picture(
-                    RenderTaskLocation::Dynamic(None, prim_screen_rect.clipped.size),
-                    prim_screen_rect.unclipped.size,
+                    RenderTaskLocation::Dynamic(None, clipped.size),
+                    unclipped.size,
                     prim_index,
-                    prim_screen_rect.clipped.origin,
+                    clipped.origin,
                     pic_state_for_children.tasks,
                     uv_rect_kind,
                 );
 
                 let readback_task_id = frame_state.render_tasks.add(
-                    RenderTask::new_readback(prim_screen_rect.clipped)
+                    RenderTask::new_readback(clipped)
                 );
 
                 self.secondary_render_task_id = Some(readback_task_id);
                 pic_state.tasks.push(readback_task_id);
 
                 let render_task_id = frame_state.render_tasks.add(picture_task);
                 pic_state.tasks.push(render_task_id);
                 self.surface = Some(PictureSurface::RenderTask(render_task_id));
@@ -562,46 +603,46 @@ impl PicturePrimitive {
                             request.push([m[i*4], m[i*4+1], m[i*4+2], m[i*4+3]]);
                         }
                     }
                 }
 
                 let uv_rect_kind = calculate_uv_rect_kind(
                     &prim_metadata.local_rect,
                     &prim_context.transform,
-                    &prim_screen_rect.clipped,
+                    &clipped,
                     frame_context.device_pixel_scale,
                 );
 
                 let picture_task = RenderTask::new_picture(
-                    RenderTaskLocation::Dynamic(None, prim_screen_rect.clipped.size),
-                    prim_screen_rect.unclipped.size,
+                    RenderTaskLocation::Dynamic(None, clipped.size),
+                    unclipped.size,
                     prim_index,
-                    prim_screen_rect.clipped.origin,
+                    clipped.origin,
                     pic_state_for_children.tasks,
                     uv_rect_kind,
                 );
 
                 let render_task_id = frame_state.render_tasks.add(picture_task);
                 pic_state.tasks.push(render_task_id);
                 self.surface = Some(PictureSurface::RenderTask(render_task_id));
             }
             Some(PictureCompositeMode::Blit) | None => {
                 let uv_rect_kind = calculate_uv_rect_kind(
                     &prim_metadata.local_rect,
                     &prim_context.transform,
-                    &prim_screen_rect.clipped,
+                    &clipped,
                     frame_context.device_pixel_scale,
                 );
 
                 let picture_task = RenderTask::new_picture(
-                    RenderTaskLocation::Dynamic(None, prim_screen_rect.clipped.size),
-                    prim_screen_rect.unclipped.size,
+                    RenderTaskLocation::Dynamic(None, clipped.size),
+                    unclipped.size,
                     prim_index,
-                    prim_screen_rect.clipped.origin,
+                    clipped.origin,
                     pic_state_for_children.tasks,
                     uv_rect_kind,
                 );
 
                 let render_task_id = frame_state.render_tasks.add(picture_task);
                 pic_state.tasks.push(render_task_id);
                 self.surface = Some(PictureSurface::RenderTask(render_task_id));
             }
--- a/gfx/webrender/src/prim_store.rs
+++ b/gfx/webrender/src/prim_store.rs
@@ -1,41 +1,42 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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, BorderRadius, BuiltDisplayList, ClipMode, ColorF};
-use api::{DeviceIntRect, DeviceIntSize, DevicePixelScale, ExtendMode, LayoutTransform};
+use api::{AlphaType, BorderRadius, BuiltDisplayList, ClipMode, ColorF, PictureRect};
+use api::{DeviceIntRect, DeviceIntSize, DevicePixelScale, ExtendMode};
 use api::{FilterOp, GlyphInstance, GradientStop, ImageKey, ImageRendering, ItemRange, ItemTag, TileOffset};
 use api::{GlyphRasterSpace, LayoutPoint, LayoutRect, LayoutSize, LayoutToWorldTransform, LayoutVector2D};
 use api::{PremultipliedColorF, PropertyBinding, Shadow, YuvColorSpace, YuvFormat, DeviceIntSideOffsets};
-use api::{BorderWidths, BoxShadowClipMode, LayoutToWorldScale, NormalBorder};
+use api::{BorderWidths, BoxShadowClipMode, LayoutToWorldScale, NormalBorder, WorldRect};
 use app_units::Au;
 use border::{BorderCacheKey, BorderRenderTaskInfo};
 use clip_scroll_tree::{ClipScrollTree, CoordinateSystemId, SpatialNodeIndex};
 use clip::{ClipNodeFlags, ClipChainId, ClipChainInstance, ClipItem};
+use euclid::{TypedVector2D, TypedTransform3D, TypedRect};
 use frame_builder::{FrameBuildingContext, FrameBuildingState, PictureContext, PictureState};
 use frame_builder::PrimitiveContext;
 use glyph_rasterizer::{FontInstance, FontTransform, GlyphKey, FONT_SIZE_LIMIT};
 use gpu_cache::{GpuBlockData, GpuCache, GpuCacheAddress, GpuCacheHandle, GpuDataRequest,
                 ToGpuBlocks};
 use gpu_types::BrushFlags;
 use image::{for_each_tile, for_each_repetition};
 use picture::{PictureCompositeMode, PicturePrimitive};
 #[cfg(debug_assertions)]
 use render_backend::FrameId;
 use render_task::{BlitSource, RenderTask, RenderTaskCacheKey};
 use render_task::{RenderTaskCacheKeyKind, RenderTaskId, RenderTaskCacheEntryHandle};
 use renderer::{MAX_VERTEX_TEXTURE_WIDTH};
 use resource_cache::{ImageProperties, ImageRequest, ResourceCache};
 use scene::SceneProperties;
 use segment::SegmentBuilder;
-use std::{cmp, mem, usize};
-use util::{MatrixHelpers, calculate_screen_bounding_rect};
-use util::{pack_as_float, recycle_vec, TransformedRectKind};
+use std::{cmp, fmt, mem, usize};
+use util::{MatrixHelpers, pack_as_float, recycle_vec, project_rect};
+use util::{TransformedRectKind, world_rect_to_device_pixels};
 
 
 const MIN_BRUSH_SPLIT_AREA: f32 = 256.0 * 256.0;
 pub const VECS_PER_SEGMENT: usize = 2;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct ScrollNodeAndClipChain {
     pub spatial_node_index: SpatialNodeIndex,
@@ -54,18 +55,18 @@ impl ScrollNodeAndClipChain {
     }
 }
 
 // This is CPU-side information about a transform, that is relevant
 // during culling and primitive prep pass. Often it is the same as
 // the information in the clip-scroll tree. However, if we decide
 // to rasterize a picture in local space, then this will be the
 // transform relative to that picture's coordinate system.
-pub struct Transform<'a> {
-    pub m: &'a LayoutToWorldTransform,
+pub struct Transform {
+    pub m: LayoutToWorldTransform,
     pub backface_is_visible: bool,
     pub transform_kind: TransformedRectKind,
 }
 
 #[derive(Debug)]
 pub struct PrimitiveRun {
     pub base_prim_index: PrimitiveIndex,
     pub count: usize,
@@ -99,50 +100,33 @@ impl PrimitiveOpacity {
     pub fn from_alpha(alpha: f32) -> PrimitiveOpacity {
         PrimitiveOpacity {
             is_opaque: alpha == 1.0,
         }
     }
 }
 
 #[derive(Debug)]
-pub enum CoordinateSpaceMapping {
+pub enum CoordinateSpaceMapping<F, T> {
     Local,
-    Offset(LayoutVector2D),
-    Transform(LayoutTransform),
+    Offset(TypedVector2D<f32, F>),
+    Transform(TypedTransform3D<f32, F, T>),
 }
 
-// Represents the local space rect of a list of
-// primitive runs. For most primitive runs, the
-// primitive runs are attached to the parent they
-// are declared in. However, when a primitive run
-// is part of a 3d rendering context, it may get
-// hoisted to a higher level in the picture tree.
-// When this happens, we need to also calculate the
-// local space rects in the original space. This
-// allows constructing the true world space polygons
-// for the primitive, to enable the plane splitting
-// logic to work correctly.
-// TODO(gw) In the future, we can probably simplify
-//          this - perhaps calculate the world space
-//          polygons directly and store internally
-//          in the picture structure.
 #[derive(Debug)]
-pub struct LocalRectBuilder {
-    kind: CoordinateSpaceMapping,
-    ref_spatial_node_index: SpatialNodeIndex,
+pub struct SpaceMapper<F, T> {
+    kind: CoordinateSpaceMapping<F, T>,
+    pub ref_spatial_node_index: SpatialNodeIndex,
     current_target_spatial_node_index: SpatialNodeIndex,
-    pub local_rect: LayoutRect,
 }
 
-impl LocalRectBuilder {
+impl<F, T> SpaceMapper<F, T> where F: fmt::Debug {
     pub fn new(ref_spatial_node_index: SpatialNodeIndex) -> Self {
-        LocalRectBuilder {
+        SpaceMapper {
             kind: CoordinateSpaceMapping::Local,
-            local_rect: LayoutRect::zero(),
             ref_spatial_node_index,
             current_target_spatial_node_index: ref_spatial_node_index,
         }
     }
 
     pub fn set_target_spatial_node(
         &mut self,
         target_node_index: SpatialNodeIndex,
@@ -152,45 +136,52 @@ impl LocalRectBuilder {
             let spatial_nodes = &clip_scroll_tree.spatial_nodes;
             let ref_spatial_node = &spatial_nodes[self.ref_spatial_node_index.0];
             let target_spatial_node = &spatial_nodes[target_node_index.0];
             self.current_target_spatial_node_index = target_node_index;
 
             self.kind = if self.ref_spatial_node_index == target_node_index {
                 CoordinateSpaceMapping::Local
             } else if ref_spatial_node.coordinate_system_id == target_spatial_node.coordinate_system_id {
-                let offset = target_spatial_node.coordinate_system_relative_offset -
-                             ref_spatial_node.coordinate_system_relative_offset;
+                let offset = TypedVector2D::new(
+                    target_spatial_node.coordinate_system_relative_offset.x -
+                        ref_spatial_node.coordinate_system_relative_offset.x,
+                    target_spatial_node.coordinate_system_relative_offset.y -
+                        ref_spatial_node.coordinate_system_relative_offset.y,
+                );
                 CoordinateSpaceMapping::Offset(offset)
             } else {
                 let transform = clip_scroll_tree.get_relative_transform(
                     target_node_index,
                     self.ref_spatial_node_index,
                 ).expect("bug: should have already been culled");
-                CoordinateSpaceMapping::Transform(transform)
+
+                CoordinateSpaceMapping::Transform(
+                    transform.with_source::<F>().with_destination::<T>()
+                )
             };
         }
     }
 
-    pub fn accumulate(&mut self, rect: &LayoutRect) {
+    pub fn map(&self, rect: &TypedRect<f32, F>) -> Option<TypedRect<f32, T>> {
         match self.kind {
             CoordinateSpaceMapping::Local => {
-                self.local_rect = self.local_rect.union(rect);
+                Some(TypedRect::from_untyped(&rect.to_untyped()))
             }
             CoordinateSpaceMapping::Offset(ref offset) => {
-                let rect = rect.translate(offset);
-                self.local_rect = self.local_rect.union(&rect);
+                Some(TypedRect::from_untyped(&rect.translate(offset).to_untyped()))
             }
             CoordinateSpaceMapping::Transform(ref transform) => {
-                match transform.transform_rect(rect) {
+                match project_rect(transform, rect) {
                     Some(bounds) => {
-                        self.local_rect = self.local_rect.union(&bounds);
+                        Some(bounds)
                     }
                     None => {
                         warn!("parent relative transform can't transform the primitive rect for {:?}", rect);
+                        None
                     }
                 }
             }
         }
     }
 }
 
 /// For external images, it's not possible to know the
@@ -223,22 +214,16 @@ impl GpuCacheAddress {
     pub fn as_int(&self) -> i32 {
         // TODO(gw): Temporarily encode GPU Cache addresses as a single int.
         //           In the future, we can change the PrimitiveInstance struct
         //           to use 2x u16 for the vertex attribute instead of an i32.
         self.v as i32 * MAX_VERTEX_TEXTURE_WIDTH as i32 + self.u as i32
     }
 }
 
-#[derive(Debug, Copy, Clone)]
-pub struct ScreenRect {
-    pub clipped: DeviceIntRect,
-    pub unclipped: DeviceIntRect,
-}
-
 // TODO(gw): Pack the fields here better!
 #[derive(Debug)]
 pub struct PrimitiveMetadata {
     pub opacity: PrimitiveOpacity,
     pub clip_chain_id: ClipChainId,
     pub spatial_node_index: SpatialNodeIndex,
     pub gpu_location: GpuCacheHandle,
     pub clip_task_id: Option<RenderTaskId>,
@@ -249,17 +234,17 @@ pub struct PrimitiveMetadata {
     pub local_rect: LayoutRect,
     pub local_clip_rect: LayoutRect,
 
     // The current combined local clip for this primitive, from
     // the primitive local clip above and the current clip chain.
     pub combined_local_clip_rect: LayoutRect,
 
     pub is_backface_visible: bool,
-    pub screen_rect: Option<ScreenRect>,
+    pub clipped_world_rect: Option<WorldRect>,
 
     /// A tag used to identify this primitive outside of WebRender. This is
     /// used for returning useful data during hit testing.
     pub tag: Option<ItemTag>,
 
     /// The last frame ID (of the `RenderTaskTree`) this primitive
     /// was prepared for rendering in.
     #[cfg(debug_assertions)]
@@ -534,16 +519,27 @@ impl BrushPrimitive {
         segment_desc: Option<BrushSegmentDescriptor>,
     ) -> Self {
         BrushPrimitive {
             kind,
             segment_desc,
         }
     }
 
+    pub fn may_need_clip_mask(&self) -> bool {
+        match self.kind {
+            BrushKind::Picture(ref pic) => {
+                pic.composite_mode.is_some()
+            }
+            _ => {
+                true
+            }
+        }
+    }
+
     pub fn new_picture(prim: PicturePrimitive) -> Self {
         BrushPrimitive {
             kind: BrushKind::Picture(prim),
             segment_desc: None,
         }
     }
 
     fn write_gpu_blocks(
@@ -1384,17 +1380,17 @@ impl PrimitiveStore {
             clip_chain_id,
             gpu_location: GpuCacheHandle::new(),
             clip_task_id: None,
             spatial_node_index,
             local_rect: *local_rect,
             local_clip_rect: *local_clip_rect,
             combined_local_clip_rect: *local_clip_rect,
             is_backface_visible,
-            screen_rect: None,
+            clipped_world_rect: None,
             tag,
             opacity: PrimitiveOpacity::translucent(),
             #[cfg(debug_assertions)]
             prepared_frame_id: FrameId(0),
         };
 
         let prim = match container {
             PrimitiveContainer::Brush(brush) => {
@@ -1560,238 +1556,251 @@ impl PrimitiveStore {
         prim_index: PrimitiveIndex,
         prim_context: &PrimitiveContext,
         pic_context: &PictureContext,
         pic_state: &mut PictureState,
         frame_context: &FrameBuildingContext,
         frame_state: &mut FrameBuildingState,
         display_list: &BuiltDisplayList,
         is_chased: bool,
-    ) -> Option<LayoutRect> {
-        let mut may_need_clip_mask = true;
-        let mut pic_state_for_children = PictureState::new();
-
+        root_spatial_node_index: SpatialNodeIndex,
+        current_pic_rect: &mut PictureRect,
+    ) -> bool {
         // If we have dependencies, we need to prepare them first, in order
         // to know the actual rect of this primitive.
         // For example, scrolling may affect the location of an item in
         // local space, which may force us to render this item on a larger
         // picture target, if being composited.
         let pic_context_for_children = {
             match self.primitives[prim_index.0].details {
-                PrimitiveDetails::Brush(ref mut brush) => {
-                    match brush.kind {
-                        BrushKind::Picture(ref mut pic) => {
-                            if !pic.resolve_scene_properties(frame_context.scene_properties) {
-                                if cfg!(debug_assertions) && is_chased {
-                                    println!("\tculled for carrying an invisible composite filter");
-                                }
-                                return None;
-                            }
-
-                            may_need_clip_mask = pic.composite_mode.is_some();
-
-                            // Mark whether this picture has a complex coordinate system.
-                            pic_state_for_children.has_non_root_coord_system |=
-                                prim_context.spatial_node.coordinate_system_id != CoordinateSystemId::root();
-
-                            Some(pic.take_context(pic_context.allow_subpixel_aa))
-                        }
-                        _ => {
-                            None
-                        }
+                PrimitiveDetails::Brush(BrushPrimitive { kind: BrushKind::Picture(ref mut pic), .. }) => {
+                    match pic.take_context(
+                        pic_context.allow_subpixel_aa,
+                        frame_context.scene_properties,
+                        is_chased,
+                    ) {
+                        Some(pic_context_for_children) => Some(pic_context_for_children),
+                        None => return false,
                     }
                 }
+                PrimitiveDetails::Brush(_) |
                 PrimitiveDetails::TextRun(..) => {
                     None
                 }
             }
         };
 
-        if let Some(pic_context_for_children) = pic_context_for_children {
-            let mut local_rect_builder = LocalRectBuilder::new(
-                prim_context.spatial_node_index,
-            );
+        let is_passthrough = match pic_context_for_children {
+            Some(pic_context_for_children) => {
+                let has_surface = pic_context_for_children.has_surface;
 
-            self.prepare_prim_runs(
-                &pic_context_for_children,
-                &mut pic_state_for_children,
-                frame_context,
-                frame_state,
-                &mut local_rect_builder,
-            );
+                let root_spatial_node_index = if has_surface {
+                    prim_context.spatial_node_index
+                } else {
+                    root_spatial_node_index
+                };
 
-            // Restore the dependencies (borrow check dance)
-            let prim = &mut self.primitives[prim_index.0];
-            let new_local_rect = prim
-                .as_pic_mut()
-                .restore_context(
-                    pic_context_for_children,
-                    local_rect_builder,
+                let mut pic_state_for_children = PictureState::new(
+                    root_spatial_node_index,
+                    frame_context.clip_scroll_tree,
                 );
 
-            if new_local_rect != prim.metadata.local_rect {
-                prim.metadata.local_rect = new_local_rect;
-                frame_state.gpu_cache.invalidate(&mut prim.metadata.gpu_location);
-                pic_state.local_rect_changed = true;
-            }
-        }
+                // Mark whether this picture has a complex coordinate system.
+                pic_state_for_children.has_non_root_coord_system |=
+                    prim_context.spatial_node.coordinate_system_id != CoordinateSystemId::root();
 
-        let prim = &mut self.primitives[prim_index.0];
+                let mut pic_rect = PictureRect::zero();
+                self.prepare_prim_runs(
+                    &pic_context_for_children,
+                    &mut pic_state_for_children,
+                    frame_context,
+                    frame_state,
+                    root_spatial_node_index,
+                    &mut pic_rect,
+                );
 
-        if prim.metadata.local_rect.size.width <= 0.0 ||
-           prim.metadata.local_rect.size.height <= 0.0 {
-            if cfg!(debug_assertions) && is_chased {
-                println!("\tculled for zero local rectangle");
-            }
-            return None;
-        }
+                let pic_rect = if has_surface {
+                    Some(pic_rect)
+                } else {
+                    *current_pic_rect = current_pic_rect.union(&pic_rect);
+                    None
+                };
 
-        // Inflate the local rect for this primitive by the inflation factor of
-        // the picture context. This ensures that even if the primitive itself
-        // is not visible, any effects from the blur radius will be correctly
-        // taken into account.
-        let local_rect = prim
-            .metadata
-            .local_rect
-            .inflate(pic_context.inflation_factor, pic_context.inflation_factor)
-            .intersection(&prim.metadata.local_clip_rect);
-        let local_rect = match local_rect {
-            Some(local_rect) => local_rect,
+                // Restore the dependencies (borrow check dance)
+                let prim = &mut self.primitives[prim_index.0];
+                let new_local_rect = prim
+                    .as_pic_mut()
+                    .restore_context(
+                        pic_context_for_children,
+                        pic_state_for_children,
+                        pic_rect,
+                    );
+
+                if new_local_rect != prim.metadata.local_rect {
+                    prim.metadata.local_rect = new_local_rect;
+                    frame_state.gpu_cache.invalidate(&mut prim.metadata.gpu_location);
+                    pic_state.local_rect_changed = true;
+                }
+
+                !has_surface
+            }
             None => {
-                if cfg!(debug_assertions) && is_chased {
-                    println!("\tculled for being out of the local clip rectangle: {:?}",
-                        prim.metadata.local_clip_rect);
-                }
-                return None
+                false
             }
         };
 
-        let clip_chain = frame_state
-            .clip_store
-            .build_clip_chain_instance(
-                prim.metadata.clip_chain_id,
-                local_rect,
-                prim.metadata.local_clip_rect,
-                prim_context.spatial_node_index,
-                &frame_context.clip_scroll_tree,
-                frame_state.gpu_cache,
-                frame_state.resource_cache,
-                frame_context.device_pixel_scale,
+        let prim = &mut self.primitives[prim_index.0];
+
+        if is_passthrough {
+            prim.metadata.clipped_world_rect = Some(frame_context.world_rect);
+        } else {
+            if prim.metadata.local_rect.size.width <= 0.0 ||
+               prim.metadata.local_rect.size.height <= 0.0 {
+                if cfg!(debug_assertions) && is_chased {
+                    println!("\tculled for zero local rectangle");
+                }
+                return false;
+            }
+
+            // Inflate the local rect for this primitive by the inflation factor of
+            // the picture context. This ensures that even if the primitive itself
+            // is not visible, any effects from the blur radius will be correctly
+            // taken into account.
+            let local_rect = prim
+                .metadata
+                .local_rect
+                .inflate(pic_context.inflation_factor, pic_context.inflation_factor)
+                .intersection(&prim.metadata.local_clip_rect);
+            let local_rect = match local_rect {
+                Some(local_rect) => local_rect,
+                None => {
+                    if cfg!(debug_assertions) && is_chased {
+                        println!("\tculled for being out of the local clip rectangle: {:?}",
+                            prim.metadata.local_clip_rect);
+                    }
+                    return false;
+                }
+            };
+
+            let clip_chain = frame_state
+                .clip_store
+                .build_clip_chain_instance(
+                    prim.metadata.clip_chain_id,
+                    local_rect,
+                    prim.metadata.local_clip_rect,
+                    prim_context.spatial_node_index,
+                    &pic_state.map_local_to_pic,
+                    &pic_state.map_pic_to_world,
+                    &frame_context.clip_scroll_tree,
+                    frame_state.gpu_cache,
+                    frame_state.resource_cache,
+                    frame_context.device_pixel_scale,
+                );
+
+            let clip_chain = match clip_chain {
+                Some(clip_chain) => clip_chain,
+                None => {
+                    prim.metadata.clipped_world_rect = None;
+                    return false;
+                }
+            };
+
+            if cfg!(debug_assertions) && is_chased {
+                println!("\teffective clip chain from {:?} {}",
+                    clip_chain.clips_range,
+                    if pic_context.apply_local_clip_rect { "(applied)" } else { "" },
+                );
+            }
+
+            pic_state.has_non_root_coord_system |= clip_chain.has_non_root_coord_system;
+
+            prim.metadata.combined_local_clip_rect = if pic_context.apply_local_clip_rect {
+                clip_chain.local_clip_rect
+            } else {
+                prim.metadata.local_clip_rect
+            };
+
+            let pic_rect = match pic_state.map_local_to_pic
+                                          .map(&prim.metadata.local_rect) {
+                Some(pic_rect) => pic_rect,
+                None => return false,
+            };
+
+            // Check if the clip bounding rect (in pic space) is visible on screen
+            // This includes both the prim bounding rect + local prim clip rect!
+            let world_rect = match pic_state.map_pic_to_world
+                                            .map(&clip_chain.pic_clip_rect) {
+                Some(world_rect) => world_rect,
+                None => {
+                    return false;
+                }
+            };
+
+            let clipped_world_rect = match world_rect.intersection(&frame_context.world_rect) {
+                Some(rect) => rect,
+                None => {
+                    return false;
+                }
+            };
+
+            prim.metadata.clipped_world_rect = Some(clipped_world_rect);
+
+            prim.build_prim_segments_if_needed(
+                pic_state,
+                frame_state,
+                frame_context,
             );
 
-        let clip_chain = match clip_chain {
-            Some(clip_chain) => clip_chain,
-            None => {
-                prim.metadata.screen_rect = None;
-                return None;
-            }
-        };
-
-        if cfg!(debug_assertions) && is_chased {
-            println!("\teffective clip chain from {:?} {}",
-                clip_chain.clips_range,
-                if pic_context.apply_local_clip_rect { "(applied)" } else { "" },
+            prim.update_clip_task(
+                prim_context,
+                clipped_world_rect,
+                &clip_chain,
+                pic_state,
+                frame_context,
+                frame_state,
+                is_chased,
             );
-        }
-
-        pic_state.has_non_root_coord_system |= clip_chain.has_non_root_coord_system;
-
-        let unclipped_device_rect = match calculate_screen_bounding_rect(
-            &prim_context.spatial_node.world_content_transform,
-            &local_rect,
-            frame_context.device_pixel_scale,
-            None, //TODO: inflate `frame_context.screen_rect` appropriately
-        ) {
-            Some(rect) => rect,
-            None => {
-                if cfg!(debug_assertions) && is_chased {
-                    println!("\tculled for being behind the near plane of transform: {:?}",
-                        prim_context.spatial_node.world_content_transform);
-                }
-                return None
-            }
-        };
-
-        let clipped_device_rect = (clip_chain.world_clip_rect * frame_context.device_pixel_scale)
-            .round_out()
-            .to_i32();
 
-        let clipped_device_rect = match clipped_device_rect.intersection(&frame_context.screen_rect) {
-            Some(clipped_device_rect) => clipped_device_rect,
-            None => return None,
-        };
-
-        prim.metadata.screen_rect = Some(ScreenRect {
-            clipped: clipped_device_rect,
-            unclipped: unclipped_device_rect,
-        });
-
-        prim.metadata.combined_local_clip_rect = if pic_context.apply_local_clip_rect {
-            clip_chain.local_clip_rect
-        } else {
-            prim.metadata.local_clip_rect
-        };
-
-        let ccr = match prim.metadata.combined_local_clip_rect.intersection(&local_rect) {
-            Some(ccr) => ccr,
-            None => return None,
-        };
+            if cfg!(debug_assertions) && is_chased {
+                println!("\tconsidered visible and ready with local rect {:?}", local_rect);
+            }
 
-        prim.build_prim_segments_if_needed(
-            pic_state,
-            frame_state,
-            frame_context,
-        );
-
-        if may_need_clip_mask && !prim.update_clip_task(
-            prim_context,
-            &clipped_device_rect,
-            &clip_chain,
-            pic_state,
-            frame_context,
-            frame_state,
-            is_chased,
-        ) {
-            return None;
-        }
-
-        if cfg!(debug_assertions) && is_chased {
-            println!("\tconsidered visible and ready with local rect {:?}", local_rect);
+            *current_pic_rect = current_pic_rect.union(&pic_rect);
         }
 
         prim.prepare_prim_for_render_inner(
             prim_index,
             prim_context,
-            pic_state_for_children,
             pic_context,
             pic_state,
             frame_context,
             frame_state,
             display_list,
             is_chased,
         );
 
-        Some(ccr)
+        true
     }
 
     // TODO(gw): Make this simpler / more efficient by tidying
     //           up the logic that early outs from prepare_prim_for_render.
     pub fn reset_prim_visibility(&mut self) {
         for prim in &mut self.primitives {
-            prim.metadata.screen_rect = None;
+            prim.metadata.clipped_world_rect = None;
         }
     }
 
     pub fn prepare_prim_runs(
         &mut self,
         pic_context: &PictureContext,
         pic_state: &mut PictureState,
         frame_context: &FrameBuildingContext,
         frame_state: &mut FrameBuildingState,
-        local_rect_builder: &mut LocalRectBuilder,
+        root_spatial_node_index: SpatialNodeIndex,
+        current_pic_rect: &mut PictureRect,
     ) {
         let display_list = &frame_context
             .pipelines
             .get(&pic_context.pipeline_id)
             .expect("No display list?")
             .display_list;
 
         for run in &pic_context.prim_runs {
@@ -1845,33 +1854,34 @@ impl PrimitiveStore {
                     continue;
                 }
 
                 // Mark whether this picture contains any complex coordinate
                 // systems, due to either the scroll node or the clip-chain.
                 pic_state.has_non_root_coord_system |=
                     spatial_node.coordinate_system_id != CoordinateSystemId::root();
 
-                local_rect_builder.set_target_spatial_node(
+                pic_state.map_local_to_pic.set_target_spatial_node(
                     spatial_node_index,
                     &frame_context.clip_scroll_tree,
                 );
 
-                if let Some(prim_local_rect) = self.prepare_prim_for_render(
+                if self.prepare_prim_for_render(
                     prim_index,
                     &prim_context,
                     pic_context,
                     pic_state,
                     frame_context,
                     frame_state,
                     display_list,
                     is_chased,
+                    root_spatial_node_index,
+                    current_pic_rect,
                 ) {
                     frame_state.profile_counters.visible_primitives.inc();
-                    local_rect_builder.accumulate(&prim_local_rect);
                 }
             }
         }
     }
 }
 
 fn build_gradient_stops_request(
     stops_handle: &mut GpuCacheHandle,
@@ -1893,38 +1903,35 @@ fn build_gradient_stops_request(
 }
 
 fn decompose_repeated_primitive(
     visible_tiles: &mut Vec<VisibleGradientTile>,
     metadata: &mut PrimitiveMetadata,
     stretch_size: &LayoutSize,
     tile_spacing: &LayoutSize,
     prim_context: &PrimitiveContext,
-    frame_context: &FrameBuildingContext,
     frame_state: &mut FrameBuildingState,
     callback: &mut FnMut(&LayoutRect, GpuDataRequest),
 ) {
     visible_tiles.clear();
 
     // Tighten the clip rect because decomposing the repeated image can
     // produce primitives that are partially covering the original image
     // rect and we want to clip these extra parts out.
     let tight_clip_rect = metadata
         .combined_local_clip_rect
         .intersection(&metadata.local_rect).unwrap();
 
-    let unclipped_device_rect = &metadata
-        .screen_rect
-        .unwrap()
-        .unclipped;
+    let clipped_world_rect = &metadata
+        .clipped_world_rect
+        .unwrap();
 
     let visible_rect = compute_conservative_visible_rect(
         prim_context,
-        frame_context,
-        unclipped_device_rect,
+        clipped_world_rect,
         &tight_clip_rect
     );
     let stride = *stretch_size + *tile_spacing;
 
     for_each_repetition(
         &metadata.local_rect,
         &visible_rect,
         &stride,
@@ -1948,33 +1955,29 @@ fn decompose_repeated_primitive(
     );
 
     if visible_tiles.is_empty() {
         // At this point if we don't have tiles to show it means we could probably
         // have done a better a job at culling during an earlier stage.
         // Clearing the screen rect has the effect of "culling out" the primitive
         // from the point of view of the batch builder, and ensures we don't hit
         // assertions later on because we didn't request any image.
-        metadata.screen_rect = None;
+        metadata.clipped_world_rect = None;
     }
 }
 
 fn compute_conservative_visible_rect(
     prim_context: &PrimitiveContext,
-    frame_context: &FrameBuildingContext,
-    clipped_device_rect: &DeviceIntRect,
+    clipped_world_rect: &WorldRect,
     local_clip_rect: &LayoutRect,
 ) -> LayoutRect {
-    let world_screen_rect = clipped_device_rect
-        .to_f32() / frame_context.device_pixel_scale;
-
     if let Some(layer_screen_rect) = prim_context
         .spatial_node
         .world_content_transform
-        .unapply(&world_screen_rect) {
+        .unapply(clipped_world_rect) {
 
         return local_clip_rect.intersection(&layer_screen_rect).unwrap_or(LayoutRect::zero());
     }
 
     *local_clip_rect
 }
 
 fn edge_flags_for_tile_spacing(tile_spacing: &LayoutSize) -> EdgeAaSegmentMask {
@@ -2161,25 +2164,23 @@ fn write_brush_segment_description(
             }
         }
     }
 }
 
 impl Primitive {
     fn update_clip_task_for_brush(
         &mut self,
+        clipped_world_rect: &WorldRect,
         prim_context: &PrimitiveContext,
         prim_clip_chain: &ClipChainInstance,
-        combined_outer_rect: &DeviceIntRect,
         pic_state: &mut PictureState,
         frame_context: &FrameBuildingContext,
         frame_state: &mut FrameBuildingState,
     ) -> bool {
-        debug_assert!(frame_context.screen_rect.contains_rect(combined_outer_rect));
-
         let brush = match self.details {
             PrimitiveDetails::Brush(ref mut brush) => brush,
             PrimitiveDetails::TextRun(..) => return false,
         };
 
         write_brush_segment_description(
             brush,
             &self.metadata,
@@ -2198,36 +2199,55 @@ impl Primitive {
             // clip the segment completely.
             let segment_clip_chain = frame_state
                 .clip_store
                 .build_clip_chain_instance(
                     self.metadata.clip_chain_id,
                     segment.local_rect,
                     self.metadata.local_clip_rect,
                     prim_context.spatial_node_index,
+                    &pic_state.map_local_to_pic,
+                    &pic_state.map_pic_to_world,
                     &frame_context.clip_scroll_tree,
                     frame_state.gpu_cache,
                     frame_state.resource_cache,
                     frame_context.device_pixel_scale,
                 );
 
             match segment_clip_chain {
                 Some(segment_clip_chain) => {
                     if segment_clip_chain.clips_range.count == 0 ||
                        (!segment.may_need_clip_mask && !segment_clip_chain.has_non_local_clips) {
                         segment.clip_task_id = BrushSegmentTaskId::Opaque;
                         continue;
                     }
 
-                    let bounds = (segment_clip_chain.world_clip_rect * frame_context.device_pixel_scale)
-                        .round_out()
-                        .to_i32();
+                    let world_clip_rect = match pic_state.map_pic_to_world.map(&segment_clip_chain.pic_clip_rect) {
+                        Some(world_clip_rect) => world_clip_rect,
+                        None => {
+                            segment.clip_task_id = BrushSegmentTaskId::Empty;
+                            continue;
+                        }
+                    };
+
+                    let world_clip_rect = match world_clip_rect.intersection(clipped_world_rect) {
+                        Some(world_clip_rect) => world_clip_rect,
+                        None => {
+                            segment.clip_task_id = BrushSegmentTaskId::Empty;
+                            continue;
+                        }
+                    };
+
+                    let bounds = world_rect_to_device_pixels(
+                        world_clip_rect,
+                        frame_context.device_pixel_scale,
+                    );
 
                     let clip_task = RenderTask::new_mask(
-                        bounds,
+                        bounds.to_i32(),
                         segment_clip_chain.clips_range,
                         frame_state.clip_store,
                         frame_state.gpu_cache,
                         frame_state.resource_cache,
                         frame_state.render_tasks,
                     );
 
                     let clip_task_id = frame_state.render_tasks.add(clip_task);
@@ -2238,32 +2258,40 @@ impl Primitive {
                     segment.clip_task_id = BrushSegmentTaskId::Empty;
                 }
             }
         }
 
         true
     }
 
-    fn reset_clip_task(&mut self) {
+    // Returns true if the primitive *might* need a clip mask. If
+    // false, there is no need to even check for clip masks for
+    // this primitive.
+    fn reset_clip_task(&mut self) -> bool {
         self.metadata.clip_task_id = None;
-        if let PrimitiveDetails::Brush(ref mut brush) = self.details {
-            if let Some(ref mut desc) = brush.segment_desc {
-                for segment in &mut desc.segments {
-                    segment.clip_task_id = BrushSegmentTaskId::Opaque;
+        match self.details {
+            PrimitiveDetails::Brush(ref mut brush) => {
+                if let Some(ref mut desc) = brush.segment_desc {
+                    for segment in &mut desc.segments {
+                        segment.clip_task_id = BrushSegmentTaskId::Opaque;
+                    }
                 }
+                brush.may_need_clip_mask()
+            }
+            PrimitiveDetails::TextRun(..) => {
+                true
             }
         }
     }
 
     fn prepare_prim_for_render_inner(
         &mut self,
         prim_index: PrimitiveIndex,
         prim_context: &PrimitiveContext,
-        pic_state_for_children: PictureState,
         pic_context: &PictureContext,
         pic_state: &mut PictureState,
         frame_context: &FrameBuildingContext,
         frame_state: &mut FrameBuildingState,
         display_list: &BuiltDisplayList,
         is_chased: bool,
     ) {
         let mut is_tiled = false;
@@ -2415,30 +2443,28 @@ impl Primitive {
                                 }
                                 ImageSource::Default => {
                                     // Normal images just reference the source texture each frame.
                                     request_source_image = true;
                                 }
                             }
 
                             if let Some(tile_size) = image_properties.tiling {
-
                                 let device_image_size = image_properties.descriptor.size;
 
                                 // Tighten the clip rect because decomposing the repeated image can
                                 // produce primitives that are partially covering the original image
                                 // rect and we want to clip these extra parts out.
                                 let tight_clip_rect = metadata
                                     .combined_local_clip_rect
                                     .intersection(&metadata.local_rect).unwrap();
 
                                 let visible_rect = compute_conservative_visible_rect(
                                     prim_context,
-                                    frame_context,
-                                    &metadata.screen_rect.unwrap().clipped,
+                                    &metadata.clipped_world_rect.unwrap(),
                                     &tight_clip_rect
                                 );
 
                                 let base_edge_flags = edge_flags_for_tile_spacing(tile_spacing);
 
                                 let stride = stretch_size + *tile_spacing;
 
                                 visible_tiles.clear();
@@ -2488,17 +2514,17 @@ impl Primitive {
                                 );
 
                                 if visible_tiles.is_empty() {
                                     // At this point if we don't have tiles to show it means we could probably
                                     // have done a better a job at culling during an earlier stage.
                                     // Clearing the screen rect has the effect of "culling out" the primitive
                                     // from the point of view of the batch builder, and ensures we don't hit
                                     // assertions later on because we didn't request any image.
-                                    metadata.screen_rect = None;
+                                    metadata.clipped_world_rect = None;
                                 }
                             } else if request_source_image {
                                 frame_state.resource_cache.request_image(
                                     request,
                                     frame_state.gpu_cache,
                                 );
                             }
                         }
@@ -2567,17 +2593,16 @@ impl Primitive {
                             is_tiled = true;
 
                             decompose_repeated_primitive(
                                 visible_tiles,
                                 metadata,
                                 &stretch_size,
                                 &tile_spacing,
                                 prim_context,
-                                frame_context,
                                 frame_state,
                                 &mut |rect, mut request| {
                                     request.push([
                                         center.x,
                                         center.y,
                                         start_radius,
                                         end_radius,
                                     ]);
@@ -2617,17 +2642,16 @@ impl Primitive {
                             is_tiled = true;
 
                             decompose_repeated_primitive(
                                 visible_tiles,
                                 metadata,
                                 &stretch_size,
                                 &tile_spacing,
                                 prim_context,
-                                frame_context,
                                 frame_state,
                                 &mut |rect, mut request| {
                                     request.push([
                                         start_point.x,
                                         start_point.y,
                                         end_point.x,
                                         end_point.y,
                                     ]);
@@ -2642,17 +2666,16 @@ impl Primitive {
                             );
                         }
                     }
                     BrushKind::Picture(ref mut pic) => {
                         pic.prepare_for_render(
                             prim_index,
                             metadata,
                             prim_context,
-                            pic_state_for_children,
                             pic_state,
                             frame_context,
                             frame_state,
                         );
                     }
                     BrushKind::Solid { ref color, ref mut opacity_binding, .. } => {
                         // If the opacity changed, invalidate the GPU cache so that
                         // the new color for this primitive gets uploaded. Also update
@@ -2705,64 +2728,70 @@ impl Primitive {
                 }
             }
         }
     }
 
     fn update_clip_task(
         &mut self,
         prim_context: &PrimitiveContext,
-        prim_screen_rect: &DeviceIntRect,
+        clipped_world_rect: WorldRect,
         clip_chain: &ClipChainInstance,
         pic_state: &mut PictureState,
         frame_context: &FrameBuildingContext,
         frame_state: &mut FrameBuildingState,
         is_chased: bool,
-    ) -> bool {
+    ) {
         if cfg!(debug_assertions) && is_chased {
-            println!("\tupdating clip task with screen rect {:?}", prim_screen_rect);
+            println!("\tupdating clip task with pic rect {:?}", clip_chain.pic_clip_rect);
         }
         // Reset clips from previous frames since we may clip differently each frame.
-        self.reset_clip_task();
+        // If this primitive never needs clip masks, just return straight away.
+        if !self.reset_clip_task() {
+            return;
+        }
 
         // First try to  render this primitive's mask using optimized brush rendering.
         if self.update_clip_task_for_brush(
+            &clipped_world_rect,
             prim_context,
             &clip_chain,
-            prim_screen_rect,
             pic_state,
             frame_context,
             frame_state,
         ) {
             if cfg!(debug_assertions) && is_chased {
                 println!("\tsegment tasks have been created for clipping");
             }
-            return true;
+            return;
         }
 
         if clip_chain.clips_range.count > 0 {
+            let device_rect = world_rect_to_device_pixels(
+                clipped_world_rect,
+                frame_context.device_pixel_scale,
+            );
+
             let clip_task = RenderTask::new_mask(
-                *prim_screen_rect,
+                device_rect.to_i32(),
                 clip_chain.clips_range,
                 frame_state.clip_store,
                 frame_state.gpu_cache,
                 frame_state.resource_cache,
                 frame_state.render_tasks,
             );
 
             let clip_task_id = frame_state.render_tasks.add(clip_task);
             if cfg!(debug_assertions) && is_chased {
-                println!("\tcreated task {:?} with combined outer rect {:?}",
-                    clip_task_id, prim_screen_rect);
+                println!("\tcreated task {:?} with world rect {:?}",
+                    clip_task_id, clipped_world_rect);
             }
             self.metadata.clip_task_id = Some(clip_task_id);
             pic_state.tasks.push(clip_task_id);
         }
-
-        true
     }
 
     fn build_prim_segments_if_needed(
         &mut self,
         pic_state: &mut PictureState,
         frame_state: &mut FrameBuildingState,
         frame_context: &FrameBuildingContext,
     ) {
--- a/gfx/webrender/src/render_backend.rs
+++ b/gfx/webrender/src/render_backend.rs
@@ -12,17 +12,18 @@ use api::{ScrollLocation, ScrollNodeStat
 use api::channel::{MsgReceiver, Payload};
 #[cfg(feature = "capture")]
 use api::CaptureBits;
 #[cfg(feature = "replay")]
 use api::CapturedDocument;
 use clip_scroll_tree::{SpatialNodeIndex, ClipScrollTree};
 #[cfg(feature = "debugger")]
 use debug_server;
-use display_list_flattener::DisplayListFlattener;
+#[cfg(feature = "replay")]
+use display_list_flattener::build_scene;
 use frame_builder::{FrameBuilder, FrameBuilderConfig};
 use gpu_cache::GpuCache;
 use hit_test::{HitTest, HitTester};
 use internal_types::{DebugOutput, FastHashMap, FastHashSet, RenderedDocument, ResultMsg};
 use profiler::{BackendProfileCounters, IpcProfileCounters, ResourceProfileCounters};
 use record::ApiRecordingReceiver;
 use renderer::{AsyncPropertySampler, PipelineInfo};
 use resource_cache::ResourceCache;
@@ -255,70 +256,16 @@ impl Document {
             }
             FrameMsg::AppendDynamicProperties(property_bindings) => {
                 self.dynamic_properties.add_properties(property_bindings);
                 DocumentOps::nop()
             }
         }
     }
 
-    // TODO: We will probably get rid of this soon and always forward to the scene building thread.
-    fn build_scene(&mut self, resource_cache: &mut ResourceCache, scene_id: u64) {
-        let max_texture_size = resource_cache.max_texture_size();
-
-        if self.view.window_size.width > max_texture_size ||
-           self.view.window_size.height > max_texture_size {
-            error!("ERROR: Invalid window dimensions {}x{}. Please call api.set_window_size()",
-                self.view.window_size.width,
-                self.view.window_size.height,
-            );
-
-            return;
-        }
-
-        let old_builder = self.frame_builder.take().unwrap_or_else(FrameBuilder::empty);
-        let root_pipeline_id = match self.pending.scene.root_pipeline_id {
-            Some(root_pipeline_id) => root_pipeline_id,
-            None => return,
-        };
-
-        if !self.pending.scene.pipelines.contains_key(&root_pipeline_id) {
-            return;
-        }
-
-        // The DisplayListFlattener  re-create the up-to-date current scene's pipeline epoch
-        // map and clip scroll tree from the information in the pending scene.
-        self.current.scene.pipeline_epochs.clear();
-        let old_scrolling_states = self.clip_scroll_tree.drain();
-
-        let frame_builder = DisplayListFlattener::create_frame_builder(
-            old_builder,
-            &self.pending.scene,
-            &mut self.clip_scroll_tree,
-            resource_cache.get_font_instances(),
-            &self.view,
-            &self.output_pipelines,
-            &self.frame_builder_config,
-            &mut self.current.scene,
-            scene_id,
-        );
-
-        self.clip_scroll_tree.finalize_and_apply_pending_scroll_offsets(old_scrolling_states);
-
-        if !self.current.removed_pipelines.is_empty() {
-            warn!("Built the scene several times without rendering it.");
-        }
-
-        self.current.removed_pipelines.extend(self.pending.removed_pipelines.drain(..));
-        self.frame_builder = Some(frame_builder);
-
-        // Advance to the next frame.
-        self.frame_id.0 += 1;
-    }
-
     fn forward_transaction_to_scene_builder(
         &mut self,
         transaction_msg: TransactionMsg,
         blobs_to_rasterize: &[ImageKey],
         document_ops: &DocumentOps,
         document_id: DocumentId,
         scene_id: u64,
         resource_cache: &mut ResourceCache,
@@ -919,19 +866,23 @@ impl RenderBackend {
                     DebugCommand::EnableDualSourceBlending(enable) => {
                         // Set in the config used for any future documents
                         // that are created.
                         self.frame_config
                             .dual_source_blending_is_enabled = enable;
 
                         // Set for any existing documents.
                         for (_, doc) in &mut self.documents {
-                            doc.frame_builder_config .dual_source_blending_is_enabled = enable;
+                            doc.frame_builder_config.dual_source_blending_is_enabled = enable;
                         }
 
+                        self.scene_tx.send(SceneBuilderRequest::SetFrameBuilderConfig(
+                            self.frame_config.clone()
+                        )).unwrap();
+
                         // We don't want to forward this message to the renderer.
                         return true;
                     }
                     DebugCommand::FetchDocuments => {
                         let json = self.get_docs_for_debugger();
                         ResultMsg::DebugOutput(DebugOutput::FetchDocuments(json))
                     }
                     DebugCommand::FetchClipScrollTree => {
@@ -1020,17 +971,17 @@ impl RenderBackend {
                     document_id,
                     scene_msg,
                     *frame_counter,
                     &mut profile_counters.ipc,
                 )
             );
         }
 
-        if transaction_msg.use_scene_builder_thread {
+        if !has_built_scene && (op.build || transaction_msg.use_scene_builder_thread) {
             let scene_id = self.make_unique_scene_id();
             let doc = self.documents.get_mut(&document_id).unwrap();
 
             doc.forward_transaction_to_scene_builder(
                 transaction_msg,
                 blob_requests,
                 &op,
                 document_id,
@@ -1042,25 +993,16 @@ impl RenderBackend {
             return;
         }
 
         self.resource_cache.post_scene_building_update(
             transaction_msg.resource_updates,
             &mut profile_counters.resources,
         );
 
-        if op.build {
-            let scene_id = self.make_unique_scene_id();
-            let doc = self.documents.get_mut(&document_id).unwrap();
-            let _timer = profile_counters.total_time.timer();
-            profile_scope!("build scene");
-
-            doc.build_scene(&mut self.resource_cache, scene_id);
-        }
-
         // If we have a sampler, get more frame ops from it and add them
         // to the transaction. This is a hook to allow the WR user code to
         // fiddle with things after a potentially long scene build, but just
         // before rendering. This is useful for rendering with the latest
         // async transforms.
         if op.render || transaction_msg.generate_frame {
             if let Some(ref sampler) = self.sampler {
                 transaction_msg.frame_ops.append(&mut sampler.sample());
@@ -1109,17 +1051,17 @@ impl RenderBackend {
             let (pending_update, rendered_document) = {
                 let _timer = profile_counters.total_time.timer();
                 let render_start_time = precise_time_ns();
 
                 let rendered_document = doc.render(
                     &mut self.resource_cache,
                     &mut self.gpu_cache,
                     &mut profile_counters.resources,
-                    op.build || has_built_scene,
+                    has_built_scene,
                 );
 
                 debug!("generated frame for document {:?} with {} passes",
                     document_id, rendered_document.frame.passes.len());
 
                 let msg = ResultMsg::UpdateGpuCache(self.gpu_cache.extract_updates());
                 self.result_tx.send(msg).unwrap();
 
@@ -1426,17 +1368,17 @@ impl RenderBackend {
                 current: SceneData {
                     scene: scene.clone(),
                     removed_pipelines: Vec::new(),
                 },
                 pending: SceneData {
                     scene,
                     removed_pipelines: Vec::new(),
                 },
-                view,
+                view: view.clone(),
                 clip_scroll_tree: ClipScrollTree::new(),
                 frame_id: FrameId(0),
                 frame_builder_config: self.frame_config.clone(),
                 frame_builder: Some(FrameBuilder::empty()),
                 output_pipelines: FastHashSet::default(),
                 render_on_scroll: None,
                 dynamic_properties: SceneProperties::new(),
                 hit_tester: None,
@@ -1445,17 +1387,25 @@ impl RenderBackend {
             let frame_name = format!("frame-{}-{}", (id.0).0, id.1);
             let render_doc = match CaptureConfig::deserialize::<Frame, _>(root, frame_name) {
                 Some(frame) => {
                     info!("\tloaded a built frame with {} passes", frame.passes.len());
                     RenderedDocument { frame, is_new_scene: true }
                 }
                 None => {
                     last_scene_id += 1;
-                    doc.build_scene(&mut self.resource_cache, last_scene_id);
+                    let built_scene = build_scene(&self.frame_config, SceneRequest {
+                        scene: doc.pending.scene.clone(),
+                        view,
+                        font_instances: self.resource_cache.get_font_instances(),
+                        output_pipelines: doc.output_pipelines.clone(),
+                        removed_pipelines: Vec::new(),
+                        scene_id: last_scene_id,
+                    });
+                    doc.new_async_scene_ready(built_scene);
                     doc.render(
                         &mut self.resource_cache,
                         &mut self.gpu_cache,
                         &mut profile_counters.resources,
                         true,
                     )
                 }
             };
--- a/gfx/webrender/src/render_task.rs
+++ b/gfx/webrender/src/render_task.rs
@@ -336,32 +336,32 @@ impl RenderTask {
             kind,
             clear_mode,
             saved_index: None,
         }
     }
 
     pub fn new_picture(
         location: RenderTaskLocation,
-        unclipped_size: DeviceIntSize,
+        unclipped_size: DeviceSize,
         prim_index: PrimitiveIndex,
         content_origin: DeviceIntPoint,
         children: Vec<RenderTaskId>,
         uv_rect_kind: UvRectKind,
     ) -> Self {
         let size = match location {
             RenderTaskLocation::Dynamic(_, size) => size,
             RenderTaskLocation::Fixed(rect) => rect.size,
             RenderTaskLocation::TextureCache(_, _, rect) => rect.size,
         };
 
         render_task_sanity_check(&size);
 
-        let can_merge = size.width >= unclipped_size.width &&
-                        size.height >= unclipped_size.height;
+        let can_merge = size.width as f32 >= unclipped_size.width &&
+                        size.height as f32 >= unclipped_size.height;
 
         RenderTask {
             location,
             children,
             kind: RenderTaskKind::Picture(PictureTask {
                 prim_index,
                 content_origin,
                 can_merge,
--- a/gfx/webrender/src/scene_builder.rs
+++ b/gfx/webrender/src/scene_builder.rs
@@ -24,16 +24,17 @@ pub enum SceneBuilderRequest {
         blob_requests: Vec<BlobImageParams>,
         blob_rasterizer: Option<Box<AsyncBlobImageRasterizer>>,
         resource_updates: Vec<ResourceUpdate>,
         frame_ops: Vec<FrameMsg>,
         render: bool,
     },
     WakeUp,
     Flush(MsgSender<()>),
+    SetFrameBuilderConfig(FrameBuilderConfig),
     Stop
 }
 
 // Message from scene builder to render backend.
 pub enum SceneBuilderResult {
     Transaction {
         document_id: DocumentId,
         built_scene: Option<BuiltScene>,
@@ -210,13 +211,16 @@ impl SceneBuilder {
                 }
             }
             SceneBuilderRequest::Stop => {
                 self.tx.send(SceneBuilderResult::Stopped).unwrap();
                 // We don't need to send a WakeUp to api_tx because we only
                 // get the Stop when the RenderBackend loop is exiting.
                 return false;
             }
+            SceneBuilderRequest::SetFrameBuilderConfig(cfg) => {
+                self.config = cfg;
+            }
         }
 
         true
     }
 }
--- a/gfx/webrender/src/spatial_node.rs
+++ b/gfx/webrender/src/spatial_node.rs
@@ -284,17 +284,17 @@ impl SpatialNode {
 
                     // Push that new coordinate system and record the new id.
                     let coord_system = CoordinateSystem {
                         offset: LayoutVector3D::new(
                             state.coordinate_system_relative_offset.x,
                             state.coordinate_system_relative_offset.y,
                             0.0,
                         ),
-                        transform: *info.resolved_transform.to_transform(),
+                        transform: relative_transform,
                         parent: Some(state.current_coordinate_system_id),
                     };
                     state.current_coordinate_system_id = CoordinateSystemId(coord_systems.len() as u32);
                     coord_systems.push(coord_system);
                 }
 
                 self.coordinate_system_id = state.current_coordinate_system_id;
             }
--- a/gfx/webrender/src/util.rs
+++ b/gfx/webrender/src/util.rs
@@ -1,21 +1,19 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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, DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePixelScale};
-use api::{DeviceRect, LayoutPixel, LayoutRect};
-use api::{WorldPixel, WorldRect};
+use api::{LayoutPixel, DeviceRect, WorldPixel, WorldRect};
 use euclid::{Point2D, Rect, Size2D, TypedPoint2D, TypedRect, TypedSize2D};
 use euclid::{TypedTransform2D, TypedTransform3D, TypedVector2D};
-use euclid::{HomogeneousVector};
 use num_traits::Zero;
 use plane_split::{Clipper, Polygon};
-use std::{i32, f32};
+use std::{i32, f32, fmt};
 use std::borrow::Cow;
 
 
 // Matches the definition of SK_ScalarNearlyZero in Skia.
 const NEARLY_ZERO: f32 = 1.0 / 4096.0;
 
 // TODO: Implement these in euclid!
 pub trait MatrixHelpers<Src, Dst> {
@@ -164,89 +162,16 @@ pub fn rect_is_empty<N: PartialEq + Zero
 pub fn rect_from_points_f(x0: f32, y0: f32, x1: f32, y1: f32) -> Rect<f32> {
     Rect::new(Point2D::new(x0, y0), Size2D::new(x1 - x0, y1 - y0))
 }
 
 pub fn lerp(a: f32, b: f32, t: f32) -> f32 {
     (b - a) * t + a
 }
 
-pub fn calculate_screen_bounding_rect(
-    transform: &LayoutToWorldFastTransform,
-    rect: &LayoutRect,
-    device_pixel_scale: DevicePixelScale,
-    screen_bounds: Option<&DeviceIntRect>,
-) -> Option<DeviceIntRect> {
-    debug!("calculate_screen_bounding_rect for {:?}", rect);
-    let homogens = [
-        transform.transform_point2d_homogeneous(&rect.origin),
-        transform.transform_point2d_homogeneous(&rect.top_right()),
-        transform.transform_point2d_homogeneous(&rect.bottom_left()),
-        transform.transform_point2d_homogeneous(&rect.bottom_right()),
-    ];
-    let max_rect = match screen_bounds {
-        Some(bounds) => bounds.to_f32(),
-        None => DeviceRect::max_rect(),
-    };
-
-    // Note: we only do the full frustum collision when the polygon approaches the camera plane.
-    // Otherwise, it will be clamped to the screen bounds anyway.
-    let world_rect = if homogens.iter().any(|h| h.w <= 0.0) {
-        debug!("transform {:?}", transform);
-        debug!("screen_bounds: {:?}", screen_bounds);
-        debug!("homogeneous points {:?}", homogens);
-
-        let mut clipper = Clipper::new();
-        clipper.add_frustum(
-            &transform.to_transform(),
-            screen_bounds.map(|b| b.to_f32() / device_pixel_scale),
-        );
-
-        let polygon = Polygon::from_rect(*rect, 1);
-        debug!("crossing detected for poly {:?}", polygon);
-        let results = clipper.clip(polygon);
-        debug!("clip results: {:?}", results);
-        if results.is_empty() {
-            return None
-        }
-
-        debug!("points:");
-        WorldRect::from_points(results
-            .into_iter()
-            // filter out parts behind the view plane
-            .flat_map(|poly| &poly.points)
-            .map(|p| {
-                let mut homo = transform.transform_point2d_homogeneous(&p.to_2d());
-                homo.w = homo.w.max(0.00000001); // avoid infinite values
-                debug!("\tpoint {:?} -> {:?} -> {:?}", p, homo, homo.to_point2d());
-                homo.to_point2d().unwrap()
-            })
-        )
-    } else {
-        // we just checked for all the points to be in positive hemisphere, so `unwrap` is valid
-        WorldRect::from_points(&[
-            homogens[0].to_point2d().unwrap(),
-            homogens[1].to_point2d().unwrap(),
-            homogens[2].to_point2d().unwrap(),
-            homogens[3].to_point2d().unwrap(),
-        ])
-    };
-
-    let result = (world_rect * device_pixel_scale)
-         .round_out()
-         .intersection(&max_rect)
-         .map(|r| r.to_i32());
-    if homogens.iter().any(|h| h.w <= 0.0) {
-        debug!("world rect {:?}", world_rect);
-        debug!("result {:?}", result);
-    }
-    result
-}
-
-
 #[repr(u32)]
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum TransformedRectKind {
     AxisAligned = 0,
     Complex = 1,
 }
@@ -456,27 +381,16 @@ impl<Src, Dst> FastTransform<Src, Dst> {
             FastTransform::Offset(offset) => {
                 let new_point = *point + offset;
                 Some(TypedPoint2D::from_untyped(&new_point.to_untyped()))
             }
             FastTransform::Transform { ref transform, .. } => transform.transform_point2d(point),
         }
     }
 
-    #[inline(always)]
-    pub fn transform_point2d_homogeneous(&self, point: &TypedPoint2D<f32, Src>) -> HomogeneousVector<f32, Dst> {
-        match *self {
-            FastTransform::Offset(offset) => {
-                let new_point = *point + offset;
-                HomogeneousVector::new(new_point.x, new_point.y, 0.0, 1.0)
-            }
-            FastTransform::Transform { ref transform, .. } => transform.transform_point2d_homogeneous(point),
-        }
-    }
-
     pub fn unapply(&self, rect: &TypedRect<f32, Dst>) -> Option<TypedRect<f32, Src>> {
         match *self {
             FastTransform::Offset(offset) =>
                 Some(TypedRect::from_untyped(&rect.to_untyped().translate(&-offset.to_untyped()))),
             FastTransform::Transform { inverse: Some(ref inverse), is_2d: true, .. }  =>
                 inverse.transform_rect(rect),
             FastTransform::Transform { ref transform, is_2d: false, .. } =>
                 Some(transform.inverse_rect_footprint(rect)),
@@ -523,8 +437,65 @@ impl<Src, Dst> From<TypedTransform3D<f32
 impl<Src, Dst> From<TypedVector2D<f32, Src>> for FastTransform<Src, Dst> {
     fn from(vector: TypedVector2D<f32, Src>) -> Self {
         FastTransform::with_vector(vector)
     }
 }
 
 pub type LayoutFastTransform = FastTransform<LayoutPixel, LayoutPixel>;
 pub type LayoutToWorldFastTransform = FastTransform<LayoutPixel, WorldPixel>;
+
+pub fn project_rect<F, T>(
+    transform: &TypedTransform3D<f32, F, T>,
+    rect: &TypedRect<f32, F>,
+) -> Option<TypedRect<f32, T>>
+ where F: fmt::Debug
+{
+    let homogens = [
+        transform.transform_point2d_homogeneous(&rect.origin),
+        transform.transform_point2d_homogeneous(&rect.top_right()),
+        transform.transform_point2d_homogeneous(&rect.bottom_left()),
+        transform.transform_point2d_homogeneous(&rect.bottom_right()),
+    ];
+
+    // Note: we only do the full frustum collision when the polygon approaches the camera plane.
+    // Otherwise, it will be clamped to the screen bounds anyway.
+    if homogens.iter().any(|h| h.w <= 0.0) {
+        let mut clipper = Clipper::new();
+        clipper.add_frustum(
+            transform,
+            None,
+        );
+
+        let polygon = Polygon::from_rect(*rect, 1);
+        let results = clipper.clip(polygon);
+        if results.is_empty() {
+            return None
+        }
+
+        Some(TypedRect::from_points(results
+            .into_iter()
+            // filter out parts behind the view plane
+            .flat_map(|poly| &poly.points)
+            .map(|p| {
+                let mut homo = transform.transform_point2d_homogeneous(&p.to_2d());
+                homo.w = homo.w.max(0.00000001); // avoid infinite values
+                homo.to_point2d().unwrap()
+            })
+        ))
+    } else {
+        // we just checked for all the points to be in positive hemisphere, so `unwrap` is valid
+        Some(TypedRect::from_points(&[
+            homogens[0].to_point2d().unwrap(),
+            homogens[1].to_point2d().unwrap(),
+            homogens[2].to_point2d().unwrap(),
+            homogens[3].to_point2d().unwrap(),
+        ]))
+    }
+}
+
+pub fn world_rect_to_device_pixels(
+    rect: WorldRect,
+    device_pixel_scale: DevicePixelScale,
+) -> DeviceRect {
+    let device_rect = rect * device_pixel_scale;
+    device_rect.round_out()
+}
--- a/gfx/webrender_api/src/api.rs
+++ b/gfx/webrender_api/src/api.rs
@@ -60,17 +60,17 @@ pub struct Transaction {
 
 impl Transaction {
     pub fn new() -> Self {
         Transaction {
             scene_ops: Vec::new(),
             frame_ops: Vec::new(),
             resource_updates: Vec::new(),
             payloads: Vec::new(),
-            use_scene_builder_thread: false, // TODO: make this true by default.
+            use_scene_builder_thread: true,
             generate_frame: false,
         }
     }
 
     // TODO: better name?
     pub fn skip_scene_builder(&mut self) {
         self.use_scene_builder_thread = false;
     }
@@ -973,16 +973,20 @@ impl RenderApi {
     /// Save a capture of the current frame state for debugging.
     pub fn save_capture(&self, path: PathBuf, bits: CaptureBits) {
         let msg = ApiMsg::DebugCommand(DebugCommand::SaveCapture(path, bits));
         self.send_message(msg);
     }
 
     /// Load a capture of the current frame state for debugging.
     pub fn load_capture(&self, path: PathBuf) -> Vec<CapturedDocument> {
+        // First flush the scene builder otherwise async scenes might clobber
+        // the capture we are about to load.
+        self.flush_scene_builder();
+
         let (tx, rx) = channel::msg_channel().unwrap();
         let msg = ApiMsg::DebugCommand(DebugCommand::LoadCapture(path, tx));
         self.send_message(msg);
 
         let mut documents = Vec::new();
         while let Ok(captured_doc) = rx.recv() {
             documents.push(captured_doc);
         }
--- a/gfx/webrender_api/src/units.rs
+++ b/gfx/webrender_api/src/units.rs
@@ -39,43 +39,34 @@ pub type DeviceSize = TypedSize2D<f32, D
 /// Geometry in the coordinate system of a Picture (intermediate
 /// surface) in physical pixels.
 #[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub struct PicturePixel;
 
 pub type PictureIntRect = TypedRect<i32, PicturePixel>;
 pub type PictureIntPoint = TypedPoint2D<i32, PicturePixel>;
 pub type PictureIntSize = TypedSize2D<i32, PicturePixel>;
+pub type PictureRect = TypedRect<f32, PicturePixel>;
+pub type PicturePoint = TypedPoint2D<f32, PicturePixel>;
+pub type PictureSize = TypedSize2D<f32, PicturePixel>;
+pub type PicturePoint3D = TypedPoint3D<f32, PicturePixel>;
+pub type PictureVector2D = TypedVector2D<f32, PicturePixel>;
+pub type PictureVector3D = TypedVector3D<f32, PicturePixel>;
 
 /// Geometry in a stacking context's local coordinate space (logical pixels).
 #[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Deserialize, Serialize)]
 pub struct LayoutPixel;
 
 pub type LayoutRect = TypedRect<f32, LayoutPixel>;
 pub type LayoutPoint = TypedPoint2D<f32, LayoutPixel>;
 pub type LayoutPoint3D = TypedPoint3D<f32, LayoutPixel>;
 pub type LayoutVector2D = TypedVector2D<f32, LayoutPixel>;
 pub type LayoutVector3D = TypedVector3D<f32, LayoutPixel>;
 pub type LayoutSize = TypedSize2D<f32, LayoutPixel>;
 
-/// Geometry in a layer's scrollable parent coordinate space (logical pixels).
-///
-/// Some layers are scrollable while some are not. There is a distinction between
-/// a layer's parent layer and a layer's scrollable parent layer (its closest parent
-/// that is scrollable, but not necessarily its immediate parent). Most of the internal
-/// transforms are expressed in terms of the scrollable parent and not the immediate
-/// parent.
-#[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
-pub struct ScrollLayerPixel;
-
-pub type ScrollLayerRect = TypedRect<f32, ScrollLayerPixel>;
-pub type ScrollLayerPoint = TypedPoint2D<f32, ScrollLayerPixel>;
-pub type ScrollLayerVector2D = TypedVector2D<f32, ScrollLayerPixel>;
-pub type ScrollLayerSize = TypedSize2D<f32, ScrollLayerPixel>;
-
 /// Geometry in the document's coordinate space (logical pixels).
 #[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub struct WorldPixel;
 
 pub type WorldRect = TypedRect<f32, WorldPixel>;
 pub type WorldPoint = TypedPoint2D<f32, WorldPixel>;
 pub type WorldSize = TypedSize2D<f32, WorldPixel>;
 pub type WorldPoint3D = TypedPoint3D<f32, WorldPixel>;
@@ -92,35 +83,27 @@ pub type TileRange = TypedRect<u16, Tile
 pub type DevicePixelScale = TypedScale<f32, WorldPixel, DevicePixel>;
 /// Scaling ratio from layout to world. Used for cases where we know the layout
 /// is in world space, or specifically want to treat it this way.
 pub type LayoutToWorldScale = TypedScale<f32, LayoutPixel, WorldPixel>;
 /// A complete scaling ratio from layout space to device pixel space.
 pub type LayoutToDeviceScale = TypedScale<f32, LayoutPixel, DevicePixel>;
 
 pub type LayoutTransform = TypedTransform3D<f32, LayoutPixel, LayoutPixel>;
-pub type LayoutToScrollTransform = TypedTransform3D<f32, LayoutPixel, ScrollLayerPixel>;
-pub type ScrollToLayoutTransform = TypedTransform3D<f32, ScrollLayerPixel, LayoutPixel>;
 pub type LayoutToWorldTransform = TypedTransform3D<f32, LayoutPixel, WorldPixel>;
 pub type WorldToLayoutTransform = TypedTransform3D<f32, WorldPixel, LayoutPixel>;
-pub type ScrollToWorldTransform = TypedTransform3D<f32, ScrollLayerPixel, WorldPixel>;
+
+pub type LayoutToPictureTransform = TypedTransform3D<f32, LayoutPixel, PicturePixel>;
+pub type PictureToLayoutTransform = TypedTransform3D<f32, PicturePixel, LayoutPixel>;
 
 // Fixed position coordinates, to avoid float precision errors.
 pub type LayoutPointAu = TypedPoint2D<Au, LayoutPixel>;
 pub type LayoutRectAu = TypedRect<Au, LayoutPixel>;
 pub type LayoutSizeAu = TypedSize2D<Au, LayoutPixel>;
 
-pub fn as_scroll_parent_rect(rect: &LayoutRect) -> ScrollLayerRect {
-    ScrollLayerRect::from_untyped(&rect.to_untyped())
-}
-
-pub fn as_scroll_parent_vector(vector: &LayoutVector2D) -> ScrollLayerVector2D {
-    ScrollLayerVector2D::from_untyped(&vector.to_untyped())
-}
-
 /// Coordinates in normalized space (between zero and one).
 #[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub struct NormalizedCoordinates;
 
 pub type NormalizedRect = TypedRect<f32, NormalizedCoordinates>;
 
 /// Stores two coordinates in texel space. The coordinates
 /// are stored in texel coordinates because the texture atlas
--- a/gfx/webrender_bindings/revision.txt
+++ b/gfx/webrender_bindings/revision.txt
@@ -1,1 +1,1 @@
-5fa5c46e167ca834d8fec3bf662bf420418698f4
+6415faa7f6acd412d4cc6b745cf802204690611c
--- a/gfx/wrench/src/reftest.rs
+++ b/gfx/wrench/src/reftest.rs
@@ -481,16 +481,18 @@ impl<'a> ReftestHarness<'a> {
         font_render_mode: Option<FontRenderMode>,
         allow_mipmaps: bool,
     ) -> (ReftestImage, RendererStats) {
         let mut reader = YamlFrameReader::new(filename);
         reader.set_font_render_mode(font_render_mode);
         reader.allow_mipmaps(allow_mipmaps);
         reader.do_frame(self.wrench);
 
+        self.wrench.api.flush_scene_builder();
+
         // wait for the frame
         self.rx.recv().unwrap();
         let stats = self.wrench.render();
 
         let window_size = self.window.get_inner_size();
         assert!(
             size.width <= window_size.width &&
             size.height <= window_size.height,
--- a/layout/reftests/bugs/reftest.list
+++ b/layout/reftests/bugs/reftest.list
@@ -1861,17 +1861,17 @@ pref(layout.css.moz-document.content.ena
 == 1059498-3.html 1059498-1-ref.html
 == 1062108-1.html 1062108-1-ref.html
 == 1062792-1.html 1062792-1-ref.html
 == 1062963-floatmanager-reflow.html 1062963-floatmanager-reflow-ref.html
 test-pref(dom.webcomponents.shadowdom.enabled,true) == 1066554-1.html 1066554-1-ref.html
 == 1069716-1.html 1069716-1-ref.html
 == 1078262-1.html about:blank
 test-pref(layout.testing.overlay-scrollbars.always-visible,false) == 1081072-1.html 1081072-1-ref.html
-fails-if(webrender) == 1081185-1.html 1081185-1-ref.html
+== 1081185-1.html 1081185-1-ref.html
 == 1097437-1.html 1097437-1-ref.html
 == 1103258-1.html 1103258-1-ref.html # assertion crash test with layers culling test
 == 1105137-1.html 1105137-1-ref.html
 fuzzy-if(d2d,0-36,0-304) fuzzy-if(/^Windows\x20NT\x2010\.0/.test(http.oscpu)&&d2d,0-139,0-701) == 1116480-1-fakeitalic-overflow.html 1116480-1-fakeitalic-overflow-ref.html
 == 1111753-1.html about:blank
 == 1114526-1.html 1114526-1-ref.html
 fuzzy-if(skiaContent,0-1,0-800000) == 1119117-1a.html 1119117-1-ref.html
 fuzzy-if(skiaContent,0-1,0-800000) == 1119117-1b.html 1119117-1-ref.html
--- a/layout/reftests/svg/as-image/reftest.list
+++ b/layout/reftests/svg/as-image/reftest.list
@@ -149,18 +149,18 @@ fuzzy-if(webrender,255-255,12-12) == img
 # with no explicit viewBox, to trigger "synthesize-viewBox" behavior
 == img-novb-widthAndHeight-meet-1-em.html  img-novb-widthAndHeight-all-1-ref.html
 == img-novb-widthAndHeight-meet-1-px.html  img-novb-widthAndHeight-all-1-ref.html
 == img-novb-widthAndHeight-slice-1-em.html img-novb-widthAndHeight-all-1-ref.html
 == img-novb-widthAndHeight-slice-1-px.html img-novb-widthAndHeight-all-1-ref.html
 
 # Alternate versions of "only one dimension is non-%-valued" tests, but now
 # with no explicit viewBox, to trigger "synthesize-viewBox" behavior
-fuzzy-if(webrender,255-255,20-20) == img-novb-height-meet-1.html    img-novb-height-all-1-ref.html
-fuzzy-if(webrender,255-255,20-20) == img-novb-height-slice-1.html   img-novb-height-all-1-ref.html
+fuzzy-if(webrender,255-255,20-40) == img-novb-height-meet-1.html    img-novb-height-all-1-ref.html
+fuzzy-if(webrender,255-255,20-40) == img-novb-height-slice-1.html   img-novb-height-all-1-ref.html
 fuzzy-if(skiaContent,0-255,0-10) fuzzy-if(webrender,255-255,20-20) == img-novb-width-meet-1.html     img-novb-width-all-1-ref.html
 fuzzy-if(skiaContent,0-255,0-10) fuzzy-if(webrender,255-255,20-20) == img-novb-width-slice-1.html    img-novb-width-all-1-ref.html
 
 # with with a fragmentIdentifier viewBox
 == img-fragment-1a.html  img-fragment-1-ref.html
 == img-fragment-1b.html  img-fragment-1-ref.html
 == img-fragment-1c.html  img-fragment-1-ref.html
 == img-fragment-2a.html  img-fragment-2-ref.html
--- a/layout/reftests/svg/filters/css-filter-chains/reftest.list
+++ b/layout/reftests/svg/filters/css-filter-chains/reftest.list
@@ -1,9 +1,9 @@
 # These tests verify that CSS filter chains behave properly.
 # e.g. filter: blur(3px) grayscale(0.5) invert(0.2);
 
 default-preferences pref(layout.css.filters.enabled,true)
 
 # Some platforms render this complex filter chain a little differently, and that's ok.
-fuzzy(0-5,0-13638) fuzzy-if(/^Windows\x20NT\x2010\.0/.test(http.oscpu)&&layersGPUAccelerated,0-35,0-13638) fuzzy-if(webrender,5-6,18006-18071) == long-chain.html long-chain-ref.html # Win10: Bug 1258241
+fuzzy(0-5,0-13638) fuzzy-if(/^Windows\x20NT\x2010\.0/.test(http.oscpu)&&layersGPUAccelerated,0-35,0-13638) fuzzy-if(webrender,5-6,17922-18643) == long-chain.html long-chain-ref.html # Win10: Bug 1258241
 == moz-element.html moz-element-ref.html
 fuzzy-if(webrender,15-15,7958-8262) == same-filter.html same-filter-ref.html
--- a/layout/reftests/svg/filters/css-filters/reftest.list
+++ b/layout/reftests/svg/filters/css-filters/reftest.list
@@ -2,17 +2,17 @@
 # e.g. filter: blur(3px)
 
 default-preferences pref(layout.css.filters.enabled,true)
 
 fuzzy-if(webrender,9-9,4780-4784) == blur.html blur-ref.html
 == blur.svg blur-ref.svg
 == blur-calc.html blur-calc-ref.html
 == blur-calc-negative.html blur-calc-negative-ref.html
-fuzzy-if(webrender,2-3,55913-56457) skip-if(d2d) == blur-cap-large-radius-on-software.html blur-cap-large-radius-on-software-ref.html
+fuzzy-if(cocoaWidget&&webrender,1-1,1-1) skip-if(d2d) == blur-cap-large-radius-on-software.html blur-cap-large-radius-on-software-ref.html
 fuzzy-if(webrender,9-9,4780-4784) == blur-em-radius.html blur-em-radius-ref.html
 == blur-invalid-radius.html blur-invalid-radius-ref.html
 fuzzy-if(webrender,9-9,4780-4784) == blur-rem-radius.html blur-rem-radius-ref.html
 == blur-zero-radius.html blur-zero-radius-ref.html
 fuzzy-if(webrender,5-7,19040-21308) == blur-zoomed-page.html blur-zoomed-page-ref.html
 == brightness.html brightness-ref.html
 == brightness-darken.html brightness-darken-ref.html
 == brightness-extreme.html brightness-extreme-ref.html
--- a/layout/reftests/transform-3d/reftest.list
+++ b/layout/reftests/transform-3d/reftest.list
@@ -78,17 +78,17 @@ fuzzy-if(cocoaWidget,0-128,0-9) random-i
 fuzzy(0-1,0-2000) == opacity-preserve3d-1.html opacity-preserve3d-1-ref.html
 fuzzy(0-1,0-15000) == opacity-preserve3d-2.html opacity-preserve3d-2-ref.html
 fuzzy(0-1,0-10000) == opacity-preserve3d-3.html opacity-preserve3d-3-ref.html
 fuzzy(0-1,0-10000) == opacity-preserve3d-4.html opacity-preserve3d-4-ref.html
 == opacity-preserve3d-5.html opacity-preserve3d-5-ref.html
 == snap-perspective-1.html snap-perspective-1-ref.html
 fuzzy-if(webrender&&!gtkWidget,1-1,16-16) == mask-layer-1.html mask-layer-ref.html
 fuzzy-if(webrender&&!gtkWidget,1-1,16-16) == mask-layer-2.html mask-layer-ref.html
-fails-if(webrender) == mask-layer-3.html mask-layer-ref.html
+fuzzy-if(webrender,0-1,0-16) == mask-layer-3.html mask-layer-ref.html
 == split-intersect1.html split-intersect1-ref.html
 fuzzy(0-255,0-150) == split-intersect2.html split-intersect2-ref.html
 fuzzy(0-255,0-100) == split-non-ortho1.html split-non-ortho1-ref.html
 fuzzy-if(winWidget,0-150,0-120) fuzzy-if(webrender&&cocoaWidget,99-99,133-133) == component-alpha-1.html component-alpha-1-ref.html
 == nested-transform-1.html nested-transform-1-ref.html
 == transform-geometry-1.html transform-geometry-1-ref.html
 == intermediate-1.html intermediate-1-ref.html
 == preserves3d-nested-filter-1.html preserves3d-nested-filter-1-ref.html
index b7f7b57a38a6bdfb13a140c300eda5519b01698a..22c06905b615f83fe24841b0e613a12c5d3dcbd6
GIT binary patch
literal 189952
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
J{y+X#<KL5F0x$po
--- a/other-licenses/7zstub/mozilla_customizations.diff
+++ b/other-licenses/7zstub/mozilla_customizations.diff
@@ -1,80 +1,47 @@
-diff --git a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp
---- a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp
+diff --git a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp
+index b1d740e..61cb260 100644
+--- a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp
 +++ b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp
-@@ -49,17 +49,17 @@ RSC=rc.exe
- # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
- # ADD BASE RSC /l 0x419 /d "NDEBUG"
- # ADD RSC /l 0x419 /d "NDEBUG"
- BSC32=bscmake.exe
- # ADD BASE BSC32 /nologo
+@@ -54,7 +54,7 @@ BSC32=bscmake.exe
  # ADD BSC32 /nologo
  LINK32=link.exe
  # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
 -# ADD LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zS.sfx" /opt:NOWIN98
 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib delayimp.lib /nologo /subsystem:windows /machine:I386 /out:"Release\7zS.sfx" /opt:NOWIN98 /delayload:user32.dll /delayload:shell32.dll /delayload:oleaut32.dll
  # SUBTRACT LINK32 /pdb:none
  
  !ELSEIF  "$(CFG)" == "SFXSetup - Win32 Debug"
- 
- # PROP BASE Use_MFC 0
- # PROP BASE Use_Debug_Libraries 1
- # PROP BASE Output_Dir "Debug"
- # PROP BASE Intermediate_Dir "Debug"
-@@ -76,17 +76,17 @@ LINK32=link.exe
- # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
- # ADD BASE RSC /l 0x419 /d "_DEBUG"
- # ADD RSC /l 0x419 /d "_DEBUG"
- BSC32=bscmake.exe
- # ADD BASE BSC32 /nologo
+@@ -81,7 +81,7 @@ BSC32=bscmake.exe
  # ADD BSC32 /nologo
  LINK32=link.exe
  # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
 -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\UTIL\7zSfxS.exe" /pdbtype:sept
 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib delayimp.lib /nologo /subsystem:windows /debug /machine:I386 /out:"Debug\7zSfxS.exe" /pdbtype:sept /delayload:user32.dll /delayload:shell32.dll /delayload:oleaut32.dll
  
  !ELSEIF  "$(CFG)" == "SFXSetup - Win32 ReleaseD"
  
- # PROP BASE Use_MFC 0
- # PROP BASE Use_Debug_Libraries 0
- # PROP BASE Output_Dir "ReleaseD"
- # PROP BASE Intermediate_Dir "ReleaseD"
- # PROP BASE Ignore_Export_Lib 0
-@@ -102,19 +102,19 @@ LINK32=link.exe
- # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
- # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
- # ADD BASE RSC /l 0x419 /d "NDEBUG"
- # ADD RSC /l 0x419 /d "NDEBUG"
- BSC32=bscmake.exe
+@@ -107,9 +107,9 @@ BSC32=bscmake.exe
  # ADD BASE BSC32 /nologo
  # ADD BSC32 /nologo
  LINK32=link.exe
 -# ADD BASE LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\UTIL\7zWinSR.exe"
 +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\UTIL\7zWinSR.exe"
  # SUBTRACT BASE LINK32 /debug /nodefaultlib
 -# ADD LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zSD.sfx" /opt:NOWIN98
 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib delayimp.lib /nologo /subsystem:windows /machine:I386 /out:"ReleaseD\7zSD.sfx" /opt:NOWIN98 /delayload:user32.dll /delayload:shell32.dll /delayload:oleaut32.dll
  # SUBTRACT LINK32 /pdb:none
  
  !ENDIF 
- 
- # Begin Target
- 
- # Name "SFXSetup - Win32 Release"
- # Name "SFXSetup - Win32 Debug"
-diff --git a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
---- a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
+diff --git a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
+index 1705a8d..e3a3bb2 100644
+--- a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
 +++ b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
-@@ -120,31 +120,226 @@ static void ShowErrorMessageSpec(const U
-   if (pos >= 0)
-   {
-     message.Delete(pos, 2);
-     message.Insert(pos, name);
-   }
+@@ -125,6 +125,179 @@ static void ShowErrorMessageSpec(const UString &name)
    ShowErrorMessage(NULL, message);
  }
  
 +/* BEGIN Mozilla customizations */
 +
 +static char const *
 +FindStrInBuf(char const * buf, size_t bufLen, char const * str)
 +{
@@ -244,18 +211,17 @@ diff --git a/other-licenses/7zstub/src/C
 +  return TRUE;
 +}
 +
 +/* END Mozilla customizations */
 +
  int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
      #ifdef UNDER_CE
      LPWSTR
-     #else
-     LPSTR
+@@ -133,13 +306,35 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
      #endif
      /* lpCmdLine */,int /* nCmdShow */)
  {
 +  /* BEGIN Mozilla customizations */
 +  // Disable current directory from being in the search path.
 +  // This call does not help with implicitly loaded DLLs.
 +  if (!RemoveCurrentDirFromSearchPath()) {
 +    WCHAR minOSTitle[512] = { '\0' };
@@ -284,99 +250,57 @@ diff --git a/other-licenses/7zstub/src/C
 +  // SetDefaultDllDirectories at all.
 +  //#ifdef _WIN32
 +  //LoadSecurityDlls();
 +  //#endif
 +  // END Mozilla customizations
  
    // InitCommonControls();
  
-   UString archiveName, switches;
-   #ifdef _SHELL_EXECUTE
-   UString executeFile, executeParameters;
-   #endif
-   NCommandLineParser::SplitCommandLine(GetCommandLineW(), archiveName, switches);
-@@ -167,16 +362,30 @@ int APIENTRY WinMain(HINSTANCE hInstance
-     if (!assumeYes)
-       ShowErrorMessage(L"Can't load config info");
-     return 1;
-   }
- 
+@@ -172,6 +367,18 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
    UString dirPrefix ("." STRING_PATH_SEPARATOR);
    UString appLaunched;
    bool showProgress = true;
 +
 +  /* BEGIN Mozilla customizations */
 +  bool extractOnly = false;
-+  if (switches.IsPrefixedBy_NoCase(L"-ms") ||
-+      switches.IsPrefixedBy_NoCase(L"/ini") ||
-+      switches.IsPrefixedBy_NoCase(L"/s")) {
-+    showProgress = false;
-+  } else if (switches.IsPrefixedBy_NoCase(L"/extractdir=")) {
++  if (switches.IsPrefixedBy_NoCase(L"/extractdir=")) {
 +    assumeYes = true;
 +    showProgress = false;
 +    extractOnly = true;
++  } else if (!switches.IsEmpty()) {
++    showProgress = false;
 +  }
 +  /* END Mozilla customizations */
 +
    if (!config.IsEmpty())
    {
      CObjectVector<CTextConfigPair> pairs;
-     if (!GetTextConfig(config, pairs))
-     {
-       if (!assumeYes)
-         ShowErrorMessage(L"Config failed");
-       return 1;
-@@ -199,17 +408,18 @@ int APIENTRY WinMain(HINSTANCE hInstance
-     
-     #ifdef _SHELL_EXECUTE
-     executeFile = GetTextConfigValue(pairs, "ExecuteFile");
-     executeParameters = GetTextConfigValue(pairs, "ExecuteParameters");
-     #endif
+@@ -204,7 +411,8 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
    }
  
    CTempDir tempDir;
 -  if (!tempDir.Create(kTempDirPrefix))
 +  /* Mozilla customizations - Added !extractOnly */
 +  if (!extractOnly && !tempDir.Create(kTempDirPrefix))
    {
      if (!assumeYes)
        ShowErrorMessage(L"Can not create temp folder archive");
-     return 1;
-   }
- 
-   CCodecs *codecs = new CCodecs;
-   CMyComPtr<IUnknown> compressCodecsInfo = codecs;
-@@ -217,17 +427,19 @@ int APIENTRY WinMain(HINSTANCE hInstance
-     HRESULT result = codecs->Load();
-     if (result != S_OK)
-     {
-       ShowErrorMessage(L"Can not load codecs");
-       return 1;
+@@ -222,7 +430,9 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
      }
    }
  
 -  const FString tempDirPath = tempDir.GetPath();
 +  /* BEGIN Mozilla customizations - added extractOnly  parameter support */
 +  const FString tempDirPath = extractOnly ? switches.Ptr(12) : GetUnicodeString(tempDir.GetPath());
 +  /* END Mozilla customizations */
    // tempDirPath = L"M:\\1\\"; // to test low disk space
    {
      bool isCorrupt = false;
-     UString errorMessage;
-     HRESULT result = ExtractArchive(codecs, fullPath, tempDirPath, showProgress,
-       isCorrupt, errorMessage);
-     
-     if (result != S_OK)
-@@ -245,16 +457,38 @@ int APIENTRY WinMain(HINSTANCE hInstance
-             errorMessage = NError::MyFormatMessage(result);
-           ::MessageBoxW(0, errorMessage, NWindows::MyLoadString(IDS_EXTRACTION_ERROR_TITLE), MB_ICONERROR);
-         }
-       }
-       return 1;
+@@ -250,6 +460,28 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
      }
    }
  
 +  /* BEGIN Mozilla customizations */
 +  // Retrieve and store any data added to this file after signing.
 +  {
 +    AString postSigningData;
 +    if (ReadPostSigningData(fullPath, postSigningData)) {
@@ -395,65 +319,45 @@ diff --git a/other-licenses/7zstub/src/C
 +  if (extractOnly) {
 +    return 0;
 +  }
 +  /* END Mozilla customizations */
 +
    #ifndef UNDER_CE
    CCurrentDirRestorer currentDirRestorer;
    if (!SetCurrentDir(tempDirPath))
-     return 1;
-   #endif
-   
-   HANDLE hProcess = 0;
- #ifdef _SHELL_EXECUTE
-diff --git a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.h b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.h
---- a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.h
+diff --git a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/Bundles/SFXSetup/resource.h b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.h
+index 533197e..975d779 100644
+--- a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/Bundles/SFXSetup/resource.h
 +++ b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.h
-@@ -1,6 +1,8 @@
- #define IDI_ICON  1
- 
- #define IDS_EXTRACTION_ERROR_TITLE       7
+@@ -4,3 +4,5 @@
  #define IDS_EXTRACTION_ERROR_MESSAGE     8
  #define IDS_CANNOT_CREATE_FOLDER      3003
  #define IDS_PROGRESS_EXTRACTING       3300
 +#define IDS_MIN_OS_TITLE                70
 +#define IDS_MIN_OS_TEXT                 71
-diff --git a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.rc b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.rc
---- a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.rc
+diff --git a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/Bundles/SFXSetup/resource.rc b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.rc
+index 9e88fd4..9fda0d0 100644
+--- a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/Bundles/SFXSetup/resource.rc
 +++ b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.rc
-@@ -6,11 +6,13 @@ MY_VERSION_INFO_APP("7z Setup SFX", "7zS
- IDI_ICON  ICON "setup.ico"
- 
- STRINGTABLE
- BEGIN
-   IDS_EXTRACTION_ERROR_TITLE  "Extraction Failed"
+@@ -11,6 +11,8 @@ BEGIN
    IDS_EXTRACTION_ERROR_MESSAGE  "File is corrupt"
    IDS_CANNOT_CREATE_FOLDER  "Cannot create folder '{0}'"
    IDS_PROGRESS_EXTRACTING  "Extracting"
 +  IDS_MIN_OS_TITLE  "Setup Error"
 +  IDS_MIN_OS_TEXT  "Microsoft Windows 7 or newer is required."
  END
  
  #include "../../UI/FileManager/ProgressDialog.rc"
-diff --git a/other-licenses/7zstub/src/CPP/7zip/UI/FileManager/ProgressDialog.cpp b/other-licenses/7zstub/src/CPP/7zip/UI/FileManager/ProgressDialog.cpp
---- a/other-licenses/7zstub/src/CPP/7zip/UI/FileManager/ProgressDialog.cpp
+diff --git a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/UI/FileManager/ProgressDialog.cpp b/other-licenses/7zstub/src/CPP/7zip/UI/FileManager/ProgressDialog.cpp
+index 27d42b2..9b61369 100644
+--- a/c:/Users/mhowell/Downloads/lzma1805/CPP/7zip/UI/FileManager/ProgressDialog.cpp
 +++ b/other-licenses/7zstub/src/CPP/7zip/UI/FileManager/ProgressDialog.cpp
-@@ -160,17 +160,18 @@ bool CProgressDialog::OnButtonClicked(in
- {
-   switch (buttonID)
-   {
-     case IDCANCEL:
-     {
+@@ -165,7 +165,8 @@ bool CProgressDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
        bool paused = Sync.GetPaused();
        Sync.SetPaused(true);
        _inCancelMessageBox = true;
 -      int res = ::MessageBoxW(*this, L"Are you sure you want to cancel?", _title, MB_YESNOCANCEL);
 +      // Mozilla Customization - Removed redundant cancel button from dialog.
 +      int res = ::MessageBoxW(*this, L"Are you sure you want to cancel?", _title, MB_YESNO);
        _inCancelMessageBox = false;
        Sync.SetPaused(paused);
        if (res == IDCANCEL || res == IDNO)
-       {
-         if (_externalCloseMessageWasReceived)
-           OnExternalCloseMessage();
-         return true;
-       }
--- a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
+++ b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
@@ -1,598 +1,596 @@
-// Main.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/MyWindows.h"
-
-#include "../../../Common/MyInitGuid.h"
-
-#include "../../../Common/CommandLineParser.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/TextConfig.h"
-
-#include "../../../Windows/DLL.h"
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/FileIO.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/NtCheck.h"
-#include "../../../Windows/ResourceString.h"
-
-#include "../../UI/Explorer/MyMessages.h"
-
-#include "ExtractEngine.h"
-
-#include "../../../../C/DllSecur.h"
-
-#include "resource.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-HINSTANCE g_hInstance;
-
-static CFSTR const kTempDirPrefix = FTEXT("7zS");
-
-#define _SHELL_EXECUTE
-
-static bool ReadDataString(CFSTR fileName, LPCSTR startID,
-    LPCSTR endID, AString &stringResult)
-{
-  stringResult.Empty();
-  NIO::CInFile inFile;
-  if (!inFile.Open(fileName))
-    return false;
-  const int kBufferSize = (1 << 12);
-
-  Byte buffer[kBufferSize];
-  int signatureStartSize = MyStringLen(startID);
-  int signatureEndSize = MyStringLen(endID);
-  
-  UInt32 numBytesPrev = 0;
-  bool writeMode = false;
-  UInt64 posTotal = 0;
-  for (;;)
-  {
-    if (posTotal > (1 << 20))
-      return (stringResult.IsEmpty());
-    UInt32 numReadBytes = kBufferSize - numBytesPrev;
-    UInt32 processedSize;
-    if (!inFile.Read(buffer + numBytesPrev, numReadBytes, processedSize))
-      return false;
-    if (processedSize == 0)
-      return true;
-    UInt32 numBytesInBuffer = numBytesPrev + processedSize;
-    UInt32 pos = 0;
-    for (;;)
-    {
-      if (writeMode)
-      {
-        if (pos > numBytesInBuffer - signatureEndSize)
-          break;
-        if (memcmp(buffer + pos, endID, signatureEndSize) == 0)
-          return true;
-        char b = buffer[pos];
-        if (b == 0)
-          return false;
-        stringResult += b;
-        pos++;
-      }
-      else
-      {
-        if (pos > numBytesInBuffer - signatureStartSize)
-          break;
-        if (memcmp(buffer + pos, startID, signatureStartSize) == 0)
-        {
-          writeMode = true;
-          pos += signatureStartSize;
-        }
-        else
-          pos++;
-      }
-    }
-    numBytesPrev = numBytesInBuffer - pos;
-    posTotal += pos;
-    memmove(buffer, buffer + pos, numBytesPrev);
-  }
-}
-
-static char kStartID[] = { ',','!','@','I','n','s','t','a','l','l','@','!','U','T','F','-','8','!', 0 };
-static char kEndID[]   = { ',','!','@','I','n','s','t','a','l','l','E','n','d','@','!', 0 };
-
-struct CInstallIDInit
-{
-  CInstallIDInit()
-  {
-    kStartID[0] = ';';
-    kEndID[0] = ';';
-  };
-} g_CInstallIDInit;
-
-
-#define NT_CHECK_FAIL_ACTION ShowErrorMessage(L"Unsupported Windows version"); return 1;
-
-static void ShowErrorMessageSpec(const UString &name)
-{
-  UString message = NError::MyFormatMessage(::GetLastError());
-  int pos = message.Find(L"%1");
-  if (pos >= 0)
-  {
-    message.Delete(pos, 2);
-    message.Insert(pos, name);
-  }
-  ShowErrorMessage(NULL, message);
-}
-
-/* BEGIN Mozilla customizations */
-
-static char const *
-FindStrInBuf(char const * buf, size_t bufLen, char const * str)
-{
-  size_t index = 0;
-  while (index < bufLen) {
-    char const * result = strstr(buf + index, str);
-    if (result) {
-      return result;
-    }
-    while ((buf[index] != '\0') && (index < bufLen)) {
-      index++;
-    }
-    index++;
-  }
-  return NULL;
-}
-
-static bool
-ReadPostSigningDataFromView(char const * view, DWORD size, AString& data)
-{
-  // Find the offset and length of the certificate table,
-  // so we know the valid range to look for the token.
-  if (size < (0x3c + sizeof(UInt32))) {
-    return false;
-  }
-  UInt32 PEHeaderOffset = *(UInt32*)(view + 0x3c);
-  UInt32 optionalHeaderOffset = PEHeaderOffset + 24;
-  UInt32 certDirEntryOffset = 0;
-  if (size < (optionalHeaderOffset + sizeof(UInt16))) {
-    return false;
-  }
-  UInt16 magic = *(UInt16*)(view + optionalHeaderOffset);
-  if (magic == 0x010b) {
-    // 32-bit executable
-    certDirEntryOffset = optionalHeaderOffset + 128;
-  } else if (magic == 0x020b) {
-    // 64-bit executable; certain header fields are wider
-    certDirEntryOffset = optionalHeaderOffset + 144;
-  } else {
-    // Unknown executable
-    return false;
-  }
-  if (size < certDirEntryOffset + 8) {
-    return false;
-  }
-  UInt32 certTableOffset = *(UInt32*)(view + certDirEntryOffset);
-  UInt32 certTableLen = *(UInt32*)(view + certDirEntryOffset + sizeof(UInt32));
-  if (certTableOffset == 0 || certTableLen == 0 ||
-      size < (certTableOffset + certTableLen)) {
-    return false;
-  }
-
-  char const token[] = "__MOZCUSTOM__:";
-  // We're searching for a string inside a binary blob,
-  // so a normal strstr that bails on the first NUL won't work.
-  char const * tokenPos = FindStrInBuf(view + certTableOffset,
-                                       certTableLen, token);
-  if (tokenPos) {
-    size_t tokenLen = (sizeof(token) / sizeof(token[0])) - 1;
-    data = AString(tokenPos + tokenLen);
-    return true;
-  }
-  return false;
-}
-
-static bool
-ReadPostSigningData(UString exePath, AString& data)
-{
-  bool retval = false;
-  HANDLE exeFile = CreateFileW(exePath, GENERIC_READ, FILE_SHARE_READ, NULL,
-                               OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-  if (exeFile != INVALID_HANDLE_VALUE) {
-    HANDLE mapping = CreateFileMapping(exeFile, NULL, PAGE_READONLY, 0, 0, NULL);
-    if (mapping != INVALID_HANDLE_VALUE) {
-      // MSDN claims the return value on failure is NULL,
-      // but I've also seen it returned on success, so double-check.
-      if (mapping || GetLastError() == ERROR_SUCCESS) {
-        char * view = (char*)MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
-        if (view) {
-          DWORD fileSize = GetFileSize(exeFile, NULL);
-          retval = ReadPostSigningDataFromView(view, fileSize, data);
-        }
-        CloseHandle(mapping);
-      }
-    }
-    CloseHandle(exeFile);
-  }
-  return retval;
-}
-
-// Delayed load libraries are loaded when the first symbol is used.
-// The following ensures that we load the delayed loaded libraries from the
-// system directory.
-struct AutoLoadSystemDependencies
-{
-  AutoLoadSystemDependencies()
-  {
-    HMODULE module = ::GetModuleHandleW(L"kernel32.dll");
-    if (module) {
-      // SetDefaultDllDirectories is always available on Windows 8 and above. It
-      // is also available on Windows Vista, Windows Server 2008, and
-      // Windows 7 when MS KB2533623 has been applied.
-      typedef BOOL (WINAPI *SetDefaultDllDirectoriesType)(DWORD);
-      SetDefaultDllDirectoriesType setDefaultDllDirectories =
-        (SetDefaultDllDirectoriesType) GetProcAddress(module, "SetDefaultDllDirectories");
-      if (setDefaultDllDirectories) {
-        setDefaultDllDirectories(0x0800 /* LOAD_LIBRARY_SEARCH_SYSTEM32 */ );
-        return;
-      }
-    }
-
-    static LPCWSTR delayDLLs[] = { L"uxtheme.dll", L"userenv.dll",
-                                   L"setupapi.dll", L"apphelp.dll",
-                                   L"propsys.dll", L"dwmapi.dll",
-                                   L"cryptbase.dll", L"oleacc.dll",
-                                   L"clbcatq.dll" };
-    WCHAR systemDirectory[MAX_PATH + 1] = { L'\0' };
-    // If GetSystemDirectory fails we accept that we'll load the DLLs from the
-    // normal search path.
-    GetSystemDirectoryW(systemDirectory, MAX_PATH + 1);
-    size_t systemDirLen = wcslen(systemDirectory);
-
-    // Make the system directory path terminate with a slash
-    if (systemDirectory[systemDirLen - 1] != L'\\' && systemDirLen) {
-      systemDirectory[systemDirLen] = L'\\';
-      ++systemDirLen;
-      // No need to re-NULL terminate
-    }
-
-    // For each known DLL ensure it is loaded from the system32 directory
-    for (size_t i = 0; i < sizeof(delayDLLs) / sizeof(delayDLLs[0]); ++i) {
-      size_t fileLen = wcslen(delayDLLs[i]);
-      wcsncpy(systemDirectory + systemDirLen, delayDLLs[i],
-      MAX_PATH - systemDirLen);
-      if (systemDirLen + fileLen <= MAX_PATH) {
-        systemDirectory[systemDirLen + fileLen] = L'\0';
-      } else {
-        systemDirectory[MAX_PATH] = L'\0';
-      }
-      LPCWSTR fullModulePath = systemDirectory; // just for code readability
-      LoadLibraryW(fullModulePath);
-    }
-  }
-} loadDLLs;
-
-BOOL
-RemoveCurrentDirFromSearchPath()
-{
-  // kernel32.dll is in the knownDLL list so it is safe to load without a full path
-  HMODULE kernel32 = LoadLibraryW(L"kernel32.dll");
-  if (!kernel32) {
-    return FALSE;
-  }
-
-  typedef BOOL (WINAPI *SetDllDirectoryType)(LPCWSTR);
-  SetDllDirectoryType SetDllDirectoryFn =
-    (SetDllDirectoryType)GetProcAddress(kernel32, "SetDllDirectoryW");
-  if (!SetDllDirectoryFn) {
-    FreeLibrary(kernel32);
-    return FALSE;
-  }
-
-  // If this call fails we can't do much about it, so ignore it.
-  // It is unlikely to fail and this is just a precaution anyway.
-  SetDllDirectoryFn(L"");
-  FreeLibrary(kernel32);
-  return TRUE;
-}
-
-/* END Mozilla customizations */
-
-int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
-    #ifdef UNDER_CE
-    LPWSTR
-    #else
-    LPSTR
-    #endif
-    /* lpCmdLine */,int /* nCmdShow */)
-{
-  /* BEGIN Mozilla customizations */
-  // Disable current directory from being in the search path.
-  // This call does not help with implicitly loaded DLLs.
-  if (!RemoveCurrentDirFromSearchPath()) {
-    WCHAR minOSTitle[512] = { '\0' };
-    WCHAR minOSText[512] = { '\0' };
-    LoadStringW(NULL, IDS_MIN_OS_TITLE, minOSTitle,
-                sizeof(minOSTitle) / sizeof(minOSTitle[0]));
-    LoadStringW(NULL, IDS_MIN_OS_TEXT, minOSText,
-                sizeof(minOSText) / sizeof(minOSText[0]));
-    MessageBoxW(NULL, minOSText, minOSTitle, MB_OK | MB_ICONERROR);
-    return 1;
-  }
-  /* END Mozilla customizations */
-
-  g_hInstance = (HINSTANCE)hInstance;
-
-  NT_CHECK
-
-  // BEGIN Mozilla customizations
-  // Our AutoLoadSystemDependencies (see above) does the same job as the
-  // LoadSecurityDlls function, but slightly better because it runs as a static
-  // initializer, and it doesn't include LOAD_LIBRARY_SEARCH_USER_DIRS in
-  // the search path, which partially defeats the purpose of calling
-  // SetDefaultDllDirectories at all.
-  //#ifdef _WIN32
-  //LoadSecurityDlls();
-  //#endif
-  // END Mozilla customizations
-
-  // InitCommonControls();
-
-  UString archiveName, switches;
-  #ifdef _SHELL_EXECUTE
-  UString executeFile, executeParameters;
-  #endif
-  NCommandLineParser::SplitCommandLine(GetCommandLineW(), archiveName, switches);
-
-  FString fullPath;
-  NDLL::MyGetModuleFileName(fullPath);
-
-  switches.Trim();
-  bool assumeYes = false;
-  if (switches.IsPrefixedBy_Ascii_NoCase("-y"))
-  {
-    assumeYes = true;
-    switches = switches.Ptr(2);
-    switches.Trim();
-  }
-
-  AString config;
-  if (!ReadDataString(fullPath, kStartID, kEndID, config))
-  {
-    if (!assumeYes)
-      ShowErrorMessage(L"Can't load config info");
-    return 1;
-  }
-
-  UString dirPrefix ("." STRING_PATH_SEPARATOR);
-  UString appLaunched;
-  bool showProgress = true;
-
-  /* BEGIN Mozilla customizations */
-  bool extractOnly = false;
-  if (switches.IsPrefixedBy_NoCase(L"-ms") ||
-      switches.IsPrefixedBy_NoCase(L"/ini") ||
-      switches.IsPrefixedBy_NoCase(L"/s")) {
-    showProgress = false;
-  } else if (switches.IsPrefixedBy_NoCase(L"/extractdir=")) {
-    assumeYes = true;
-    showProgress = false;
-    extractOnly = true;
-  }
-  /* END Mozilla customizations */
-
-  if (!config.IsEmpty())
-  {
-    CObjectVector<CTextConfigPair> pairs;
-    if (!GetTextConfig(config, pairs))
-    {
-      if (!assumeYes)
-        ShowErrorMessage(L"Config failed");
-      return 1;
-    }
-    UString friendlyName = GetTextConfigValue(pairs, "Title");
-    UString installPrompt = GetTextConfigValue(pairs, "BeginPrompt");
-    UString progress = GetTextConfigValue(pairs, "Progress");
-    if (progress.IsEqualTo_Ascii_NoCase("no"))
-      showProgress = false;
-    int index = FindTextConfigItem(pairs, "Directory");
-    if (index >= 0)
-      dirPrefix = pairs[index].String;
-    if (!installPrompt.IsEmpty() && !assumeYes)
-    {
-      if (MessageBoxW(0, installPrompt, friendlyName, MB_YESNO |
-          MB_ICONQUESTION) != IDYES)
-        return 0;
-    }
-    appLaunched = GetTextConfigValue(pairs, "RunProgram");
-    
-    #ifdef _SHELL_EXECUTE
-    executeFile = GetTextConfigValue(pairs, "ExecuteFile");
-    executeParameters = GetTextConfigValue(pairs, "ExecuteParameters");
-    #endif
-  }
-
-  CTempDir tempDir;
-  /* Mozilla customizations - Added !extractOnly */
-  if (!extractOnly && !tempDir.Create(kTempDirPrefix))
-  {
-    if (!assumeYes)
-      ShowErrorMessage(L"Can not create temp folder archive");
-    return 1;
-  }
-
-  CCodecs *codecs = new CCodecs;
-  CMyComPtr<IUnknown> compressCodecsInfo = codecs;
-  {
-    HRESULT result = codecs->Load();
-    if (result != S_OK)
-    {
-      ShowErrorMessage(L"Can not load codecs");
-      return 1;
-    }
-  }
-
-  /* BEGIN Mozilla customizations - added extractOnly  parameter support */
-  const FString tempDirPath = extractOnly ? switches.Ptr(12) : GetUnicodeString(tempDir.GetPath());
-  /* END Mozilla customizations */
-  // tempDirPath = L"M:\\1\\"; // to test low disk space
-  {
-    bool isCorrupt = false;
-    UString errorMessage;
-    HRESULT result = ExtractArchive(codecs, fullPath, tempDirPath, showProgress,
-      isCorrupt, errorMessage);
-    
-    if (result != S_OK)
-    {
-      if (!assumeYes)
-      {
-        if (result == S_FALSE || isCorrupt)
-        {
-          NWindows::MyLoadString(IDS_EXTRACTION_ERROR_MESSAGE, errorMessage);
-          result = E_FAIL;
-        }
-        if (result != E_ABORT)
-        {
-          if (errorMessage.IsEmpty())
-            errorMessage = NError::MyFormatMessage(result);
-          ::MessageBoxW(0, errorMessage, NWindows::MyLoadString(IDS_EXTRACTION_ERROR_TITLE), MB_ICONERROR);
-        }
-      }
-      return 1;
-    }
-  }
-
-  /* BEGIN Mozilla customizations */
-  // Retrieve and store any data added to this file after signing.
-  {
-    AString postSigningData;
-    if (ReadPostSigningData(fullPath, postSigningData)) {
-      FString postSigningDataFilePath(tempDirPath);
-      NFile::NName::NormalizeDirPathPrefix(postSigningDataFilePath);
-      postSigningDataFilePath += L"postSigningData";
-
-      NFile::NIO::COutFile postSigningDataFile;
-      postSigningDataFile.Create(postSigningDataFilePath, true);
-
-      UInt32 written = 0;
-      postSigningDataFile.Write(postSigningData, postSigningData.Len(), written);
-    }
-  }
-
-  if (extractOnly) {
-    return 0;
-  }
-  /* END Mozilla customizations */
-
-  #ifndef UNDER_CE
-  CCurrentDirRestorer currentDirRestorer;
-  if (!SetCurrentDir(tempDirPath))
-    return 1;
-  #endif
-  
-  HANDLE hProcess = 0;
-#ifdef _SHELL_EXECUTE
-  if (!executeFile.IsEmpty())
-  {
-    CSysString filePath (GetSystemString(executeFile));
-    SHELLEXECUTEINFO execInfo;
-    execInfo.cbSize = sizeof(execInfo);
-    execInfo.fMask = SEE_MASK_NOCLOSEPROCESS
-      #ifndef UNDER_CE
-      | SEE_MASK_FLAG_DDEWAIT
-      #endif
-      ;
-    execInfo.hwnd = NULL;
-    execInfo.lpVerb = NULL;
-    execInfo.lpFile = filePath;
-
-    if (!switches.IsEmpty())
-    {
-      executeParameters.Add_Space_if_NotEmpty();
-      executeParameters += switches;
-    }
-
-    CSysString parametersSys (GetSystemString(executeParameters));
-    if (parametersSys.IsEmpty())
-      execInfo.lpParameters = NULL;
-    else
-      execInfo.lpParameters = parametersSys;
-
-    execInfo.lpDirectory = NULL;
-    execInfo.nShow = SW_SHOWNORMAL;
-    execInfo.hProcess = 0;
-    /* BOOL success = */ ::ShellExecuteEx(&execInfo);
-    UINT32 result = (UINT32)(UINT_PTR)execInfo.hInstApp;
-    if (result <= 32)
-    {
-      if (!assumeYes)
-        ShowErrorMessage(L"Can not open file");
-      return 1;
-    }
-    hProcess = execInfo.hProcess;
-  }
-  else
-#endif
-  {
-    if (appLaunched.IsEmpty())
-    {
-      appLaunched = L"setup.exe";
-      if (!NFind::DoesFileExist(us2fs(appLaunched)))
-      {
-        if (!assumeYes)
-          ShowErrorMessage(L"Can not find setup.exe");
-        return 1;
-      }
-    }
-    
-    {
-      FString s2 = tempDirPath;
-      NName::NormalizeDirPathPrefix(s2);
-      appLaunched.Replace(L"%%T" WSTRING_PATH_SEPARATOR, fs2us(s2));
-    }
-    
-    UString appNameForError = appLaunched; // actually we need to rtemove parameters also
-
-    appLaunched.Replace(L"%%T", fs2us(tempDirPath));
-
-    if (!switches.IsEmpty())
-    {
-      appLaunched.Add_Space();
-      appLaunched += switches;
-    }
-    STARTUPINFO startupInfo;
-    startupInfo.cb = sizeof(startupInfo);
-    startupInfo.lpReserved = 0;
-    startupInfo.lpDesktop = 0;
-    startupInfo.lpTitle = 0;
-    startupInfo.dwFlags = 0;
-    startupInfo.cbReserved2 = 0;
-    startupInfo.lpReserved2 = 0;
-    
-    PROCESS_INFORMATION processInformation;
-    
-    CSysString appLaunchedSys (GetSystemString(dirPrefix + appLaunched));
-    
-    BOOL createResult = CreateProcess(NULL, (LPTSTR)(LPCTSTR)appLaunchedSys,
-      NULL, NULL, FALSE, 0, NULL, NULL /*tempDir.GetPath() */,
-      &startupInfo, &processInformation);
-    if (createResult == 0)
-    {
-      if (!assumeYes)
-      {
-        // we print name of exe file, if error message is
-        // ERROR_BAD_EXE_FORMAT: "%1 is not a valid Win32 application".
-        ShowErrorMessageSpec(appNameForError);
-      }
-      return 1;
-    }
-    ::CloseHandle(processInformation.hThread);
-    hProcess = processInformation.hProcess;
-  }
-  if (hProcess != 0)
-  {
-    WaitForSingleObject(hProcess, INFINITE);
-    ::CloseHandle(hProcess);
-  }
-  return 0;
-}
+// Main.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/CommandLineParser.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/TextConfig.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/NtCheck.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "../../UI/Explorer/MyMessages.h"
+
+#include "ExtractEngine.h"
+
+#include "../../../../C/DllSecur.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+HINSTANCE g_hInstance;
+
+static CFSTR const kTempDirPrefix = FTEXT("7zS");
+
+#define _SHELL_EXECUTE
+
+static bool ReadDataString(CFSTR fileName, LPCSTR startID,
+    LPCSTR endID, AString &stringResult)
+{
+  stringResult.Empty();
+  NIO::CInFile inFile;
+  if (!inFile.Open(fileName))
+    return false;
+  const int kBufferSize = (1 << 12);
+
+  Byte buffer[kBufferSize];
+  int signatureStartSize = MyStringLen(startID);
+  int signatureEndSize = MyStringLen(endID);
+  
+  UInt32 numBytesPrev = 0;
+  bool writeMode = false;
+  UInt64 posTotal = 0;
+  for (;;)
+  {
+    if (posTotal > (1 << 20))
+      return (stringResult.IsEmpty());
+    UInt32 numReadBytes = kBufferSize - numBytesPrev;
+    UInt32 processedSize;
+    if (!inFile.Read(buffer + numBytesPrev, numReadBytes, processedSize))
+      return false;
+    if (processedSize == 0)
+      return true;
+    UInt32 numBytesInBuffer = numBytesPrev + processedSize;
+    UInt32 pos = 0;
+    for (;;)
+    {
+      if (writeMode)
+      {
+        if (pos > numBytesInBuffer - signatureEndSize)
+          break;
+        if (memcmp(buffer + pos, endID, signatureEndSize) == 0)
+          return true;
+        char b = buffer[pos];
+        if (b == 0)
+          return false;
+        stringResult += b;
+        pos++;
+      }
+      else
+      {
+        if (pos > numBytesInBuffer - signatureStartSize)
+          break;
+        if (memcmp(buffer + pos, startID, signatureStartSize) == 0)
+        {
+          writeMode = true;
+          pos += signatureStartSize;
+        }
+        else
+          pos++;
+      }
+    }
+    numBytesPrev = numBytesInBuffer - pos;
+    posTotal += pos;
+    memmove(buffer, buffer + pos, numBytesPrev);
+  }
+}
+
+static char kStartID[] = { ',','!','@','I','n','s','t','a','l','l','@','!','U','T','F','-','8','!', 0 };
+static char kEndID[]   = { ',','!','@','I','n','s','t','a','l','l','E','n','d','@','!', 0 };
+
+struct CInstallIDInit
+{
+  CInstallIDInit()
+  {
+    kStartID[0] = ';';
+    kEndID[0] = ';';
+  };
+} g_CInstallIDInit;
+
+
+#define NT_CHECK_FAIL_ACTION ShowErrorMessage(L"Unsupported Windows version"); return 1;
+
+static void ShowErrorMessageSpec(const UString &name)
+{
+  UString message = NError::MyFormatMessage(::GetLastError());
+  int pos = message.Find(L"%1");
+  if (pos >= 0)
+  {
+    message.Delete(pos, 2);
+    message.Insert(pos, name);
+  }
+  ShowErrorMessage(NULL, message);
+}
+
+/* BEGIN Mozilla customizations */
+
+static char const *
+FindStrInBuf(char const * buf, size_t bufLen, char const * str)
+{
+  size_t index = 0;
+  while (index < bufLen) {
+    char const * result = strstr(buf + index, str);
+    if (result) {
+      return result;
+    }
+    while ((buf[index] != '\0') && (index < bufLen)) {
+      index++;
+    }
+    index++;
+  }
+  return NULL;
+}
+
+static bool
+ReadPostSigningDataFromView(char const * view, DWORD size, AString& data)
+{
+  // Find the offset and length of the certificate table,
+  // so we know the valid range to look for the token.
+  if (size < (0x3c + sizeof(UInt32))) {
+    return false;
+  }
+  UInt32 PEHeaderOffset = *(UInt32*)(view + 0x3c);
+  UInt32 optionalHeaderOffset = PEHeaderOffset + 24;
+  UInt32 certDirEntryOffset = 0;
+  if (size < (optionalHeaderOffset + sizeof(UInt16))) {
+    return false;
+  }
+  UInt16 magic = *(UInt16*)(view + optionalHeaderOffset);
+  if (magic == 0x010b) {
+    // 32-bit executable
+    certDirEntryOffset = optionalHeaderOffset + 128;
+  } else if (magic == 0x020b) {
+    // 64-bit executable; certain header fields are wider
+    certDirEntryOffset = optionalHeaderOffset + 144;
+  } else {
+    // Unknown executable
+    return false;
+  }
+  if (size < certDirEntryOffset + 8) {
+    return false;
+  }
+  UInt32 certTableOffset = *(UInt32*)(view + certDirEntryOffset);
+  UInt32 certTableLen = *(UInt32*)(view + certDirEntryOffset + sizeof(UInt32));
+  if (certTableOffset == 0 || certTableLen == 0 ||
+      size < (certTableOffset + certTableLen)) {
+    return false;
+  }
+
+  char const token[] = "__MOZCUSTOM__:";
+  // We're searching for a string inside a binary blob,
+  // so a normal strstr that bails on the first NUL won't work.
+  char const * tokenPos = FindStrInBuf(view + certTableOffset,
+                                       certTableLen, token);
+  if (tokenPos) {
+    size_t tokenLen = (sizeof(token) / sizeof(token[0])) - 1;
+    data = AString(tokenPos + tokenLen);
+    return true;
+  }
+  return false;
+}
+
+static bool
+ReadPostSigningData(UString exePath, AString& data)
+{
+  bool retval = false;
+  HANDLE exeFile = CreateFileW(exePath, GENERIC_READ, FILE_SHARE_READ, NULL,
+                               OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+  if (exeFile != INVALID_HANDLE_VALUE) {
+    HANDLE mapping = CreateFileMapping(exeFile, NULL, PAGE_READONLY, 0, 0, NULL);
+    if (mapping != INVALID_HANDLE_VALUE) {
+      // MSDN claims the return value on failure is NULL,
+      // but I've also seen it returned on success, so double-check.
+      if (mapping || GetLastError() == ERROR_SUCCESS) {
+        char * view = (char*)MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
+        if (view) {
+          DWORD fileSize = GetFileSize(exeFile, NULL);
+          retval = ReadPostSigningDataFromView(view, fileSize, data);
+        }
+        CloseHandle(mapping);
+      }
+    }
+    CloseHandle(exeFile);
+  }
+  return retval;
+}
+
+// Delayed load libraries are loaded when the first symbol is used.
+// The following ensures that we load the delayed loaded libraries from the
+// system directory.
+struct AutoLoadSystemDependencies
+{
+  AutoLoadSystemDependencies()
+  {
+    HMODULE module = ::GetModuleHandleW(L"kernel32.dll");
+    if (module) {
+      // SetDefaultDllDirectories is always available on Windows 8 and above. It
+      // is also available on Windows Vista, Windows Server 2008, and
+      // Windows 7 when MS KB2533623 has been applied.
+      typedef BOOL (WINAPI *SetDefaultDllDirectoriesType)(DWORD);
+      SetDefaultDllDirectoriesType setDefaultDllDirectories =
+        (SetDefaultDllDirectoriesType) GetProcAddress(module, "SetDefaultDllDirectories");
+      if (setDefaultDllDirectories) {
+        setDefaultDllDirectories(0x0800 /* LOAD_LIBRARY_SEARCH_SYSTEM32 */ );
+        return;
+      }
+    }
+
+    static LPCWSTR delayDLLs[] = { L"uxtheme.dll", L"userenv.dll",
+                                   L"setupapi.dll", L"apphelp.dll",
+                                   L"propsys.dll", L"dwmapi.dll",
+                                   L"cryptbase.dll", L"oleacc.dll",
+                                   L"clbcatq.dll" };
+    WCHAR systemDirectory[MAX_PATH + 1] = { L'\0' };
+    // If GetSystemDirectory fails we accept that we'll load the DLLs from the
+    // normal search path.
+    GetSystemDirectoryW(systemDirectory, MAX_PATH + 1);
+    size_t systemDirLen = wcslen(systemDirectory);
+
+    // Make the system directory path terminate with a slash
+    if (systemDirectory[systemDirLen - 1] != L'\\' && systemDirLen) {
+      systemDirectory[systemDirLen] = L'\\';
+      ++systemDirLen;
+      // No need to re-NULL terminate
+    }
+
+    // For each known DLL ensure it is loaded from the system32 directory
+    for (size_t i = 0; i < sizeof(delayDLLs) / sizeof(delayDLLs[0]); ++i) {
+      size_t fileLen = wcslen(delayDLLs[i]);
+      wcsncpy(systemDirectory + systemDirLen, delayDLLs[i],
+      MAX_PATH - systemDirLen);
+      if (systemDirLen + fileLen <= MAX_PATH) {
+        systemDirectory[systemDirLen + fileLen] = L'\0';
+      } else {
+        systemDirectory[MAX_PATH] = L'\0';
+      }
+      LPCWSTR fullModulePath = systemDirectory; // just for code readability
+      LoadLibraryW(fullModulePath);
+    }
+  }
+} loadDLLs;
+
+BOOL
+RemoveCurrentDirFromSearchPath()
+{
+  // kernel32.dll is in the knownDLL list so it is safe to load without a full path
+  HMODULE kernel32 = LoadLibraryW(L"kernel32.dll");
+  if (!kernel32) {
+    return FALSE;
+  }
+
+  typedef BOOL (WINAPI *SetDllDirectoryType)(LPCWSTR);
+  SetDllDirectoryType SetDllDirectoryFn =
+    (SetDllDirectoryType)GetProcAddress(kernel32, "SetDllDirectoryW");
+  if (!SetDllDirectoryFn) {
+    FreeLibrary(kernel32);
+    return FALSE;
+  }
+
+  // If this call fails we can't do much about it, so ignore it.
+  // It is unlikely to fail and this is just a precaution anyway.
+  SetDllDirectoryFn(L"");
+  FreeLibrary(kernel32);
+  return TRUE;
+}
+
+/* END Mozilla customizations */
+
+int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
+    #ifdef UNDER_CE
+    LPWSTR
+    #else
+    LPSTR
+    #endif
+    /* lpCmdLine */,int /* nCmdShow */)
+{
+  /* BEGIN Mozilla customizations */
+  // Disable current directory from being in the search path.
+  // This call does not help with implicitly loaded DLLs.
+  if (!RemoveCurrentDirFromSearchPath()) {
+    WCHAR minOSTitle[512] = { '\0' };
+    WCHAR minOSText[512] = { '\0' };
+    LoadStringW(NULL, IDS_MIN_OS_TITLE, minOSTitle,
+                sizeof(minOSTitle) / sizeof(minOSTitle[0]));
+    LoadStringW(NULL, IDS_MIN_OS_TEXT, minOSText,
+                sizeof(minOSText) / sizeof(minOSText[0]));
+    MessageBoxW(NULL, minOSText, minOSTitle, MB_OK | MB_ICONERROR);
+    return 1;
+  }
+  /* END Mozilla customizations */
+
+  g_hInstance = (HINSTANCE)hInstance;
+
+  NT_CHECK
+
+  // BEGIN Mozilla customizations
+  // Our AutoLoadSystemDependencies (see above) does the same job as the
+  // LoadSecurityDlls function, but slightly better because it runs as a static
+  // initializer, and it doesn't include LOAD_LIBRARY_SEARCH_USER_DIRS in
+  // the search path, which partially defeats the purpose of calling
+  // SetDefaultDllDirectories at all.
+  //#ifdef _WIN32
+  //LoadSecurityDlls();
+  //#endif
+  // END Mozilla customizations
+
+  // InitCommonControls();
+
+  UString archiveName, switches;
+  #ifdef _SHELL_EXECUTE
+  UString executeFile, executeParameters;
+  #endif
+  NCommandLineParser::SplitCommandLine(GetCommandLineW(), archiveName, switches);
+
+  FString fullPath;
+  NDLL::MyGetModuleFileName(fullPath);
+
+  switches.Trim();
+  bool assumeYes = false;
+  if (switches.IsPrefixedBy_Ascii_NoCase("-y"))
+  {
+    assumeYes = true;
+    switches = switches.Ptr(2);
+    switches.Trim();
+  }
+
+  AString config;
+  if (!ReadDataString(fullPath, kStartID, kEndID, config))
+  {
+    if (!assumeYes)
+      ShowErrorMessage(L"Can't load config info");
+    return 1;
+  }
+
+  UString dirPrefix ("." STRING_PATH_SEPARATOR);
+  UString appLaunched;
+  bool showProgress = true;
+
+  /* BEGIN Mozilla customizations */
+  bool extractOnly = false;
+  if (switches.IsPrefixedBy_NoCase(L"/extractdir=")) {
+    assumeYes = true;
+    showProgress = false;
+    extractOnly = true;
+  } else if (!switches.IsEmpty()) {
+    showProgress = false;
+  }
+  /* END Mozilla customizations */
+
+  if (!config.IsEmpty())
+  {
+    CObjectVector<CTextConfigPair> pairs;
+    if (!GetTextConfig(config, pairs))
+    {
+      if (!assumeYes)
+        ShowErrorMessage(L"Config failed");
+      return 1;
+    }
+    UString friendlyName = GetTextConfigValue(pairs, "Title");
+    UString installPrompt = GetTextConfigValue(pairs, "BeginPrompt");
+    UString progress = GetTextConfigValue(pairs, "Progress");
+    if (progress.IsEqualTo_Ascii_NoCase("no"))
+      showProgress = false;
+    int index = FindTextConfigItem(pairs, "Directory");
+    if (index >= 0)
+      dirPrefix = pairs[index].String;
+    if (!installPrompt.IsEmpty() && !assumeYes)
+    {
+      if (MessageBoxW(0, installPrompt, friendlyName, MB_YESNO |
+          MB_ICONQUESTION) != IDYES)
+        return 0;
+    }
+    appLaunched = GetTextConfigValue(pairs, "RunProgram");
+    
+    #ifdef _SHELL_EXECUTE
+    executeFile = GetTextConfigValue(pairs, "ExecuteFile");
+    executeParameters = GetTextConfigValue(pairs, "ExecuteParameters");
+    #endif
+  }
+
+  CTempDir tempDir;
+  /* Mozilla customizations - Added !extractOnly */
+  if (!extractOnly && !tempDir.Create(kTempDirPrefix))
+  {
+    if (!assumeYes)
+      ShowErrorMessage(L"Can not create temp folder archive");
+    return 1;
+  }
+
+  CCodecs *codecs = new CCodecs;
+  CMyComPtr<IUnknown> compressCodecsInfo = codecs;
+  {
+    HRESULT result = codecs->Load();
+    if (result != S_OK)
+    {
+      ShowErrorMessage(L"Can not load codecs");
+      return 1;
+    }
+  }
+
+  /* BEGIN Mozilla customizations - added extractOnly  parameter support */
+  const FString tempDirPath = extractOnly ? switches.Ptr(12) : GetUnicodeString(tempDir.GetPath());
+  /* END Mozilla customizations */
+  // tempDirPath = L"M:\\1\\"; // to test low disk space
+  {
+    bool isCorrupt = false;
+    UString errorMessage;
+    HRESULT result = ExtractArchive(codecs, fullPath, tempDirPath, showProgress,
+      isCorrupt, errorMessage);
+    
+    if (result != S_OK)
+    {
+      if (!assumeYes)
+      {
+        if (result == S_FALSE || isCorrupt)
+        {
+          NWindows::MyLoadString(IDS_EXTRACTION_ERROR_MESSAGE, errorMessage);
+          result = E_FAIL;
+        }
+        if (result != E_ABORT)
+        {
+          if (errorMessage.IsEmpty())
+            errorMessage = NError::MyFormatMessage(result);
+          ::MessageBoxW(0, errorMessage, NWindows::MyLoadString(IDS_EXTRACTION_ERROR_TITLE), MB_ICONERROR);
+        }
+      }
+      return 1;
+    }
+  }
+
+  /* BEGIN Mozilla customizations */
+  // Retrieve and store any data added to this file after signing.
+  {
+    AString postSigningData;
+    if (ReadPostSigningData(fullPath, postSigningData)) {
+      FString postSigningDataFilePath(tempDirPath);
+      NFile::NName::NormalizeDirPathPrefix(postSigningDataFilePath);
+      postSigningDataFilePath += L"postSigningData";
+
+      NFile::NIO::COutFile postSigningDataFile;
+      postSigningDataFile.Create(postSigningDataFilePath, true);
+
+      UInt32 written = 0;
+      postSigningDataFile.Write(postSigningData, postSigningData.Len(), written);
+    }
+  }
+
+  if (extractOnly) {
+    return 0;
+  }
+  /* END Mozilla customizations */
+
+  #ifndef UNDER_CE
+  CCurrentDirRestorer currentDirRestorer;
+  if (!SetCurrentDir(tempDirPath))
+    return 1;
+  #endif
+  
+  HANDLE hProcess = 0;
+#ifdef _SHELL_EXECUTE
+  if (!executeFile.IsEmpty())
+  {
+    CSysString filePath (GetSystemString(executeFile));
+    SHELLEXECUTEINFO execInfo;
+    execInfo.cbSize = sizeof(execInfo);
+    execInfo.fMask = SEE_MASK_NOCLOSEPROCESS
+      #ifndef UNDER_CE
+      | SEE_MASK_FLAG_DDEWAIT
+      #endif
+      ;
+    execInfo.hwnd = NULL;
+    execInfo.lpVerb = NULL;
+    execInfo.lpFile = filePath;
+
+    if (!switches.IsEmpty())
+    {
+      executeParameters.Add_Space_if_NotEmpty();
+      executeParameters += switches;
+    }
+
+    CSysString parametersSys (GetSystemString(executeParameters));
+    if (parametersSys.IsEmpty())
+      execInfo.lpParameters = NULL;
+    else
+      execInfo.lpParameters = parametersSys;
+
+    execInfo.lpDirectory = NULL;
+    execInfo.nShow = SW_SHOWNORMAL;
+    execInfo.hProcess = 0;
+    /* BOOL success = */ ::ShellExecuteEx(&execInfo);
+    UINT32 result = (UINT32)(UINT_PTR)execInfo.hInstApp;
+    if (result <= 32)
+    {
+      if (!assumeYes)
+        ShowErrorMessage(L"Can not open file");
+      return 1;
+    }
+    hProcess = execInfo.hProcess;
+  }
+  else
+#endif
+  {
+    if (appLaunched.IsEmpty())
+    {
+      appLaunched = L"setup.exe";
+      if (!NFind::DoesFileExist(us2fs(appLaunched)))
+      {
+        if (!assumeYes)
+          ShowErrorMessage(L"Can not find setup.exe");
+        return 1;
+      }
+    }
+    
+    {
+      FString s2 = tempDirPath;
+      NName::NormalizeDirPathPrefix(s2);
+      appLaunched.Replace(L"%%T" WSTRING_PATH_SEPARATOR, fs2us(s2));
+    }
+    
+    UString appNameForError = appLaunched; // actually we need to rtemove parameters also
+
+    appLaunched.Replace(L"%%T", fs2us(tempDirPath));
+
+    if (!switches.IsEmpty())
+    {
+      appLaunched.Add_Space();
+      appLaunched += switches;
+    }
+    STARTUPINFO startupInfo;
+    startupInfo.cb = sizeof(startupInfo);
+    startupInfo.lpReserved = 0;
+    startupInfo.lpDesktop = 0;
+    startupInfo.lpTitle = 0;
+    startupInfo.dwFlags = 0;
+    startupInfo.cbReserved2 = 0;
+    startupInfo.lpReserved2 = 0;
+    
+    PROCESS_INFORMATION processInformation;
+    
+    CSysString appLaunchedSys (GetSystemString(dirPrefix + appLaunched));
+    
+    BOOL createResult = CreateProcess(NULL, (LPTSTR)(LPCTSTR)appLaunchedSys,
+      NULL, NULL, FALSE, 0, NULL, NULL /*tempDir.GetPath() */,
+      &startupInfo, &processInformation);
+    if (createResult == 0)
+    {
+      if (!assumeYes)
+      {
+        // we print name of exe file, if error message is
+        // ERROR_BAD_EXE_FORMAT: "%1 is not a valid Win32 application".
+        ShowErrorMessageSpec(appNameForError);
+      }
+      return 1;
+    }
+    ::CloseHandle(processInformation.hThread);
+    hProcess = processInformation.hProcess;
+  }
+  if (hProcess != 0)
+  {
+    WaitForSingleObject(hProcess, INFINITE);
+    ::CloseHandle(hProcess);
+  }
+  return 0;
+}
--- a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.h
+++ b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.h
@@ -1,8 +1,8 @@
-#define IDI_ICON  1
-
-#define IDS_EXTRACTION_ERROR_TITLE       7
-#define IDS_EXTRACTION_ERROR_MESSAGE     8
-#define IDS_CANNOT_CREATE_FOLDER      3003
-#define IDS_PROGRESS_EXTRACTING       3300
-#define IDS_MIN_OS_TITLE                70
-#define IDS_MIN_OS_TEXT                 71
+#define IDI_ICON  1
+
+#define IDS_EXTRACTION_ERROR_TITLE       7
+#define IDS_EXTRACTION_ERROR_MESSAGE     8
+#define IDS_CANNOT_CREATE_FOLDER      3003
+#define IDS_PROGRESS_EXTRACTING       3300
+#define IDS_MIN_OS_TITLE                70
+#define IDS_MIN_OS_TEXT                 71
--- a/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.rc
+++ b/other-licenses/7zstub/src/CPP/7zip/Bundles/SFXSetup/resource.rc
@@ -1,18 +1,18 @@
-#include "../../MyVersionInfo.rc"
-#include "resource.h"
-
-MY_VERSION_INFO_APP("7z Setup SFX", "7zS.sfx")
-
-IDI_ICON  ICON "setup.ico"
-
-STRINGTABLE
-BEGIN
-  IDS_EXTRACTION_ERROR_TITLE  "Extraction Failed"
-  IDS_EXTRACTION_ERROR_MESSAGE  "File is corrupt"
-  IDS_CANNOT_CREATE_FOLDER  "Cannot create folder '{0}'"
-  IDS_PROGRESS_EXTRACTING  "Extracting"
-  IDS_MIN_OS_TITLE  "Setup Error"
-  IDS_MIN_OS_TEXT  "Microsoft Windows 7 or newer is required."
-END
-
-#include "../../UI/FileManager/ProgressDialog.rc"
+#include "../../MyVersionInfo.rc"
+#include "resource.h"
+
+MY_VERSION_INFO_APP("7z Setup SFX", "7zS.sfx")
+
+IDI_ICON  ICON "setup.ico"
+
+STRINGTABLE
+BEGIN
+  IDS_EXTRACTION_ERROR_TITLE  "Extraction Failed"
+  IDS_EXTRACTION_ERROR_MESSAGE  "File is corrupt"
+  IDS_CANNOT_CREATE_FOLDER  "Cannot create folder '{0}'"
+  IDS_PROGRESS_EXTRACTING  "Extracting"
+  IDS_MIN_OS_TITLE  "Setup Error"
+  IDS_MIN_OS_TEXT  "Microsoft Windows 7 or newer is required."
+END
+
+#include "../../UI/FileManager/ProgressDialog.rc"
--- a/other-licenses/7zstub/src/CPP/7zip/UI/FileManager/ProgressDialog.cpp
+++ b/other-licenses/7zstub/src/CPP/7zip/UI/FileManager/ProgressDialog.cpp
@@ -1,197 +1,197 @@
-// ProgressDialog.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-
-#include "resource.h"
-
-#include "ProgressDialog.h"
-
-using namespace NWindows;
-
-extern HINSTANCE g_hInstance;
-
-static const UINT_PTR kTimerID = 3;
-static const UINT kTimerElapse = 100;
-
-#ifdef LANG
-#include "LangUtils.h"
-#endif
-
-HRESULT CProgressSync::ProcessStopAndPause()
-{
-  for (;;)
-  {
-    if (GetStopped())
-      return E_ABORT;
-    if (!GetPaused())
-      break;
-    ::Sleep(100);
-  }
-  return S_OK;
-}
-
-#ifndef _SFX
-CProgressDialog::~CProgressDialog()
-{
-  AddToTitle(L"");
-}
-void CProgressDialog::AddToTitle(LPCWSTR s)
-{
-  if (MainWindow != 0)
-    MySetWindowText(MainWindow, UString(s) + MainTitle);
-}
-#endif
-
-
-bool CProgressDialog::OnInit()
-{
-  _range = (UInt64)(Int64)-1;
-  _prevPercentValue = -1;
-
-  _wasCreated = true;
-  _dialogCreatedEvent.Set();
-
-  #ifdef LANG
-  LangSetDlgItems(*this, NULL, 0);
-  #endif
-
-  m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
-
-  if (IconID >= 0)
-  {
-    HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID));
-    SetIcon(ICON_BIG, icon);
-  }
-
-  _timer = SetTimer(kTimerID, kTimerElapse);
-  SetText(_title);
-  CheckNeedClose();
-  return CModalDialog::OnInit();
-}
-
-void CProgressDialog::OnCancel() { Sync.SetStopped(true); }
-void CProgressDialog::OnOK() { }
-
-void CProgressDialog::SetRange(UInt64 range)
-{
-  _range = range;
-  _peviousPos = (UInt64)(Int64)-1;
-  _converter.Init(range);
-  m_ProgressBar.SetRange32(0 , _converter.Count(range)); // Test it for 100%
-}
-
-void CProgressDialog::SetPos(UInt64 pos)
-{
-  bool redraw = true;
-  if (pos < _range && pos > _peviousPos)
-  {
-    UInt64 posDelta = pos - _peviousPos;
-    if (posDelta < (_range >> 10))
-      redraw = false;
-  }
-  if (redraw)
-  {
-    m_ProgressBar.SetPos(_converter.Count(pos));  // Test it for 100%
-    _peviousPos = pos;
-  }
-}
-
-bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */)
-{
-  if (Sync.GetPaused())
-    return true;
-
-  CheckNeedClose();
-
-  UInt64 total, completed;
-  Sync.GetProgress(total, completed);
-  if (total != _range)
-    SetRange(total);
-  SetPos(completed);
-
-  if (total == 0)
-    total = 1;
-
-  int percentValue = (int)(completed * 100 / total);
-  if (percentValue != _prevPercentValue)
-  {
-    wchar_t s[64];
-    ConvertUInt64ToString(percentValue, s);
-    UString title = s;
-    title += "% ";
-    SetText(title + _title);
-    #ifndef _SFX
-    AddToTitle(title + MainAddTitle);
-    #endif
-    _prevPercentValue = percentValue;
-  }
-  return true;
-}
-
-bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
-  switch (message)
-  {
-    case kCloseMessage:
-    {
-      KillTimer(_timer);
-      _timer = 0;
-      if (_inCancelMessageBox)
-      {
-        _externalCloseMessageWasReceived = true;
-        break;
-      }
-      return OnExternalCloseMessage();
-    }
-    /*
-    case WM_SETTEXT:
-    {
-      if (_timer == 0)
-        return true;
-    }
-    */
-  }
-  return CModalDialog::OnMessage(message, wParam, lParam);
-}
-
-bool CProgressDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
-{
-  switch (buttonID)
-  {
-    case IDCANCEL:
-    {
-      bool paused = Sync.GetPaused();
-      Sync.SetPaused(true);
-      _inCancelMessageBox = true;
-      // Mozilla Customization - Removed redundant cancel button from dialog.
-      int res = ::MessageBoxW(*this, L"Are you sure you want to cancel?", _title, MB_YESNO);
-      _inCancelMessageBox = false;
-      Sync.SetPaused(paused);
-      if (res == IDCANCEL || res == IDNO)
-      {
-        if (_externalCloseMessageWasReceived)
-          OnExternalCloseMessage();
-        return true;
-      }
-      break;
-    }
-  }
-  return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
-}
-
-void CProgressDialog::CheckNeedClose()
-{
-  if (_needClose)
-  {
-    PostMsg(kCloseMessage);
-    _needClose = false;
-  }
-}
-
-bool CProgressDialog::OnExternalCloseMessage()
-{
-  End(0);
-  return true;
-}
+// ProgressDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "resource.h"
+
+#include "ProgressDialog.h"
+
+using namespace NWindows;
+
+extern HINSTANCE g_hInstance;
+
+static const UINT_PTR kTimerID = 3;
+static const UINT kTimerElapse = 100;
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+HRESULT CProgressSync::ProcessStopAndPause()
+{
+  for (;;)
+  {
+    if (GetStopped())
+      return E_ABORT;
+    if (!GetPaused())
+      break;
+    ::Sleep(100);
+  }
+  return S_OK;
+}
+
+#ifndef _SFX
+CProgressDialog::~CProgressDialog()
+{
+  AddToTitle(L"");
+}
+void CProgressDialog::AddToTitle(LPCWSTR s)
+{
+  if (MainWindow != 0)
+    MySetWindowText(MainWindow, UString(s) + MainTitle);
+}
+#endif
+
+
+bool CProgressDialog::OnInit()
+{
+  _range = (UInt64)(Int64)-1;
+  _prevPercentValue = -1;
+
+  _wasCreated = true;
+  _dialogCreatedEvent.Set();
+
+  #ifdef LANG
+  LangSetDlgItems(*this, NULL, 0);
+  #endif
+
+  m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
+
+  if (IconID >= 0)
+  {
+    HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID));
+    SetIcon(ICON_BIG, icon);
+  }
+
+  _timer = SetTimer(kTimerID, kTimerElapse);
+  SetText(_title);
+  CheckNeedClose();
+  return CModalDialog::OnInit();
+}
+
+void CProgressDialog::OnCancel() { Sync.SetStopped(true); }
+void CProgressDialog::OnOK() { }
+
+void CProgressDialog::SetRange(UInt64 range)
+{
+  _range = range;
+  _peviousPos = (UInt64)(Int64)-1;
+  _converter.Init(range);
+  m_ProgressBar.SetRange32(0 , _converter.Count(range)); // Test it for 100%
+}
+
+void CProgressDialog::SetPos(UInt64 pos)
+{
+  bool redraw = true;
+  if (pos < _range && pos > _peviousPos)
+  {
+    UInt64 posDelta = pos - _peviousPos;
+    if (posDelta < (_range >> 10))
+      redraw = false;
+  }
+  if (redraw)
+  {
+    m_ProgressBar.SetPos(_converter.Count(pos));  // Test it for 100%
+    _peviousPos = pos;
+  }
+}
+
+bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */)
+{
+  if (Sync.GetPaused())
+    return true;
+
+  CheckNeedClose();
+
+  UInt64 total, completed;
+  Sync.GetProgress(total, completed);
+  if (total != _range)
+    SetRange(total);
+  SetPos(completed);
+
+  if (total == 0)
+    total = 1;
+
+  int percentValue = (int)(completed * 100 / total);
+  if (percentValue != _prevPercentValue)
+  {
+    wchar_t s[64];
+    ConvertUInt64ToString(percentValue, s);
+    UString title = s;
+    title += "% ";
+    SetText(title + _title);
+    #ifndef _SFX
+    AddToTitle(title + MainAddTitle);
+    #endif
+    _prevPercentValue = percentValue;
+  }
+  return true;
+}
+
+bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+  switch (message)
+  {
+    case kCloseMessage:
+    {
+      KillTimer(_timer);
+      _timer = 0;
+      if (_inCancelMessageBox)
+      {
+        _externalCloseMessageWasReceived = true;
+        break;
+      }
+      return OnExternalCloseMessage();
+    }
+    /*
+    case WM_SETTEXT:
+    {
+      if (_timer == 0)
+        return true;
+    }
+    */
+  }
+  return CModalDialog::OnMessage(message, wParam, lParam);
+}
+
+bool CProgressDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    case IDCANCEL:
+    {
+      bool paused = Sync.GetPaused();
+      Sync.SetPaused(true);
+      _inCancelMessageBox = true;
+      // Mozilla Customization - Removed redundant cancel button from dialog.
+      int res = ::MessageBoxW(*this, L"Are you sure you want to cancel?", _title, MB_YESNO);
+      _inCancelMessageBox = false;
+      Sync.SetPaused(paused);
+      if (res == IDCANCEL || res == IDNO)
+      {
+        if (_externalCloseMessageWasReceived)
+          OnExternalCloseMessage();
+        return true;
+      }
+      break;
+    }
+  }
+  return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CProgressDialog::CheckNeedClose()
+{
+  if (_needClose)
+  {
+    PostMsg(kCloseMessage);
+    _needClose = false;
+  }
+}
+
+bool CProgressDialog::OnExternalCloseMessage()
+{
+  End(0);
+  return true;
+}
--- a/servo/components/style/gecko/selector_parser.rs
+++ b/servo/components/style/gecko/selector_parser.rs
@@ -49,24 +49,24 @@ macro_rules! pseudo_class_name {
                 #[doc = $css]
                 $name,
             )*
             $(
                 #[doc = $s_css]
                 $s_name(PseudoClassStringArg),
             )*
             /// The `:dir` pseudo-class.
-            Dir(Box<Direction>),
+            Dir(Direction),
             /// The non-standard `:-moz-any` pseudo-class.
             ///
             /// TODO(emilio): We disallow combinators and pseudos here, so we
             /// should use SimpleSelector instead
             MozAny(ThinBoxedSlice<Selector<SelectorImpl>>),
             /// The non-standard `:-moz-locale-dir` pseudo-class.
-            MozLocaleDir(Box<Direction>),
+            MozLocaleDir(Direction),
         }
     }
 }
 apply_non_ts_list!(pseudo_class_name);
 
 impl ToCss for NonTSPseudoClass {
     fn to_css<W>(&self, dest: &mut W) -> fmt::Result
     where
@@ -406,24 +406,20 @@ impl<'a, 'i> ::selectors::Parser<'i> for
                     $($s_css => {
                         let name = parser.expect_ident_or_string()?;
                         // convert to null terminated utf16 string
                         // since that's what Gecko deals with
                         let utf16: Vec<u16> = name.encode_utf16().chain(Some(0u16)).collect();
                         NonTSPseudoClass::$s_name(utf16.into_boxed_slice().into())
                     }, )*
                     "-moz-locale-dir" => {
-                        NonTSPseudoClass::MozLocaleDir(
-                            Box::new(Direction::parse(parser)?)
-                        )
+                        NonTSPseudoClass::MozLocaleDir(Direction::parse(parser)?)
                     },
                     "dir" => {
-                        NonTSPseudoClass::Dir(
-                            Box::new(Direction::parse(parser)?)
-                        )
+                        NonTSPseudoClass::Dir(Direction::parse(parser)?)
                     },
                     "-moz-any" => {
                         NonTSPseudoClass::MozAny(
                             selector_parser::parse_compound_selector_list(
                                 self,
                                 parser,
                             )?.into()
                         )
--- a/servo/components/style/gecko/wrapper.rs
+++ b/servo/components/style/gecko/wrapper.rs
@@ -64,17 +64,17 @@ use gecko_bindings::sugar::ownership::{H
 use hash::FxHashMap;
 use logical_geometry::WritingMode;
 use media_queries::Device;
 use properties::{ComputedValues, LonghandId};
 use properties::{Importance, PropertyDeclaration, PropertyDeclarationBlock};
 use properties::animated_properties::{AnimationValue, AnimationValueMap};
 use properties::style_structs::Font;
 use rule_tree::CascadeLevel as ServoCascadeLevel;
-use selector_parser::{AttrValue, Direction, PseudoClassStringArg};
+use selector_parser::{AttrValue, HorizontalDirection, PseudoClassStringArg};
 use selectors::{Element, OpaqueElement};
 use selectors::attr::{AttrSelectorOperation, AttrSelectorOperator};
 use selectors::attr::{CaseSensitivity, NamespaceConstraint};
 use selectors::matching::{ElementSelectorFlags, MatchingContext};
 use selectors::matching::VisitedHandlingMode;
 use selectors::sink::Push;
 use servo_arc::{Arc, ArcBorrow, RawOffsetArc};
 use shared_lock::Locked;
@@ -2232,34 +2232,32 @@ impl<'le> ::selectors::Element for Gecko
             NonTSPseudoClass::MozAny(ref sels) => context.nest(|context| {
                 sels.iter()
                     .any(|s| matches_complex_selector(s.iter(), self, context, flags_setter))
             }),
             NonTSPseudoClass::Lang(ref lang_arg) => self.match_element_lang(None, lang_arg),
             NonTSPseudoClass::MozLocaleDir(ref dir) => {
                 let state_bit = DocumentState::NS_DOCUMENT_STATE_RTL_LOCALE;
                 if context.extra_data.document_state.intersects(state_bit) {
-                    // NOTE(emilio): We could still return false for
-                    // Direction::Other(..), but we don't bother.
+                    // NOTE(emilio): We could still return false for values
+                    // other than "ltr" and "rtl", but we don't bother.
                     return !context.in_negation();
                 }
 
                 let doc_is_rtl = self.document_state().contains(state_bit);
 
-                match **dir {
-                    Direction::Ltr => !doc_is_rtl,
-                    Direction::Rtl => doc_is_rtl,
-                    Direction::Other(..) => false,
+                match dir.as_horizontal_direction() {
+                    Some(HorizontalDirection::Ltr) => !doc_is_rtl,
+                    Some(HorizontalDirection::Rtl) => doc_is_rtl,
+                    None => false,
                 }
             },
-            NonTSPseudoClass::Dir(ref dir) => match **dir {
-                Direction::Ltr => self.state().intersects(ElementState::IN_LTR_STATE),
-                Direction::Rtl => self.state().intersects(ElementState::IN_RTL_STATE),
-                Direction::Other(..) => false,
-            },
+            NonTSPseudoClass::Dir(ref dir) => {
+                self.state().intersects(dir.element_state())
+            }
         }
     }
 
     fn match_pseudo_element(
         &self,
         pseudo_element: &PseudoElement,
         _context: &mut MatchingContext<Self::Impl>,
     ) -> bool {
--- a/servo/components/style/invalidation/element/element_wrapper.rs
+++ b/servo/components/style/invalidation/element/element_wrapper.rs
@@ -183,18 +183,17 @@ where
             // just add its state flags to the NonTSPseudoClass, because if we
             // added all of them there, and tested via intersects() here, we'd
             // get incorrect behavior for :not(:dir()) cases.
             //
             // FIXME(bz): How can I set this up so once Servo adds :dir()
             // support we don't forget to update this code?
             #[cfg(feature = "gecko")]
             NonTSPseudoClass::Dir(ref dir) => {
-                use invalidation::element::invalidation_map::dir_selector_to_state;
-                let selector_flag = dir_selector_to_state(dir);
+                let selector_flag = dir.element_state();
                 if selector_flag.is_empty() {
                     // :dir() with some random argument; does not match.
                     return false;
                 }
                 let state = match self.snapshot().and_then(|s| s.state()) {
                     Some(snapshot_state) => snapshot_state,
                     None => self.element.state(),
                 };
--- a/servo/components/style/invalidation/element/invalidation_map.rs
+++ b/servo/components/style/invalidation/element/invalidation_map.rs
@@ -5,39 +5,23 @@
 //! Code for invalidations due to state or attribute changes.
 
 use {Atom, LocalName, Namespace};
 use context::QuirksMode;
 use element_state::{DocumentState, ElementState};
 use fallible::FallibleVec;
 use hashglobe::FailedAllocationError;
 use selector_map::{MaybeCaseInsensitiveHashMap, SelectorMap, SelectorMapEntry};
-#[cfg(feature = "gecko")]
-use selector_parser::Direction;
 use selector_parser::SelectorImpl;
 use selectors::attr::NamespaceConstraint;
 use selectors::parser::{Combinator, Component};
 use selectors::parser::{Selector, SelectorIter, Visit};
 use selectors::visitor::SelectorVisitor;
 use smallvec::SmallVec;
 
-#[cfg(feature = "gecko")]
-/// Gets the element state relevant to the given `:dir` pseudo-class selector.
-pub fn dir_selector_to_state(dir: &Direction) -> ElementState {
-    match *dir {
-        Direction::Ltr => ElementState::IN_LTR_STATE,
-        Direction::Rtl => ElementState::IN_RTL_STATE,
-        Direction::Other(_) => {
-            // :dir(something-random) is a valid selector, but shouldn't
-            // match anything.
-            ElementState::empty()
-        },
-    }
-}
-
 /// Mapping between (partial) CompoundSelectors (and the combinator to their
 /// right) and the states and attributes they depend on.
 ///
 /// In general, for all selectors in all applicable stylesheets of the form:
 ///
 /// |a _ b _ c _ d _ e|
 ///
 /// Where:
@@ -377,17 +361,17 @@ impl<'a> SelectorVisitor for CompoundSel
             },
             Component::Class(ref class) => {
                 self.classes.push(class.clone());
             },
             Component::NonTSPseudoClass(ref pc) => {
                 self.other_attributes |= pc.is_attr_based();
                 self.state |= match *pc {
                     #[cfg(feature = "gecko")]
-                    NonTSPseudoClass::Dir(ref dir) => dir_selector_to_state(dir),
+                    NonTSPseudoClass::Dir(ref dir) => dir.element_state(),
                     _ => pc.state_flag(),
                 };
                 *self.document_state |= pc.document_state_flag();
             },
             _ => {},
         }
 
         true
--- a/servo/components/style/selector_parser.rs
+++ b/servo/components/style/selector_parser.rs
@@ -2,20 +2,23 @@
  * 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/. */
 
 //! The pseudo-classes and pseudo-elements supported by the style system.
 
 #![deny(missing_docs)]
 
 use cssparser::{Parser as CssParser, ParserInput};
+use element_state::ElementState;
 use selectors::parser::SelectorList;
 use std::fmt::{self, Debug, Write};
+use string_cache::Atom;
 use style_traits::{CssWriter, ParseError, ToCss};
 use stylesheets::{Namespaces, Origin, UrlExtraData};
+use values::serialize_atom_identifier;
 
 /// A convenient alias for the type that represents an attribute value used for
 /// selector parser implementation.
 pub type AttrValue = <SelectorImpl as ::selectors::SelectorImpl>::AttrValue;
 
 #[cfg(feature = "servo")]
 pub use servo::selector_parser::*;
 
@@ -167,46 +170,62 @@ impl<T> PerPseudoElementMap<T> {
 
     /// Get an iterator for the entries.
     pub fn iter(&self) -> ::std::slice::Iter<Option<T>> {
         self.entries.iter()
     }
 }
 
 /// Values for the :dir() pseudo class
+///
+/// "ltr" and "rtl" values are normalized to lowercase.
 #[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq)]
-pub enum Direction {
-    /// left-to-right semantic directionality
+pub struct Direction(pub Atom);
+
+/// Horizontal values for the :dir() pseudo class
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum HorizontalDirection {
+    /// :dir(ltr)
     Ltr,
-    /// right-to-left semantic directionality
+    /// :dir(rtl)
     Rtl,
-    /// Some other provided directionality value
-    ///
-    /// TODO(emilio): If we atomize we can then unbox in NonTSPseudoClass.
-    Other(Box<str>),
 }
 
 impl Direction {
     /// Parse a direction value.
     pub fn parse<'i, 't>(parser: &mut CssParser<'i, 't>) -> Result<Self, ParseError<'i>> {
         let ident = parser.expect_ident()?;
-        Ok(match_ignore_ascii_case! { &ident,
-            "rtl" => Direction::Rtl,
-            "ltr" => Direction::Ltr,
-            _ => Direction::Other(Box::from(ident.as_ref())),
-        })
+        Ok(Direction(match_ignore_ascii_case! { &ident,
+            "rtl" => atom!("rtl"),
+            "ltr" => atom!("ltr"),
+            _ => Atom::from(ident.as_ref()),
+        }))
+    }
+
+    /// Convert this Direction into a HorizontalDirection, if applicable
+    pub fn as_horizontal_direction(&self) -> Option<HorizontalDirection> {
+        if self.0 == atom!("ltr") {
+            Some(HorizontalDirection::Ltr)
+        } else if self.0 == atom!("rtl") {
+            Some(HorizontalDirection::Rtl)
+        } else {
+            None
+        }
+    }
+
+    /// Gets the element state relevant to this :dir() selector.
+    pub fn element_state(&self) -> ElementState {
+        match self.as_horizontal_direction() {
+            Some(HorizontalDirection::Ltr) => ElementState::IN_LTR_STATE,
+            Some(HorizontalDirection::Rtl) => ElementState::IN_RTL_STATE,
+            None => ElementState::empty(),
+        }
     }
 }
 
 impl ToCss for Direction {
     fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
     where
         W: Write,
     {
-        let dir_str = match *self {
-            Direction::Rtl => "rtl",
-            Direction::Ltr => "ltr",
-            // FIXME: This should be escaped as an identifier; see #19231
-            Direction::Other(ref other) => other,
-        };
-        dest.write_str(dir_str)
+        serialize_atom_identifier(&self.0, dest)
     }
 }
--- a/taskcluster/ci/build/linux.yml
+++ b/taskcluster/ci/build/linux.yml
@@ -19,16 +19,17 @@ linux64/opt:
             - builds/releng_base_linux_64_builds.py
         script: "mozharness/scripts/fx_desktop_build.py"
         secrets: true
         tooltool-downloads: public
         need-xvfb: true
     toolchains:
         - linux64-binutils
         - linux64-clang
+        - linux64-gcc
         - linux64-rust
         - linux64-rust-size
         - linux64-cbindgen
         - linux64-sccache
         - linux64-node
 
 linux64-plain/opt:
     description: "Linux64 Opt Plain"
@@ -354,16 +355,17 @@ linux/opt:
             - builds/releng_base_linux_32_builds.py
         script: "mozharness/scripts/fx_desktop_build.py"
         secrets: true
         tooltool-downloads: public
         need-xvfb: true
     toolchains:
         - linux64-binutils
         - linux64-clang
+        - linux64-gcc
         - linux64-rust
         - linux64-rust-size
         - linux64-cbindgen
         - linux64-sccache
         - linux64-node
 
 linux/debug:
     description: "Linux32 Debug"
--- a/testing/marionette/listener.js
+++ b/testing/marionette/listener.js
@@ -783,16 +783,18 @@ async function performActions(msg) {
  * as if the state was released by an explicit series of actions. It also
  * clears all the internal state of the virtual devices.
  */
 async function releaseActions() {
   await action.dispatchTickActions(
       action.inputsToCancel.reverse(), 0, curContainer.frame);
   action.inputsToCancel.length = 0;
   action.inputStateMap.clear();
+
+  event.DoubleClickTracker.resetClick();
 }
 
 /**
  * Start action chain on one finger.
  */
 function actionChain(chain, touchId) {
   let touchProvider = {};
   touchProvider.createATouch = createATouch;
--- a/testing/mozbase/mozrunner/mozrunner/devices/android_device.py
+++ b/testing/mozbase/mozrunner/mozrunner/devices/android_device.py
@@ -223,30 +223,37 @@ def verify_android_device(build_obj, ins
         # the current build is installed, and certainly no way to
         # determine if the installed build is the desired build.
         # Installing every time is problematic because:
         #  - it prevents testing against other builds (downloaded apk)
         #  - installation may take a couple of minutes.
         if not app:
             app = build_obj.substs["ANDROID_PACKAGE_NAME"]
         device = _get_device(build_obj.substs, device_serial)
-        if not device.is_app_installed(app):
-            if 'fennec' not in app and 'firefox' not in app:
-                raw_input(
-                    "It looks like %s is not installed on this device,\n"
-                    "but I don't know how to install it.\n"
-                    "Install it now, then hit Enter " % app)
-            else:
-                response = raw_input(
-                    "It looks like %s is not installed on this device.\n"
-                    "Install Firefox? (Y/n) " % app).strip()
-                if response.lower().startswith('y') or response == '':
-                    _log_info("Installing Firefox. This may take a while...")
-                    build_obj._run_make(directory=".", target='install',
-                                        ensure_exit_code=False)
+        response = ''
+        while not device.is_app_installed(app):
+            try:
+                if 'fennec' not in app and 'firefox' not in app:
+                    response = raw_input(
+                        "It looks like %s is not installed on this device,\n"
+                        "but I don't know how to install it.\n"
+                        "Install it now, then hit Enter or quit to exit " % app)
+                else:
+                    response = response = raw_input(
+                        "It looks like %s is not installed on this device.\n"
+                        "Install Firefox? (Y/n) or quit to exit " % app).strip()
+                    if response.lower().startswith('y') or response == '':
+                        _log_info("Installing Firefox. This may take a while...")
+                        build_obj._run_make(directory=".", target='install',
+                                            ensure_exit_code=False)
+            except EOFError:
+                response = 'quit'
+            if response == 'quit':
+                device_verified = False
+                break
 
     if device_verified and xre:
         # Check whether MOZ_HOST_BIN has been set to a valid xre; if not,
         # prompt to install one.
         xre_path = os.environ.get('MOZ_HOST_BIN')
         err = None
         if not xre_path:
             err = "environment variable MOZ_HOST_BIN is not set to a directory " \
--- a/testing/raptor/mach_commands.py
+++ b/testing/raptor/mach_commands.py
@@ -21,38 +21,38 @@ from mozboot.util import get_state_dir
 from mozbuild.base import MozbuildObject, MachCommandBase
 
 HERE = os.path.dirname(os.path.realpath(__file__))
 BENCHMARK_REPOSITORY = 'https://github.com/mozilla/perf-automation'
 BENCHMARK_REVISION = '4befd28725c687b91ce749420eab29352ecbcab4'
 
 
 class RaptorRunner(MozbuildObject):
-    def run_test(self, raptor_args):
+    def run_test(self, raptor_args, app=None):
         """
         We want to do couple of things before running raptor
         1. Clone mozharness
         2. Make config for raptor mozharness
         3. Run mozharness
         """
 
-        self.init_variables(raptor_args)
+        self.init_variables(raptor_args, app=app)
         self.setup_benchmarks()
         self.make_config()
         self.write_config()
         self.make_args()
         return self.run_mozharness()
 
-    def init_variables(self, raptor_args):
+    def init_variables(self, raptor_args, app=None):
         self.raptor_dir = os.path.join(self.topsrcdir, 'testing', 'raptor')
         self.mozharness_dir = os.path.join(self.topsrcdir, 'testing',
                                            'mozharness')
         self.config_file_path = os.path.join(self._topobjdir, 'testing',
                                              'raptor-in_tree_conf.json')
-        self.binary_path = self.get_binary_path()
+        self.binary_path = self.get_binary_path() if app != 'geckoview' else None
         self.virtualenv_script = os.path.join(self.topsrcdir, 'third_party', 'python',
                                               'virtualenv', 'virtualenv.py')
         self.virtualenv_path = os.path.join(self._topobjdir, 'testing',
                                             'raptor-venv')
         self.python_interp = sys.executable
         self.raptor_args = raptor_args
 
     def setup_benchmarks(self):
@@ -155,15 +155,26 @@ def create_parser():
 
 
 @CommandProvider
 class MachRaptor(MachCommandBase):
     @Command('raptor-test', category='testing',
              description='Run raptor performance tests.',
              parser=create_parser)
     def run_raptor_test(self, **kwargs):
+
+        from mozrunner.devices.android_device import verify_android_device
+
+        build_obj = MozbuildObject.from_environment(cwd=HERE)
+        if not verify_android_device(build_obj, install=True, app=kwargs['binary']):
+            return 1
+
+        debug_command = '--debug-command'
+        if debug_command in sys.argv:
+            sys.argv.remove(debug_command)
+
         raptor = self._spawn(RaptorRunner)
 
         try:
-            return raptor.run_test(sys.argv[2:])
+            return raptor.run_test(sys.argv[2:], app=kwargs['app'])
         except Exception as e:
             print(str(e))
             return 1
--- a/testing/raptor/raptor/raptor.py
+++ b/testing/raptor/raptor/raptor.py
@@ -169,16 +169,19 @@ class Raptor(object):
         # some tests require tools to playback the test pages
         if test.get('playback', None) is not None:
             self.get_playback_config(test)
             # startup the playback tool
             self.playback = get_playback(self.config)
 
         # for geckoview we must copy the profile onto the device and set perms
         if self.config['app'] == "geckoview":
+            if not self.device.is_app_installed(self.config['binary']):
+                raise Exception('%s is not installed' % self.config['binary'])
+
             self.log.info("copying firefox profile onto the android device")
             self.device_profile = "/sdcard/raptor-profile"
             if self.device.is_dir(self.device_profile):
                 self.device.rm(self.device_profile, recursive=True)
 
             self.device.mkdir(self.device_profile)
             self.device.push(self.profile.profile, self.device_profile)
 
@@ -187,22 +190,28 @@ class Raptor(object):
 
             # now start the geckoview app
             self.log.info("starting %s" % self.config['app'])
 
             extra_args = ["-profile", self.device_profile,
                           "--es", "env0", "LOG_VERBOSE=1",
                           "--es", "env1", "R_LOG_LEVEL=6"]
 
-            self.device.launch_activity(self.config['binary'],
-                                        "GeckoViewActivity",
-                                        extra_args=extra_args,
-                                        url='about:blank',
-                                        fail_if_running=False)
-
+            try:
+                # make sure the geckoview app is not running before
+                # attempting to start.
+                self.device.stop_application(self.config['binary'])
+                self.device.launch_activity(self.config['binary'],
+                                            "GeckoViewActivity",
+                                            extra_args=extra_args,
+                                            url='about:blank',
+                                            fail_if_running=False)
+            except Exception:
+                self.log.error("Exception launching %s" % self.config['binary'])
+                raise
             self.control_server.device = self.device
             self.control_server.app_name = self.config['binary']
 
         else:
             # now start the desktop browser
             self.log.info("starting %s" % self.config['app'])
 
             self.runner.start()
--- a/testing/web-platform/meta/MANIFEST.json
+++ b/testing/web-platform/meta/MANIFEST.json
@@ -649698,17 +649698,17 @@
    "ad179673176b9d8ae90837c7cf09d33c75780a75",
    "wdspec"
   ],
   "webdriver/tests/actions/pointer_origin.py": [
    "cad59f0a13b1f584ea45226f061be0038b9de220",
    "wdspec"
   ],
   "webdriver/tests/actions/sequence.py": [
-   "426dbe82f48e265d77a60382a89aa80f466ce631",
+   "b62d00c3e9b82d6200b3f6a0cd99d8a208281601",
    "wdspec"
   ],
   "webdriver/tests/actions/special_keys.py": [
    "d2a44229ce06cb63fc386221c4870d7e1f6eda1c",
    "wdspec"
   ],
   "webdriver/tests/actions/support/__init__.py": [
    "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",
@@ -650286,17 +650286,17 @@
    "b8ef418e115fcdafa861dcb8f61b01116e9e81f6",
    "wdspec"
   ],
   "webdriver/tests/send_alert_text/__init__.py": [
    "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",
    "support"
   ],
   "webdriver/tests/send_alert_text/send.py": [
-   "edc37d6edb483c232401676f6c11ab7512774605",
+   "6dbc03f94019abf6fc467ae2baf8fb9d21823e64",
    "wdspec"
   ],
   "webdriver/tests/set_timeouts/__init__.py": [
    "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",
    "support"
   ],
   "webdriver/tests/set_timeouts/set.py": [
    "a78ab2e68e82ba28c15748bb98239b3d232dc9f1",
deleted file mode 100644
--- a/testing/web-platform/meta/css/css-transforms/transform3d-preserve3d-011.html.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[transform3d-preserve3d-011.html]
-  expected:
-    if webrender: FAIL
--- a/testing/web-platform/tests/webdriver/tests/actions/sequence.py
+++ b/testing/web-platform/tests/webdriver/tests/actions/sequence.py
@@ -1,39 +1,88 @@
 # META: timeout=long
 
 from tests.actions.support.refine import get_keys, filter_dict, get_events
-from tests.actions.support.keys import Keys
 
 
-def test_no_actions_send_no_events(session, key_reporter, key_chain):
+def test_perform_no_actions_send_no_events(session, key_reporter, key_chain):
     key_chain.perform()
     assert len(get_keys(key_reporter)) == 0
     assert len(get_events(session)) == 0
 
 
+def test_release_no_actions_sends_no_events(session, key_reporter):
+    session.actions.release()
+    assert len(get_keys(key_reporter)) == 0
+    assert len(get_events(session)) == 0
+
+
 def test_release_char_sequence_sends_keyup_events_in_reverse(session,
                                                              key_reporter,
                                                              key_chain):
     key_chain \
         .key_down("a") \
         .key_down("b") \
         .perform()
     # reset so we only see the release events
     session.execute_script("resetEvents();")
     session.actions.release()
     expected = [
         {"code": "KeyB", "key": "b", "type": "keyup"},
         {"code": "KeyA", "key": "a", "type": "keyup"},
     ]
     all_events = get_events(session)
     events = [filter_dict(e, expected[0]) for e in all_events]
-    if len(events) > 0 and events[0]["code"] == None:
+    if len(events) > 0 and events[0]["code"] is None:
         # Remove 'code' entry if browser doesn't support it
         expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
         events = [filter_dict(e, expected[0]) for e in events]
     assert events == expected
 
 
-def test_release_no_actions_sends_no_events(session, key_reporter):
+def test_release_mouse_sequence_resets_dblclick_state(session,
+                                                      test_actions_page,
+                                                      mouse_chain):
+    reporter = session.find.css("#outer", all=False)
+
+    mouse_chain \
+        .click(element=reporter) \
+        .perform()
     session.actions.release()
-    assert len(get_keys(key_reporter)) == 0
-    assert len(get_events(session)) == 0
+    mouse_chain \
+        .perform()
+    events = get_events(session)
+
+    expected = [
+        {"type": "mousedown", "button": 0},
+        {"type": "mouseup", "button": 0},
+        {"type": "click", "button": 0},
+        {"type": "mousedown", "button": 0},
+        {"type": "mouseup", "button": 0},
+        {"type": "click", "button": 0},
+    ]
+    filtered_events = [filter_dict(e, expected[0]) for e in events]
+    assert expected == filtered_events[1:]
+
+
+def test_no_release_mouse_sequence_keeps_dblclick_state(session,
+                                                        test_actions_page,
+                                                        mouse_chain):
+    reporter = session.find.css("#outer", all=False)
+
+    mouse_chain \
+        .click(element=reporter) \
+        .perform()
+    mouse_chain \
+        .perform()
+    events = get_events(session)
+
+    expected = [
+        {"type": "mousedown", "button": 0},
+        {"type": "mouseup", "button": 0},
+        {"type": "click", "button": 0},
+        {"type": "mousedown", "button": 0},
+        {"type": "mouseup", "button": 0},
+        {"type": "click", "button": 0},
+        {"type": "dblclick", "button": 0},
+    ]
+    filtered_events = [filter_dict(e, expected[0]) for e in events]
+    assert expected == filtered_events[1:]
--- a/toolkit/components/aboutmemory/content/aboutMemory.js
+++ b/toolkit/components/aboutmemory/content/aboutMemory.js
@@ -1424,24 +1424,16 @@ function appendProcessAboutMemoryElement
 
   let appendLink = function(aHere, aThere, aArrow) {
     let link = appendElementWithText(aP, "a", "upDownArrow", aArrow);
     link.href = "#" + aThere + aN;
     link.id = aHere + aN;
     link.title = "Go to the " + aThere + " of " + aProcess;
     link.style = "text-decoration: none";
 
-    // This jumps to the anchor without the page location getting the anchor
-    // name tacked onto its end, which is what happens with a vanilla link.
-    link.addEventListener("click", function(event) {
-      document.documentElement.scrollTop =
-        document.querySelector(event.target.href).offsetTop;
-      event.preventDefault();
-    });
-
     // This gives nice spacing when we copy and paste.
     appendElementWithText(aP, "span", "", "\n");
   };
 
   appendElementWithText(aP, "h1", "", aProcess);
   appendLink("start", "end", kDownwardsArrow);
 
   // We'll fill this in later.