Bug 1579235 - Part 8 - Remove overlay tiles, they can be alpha tiles …

…instead. r=nical

A previous patch in this series introduced overlay tiles. However,
now that native surfaces exist for for the opaque and alpha tiles
within a slice, we can remove the overlay tiles array and add
these special tiles to the alpha surface.

Differential Revision: https://phabricator.services.mozilla.com/D64899

[ghsync] From https://hg.mozilla.org/mozilla-central/rev/38b7f4761f5041a0e3b2326c2be37f98da509e21

webrender/src/composite.rs

@@ -71,17 +71,6 @@ pub enum CompositeSurfaceFormat {
     Yuv,
 }
 
-/// The ordering that this tile should be composited with.
-#[cfg_attr(feature = "capture", derive(Serialize))]
-#[cfg_attr(feature = "replay", derive(Deserialize))]
-#[derive(Debug, Copy, Clone)]
-pub enum TileCompositeMode {
-    /// Normal z-ordering for this tile
-    Default,
-    /// This tile overlaps a compositor surface - draw it after them
-    Over,
-}
-
 /// Describes the geometry and surface of a tile to be composited
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
@@ -93,7 +82,6 @@ pub struct CompositeTile {
     pub valid_rect: DeviceRect,
     pub z_id: ZBufferId,
     pub tile_id: Option<NativeTileId>,
-    pub mode: TileCompositeMode,
 }
 
 /// Describes information about drawing a primitive as a compositor surface.
@@ -423,24 +411,6 @@ impl CompositeState {
                 visible_alpha_tile_count += 1;
             }
 
-            // Determine ordering of this tile, based on presence of compositor
-            // surfaces that intersect the tile.
-            let mut mode = TileCompositeMode::Default;
-
-            if tile.has_compositor_surface {
-                // TODO(gw): This will almost always select over blend, due to the
-                //           background rectangle. In future, we can optimize this
-                //           case to only check items that come _after_ the compositor
-                //           surface z_id? A better option might be to tweak the z_id
-                //           values so that the alpha pixels get z-rejected?
-                for surface in &tile_cache.external_surfaces {
-                    if surface.device_rect.intersects(&tile.device_valid_rect) {
-                        mode = TileCompositeMode::Over;
-                        break;
-                    }
-                }
-            }
-
             let tile = CompositeTile {
                 surface,
                 rect: device_rect,
@@ -449,7 +419,6 @@ impl CompositeState {
                 clip_rect: device_clip_rect,
                 z_id,
                 tile_id,
-                mode,
             };
 
             self.push_tile(tile, is_opaque);
@@ -564,19 +533,12 @@ impl CompositeState {
                 self.clear_tiles.push(tile);
             }
             CompositeTileSurface::Texture { .. } => {
-                match tile.mode {
-                    TileCompositeMode::Default => {
-                        // Texture surfaces get bucketed by opaque/alpha, for z-rejection
-                        // on the Draw compositor mode.
-                        if is_opaque {
-                            self.opaque_tiles.push(tile);
-                        } else {
-                            self.alpha_tiles.push(tile);
-                        }
-                    }
-                    TileCompositeMode::Over => {
-                        self.alpha_tiles.push(tile);
-                    }
+                // Texture surfaces get bucketed by opaque/alpha, for z-rejection
+                // on the Draw compositor mode.
+                if is_opaque {
+                    self.opaque_tiles.push(tile);
+                } else {
+                    self.alpha_tiles.push(tile);
                 }
             }
         }

webrender/src/picture.rs

@@ -69,7 +69,7 @@
 //! content will all be squashed into a single slice, in order to save GPU memory
 //! and compositing performance.
 //!
-//! ## Overlay Tiles
+//! ## Compositor Surfaces
 //!
 //! Sometimes, a primitive would prefer to exist as a native compositor surface.
 //! This allows a large and/or regularly changing primitive (such as a video, or
@@ -79,12 +79,12 @@
 //! Since drawing a primitive as a compositor surface alters the ordering of
 //! primitives in a tile, we use 'overlay tiles' to ensure correctness. If a
 //! tile has a compositor surface, _and_ that tile has primitives that overlap
-//! the compositor surface rect, the tile switches to be drawn in overlay mode.
+//! the compositor surface rect, the tile switches to be drawn in alpha mode.
 //!
 //! We rely on only promoting compositor surfaces that are opaque primitives.
 //! With this assumption, the tile(s) that intersect the compositor surface get
 //! a 'cutout' in the rectangle where the compositor surface exists (not the
-//! entire tile), allowing that tile to be drawn as an overlay after the
+//! entire tile), allowing that tile to be drawn as an alpha tile after the
 //! compositor surface.
 //!
 //! Tiles are only drawn in overlay mode if there is content that exists on top
@@ -492,6 +492,9 @@ struct TilePostUpdateContext<'a> {
 
     /// The local rect of the overall picture cache
     local_rect: PictureRect,
+
+    /// A list of the external surfaces that are present on this slice
+    external_surfaces: &'a [ExternalSurfaceDescriptor],
 }
 
 // Mutable state passed to picture cache tiles during post_update
@@ -1210,7 +1213,21 @@ impl Tile {
         let clipped_rect = self.current_descriptor.local_valid_rect
             .intersection(&ctx.local_clip_rect)
             .unwrap_or_else(PictureRect::zero);
-        let is_opaque = ctx.backdrop.rect.contains_rect(&clipped_rect);
+        let mut is_opaque = ctx.backdrop.rect.contains_rect(&clipped_rect);
+
+        if self.has_compositor_surface {
+            // TODO(gw): This will almost always select over blend, due to the
+            //           background rectangle. In future, we can optimize this
+            //           case to only check items that come _after_ the compositor
+            //           surface z_id? A better option might be to tweak the z_id
+            //           values so that the alpha pixels get z-rejected?
+            for surface in ctx.external_surfaces {
+                if surface.device_rect.intersects(&self.device_valid_rect) {
+                    is_opaque = false;
+                    break;
+                }
+            }
+        }
 
         if is_opaque != self.is_opaque {
             // If opacity changed, the native compositor surface and all tiles get invalidated.
@@ -3217,6 +3234,7 @@ impl TileCacheInstance {
             color_bindings: &self.color_bindings,
             current_tile_size: self.current_tile_size,
             local_rect: self.local_rect,
+            external_surfaces: &self.external_surfaces,
         };
 
         let mut state = TilePostUpdateState {