Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1035 insertions, 0 deletions

diff --git a/gfx/wr/webrender/src/render_target.rs b/gfx/wr/webrender/src/render_target.rs
new file mode 100644
index 0000000000..d8f62a6088
--- /dev/null
+++ b/gfx/wr/webrender/src/render_target.rs
@@ -0,0 +1,1035 @@
+/* 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::units::*;
+use api::{ColorF, ClipMode, ImageFormat, LineOrientation, BorderStyle};
+use crate::batch::{AlphaBatchBuilder, AlphaBatchContainer, BatchTextures, add_quad_to_batch};
+use crate::batch::{ClipBatcher, BatchBuilder, INVALID_SEGMENT_INDEX};
+use crate::command_buffer::{CommandBufferList};
+use crate::spatial_tree::SpatialTree;
+use crate::clip::{ClipStore, ClipNodeRange, ClipItemKind};
+use crate::frame_builder::{FrameGlobalResources};
+use crate::gpu_cache::{GpuCache, GpuCacheAddress};
+use crate::gpu_types::{BorderInstance, SvgFilterInstance, BlurDirection, BlurInstance, PrimitiveHeaders, ScalingInstance};
+use crate::gpu_types::{TransformPalette, ZBufferIdGenerator, TransformPaletteId, PrimitiveInstanceData, MaskInstance};
+use crate::gpu_types::{ZBufferId};
+use crate::internal_types::{FastHashMap, TextureSource, CacheTextureId};
+use crate::picture::{SliceId, SurfaceInfo, ResolvedSurfaceTexture, TileCacheInstance};
+use crate::prim_store::{PrimitiveInstance, PrimitiveStore, PrimitiveScratchBuffer};
+use crate::prim_store::gradient::{
+    FastLinearGradientInstance, LinearGradientInstance, RadialGradientInstance,
+    ConicGradientInstance,
+};
+use crate::renderer::{GpuBufferAddress, GpuBufferBuilder};
+use crate::render_backend::DataStores;
+use crate::render_task::{RenderTaskKind, RenderTaskAddress};
+use crate::render_task::{RenderTask, ScalingTask, SvgFilterInfo};
+use crate::render_task_graph::{RenderTaskGraph, RenderTaskId};
+use crate::resource_cache::ResourceCache;
+use crate::spatial_tree::{SpatialNodeIndex};
+
+
+const STYLE_SOLID: i32 = ((BorderStyle::Solid as i32) << 8) | ((BorderStyle::Solid as i32) << 16);
+const STYLE_MASK: i32 = 0x00FF_FF00;
+
+/// A tag used to identify the output format of a `RenderTarget`.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub enum RenderTargetKind {
+    Color, // RGBA8
+    Alpha, // R8
+}
+
+/// Identifies a given `RenderTarget` in a `RenderTargetList`.
+#[derive(Debug, Copy, Clone)]
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct RenderTargetIndex(pub usize);
+
+pub struct RenderTargetContext<'a, 'rc> {
+    pub global_device_pixel_scale: DevicePixelScale,
+    pub prim_store: &'a PrimitiveStore,
+    pub clip_store: &'a ClipStore,
+    pub resource_cache: &'rc mut ResourceCache,
+    pub use_dual_source_blending: bool,
+    pub use_advanced_blending: bool,
+    pub break_advanced_blend_batches: bool,
+    pub batch_lookback_count: usize,
+    pub spatial_tree: &'a SpatialTree,
+    pub data_stores: &'a DataStores,
+    pub surfaces: &'a [SurfaceInfo],
+    pub scratch: &'a PrimitiveScratchBuffer,
+    pub screen_world_rect: WorldRect,
+    pub globals: &'a FrameGlobalResources,
+    pub tile_caches: &'a FastHashMap<SliceId, Box<TileCacheInstance>>,
+    pub root_spatial_node_index: SpatialNodeIndex,
+}
+
+/// Represents a number of rendering operations on a surface.
+///
+/// In graphics parlance, a "render target" usually means "a surface (texture or
+/// framebuffer) bound to the output of a shader". This trait has a slightly
+/// different meaning, in that it represents the operations on that surface
+/// _before_ it's actually bound and rendered. So a `RenderTarget` is built by
+/// the `RenderBackend` by inserting tasks, and then shipped over to the
+/// `Renderer` where a device surface is resolved and the tasks are transformed
+/// into draw commands on that surface.
+///
+/// We express this as a trait to generalize over color and alpha surfaces.
+/// a given `RenderTask` will draw to one or the other, depending on its type
+/// and sometimes on its parameters. See `RenderTask::target_kind`.
+pub trait RenderTarget {
+    /// Creates a new RenderTarget of the given type.
+    fn new(
+        texture_id: CacheTextureId,
+        screen_size: DeviceIntSize,
+        gpu_supports_fast_clears: bool,
+        used_rect: DeviceIntRect,
+    ) -> Self;
+
+    /// Optional hook to provide additional processing for the target at the
+    /// end of the build phase.
+    fn build(
+        &mut self,
+        _ctx: &mut RenderTargetContext,
+        _gpu_cache: &mut GpuCache,
+        _render_tasks: &RenderTaskGraph,
+        _prim_headers: &mut PrimitiveHeaders,
+        _transforms: &mut TransformPalette,
+        _z_generator: &mut ZBufferIdGenerator,
+        _prim_instances: &[PrimitiveInstance],
+        _cmd_buffers: &CommandBufferList,
+    ) {
+    }
+
+    /// Associates a `RenderTask` with this target. That task must be assigned
+    /// to a region returned by invoking `allocate()` on this target.
+    ///
+    /// TODO(gw): It's a bit odd that we need the deferred resolves and mutable
+    /// GPU cache here. They are typically used by the build step above. They
+    /// are used for the blit jobs to allow resolve_image to be called. It's a
+    /// bit of extra overhead to store the image key here and the resolve them
+    /// in the build step separately.  BUT: if/when we add more texture cache
+    /// target jobs, we might want to tidy this up.
+    fn add_task(
+        &mut self,
+        task_id: RenderTaskId,
+        ctx: &RenderTargetContext,
+        gpu_cache: &mut GpuCache,
+        gpu_buffer_builder: &mut GpuBufferBuilder,
+        render_tasks: &RenderTaskGraph,
+        clip_store: &ClipStore,
+        transforms: &mut TransformPalette,
+    );
+
+    fn needs_depth(&self) -> bool;
+    fn texture_id(&self) -> CacheTextureId;
+}
+
+/// A series of `RenderTarget` instances, serving as the high-level container
+/// into which `RenderTasks` are assigned.
+///
+/// During the build phase, we iterate over the tasks in each `RenderPass`. For
+/// each task, we invoke `allocate()` on the `RenderTargetList`, which in turn
+/// attempts to allocate an output region in the last `RenderTarget` in the
+/// list. If allocation fails (or if the list is empty), a new `RenderTarget` is
+/// created and appended to the list. The build phase then assign the task into
+/// the target associated with the final allocation.
+///
+/// The result is that each `RenderPass` is associated with one or two
+/// `RenderTargetLists`, depending on whether we have all our tasks have the
+/// same `RenderTargetKind`. The lists are then shipped to the `Renderer`, which
+/// allocates a device texture array, with one slice per render target in the
+/// list.
+///
+/// The upshot of this scheme is that it maximizes batching. In a given pass,
+/// we need to do a separate batch for each individual render target. But with
+/// the texture array, we can expose the entirety of the previous pass to each
+/// task in the current pass in a single batch, which generally allows each
+/// task to be drawn in a single batch regardless of how many results from the
+/// previous pass it depends on.
+///
+/// Note that in some cases (like drop-shadows), we can depend on the output of
+/// a pass earlier than the immediately-preceding pass.
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct RenderTargetList<T> {
+    pub format: ImageFormat,
+    pub targets: Vec<T>,
+}
+
+impl<T: RenderTarget> RenderTargetList<T> {
+    pub fn new(
+        format: ImageFormat,
+    ) -> Self {
+        RenderTargetList {
+            format,
+            targets: Vec::new(),
+        }
+    }
+
+    pub fn build(
+        &mut self,
+        ctx: &mut RenderTargetContext,
+        gpu_cache: &mut GpuCache,
+        render_tasks: &RenderTaskGraph,
+        prim_headers: &mut PrimitiveHeaders,
+        transforms: &mut TransformPalette,
+        z_generator: &mut ZBufferIdGenerator,
+        prim_instances: &[PrimitiveInstance],
+        cmd_buffers: &CommandBufferList,
+    ) {
+        if self.targets.is_empty() {
+            return;
+        }
+
+        for target in &mut self.targets {
+            target.build(
+                ctx,
+                gpu_cache,
+                render_tasks,
+                prim_headers,
+                transforms,
+                z_generator,
+                prim_instances,
+                cmd_buffers,
+            );
+        }
+    }
+
+    pub fn needs_depth(&self) -> bool {
+        self.targets.iter().any(|target| target.needs_depth())
+    }
+}
+
+
+/// Contains the work (in the form of instance arrays) needed to fill a color
+/// color output surface (RGBA8).
+///
+/// See `RenderTarget`.
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct ColorRenderTarget {
+    pub alpha_batch_containers: Vec<AlphaBatchContainer>,
+    // List of blur operations to apply for this render target.
+    pub vertical_blurs: FastHashMap<TextureSource, Vec<BlurInstance>>,
+    pub horizontal_blurs: FastHashMap<TextureSource, Vec<BlurInstance>>,
+    pub scalings: FastHashMap<TextureSource, Vec<ScalingInstance>>,
+    pub svg_filters: Vec<(BatchTextures, Vec<SvgFilterInstance>)>,
+    pub blits: Vec<BlitJob>,
+    alpha_tasks: Vec<RenderTaskId>,
+    screen_size: DeviceIntSize,
+    pub texture_id: CacheTextureId,
+    // Track the used rect of the render target, so that
+    // we can set a scissor rect and only clear to the
+    // used portion of the target as an optimization.
+    pub used_rect: DeviceIntRect,
+    pub resolve_ops: Vec<ResolveOp>,
+    pub clear_color: Option<ColorF>,
+
+    pub prim_instances: Vec<PrimitiveInstanceData>,
+    pub mask_instances_fast: Vec<MaskInstance>,
+    pub mask_instances_slow: Vec<MaskInstance>,
+}
+
+impl RenderTarget for ColorRenderTarget {
+    fn new(
+        texture_id: CacheTextureId,
+        screen_size: DeviceIntSize,
+        _: bool,
+        used_rect: DeviceIntRect,
+    ) -> Self {
+        ColorRenderTarget {
+            alpha_batch_containers: Vec::new(),
+            vertical_blurs: FastHashMap::default(),
+            horizontal_blurs: FastHashMap::default(),
+            scalings: FastHashMap::default(),
+            svg_filters: Vec::new(),
+            blits: Vec::new(),
+            alpha_tasks: Vec::new(),
+            screen_size,
+            texture_id,
+            used_rect,
+            resolve_ops: Vec::new(),
+            clear_color: Some(ColorF::TRANSPARENT),
+            prim_instances: Vec::new(),
+            mask_instances_fast: Vec::new(),
+            mask_instances_slow: Vec::new(),
+        }
+    }
+
+    fn build(
+        &mut self,
+        ctx: &mut RenderTargetContext,
+        gpu_cache: &mut GpuCache,
+        render_tasks: &RenderTaskGraph,
+        prim_headers: &mut PrimitiveHeaders,
+        transforms: &mut TransformPalette,
+        z_generator: &mut ZBufferIdGenerator,
+        prim_instances: &[PrimitiveInstance],
+        cmd_buffers: &CommandBufferList,
+    ) {
+        profile_scope!("build");
+        let mut merged_batches = AlphaBatchContainer::new(None);
+        let mut gpu_buffer_builder = GpuBufferBuilder::new();
+
+        for task_id in &self.alpha_tasks {
+            profile_scope!("alpha_task");
+            let task = &render_tasks[*task_id];
+
+            match task.kind {
+                RenderTaskKind::Picture(ref pic_task) => {
+                    let target_rect = task.get_target_rect();
+
+                    let scissor_rect = if pic_task.can_merge {
+                        None
+                    } else {
+                        Some(target_rect)
+                    };
+
+                    if !pic_task.can_use_shared_surface {
+                        self.clear_color = pic_task.clear_color;
+                    }
+
+                    // TODO(gw): The type names of AlphaBatchBuilder and BatchBuilder
+                    //           are still confusing. Once more of the picture caching
+                    //           improvement code lands, the AlphaBatchBuilder and
+                    //           AlphaBatchList types will be collapsed into one, which
+                    //           should simplify coming up with better type names.
+                    let alpha_batch_builder = AlphaBatchBuilder::new(
+                        self.screen_size,
+                        ctx.break_advanced_blend_batches,
+                        ctx.batch_lookback_count,
+                        *task_id,
+                        (*task_id).into(),
+                    );
+
+                    let mut batch_builder = BatchBuilder::new(alpha_batch_builder);
+                    let cmd_buffer = cmd_buffers.get(pic_task.cmd_buffer_index);
+
+                    cmd_buffer.iter_prims(&mut |cmd, spatial_node_index, segments| {
+                        batch_builder.add_prim_to_batch(
+                            cmd,
+                            spatial_node_index,
+                            ctx,
+                            gpu_cache,
+                            render_tasks,
+                            prim_headers,
+                            transforms,
+                            pic_task.raster_spatial_node_index,
+                            pic_task.surface_spatial_node_index,
+                            z_generator,
+                            prim_instances,
+                            &mut gpu_buffer_builder,
+                            segments,
+                        );
+                    });
+
+                    let alpha_batch_builder = batch_builder.finalize();
+
+                    alpha_batch_builder.build(
+                        &mut self.alpha_batch_containers,
+                        &mut merged_batches,
+                        target_rect,
+                        scissor_rect,
+                    );
+                }
+                _ => {
+                    unreachable!();
+                }
+            }
+        }
+
+        if !merged_batches.is_empty() {
+            self.alpha_batch_containers.push(merged_batches);
+        }
+    }
+
+    fn texture_id(&self) -> CacheTextureId {
+        self.texture_id
+    }
+
+    fn add_task(
+        &mut self,
+        task_id: RenderTaskId,
+        ctx: &RenderTargetContext,
+        gpu_cache: &mut GpuCache,
+        gpu_buffer_builder: &mut GpuBufferBuilder,
+        render_tasks: &RenderTaskGraph,
+        _: &ClipStore,
+        transforms: &mut TransformPalette,
+    ) {
+        profile_scope!("add_task");
+        let task = &render_tasks[task_id];
+
+        match task.kind {
+            RenderTaskKind::Prim(ref info) => {
+                let render_task_address = task_id.into();
+
+                add_quad_to_batch(
+                    render_task_address,
+                    info.transform_id,
+                    info.prim_address,
+                    info.quad_flags,
+                    info.edge_flags,
+                    INVALID_SEGMENT_INDEX as u8,
+                    RenderTaskId::INVALID,
+                    ZBufferId(0),
+                    render_tasks,
+                    |_, instance| {
+                        self.prim_instances.push(instance);
+                    }
+                );
+
+                let mask_instances_fast = &mut self.mask_instances_fast;
+                let mask_instances_slow = &mut self.mask_instances_slow;
+
+                build_mask_tasks(
+                    info.clip_node_range,
+                    info.prim_spatial_node_index,
+                    ctx.clip_store,
+                    ctx.data_stores,
+                    ctx.spatial_tree,
+                    gpu_buffer_builder,
+                    transforms,
+                    |fast_path, clip_address, clip_transform_id| {
+                        add_quad_to_batch(
+                            render_task_address,
+                            info.transform_id,
+                            info.prim_address,
+                            info.quad_flags,
+                            info.edge_flags,
+                            INVALID_SEGMENT_INDEX as u8,
+                            RenderTaskId::INVALID,
+                            ZBufferId(0),
+                            render_tasks,
+                            |_, prim| {
+                                let instance = MaskInstance {
+                                    prim,
+                                    clip_transform_id,
+                                    clip_address: clip_address.as_int(),
+                                    info: [0; 2],
+                                };
+
+                                if fast_path {
+                                    mask_instances_fast.push(instance);
+                                } else {
+                                    mask_instances_slow.push(instance);
+                                }
+                            }
+                        );
+                    }
+                );
+            }
+            RenderTaskKind::VerticalBlur(..) => {
+                add_blur_instances(
+                    &mut self.vertical_blurs,
+                    BlurDirection::Vertical,
+                    task_id.into(),
+                    task.children[0],
+                    render_tasks,
+                );
+            }
+            RenderTaskKind::HorizontalBlur(..) => {
+                add_blur_instances(
+                    &mut self.horizontal_blurs,
+                    BlurDirection::Horizontal,
+                    task_id.into(),
+                    task.children[0],
+                    render_tasks,
+                );
+            }
+            RenderTaskKind::Picture(ref pic_task) => {
+                if let Some(ref resolve_op) = pic_task.resolve_op {
+                    self.resolve_ops.push(resolve_op.clone());
+                }
+                self.alpha_tasks.push(task_id);
+            }
+            RenderTaskKind::SvgFilter(ref task_info) => {
+                add_svg_filter_instances(
+                    &mut self.svg_filters,
+                    render_tasks,
+                    &task_info.info,
+                    task_id,
+                    task.children.get(0).cloned(),
+                    task.children.get(1).cloned(),
+                    task_info.extra_gpu_cache_handle.map(|handle| gpu_cache.get_address(&handle)),
+                )
+            }
+            RenderTaskKind::Image(..) |
+            RenderTaskKind::Cached(..) |
+            RenderTaskKind::ClipRegion(..) |
+            RenderTaskKind::Border(..) |
+            RenderTaskKind::CacheMask(..) |
+            RenderTaskKind::FastLinearGradient(..) |
+            RenderTaskKind::LinearGradient(..) |
+            RenderTaskKind::RadialGradient(..) |
+            RenderTaskKind::ConicGradient(..) |
+            RenderTaskKind::TileComposite(..) |
+            RenderTaskKind::LineDecoration(..) => {
+                panic!("Should not be added to color target!");
+            }
+            RenderTaskKind::Readback(..) => {}
+            RenderTaskKind::Scaling(ref info) => {
+                add_scaling_instances(
+                    info,
+                    &mut self.scalings,
+                    task,
+                    task.children.first().map(|&child| &render_tasks[child]),
+                );
+            }
+            RenderTaskKind::Blit(ref task_info) => {
+                let target_rect = task.get_target_rect();
+                self.blits.push(BlitJob {
+                    source: task_info.source,
+                    target_rect,
+                });
+            }
+            #[cfg(test)]
+            RenderTaskKind::Test(..) => {}
+        }
+    }
+
+    fn needs_depth(&self) -> bool {
+        self.alpha_batch_containers.iter().any(|ab| {
+            !ab.opaque_batches.is_empty()
+        })
+    }
+}
+
+/// Contains the work (in the form of instance arrays) needed to fill an alpha
+/// output surface (R8).
+///
+/// See `RenderTarget`.
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct AlphaRenderTarget {
+    pub clip_batcher: ClipBatcher,
+    // List of blur operations to apply for this render target.
+    pub vertical_blurs: FastHashMap<TextureSource, Vec<BlurInstance>>,
+    pub horizontal_blurs: FastHashMap<TextureSource, Vec<BlurInstance>>,
+    pub scalings: FastHashMap<TextureSource, Vec<ScalingInstance>>,
+    pub zero_clears: Vec<RenderTaskId>,
+    pub one_clears: Vec<RenderTaskId>,
+    pub texture_id: CacheTextureId,
+}
+
+impl RenderTarget for AlphaRenderTarget {
+    fn new(
+        texture_id: CacheTextureId,
+        _: DeviceIntSize,
+        gpu_supports_fast_clears: bool,
+        _: DeviceIntRect,
+    ) -> Self {
+        AlphaRenderTarget {
+            clip_batcher: ClipBatcher::new(gpu_supports_fast_clears),
+            vertical_blurs: FastHashMap::default(),
+            horizontal_blurs: FastHashMap::default(),
+            scalings: FastHashMap::default(),
+            zero_clears: Vec::new(),
+            one_clears: Vec::new(),
+            texture_id,
+        }
+    }
+
+    fn texture_id(&self) -> CacheTextureId {
+        self.texture_id
+    }
+
+    fn add_task(
+        &mut self,
+        task_id: RenderTaskId,
+        ctx: &RenderTargetContext,
+        gpu_cache: &mut GpuCache,
+        _: &mut GpuBufferBuilder,
+        render_tasks: &RenderTaskGraph,
+        clip_store: &ClipStore,
+        transforms: &mut TransformPalette,
+    ) {
+        profile_scope!("add_task");
+        let task = &render_tasks[task_id];
+        let target_rect = task.get_target_rect();
+
+        match task.kind {
+            RenderTaskKind::Prim(..) |
+            RenderTaskKind::Image(..) |
+            RenderTaskKind::Cached(..) |
+            RenderTaskKind::Readback(..) |
+            RenderTaskKind::Picture(..) |
+            RenderTaskKind::Blit(..) |
+            RenderTaskKind::Border(..) |
+            RenderTaskKind::LineDecoration(..) |
+            RenderTaskKind::FastLinearGradient(..) |
+            RenderTaskKind::LinearGradient(..) |
+            RenderTaskKind::RadialGradient(..) |
+            RenderTaskKind::ConicGradient(..) |
+            RenderTaskKind::TileComposite(..) |
+            RenderTaskKind::SvgFilter(..) => {
+                panic!("BUG: should not be added to alpha target!");
+            }
+            RenderTaskKind::VerticalBlur(..) => {
+                self.zero_clears.push(task_id);
+                add_blur_instances(
+                    &mut self.vertical_blurs,
+                    BlurDirection::Vertical,
+                    task_id.into(),
+                    task.children[0],
+                    render_tasks,
+                );
+            }
+            RenderTaskKind::HorizontalBlur(..) => {
+                self.zero_clears.push(task_id);
+                add_blur_instances(
+                    &mut self.horizontal_blurs,
+                    BlurDirection::Horizontal,
+                    task_id.into(),
+                    task.children[0],
+                    render_tasks,
+                );
+            }
+            RenderTaskKind::CacheMask(ref task_info) => {
+                let clear_to_one = self.clip_batcher.add(
+                    task_info.clip_node_range,
+                    task_info.root_spatial_node_index,
+                    render_tasks,
+                    gpu_cache,
+                    clip_store,
+                    transforms,
+                    task_info.actual_rect,
+                    task_info.device_pixel_scale,
+                    target_rect.min.to_f32(),
+                    task_info.actual_rect.min,
+                    ctx,
+                );
+                if task_info.clear_to_one || clear_to_one {
+                    self.one_clears.push(task_id);
+                }
+            }
+            RenderTaskKind::ClipRegion(ref region_task) => {
+                if region_task.clear_to_one {
+                    self.one_clears.push(task_id);
+                }
+                let device_rect = DeviceRect::from_size(
+                    target_rect.size().to_f32(),
+                );
+                self.clip_batcher.add_clip_region(
+                    region_task.local_pos,
+                    device_rect,
+                    region_task.clip_data.clone(),
+                    target_rect.min.to_f32(),
+                    DevicePoint::zero(),
+                    region_task.device_pixel_scale.0,
+                );
+            }
+            RenderTaskKind::Scaling(ref info) => {
+                add_scaling_instances(
+                    info,
+                    &mut self.scalings,
+                    task,
+                    task.children.first().map(|&child| &render_tasks[child]),
+                );
+            }
+            #[cfg(test)]
+            RenderTaskKind::Test(..) => {}
+        }
+    }
+
+    fn needs_depth(&self) -> bool {
+        false
+    }
+}
+
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+#[derive(Debug, PartialEq, Clone)]
+pub struct ResolveOp {
+    pub src_task_ids: Vec<RenderTaskId>,
+    pub dest_task_id: RenderTaskId,
+}
+
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub enum PictureCacheTargetKind {
+    Draw {
+        alpha_batch_container: AlphaBatchContainer,
+    },
+    Blit {
+        task_id: RenderTaskId,
+        sub_rect_offset: DeviceIntVector2D,
+    },
+}
+
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct PictureCacheTarget {
+    pub surface: ResolvedSurfaceTexture,
+    pub kind: PictureCacheTargetKind,
+    pub clear_color: Option<ColorF>,
+    pub dirty_rect: DeviceIntRect,
+    pub valid_rect: DeviceIntRect,
+}
+
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct TextureCacheRenderTarget {
+    pub target_kind: RenderTargetKind,
+    pub horizontal_blurs: FastHashMap<TextureSource, Vec<BlurInstance>>,
+    pub blits: Vec<BlitJob>,
+    pub border_segments_complex: Vec<BorderInstance>,
+    pub border_segments_solid: Vec<BorderInstance>,
+    pub clears: Vec<DeviceIntRect>,
+    pub line_decorations: Vec<LineDecorationJob>,
+    pub fast_linear_gradients: Vec<FastLinearGradientInstance>,
+    pub linear_gradients: Vec<LinearGradientInstance>,
+    pub radial_gradients: Vec<RadialGradientInstance>,
+    pub conic_gradients: Vec<ConicGradientInstance>,
+}
+
+impl TextureCacheRenderTarget {
+    pub fn new(target_kind: RenderTargetKind) -> Self {
+        TextureCacheRenderTarget {
+            target_kind,
+            horizontal_blurs: FastHashMap::default(),
+            blits: vec![],
+            border_segments_complex: vec![],
+            border_segments_solid: vec![],
+            clears: vec![],
+            line_decorations: vec![],
+            fast_linear_gradients: vec![],
+            linear_gradients: vec![],
+            radial_gradients: vec![],
+            conic_gradients: vec![],
+        }
+    }
+
+    pub fn add_task(
+        &mut self,
+        task_id: RenderTaskId,
+        render_tasks: &RenderTaskGraph,
+    ) {
+        profile_scope!("add_task");
+        let task_address = task_id.into();
+
+        let task = &render_tasks[task_id];
+        let target_rect = task.get_target_rect();
+
+        match task.kind {
+            RenderTaskKind::LineDecoration(ref info) => {
+                self.clears.push(target_rect);
+
+                self.line_decorations.push(LineDecorationJob {
+                    task_rect: target_rect.to_f32(),
+                    local_size: info.local_size,
+                    style: info.style as i32,
+                    axis_select: match info.orientation {
+                        LineOrientation::Horizontal => 0.0,
+                        LineOrientation::Vertical => 1.0,
+                    },
+                    wavy_line_thickness: info.wavy_line_thickness,
+                });
+            }
+            RenderTaskKind::HorizontalBlur(..) => {
+                add_blur_instances(
+                    &mut self.horizontal_blurs,
+                    BlurDirection::Horizontal,
+                    task_address,
+                    task.children[0],
+                    render_tasks,
+                );
+            }
+            RenderTaskKind::Blit(ref task_info) => {
+                // Add a blit job to copy from an existing render
+                // task to this target.
+                self.blits.push(BlitJob {
+                    source: task_info.source,
+                    target_rect,
+                });
+            }
+            RenderTaskKind::Border(ref task_info) => {
+                self.clears.push(target_rect);
+
+                let task_origin = target_rect.min.to_f32();
+                // TODO(gw): Clone here instead of a move of this vec, since the frame
+                //           graph is immutable by this point. It's rare that borders
+                //           are drawn since they are persisted in the texture cache,
+                //           but perhaps this could be improved in future.
+                let instances = task_info.instances.clone();
+                for mut instance in instances {
+                    // TODO(gw): It may be better to store the task origin in
+                    //           the render task data instead of per instance.
+                    instance.task_origin = task_origin;
+                    if instance.flags & STYLE_MASK == STYLE_SOLID {
+                        self.border_segments_solid.push(instance);
+                    } else {
+                        self.border_segments_complex.push(instance);
+                    }
+                }
+            }
+            RenderTaskKind::FastLinearGradient(ref task_info) => {
+                self.fast_linear_gradients.push(task_info.to_instance(&target_rect));
+            }
+            RenderTaskKind::LinearGradient(ref task_info) => {
+                self.linear_gradients.push(task_info.to_instance(&target_rect));
+            }
+            RenderTaskKind::RadialGradient(ref task_info) => {
+                self.radial_gradients.push(task_info.to_instance(&target_rect));
+            }
+            RenderTaskKind::ConicGradient(ref task_info) => {
+                self.conic_gradients.push(task_info.to_instance(&target_rect));
+            }
+            RenderTaskKind::Prim(..) |
+            RenderTaskKind::Image(..) |
+            RenderTaskKind::Cached(..) |
+            RenderTaskKind::VerticalBlur(..) |
+            RenderTaskKind::Picture(..) |
+            RenderTaskKind::ClipRegion(..) |
+            RenderTaskKind::CacheMask(..) |
+            RenderTaskKind::Readback(..) |
+            RenderTaskKind::Scaling(..) |
+            RenderTaskKind::TileComposite(..) |
+            RenderTaskKind::SvgFilter(..) => {
+                panic!("BUG: unexpected task kind for texture cache target");
+            }
+            #[cfg(test)]
+            RenderTaskKind::Test(..) => {}
+        }
+    }
+}
+
+fn add_blur_instances(
+    instances: &mut FastHashMap<TextureSource, Vec<BlurInstance>>,
+    blur_direction: BlurDirection,
+    task_address: RenderTaskAddress,
+    src_task_id: RenderTaskId,
+    render_tasks: &RenderTaskGraph,
+) {
+    let source = render_tasks[src_task_id].get_texture_source();
+
+    let instance = BlurInstance {
+        task_address,
+        src_task_address: src_task_id.into(),
+        blur_direction,
+    };
+
+    instances
+        .entry(source)
+        .or_insert(Vec::new())
+        .push(instance);
+}
+
+fn add_scaling_instances(
+    task: &ScalingTask,
+    instances: &mut FastHashMap<TextureSource, Vec<ScalingInstance>>,
+    target_task: &RenderTask,
+    source_task: Option<&RenderTask>,
+) {
+    let target_rect = target_task
+        .get_target_rect()
+        .inner_box(task.padding)
+        .to_f32();
+
+    let source = source_task.unwrap().get_texture_source();
+
+    let source_rect = source_task.unwrap().get_target_rect().to_f32();
+
+    instances
+        .entry(source)
+        .or_insert(Vec::new())
+        .push(ScalingInstance {
+            target_rect,
+            source_rect,
+        });
+}
+
+fn build_mask_tasks<F>(
+    clips_range: ClipNodeRange,
+    prim_spatial_node_index: SpatialNodeIndex,
+    clip_store: &ClipStore,
+    data_stores: &DataStores,
+    spatial_tree: &SpatialTree,
+    gpu_buffer_builder: &mut GpuBufferBuilder,
+    transforms: &mut TransformPalette,
+    mut f: F,
+) where F: FnMut(bool, GpuBufferAddress, TransformPaletteId) {
+    for i in 0 .. clips_range.count {
+        let clip_instance = clip_store.get_instance_from_range(&clips_range, i);
+        let clip_node = &data_stores.clip[clip_instance.handle];
+
+        // TODO(gw): We know that the prim <-> clip mapping is 2d in this initial patch
+        //           set, due to the checks in `can_use_clip_chain_for_quad_path`. The
+        //           next set of patches needs to account for perspective here in how
+        //           we draw the mask.
+
+        let clip_transform_id = transforms.get_id(
+            prim_spatial_node_index,
+            clip_node.item.spatial_node_index,
+            spatial_tree,
+        );
+
+        match clip_node.item.kind {
+            ClipItemKind::RoundedRectangle { rect, radius, mode } => {
+                let (fast_path, clip_address) = if radius.is_uniform().is_some() {
+                    let mut writer = gpu_buffer_builder.write_blocks(3);
+                    writer.push_one(rect);
+                    writer.push_one([radius.top_left.width, 0.0, 0.0, 0.0]);
+                    writer.push_one([mode as i32 as f32, 0.0, 0.0, 0.0]);
+                    let clip_address = writer.finish();
+
+                    (true, clip_address)
+                } else {
+                    let mut writer = gpu_buffer_builder.write_blocks(4);
+                    writer.push_one(rect);
+                    writer.push_one([
+                        radius.top_left.width,
+                        radius.top_left.height,
+                        radius.top_right.width,
+                        radius.top_right.height,
+                    ]);
+                    writer.push_one([
+                        radius.bottom_left.width,
+                        radius.bottom_left.height,
+                        radius.bottom_right.width,
+                        radius.bottom_right.height,
+                    ]);
+                    writer.push_one([mode as i32 as f32, 0.0, 0.0, 0.0]);
+                    let clip_address = writer.finish();
+
+                    (false, clip_address)
+                };
+
+                f(fast_path, clip_address, clip_transform_id);
+            }
+            ClipItemKind::Rectangle { rect, mode: ClipMode::ClipOut, .. } => {
+                let mut writer = gpu_buffer_builder.write_blocks(3);
+                writer.push_one(rect);
+                writer.push_one([0.0, 0.0, 0.0, 0.0]);
+                writer.push_one([ClipMode::ClipOut as i32 as f32, 0.0, 0.0, 0.0]);
+                let clip_address = writer.finish();
+
+                f(true, clip_address, clip_transform_id);
+            }
+            ClipItemKind::Rectangle { mode: ClipMode::Clip, .. } => {
+                // Handled by local clip rect in vertex shader
+            }
+            ClipItemKind::BoxShadow { .. } => {
+                panic!("bug: box-shadow clips not expected on non-legacy rect/quads");
+            }
+            ClipItemKind::Image { .. } => {
+                panic!("bug: image-masks not expected on rect/quads");
+            }
+        }
+    }
+}
+
+fn add_svg_filter_instances(
+    instances: &mut Vec<(BatchTextures, Vec<SvgFilterInstance>)>,
+    render_tasks: &RenderTaskGraph,
+    filter: &SvgFilterInfo,
+    task_id: RenderTaskId,
+    input_1_task: Option<RenderTaskId>,
+    input_2_task: Option<RenderTaskId>,
+    extra_data_address: Option<GpuCacheAddress>,
+) {
+    let mut textures = BatchTextures::empty();
+
+    if let Some(id) = input_1_task {
+        textures.input.colors[0] = render_tasks[id].get_texture_source();
+    }
+
+    if let Some(id) = input_2_task {
+        textures.input.colors[1] = render_tasks[id].get_texture_source();
+    }
+
+    let kind = match filter {
+        SvgFilterInfo::Blend(..) => 0,
+        SvgFilterInfo::Flood(..) => 1,
+        SvgFilterInfo::LinearToSrgb => 2,
+        SvgFilterInfo::SrgbToLinear => 3,
+        SvgFilterInfo::Opacity(..) => 4,
+        SvgFilterInfo::ColorMatrix(..) => 5,
+        SvgFilterInfo::DropShadow(..) => 6,
+        SvgFilterInfo::Offset(..) => 7,
+        SvgFilterInfo::ComponentTransfer(..) => 8,
+        SvgFilterInfo::Identity => 9,
+        SvgFilterInfo::Composite(..) => 10,
+    };
+
+    let input_count = match filter {
+        SvgFilterInfo::Flood(..) => 0,
+
+        SvgFilterInfo::LinearToSrgb |
+        SvgFilterInfo::SrgbToLinear |
+        SvgFilterInfo::Opacity(..) |
+        SvgFilterInfo::ColorMatrix(..) |
+        SvgFilterInfo::Offset(..) |
+        SvgFilterInfo::ComponentTransfer(..) |
+        SvgFilterInfo::Identity => 1,
+
+        // Not techincally a 2 input filter, but we have 2 inputs here: original content & blurred content.
+        SvgFilterInfo::DropShadow(..) |
+        SvgFilterInfo::Blend(..) |
+        SvgFilterInfo::Composite(..) => 2,
+    };
+
+    let generic_int = match filter {
+        SvgFilterInfo::Blend(mode) => *mode as u16,
+        SvgFilterInfo::ComponentTransfer(data) =>
+            (data.r_func.to_int() << 12 |
+             data.g_func.to_int() << 8 |
+             data.b_func.to_int() << 4 |
+             data.a_func.to_int()) as u16,
+        SvgFilterInfo::Composite(operator) =>
+            operator.as_int() as u16,
+        SvgFilterInfo::LinearToSrgb |
+        SvgFilterInfo::SrgbToLinear |
+        SvgFilterInfo::Flood(..) |
+        SvgFilterInfo::Opacity(..) |
+        SvgFilterInfo::ColorMatrix(..) |
+        SvgFilterInfo::DropShadow(..) |
+        SvgFilterInfo::Offset(..) |
+        SvgFilterInfo::Identity => 0,
+    };
+
+    let instance = SvgFilterInstance {
+        task_address: task_id.into(),
+        input_1_task_address: input_1_task.map(|id| id.into()).unwrap_or(RenderTaskAddress(0)),
+        input_2_task_address: input_2_task.map(|id| id.into()).unwrap_or(RenderTaskAddress(0)),
+        kind,
+        input_count,
+        generic_int,
+        extra_data_address: extra_data_address.unwrap_or(GpuCacheAddress::INVALID),
+    };
+
+    for (ref mut batch_textures, ref mut batch) in instances.iter_mut() {
+        if let Some(combined_textures) = batch_textures.combine_textures(textures) {
+            batch.push(instance);
+            // Update the batch textures to the newly combined batch textures
+            *batch_textures = combined_textures;
+            return;
+        }
+    }
+
+    instances.push((textures, vec![instance]));
+}
+
+// Information required to do a blit from a source to a target.
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct BlitJob {
+    pub source: RenderTaskId,
+    pub target_rect: DeviceIntRect,
+}
+
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+#[derive(Clone, Debug)]
+pub struct LineDecorationJob {
+    pub task_rect: DeviceRect,
+    pub local_size: LayoutSize,
+    pub wavy_line_thickness: f32,
+    pub style: i32,
+    pub axis_select: f32,
+}