Bug 1946487 - Fix transparent top level windows with layer compositor r=gfx-reviewers,lsalzman

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

Author: Glenn Watson

webrender/src/composite.rs

@@ -1139,6 +1139,20 @@ pub struct NativeSurfaceInfo {
     pub fbo_id: u32,
 }
 
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct WindowProperties {
+    pub is_opaque: bool,
+}
+
+impl Default for WindowProperties {
+    fn default() -> Self {
+        WindowProperties {
+            is_opaque: true,
+        }
+    }
+}
+
 #[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
@@ -1407,6 +1421,9 @@ pub trait LayerCompositor {
 
     // Finish compositing this frame - commit the visual tree to the OS
     fn end_frame(&mut self);
+
+    // Get current information about the window, such as opacity
+    fn get_window_properties(&self) -> WindowProperties;
 }
 
 /// Information about the underlying data buffer of a mapped tile.

webrender/src/lib.rs

@@ -169,7 +169,7 @@ extern crate webrender_build;
 pub use crate::composite::{LayerCompositor, CompositorInputConfig, CompositorSurfaceUsage};
 pub use crate::composite::{CompositorConfig, Compositor, CompositorCapabilities, CompositorSurfaceTransform};
 pub use crate::composite::{NativeSurfaceId, NativeTileId, NativeSurfaceInfo, PartialPresentCompositor};
-pub use crate::composite::{MappableCompositor, MappedTileInfo, SWGLCompositeSurfaceInfo, WindowVisibility};
+pub use crate::composite::{MappableCompositor, MappedTileInfo, SWGLCompositeSurfaceInfo, WindowVisibility, WindowProperties};
 pub use crate::device::{UploadMethod, VertexUsageHint, get_gl_target, get_unoptimized_shader_source};
 pub use crate::device::{ProgramBinary, ProgramCache, ProgramCacheObserver, FormatDesc};
 pub use crate::device::Device;

webrender/src/renderer/mod.rs

@@ -3454,6 +3454,14 @@ impl Renderer {
         let _gm = self.gpu_profiler.start_marker("framebuffer");
         let _timer = self.gpu_profiler.start_timer(GPU_TAG_COMPOSITE);
 
+        let window_is_opaque = match self.compositor_config.layer_compositor() {
+            Some(ref compositor) => {
+                let props = compositor.get_window_properties();
+                props.is_opaque
+            }
+            None => true,
+        };
+
         let mut input_layers: Vec<CompositorInputLayer> = Vec::new();
         let mut swapchain_layers = Vec::new();
         let cap = composite_state.tiles.len();
@@ -3501,7 +3509,7 @@ impl Renderer {
             match tile.kind {
                 TileKind::Opaque | TileKind::Alpha => {
                     // Store (index of tile, index of layer) so we can segment them below
-                    occlusion.add(&rect, is_opaque, idx); // (idx, input_layers.len() - 1));
+                    occlusion.add(&rect, is_opaque, idx);
                 }
                 TileKind::Clear => {
                     // Clear tiles are specific to how we render the window buttons on
@@ -3590,7 +3598,11 @@ impl Renderer {
             if let Some(new_layer_kind) = new_layer_kind {
                 let (offset, clip_rect, is_opaque) = match usage {
                     CompositorSurfaceUsage::Content => {
-                        (DeviceIntPoint::zero(), device_size.into(), input_layers.is_empty())
+                        (
+                            DeviceIntPoint::zero(),
+                            device_size.into(),
+                            input_layers.is_empty() && window_is_opaque,
+                        )
                     }
                     CompositorSurfaceUsage::External { .. } => {
                         let rect = composite_state.get_device_rect(

webrender_bindings/src/bindings.rs

@@ -42,7 +42,7 @@ use webrender::{
     MappableCompositor, MappedTileInfo, NativeSurfaceId, NativeSurfaceInfo, NativeTileId, PartialPresentCompositor,
     PipelineInfo, ProfilerHooks, RecordedFrameHandle, RenderBackendHooks, Renderer, RendererStats,
     SWGLCompositeSurfaceInfo, SceneBuilderHooks, ShaderPrecacheFlags, Shaders, SharedShaders, TextureCacheConfig,
-    UploadMethod, WebRenderOptions, WindowVisibility, ONE_TIME_USAGE_HINT, CompositorInputConfig, CompositorSurfaceUsage,
+    UploadMethod, WebRenderOptions, WindowVisibility, WindowProperties, ONE_TIME_USAGE_HINT, CompositorInputConfig, CompositorSurfaceUsage,
 };
 use wr_malloc_size_of::MallocSizeOfOps;
 
@@ -1325,6 +1325,7 @@ extern "C" {
     fn wr_compositor_deinit(compositor: *mut c_void);
     fn wr_compositor_get_capabilities(compositor: *mut c_void, caps: *mut CompositorCapabilities);
     fn wr_compositor_get_window_visibility(compositor: *mut c_void, caps: *mut WindowVisibility);
+    fn wr_compositor_get_window_properties(compositor: *mut c_void, props: *mut WindowProperties);
     fn wr_compositor_bind_swapchain(compositor: *mut c_void, id: NativeSurfaceId);
     fn wr_compositor_present_swapchain(compositor: *mut c_void, id: NativeSurfaceId);
     fn wr_compositor_map_tile(
@@ -1695,6 +1696,14 @@ impl LayerCompositor for WrLayerCompositor {
 
         self.surface_pool.append(&mut self.visual_tree);
     }
+
+    fn get_window_properties(&self) -> WindowProperties {
+        unsafe {
+            let mut props: WindowProperties = Default::default();
+            wr_compositor_get_window_properties(self.compositor, &mut props);
+            props
+        }
+    }
 }
 
 impl Drop for WrLayerCompositor {