Allow picture caching to work across scenes (display lists).

This patch hooks up the primitive interning work with the tile
caching work.

Since we have a uid that guarantees uniqueness of the content of
primitives and clip nodes, we can use that to construct a
(reasonably) efficient hash key for the content of a tile.

Along with some additional information (such as the state of the
transforms used by the tile), we can construct a hash key for
the content of a tile that is stable across new display lists,
even if the shape of the clip-scroll tree changes in ways that
don't affect the tile.

This patch takes advantage of that to retain tiles when a new
scene is built, where the content of a tile would result in
the same output.

Author: gw3583

webrender/src/batch.rs

@@ -1001,7 +1001,7 @@ impl AlphaBatchBuilder {
                                         let tile = &tile_cache.tiles[i as usize];
 
                                         // Check if the tile is visible.
-                                        if !tile.is_visible {
+                                        if !tile.is_visible || !tile.in_use {
                                             continue;
                                         }
 

webrender/src/frame_builder.rs

@@ -12,7 +12,7 @@ use gpu_cache::GpuCache;
 use gpu_types::{PrimitiveHeaders, TransformPalette, UvRectKind, ZBufferIdGenerator};
 use hit_test::{HitTester, HitTestingRun};
 use internal_types::{FastHashMap, PlaneSplitter};
-use picture::{PictureSurface, PictureUpdateState, SurfaceInfo, ROOT_SURFACE_INDEX, SurfaceIndex};
+use picture::{PictureSurface, PictureUpdateState, SurfaceInfo, ROOT_SURFACE_INDEX, SurfaceIndex, TileDescriptor};
 use prim_store::{PrimitiveStore, SpaceMapper, PictureIndex, PrimitiveDebugId, PrimitiveScratchBuffer};
 #[cfg(feature = "replay")]
 use prim_store::{PrimitiveStoreStats};
@@ -23,8 +23,9 @@ use resource_cache::{ResourceCache};
 use scene::{ScenePipeline, SceneProperties};
 use segment::SegmentBuilder;
 use spatial_node::SpatialNode;
-use std::f32;
+use std::{f32, mem};
 use std::sync::Arc;
+use texture_cache::TextureCacheHandle;
 use tiling::{Frame, RenderPass, RenderPassKind, RenderTargetContext};
 use tiling::{SpecialRenderPasses};
 
@@ -60,6 +61,9 @@ pub struct FrameBuilder {
     background_color: Option<ColorF>,
     window_size: DeviceIntSize,
     root_pic_index: PictureIndex,
+    /// Cache of surface tiles from the previous frame builder
+    /// that can optionally be consumed by this frame builder.
+    pending_retained_tiles: FastHashMap<TileDescriptor, TextureCacheHandle>,
     pub prim_store: PrimitiveStore,
     pub clip_store: ClipStore,
     pub hit_testing_runs: Vec<HitTestingRun>,
@@ -144,6 +148,7 @@ impl FrameBuilder {
             window_size: DeviceIntSize::zero(),
             background_color: None,
             root_pic_index: PictureIndex(0),
+            pending_retained_tiles: FastHashMap::default(),
             config: FrameBuilderConfig {
                 default_font_render_mode: FontRenderMode::Mono,
                 dual_source_blending_is_enabled: true,
@@ -153,6 +158,17 @@ impl FrameBuilder {
         }
     }
 
+    /// Provide any cached surface tiles from the previous frame builder
+    /// to a new frame builder. These will be consumed or dropped the
+    /// first time a new frame builder creates a frame.
+    pub fn set_retained_tiles(
+        &mut self,
+        retained_tiles: FastHashMap<TileDescriptor, TextureCacheHandle>,
+    ) {
+        debug_assert!(self.pending_retained_tiles.is_empty());
+        self.pending_retained_tiles = retained_tiles;
+    }
+
     pub fn with_display_list_flattener(
         screen_rect: DeviceIntRect,
         background_color: Option<ColorF>,
@@ -167,10 +183,24 @@ impl FrameBuilder {
             screen_rect,
             background_color,
             window_size,
+            pending_retained_tiles: FastHashMap::default(),
             config: flattener.config,
         }
     }
 
+    /// Destroy an existing frame builder. This is called just before
+    /// a frame builder is replaced with a newly built scene.
+    pub fn destroy(
+        self,
+        retained_tiles: &mut FastHashMap<TileDescriptor, TextureCacheHandle>,
+        resource_cache: &ResourceCache,
+    ) {
+        self.prim_store.destroy(
+            retained_tiles,
+            resource_cache,
+        );
+    }
+
     /// Compute the contribution (bounding rectangles, and resources) of layers and their
     /// primitives in screen space.
     fn build_layer_screen_rects_and_cull_layers(
@@ -227,6 +257,10 @@ impl FrameBuilder {
         surfaces.push(root_surface);
 
         let mut pic_update_state = PictureUpdateState::new(surfaces);
+        let mut retained_tiles = mem::replace(
+            &mut self.pending_retained_tiles,
+            FastHashMap::default(),
+        );
 
         // The first major pass of building a frame is to walk the picture
         // tree. This pass must be quick (it should never touch individual
@@ -240,8 +274,10 @@ impl FrameBuilder {
             &mut pic_update_state,
             &frame_context,
             resource_cache,
+            gpu_cache,
             &resources.prim_data_store,
             &self.clip_store,
+            &mut retained_tiles,
         );
 
         let mut frame_state = FrameBuildingState {