Bug 1666055 - Disable buffer textures as external compositor surfaces on MacOS. r=lsalzman

When using the native RenderCompositor+SWGL on MacOS, we don't support passing buffer textures directly to the compositor.

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

gfx/layers/composite/GPUVideoTextureHost.cpp

@@ -245,16 +245,15 @@ void GPUVideoTextureHost::PushResourceUpdates(
 void GPUVideoTextureHost::PushDisplayItems(
     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
-    const Range<wr::ImageKey>& aImageKeys,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
-    const bool aPreferCompositorSurface) {
   MOZ_ASSERT(EnsureWrappedTextureHost(), "Image isn't valid yet");
   MOZ_ASSERT(aImageKeys.length() > 0);
   if (!EnsureWrappedTextureHost()) {
     return;
   }
 
-  EnsureWrappedTextureHost()->PushDisplayItems(
+  EnsureWrappedTextureHost()->PushDisplayItems(aBuilder, aBounds, aClip,
-      aBuilder, aBounds, aClip, aFilter, aImageKeys, aPreferCompositorSurface);
+                                               aFilter, aImageKeys, aFlags);
 }
 
 void GPUVideoTextureHost::UnbindTextureSource() {

gfx/layers/composite/GPUVideoTextureHost.h

@@ -68,7 +68,7 @@ class GPUVideoTextureHost : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
   void UnbindTextureSource() override;
   void NotifyNotUsed() override;

gfx/layers/composite/TextureHost.cpp

@@ -741,15 +741,18 @@ void BufferTextureHost::PushDisplayItems(wr::DisplayListBuilder& aBuilder,
                                          const wr::LayoutRect& aClip,
                                          wr::ImageRendering aFilter,
                                          const Range<wr::ImageKey>& aImageKeys,
-                                         const bool aPreferCompositorSurface) {
+                                         PushDisplayItemFlagSet aFlags) {
   // SWGL should always try to bypass shaders and composite directly.
-  bool useExternalSurface = gfx::gfxVars::UseSoftwareWebRender();
+  bool preferCompositorSurface =
+      aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE);
+  bool useExternalSurface =
+      aFlags.contains(PushDisplayItemFlag::SUPPORTS_EXTERNAL_BUFFER_TEXTURES);
   if (GetFormat() != gfx::SurfaceFormat::YUV) {
     MOZ_ASSERT(aImageKeys.length() == 1);
     aBuilder.PushImage(aBounds, aClip, true, aFilter, aImageKeys[0],
                        !(mFlags & TextureFlags::NON_PREMULTIPLIED),
                        wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f},
-                       aPreferCompositorSurface, useExternalSurface);
+                       preferCompositorSurface, useExternalSurface);
   } else {
     MOZ_ASSERT(aImageKeys.length() == 3);
     const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
@@ -757,8 +760,8 @@ void BufferTextureHost::PushDisplayItems(wr::DisplayListBuilder& aBuilder,
         aBounds, aClip, true, aImageKeys[0], aImageKeys[1], aImageKeys[2],
         wr::ToWrColorDepth(desc.colorDepth()),
         wr::ToWrYuvColorSpace(desc.yUVColorSpace()),
-        wr::ToWrColorRange(desc.colorRange()), aFilter,
+        wr::ToWrColorRange(desc.colorRange()), aFilter, preferCompositorSurface,
-        aPreferCompositorSurface, useExternalSurface);
+        useExternalSurface);
   }
 }
 

gfx/layers/composite/TextureHost.h

@@ -690,6 +690,17 @@ class TextureHost : public AtomicRefCountedWithFinalize<TextureHost> {
     MOZ_ASSERT_UNREACHABLE("Unimplemented");
   }
 
+  enum class PushDisplayItemFlag {
+    // Passed if the caller wants these display items to be promoted
+    // to compositor surfaces if possible.
+    PREFER_COMPOSITOR_SURFACE,
+
+    // Passed in the RenderCompositor supports BufferTextureHosts
+    // being used directly as external compositor surfaces.
+    SUPPORTS_EXTERNAL_BUFFER_TEXTURES,
+  };
+  using PushDisplayItemFlagSet = EnumSet<PushDisplayItemFlag>;
+
   // Put all necessary WR commands into DisplayListBuilder for this textureHost
   // rendering.
   virtual void PushDisplayItems(wr::DisplayListBuilder& aBuilder,
@@ -697,7 +708,7 @@ class TextureHost : public AtomicRefCountedWithFinalize<TextureHost> {
                                 const wr::LayoutRect& aClip,
                                 wr::ImageRendering aFilter,
                                 const Range<wr::ImageKey>& aKeys,
-                                const bool aPreferCompositorSurface) {
+                                PushDisplayItemFlagSet aFlags) {
     MOZ_ASSERT_UNREACHABLE(
         "No PushDisplayItems() implementation for this TextureHost type.");
   }
@@ -845,7 +856,7 @@ class BufferTextureHost : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
   void ReadUnlock() override;
   bool IsDirectMap() override {

gfx/layers/d3d11/TextureD3D11.cpp

@@ -1051,8 +1051,9 @@ void DXGITextureHostD3D11::PushResourceUpdates(
 void DXGITextureHostD3D11::PushDisplayItems(
     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
-    const Range<wr::ImageKey>& aImageKeys,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
-    const bool aPreferCompositorSurface) {
+  bool preferCompositorSurface =
+      aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE);
   if (!gfx::gfxVars::UseWebRenderANGLE()) {
     MOZ_ASSERT_UNREACHABLE("unexpected to be called without ANGLE");
     return;
@@ -1073,7 +1074,7 @@ void DXGITextureHostD3D11::PushDisplayItems(
       aBuilder.PushImage(aBounds, aClip, true, aFilter, aImageKeys[0],
                          !(mFlags & TextureFlags::NON_PREMULTIPLIED),
                          wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f},
-                         aPreferCompositorSurface);
+                         preferCompositorSurface);
       break;
     }
     case gfx::SurfaceFormat::P010:
@@ -1091,7 +1092,7 @@ void DXGITextureHostD3D11::PushDisplayItems(
           GetFormat() == gfx::SurfaceFormat::NV12 ? wr::ColorDepth::Color8
                                                   : wr::ColorDepth::Color16,
           wr::ToWrYuvColorSpace(mYUVColorSpace),
-          wr::ToWrColorRange(mColorRange), aFilter, aPreferCompositorSurface,
+          wr::ToWrColorRange(mColorRange), aFilter, preferCompositorSurface,
           supportsExternalCompositing);
       break;
     }
@@ -1305,8 +1306,7 @@ void DXGIYCbCrTextureHostD3D11::PushResourceUpdates(
 void DXGIYCbCrTextureHostD3D11::PushDisplayItems(
     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
-    const Range<wr::ImageKey>& aImageKeys,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
-    const bool aPreferCompositorSurface) {
   if (!gfx::gfxVars::UseWebRenderANGLE()) {
     MOZ_ASSERT_UNREACHABLE("unexpected to be called without ANGLE");
     return;
@@ -1323,7 +1323,8 @@ void DXGIYCbCrTextureHostD3D11::PushDisplayItems(
   aBuilder.PushYCbCrPlanarImage(
       aBounds, aClip, true, aImageKeys[0], aImageKeys[1], aImageKeys[2],
       wr::ToWrColorDepth(mColorDepth), wr::ToWrYuvColorSpace(mYUVColorSpace),
-      wr::ToWrColorRange(mColorRange), aFilter, aPreferCompositorSurface);
+      wr::ToWrColorRange(mColorRange), aFilter,
+      aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE));
 }
 
 bool DXGIYCbCrTextureHostD3D11::AcquireTextureSource(

gfx/layers/d3d11/TextureD3D11.h

@@ -360,7 +360,7 @@ class DXGITextureHostD3D11 : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
  protected:
   bool LockInternal();
@@ -429,7 +429,7 @@ class DXGIYCbCrTextureHostD3D11 : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
  private:
   bool EnsureTextureSource();

gfx/layers/ipc/ImageBridgeParent.cpp

@@ -765,7 +765,7 @@ RefPtr<TextureHost> GetNullPluginTextureHost() {
                           const wr::LayoutRect& aClip,
                           wr::ImageRendering aFilter,
                           const Range<wr::ImageKey>& aImageKeys,
-                          const bool aPreferCompositorSurface) override {}
+                          PushDisplayItemFlagSet aFlags) override {}
   };
 
   static StaticRefPtr<TextureHost> sNullPluginTextureHost;

gfx/layers/opengl/DMABUFTextureHostOGL.cpp

@@ -185,8 +185,9 @@ void DMABUFTextureHostOGL::PushResourceUpdates(
 void DMABUFTextureHostOGL::PushDisplayItems(
     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
-    const Range<wr::ImageKey>& aImageKeys,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
-    const bool aPreferCompositorSurface) {
+  bool preferCompositorSurface =
+      aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE);
   switch (mSurface->GetFormat()) {
     case gfx::SurfaceFormat::R8G8B8X8:
     case gfx::SurfaceFormat::R8G8B8A8:
@@ -196,7 +197,7 @@ void DMABUFTextureHostOGL::PushDisplayItems(
       aBuilder.PushImage(aBounds, aClip, true, aFilter, aImageKeys[0],
                          !(mFlags & TextureFlags::NON_PREMULTIPLIED),
                          wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f},
-                         aPreferCompositorSurface);
+                         preferCompositorSurface);
       break;
     }
     case gfx::SurfaceFormat::NV12: {
@@ -208,7 +209,7 @@ void DMABUFTextureHostOGL::PushDisplayItems(
                              wr::ColorDepth::Color8,
                              wr::ToWrYuvColorSpace(GetYUVColorSpace()),
                              wr::ToWrColorRange(GetColorRange()), aFilter,
-                             aPreferCompositorSurface);
+                             preferCompositorSurface);
       break;
     }
     case gfx::SurfaceFormat::YUV: {
@@ -220,7 +221,7 @@ void DMABUFTextureHostOGL::PushDisplayItems(
           aBounds, aClip, true, aImageKeys[0], aImageKeys[1], aImageKeys[2],
           wr::ColorDepth::Color8, wr::ToWrYuvColorSpace(GetYUVColorSpace()),
           wr::ToWrColorRange(GetColorRange()), aFilter,
-          aPreferCompositorSurface);
+          preferCompositorSurface);
       break;
     }
     default: {

gfx/layers/opengl/DMABUFTextureHostOGL.h

@@ -65,7 +65,7 @@ class DMABUFTextureHostOGL : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
  private:
   GLTextureSource* CreateTextureSourceForPlane(size_t aPlane);

gfx/layers/opengl/MacIOSurfaceTextureHostOGL.cpp

@@ -224,8 +224,9 @@ void MacIOSurfaceTextureHostOGL::PushResourceUpdates(
 void MacIOSurfaceTextureHostOGL::PushDisplayItems(
     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
-    const Range<wr::ImageKey>& aImageKeys,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
-    const bool aPreferCompositorSurface) {
+  bool preferCompositorSurface =
+      aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE);
   switch (GetFormat()) {
     case gfx::SurfaceFormat::R8G8B8X8:
     case gfx::SurfaceFormat::R8G8B8A8:
@@ -236,7 +237,7 @@ void MacIOSurfaceTextureHostOGL::PushDisplayItems(
       aBuilder.PushImage(aBounds, aClip, true, aFilter, aImageKeys[0],
                          !(mFlags & TextureFlags::NON_PREMULTIPLIED),
                          wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f},
-                         aPreferCompositorSurface,
+                         preferCompositorSurface,
                          /* aSupportsExternalCompositing */ true);
       break;
     }
@@ -248,8 +249,8 @@ void MacIOSurfaceTextureHostOGL::PushDisplayItems(
       aBuilder.PushYCbCrInterleavedImage(
           aBounds, aClip, true, aImageKeys[0], wr::ColorDepth::Color8,
           wr::ToWrYuvColorSpace(GetYUVColorSpace()),
-          wr::ToWrColorRange(GetColorRange()), aFilter,
+          wr::ToWrColorRange(GetColorRange()), aFilter, preferCompositorSurface,
-          aPreferCompositorSurface, /* aSupportsExternalCompositing */ true);
+          /* aSupportsExternalCompositing */ true);
       break;
     }
     case gfx::SurfaceFormat::NV12: {
@@ -260,8 +261,8 @@ void MacIOSurfaceTextureHostOGL::PushDisplayItems(
       aBuilder.PushNV12Image(
           aBounds, aClip, true, aImageKeys[0], aImageKeys[1],
           wr::ColorDepth::Color8, wr::ToWrYuvColorSpace(GetYUVColorSpace()),
-          wr::ToWrColorRange(GetColorRange()), aFilter,
+          wr::ToWrColorRange(GetColorRange()), aFilter, preferCompositorSurface,
-          aPreferCompositorSurface, /* aSupportsExternalCompositing */ true);
+          /* aSupportsExternalCompositing */ true);
       break;
     }
     default: {

gfx/layers/opengl/MacIOSurfaceTextureHostOGL.h

@@ -77,7 +77,7 @@ class MacIOSurfaceTextureHostOGL : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
   gfx::YUVColorSpace GetYUVColorSpace() const override;
   gfx::ColorRange GetColorRange() const override;

gfx/layers/opengl/TextureHostOGL.cpp

@@ -699,17 +699,18 @@ void SurfaceTextureHost::PushDisplayItems(wr::DisplayListBuilder& aBuilder,
                                           const wr::LayoutRect& aClip,
                                           wr::ImageRendering aFilter,
                                           const Range<wr::ImageKey>& aImageKeys,
-                                          const bool aPreferCompositorSurface) {
+                                          PushDisplayItemFlagSet aFlags) {
   switch (GetFormat()) {
     case gfx::SurfaceFormat::R8G8B8X8:
     case gfx::SurfaceFormat::R8G8B8A8:
     case gfx::SurfaceFormat::B8G8R8A8:
     case gfx::SurfaceFormat::B8G8R8X8: {
       MOZ_ASSERT(aImageKeys.length() == 1);
-      aBuilder.PushImage(aBounds, aClip, true, aFilter, aImageKeys[0],
+      aBuilder.PushImage(
+          aBounds, aClip, true, aFilter, aImageKeys[0],
           !(mFlags & TextureFlags::NON_PREMULTIPLIED),
           wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f},
-                         aPreferCompositorSurface);
+          aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE));
       break;
     }
     default: {
@@ -994,18 +995,18 @@ void AndroidHardwareBufferTextureHost::PushResourceUpdates(
 void AndroidHardwareBufferTextureHost::PushDisplayItems(
     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
-    const Range<wr::ImageKey>& aImageKeys,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
-    const bool aPreferCompositorSurface) {
   switch (GetFormat()) {
     case gfx::SurfaceFormat::R8G8B8X8:
     case gfx::SurfaceFormat::R8G8B8A8:
     case gfx::SurfaceFormat::B8G8R8A8:
     case gfx::SurfaceFormat::B8G8R8X8: {
       MOZ_ASSERT(aImageKeys.length() == 1);
-      aBuilder.PushImage(aBounds, aClip, true, aFilter, aImageKeys[0],
+      aBuilder.PushImage(
+          aBounds, aClip, true, aFilter, aImageKeys[0],
           !(mFlags & TextureFlags::NON_PREMULTIPLIED),
           wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f},
-                         aPreferCompositorSurface);
+          aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE));
       break;
     }
     default: {
@@ -1199,13 +1200,13 @@ void EGLImageTextureHost::PushResourceUpdates(
 void EGLImageTextureHost::PushDisplayItems(
     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
-    const Range<wr::ImageKey>& aImageKeys,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
-    const bool aPreferCompositorSurface) {
   MOZ_ASSERT(aImageKeys.length() == 1);
-  aBuilder.PushImage(aBounds, aClip, true, aFilter, aImageKeys[0],
+  aBuilder.PushImage(
+      aBounds, aClip, true, aFilter, aImageKeys[0],
       !(mFlags & TextureFlags::NON_PREMULTIPLIED),
       wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f},
-                     aPreferCompositorSurface);
+      aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE));
 }
 
 //

gfx/layers/opengl/TextureHostOGL.h

@@ -448,7 +448,7 @@ class SurfaceTextureHost : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
   // gecko does not need deferred deletion with WebRender
   // GPU/hardware task end could be checked by android fence.
@@ -521,7 +521,7 @@ class AndroidHardwareBufferTextureHost : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
   void SetAcquireFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
 
@@ -637,7 +637,7 @@ class EGLImageTextureHost final : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
  protected:
   const EGLImage mImage;

gfx/layers/wr/AsyncImagePipelineManager.cpp

@@ -434,14 +434,19 @@ void AsyncImagePipelineManager::ApplyAsyncImageForPipeline(
     if (aPipeline->mUseExternalImage) {
       MOZ_ASSERT(aPipeline->mCurrentTexture->AsWebRenderTextureHost());
       Range<wr::ImageKey> range_keys(&keys[0], keys.Length());
-      bool prefer_compositor_surface =
+      TextureHost::PushDisplayItemFlagSet flags;
-          IsOpaque(aPipeline->mCurrentTexture->GetFormat()) ||
+      if (IsOpaque(aPipeline->mCurrentTexture->GetFormat()) ||
           bool(aPipeline->mCurrentTexture->GetFlags() &
-               TextureFlags::IS_OPAQUE);
+               TextureFlags::IS_OPAQUE)) {
+        flags += TextureHost::PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE;
+      }
+      if (mApi->SupportsExternalBufferTextures()) {
+        flags +=
+            TextureHost::PushDisplayItemFlag::SUPPORTS_EXTERNAL_BUFFER_TEXTURES;
+      }
       aPipeline->mCurrentTexture->PushDisplayItems(
           builder, wr::ToLayoutRect(rect), wr::ToLayoutRect(rect),
-          aPipeline->mFilter, range_keys,
+          aPipeline->mFilter, range_keys, flags);
-          /* aPreferCompositorSurface */ prefer_compositor_surface);
       HoldExternalImage(aPipelineId, aEpoch, aPipeline->mCurrentTexture);
     } else {
       MOZ_ASSERT(keys.Length() == 1);

gfx/layers/wr/WebRenderTextureHost.cpp

@@ -207,12 +207,11 @@ void WebRenderTextureHost::PushResourceUpdates(
 void WebRenderTextureHost::PushDisplayItems(
     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
-    const Range<wr::ImageKey>& aImageKeys,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
-    const bool aPreferCompositorSurface) {
   MOZ_ASSERT(aImageKeys.length() > 0);
 
   mWrappedTextureHost->PushDisplayItems(aBuilder, aBounds, aClip, aFilter,
-                                        aImageKeys, aPreferCompositorSurface);
+                                        aImageKeys, aFlags);
 }
 
 bool WebRenderTextureHost::NeedsYFlip() const {

gfx/layers/wr/WebRenderTextureHost.h

@@ -85,7 +85,7 @@ class WebRenderTextureHost : public TextureHost {
                         const wr::LayoutRect& aBounds,
                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
                         const Range<wr::ImageKey>& aImageKeys,
-                        const bool aPreferCompositorSurface) override;
+                        PushDisplayItemFlagSet aFlags) override;
 
   bool NeedsYFlip() const override;
 

gfx/webrender_bindings/RenderCompositor.h

@@ -78,6 +78,10 @@ class RenderCompositor {
 
   virtual bool UseTripleBuffering() const { return false; }
 
+  // True if AttachExternalImage supports being used with an external
+  // image that maps to a RenderBufferTextureHost
+  virtual bool SupportsExternalBufferTextures() const { return false; }
+
   virtual LayoutDeviceIntSize GetBufferSize() = 0;
 
   widget::CompositorWidget* GetWidget() const { return mWidget; }

gfx/webrender_bindings/RenderCompositorSWGL.h

@@ -35,6 +35,8 @@ class RenderCompositorSWGL : public RenderCompositor {
 
   LayoutDeviceIntSize GetBufferSize() override;
 
+  bool SupportsExternalBufferTextures() const override { return true; }
+
   // Interface for wr::Compositor
   CompositorCapabilities GetCompositorCapabilities() override;
 

gfx/webrender_bindings/RenderThread.cpp

@@ -35,7 +35,7 @@
 
 #ifdef MOZ_WIDGET_ANDROID
 #  include "GLLibraryEGL.h"
-#  include "mozilla/webrender/RenderAndroidSurfaceTextureHostOGL.h"
+#  include "mozilla/webrender/RenderAndroidSurfaceTextureHost.h"
 #endif
 
 #ifdef MOZ_WIDGET_GTK

gfx/webrender_bindings/WebRenderAPI.cpp

@@ -59,6 +59,7 @@ class NewRenderer : public RendererEvent {
   NewRenderer(wr::DocumentHandle** aDocHandle,
               layers::CompositorBridgeParent* aBridge, int32_t* aMaxTextureSize,
               bool* aUseANGLE, bool* aUseDComp, bool* aUseTripleBuffering,
+              bool* aSupportsExternalBufferTextures,
               RefPtr<widget::CompositorWidget>&& aWidget,
               layers::SynchronousTask* aTask, LayoutDeviceIntSize aSize,
               layers::SyncHandle* aHandle, nsACString* aError)
@@ -67,6 +68,7 @@ class NewRenderer : public RendererEvent {
         mUseANGLE(aUseANGLE),
         mUseDComp(aUseDComp),
         mUseTripleBuffering(aUseTripleBuffering),
+        mSupportsExternalBufferTextures(aSupportsExternalBufferTextures),
         mBridge(aBridge),
         mCompositorWidget(std::move(aWidget)),
         mTask(aTask),
@@ -93,6 +95,8 @@ class NewRenderer : public RendererEvent {
     *mUseANGLE = compositor->UseANGLE();
     *mUseDComp = compositor->UseDComp();
     *mUseTripleBuffering = compositor->UseTripleBuffering();
+    *mSupportsExternalBufferTextures =
+        compositor->SupportsExternalBufferTextures();
 
     // Only allow the panic on GL error functionality in nightly builds,
     // since it (deliberately) crashes the GPU process if any GL call
@@ -179,6 +183,7 @@ class NewRenderer : public RendererEvent {
   bool* mUseANGLE;
   bool* mUseDComp;
   bool* mUseTripleBuffering;
+  bool* mSupportsExternalBufferTextures;
   layers::CompositorBridgeParent* mBridge;
   RefPtr<widget::CompositorWidget> mCompositorWidget;
   layers::SynchronousTask* mTask;
@@ -345,15 +350,16 @@ already_AddRefed<WebRenderAPI> WebRenderAPI::Create(
   bool useANGLE = false;
   bool useDComp = false;
   bool useTripleBuffering = false;
+  bool supportsExternalBufferTextures = false;
   layers::SyncHandle syncHandle = 0;
 
   // Dispatch a synchronous task because the DocumentHandle object needs to be
   // created on the render thread. If need be we could delay waiting on this
   // task until the next time we need to access the DocumentHandle object.
   layers::SynchronousTask task("Create Renderer");
-  auto event = MakeUnique<NewRenderer>(&docHandle, aBridge, &maxTextureSize,
+  auto event = MakeUnique<NewRenderer>(
-                                       &useANGLE, &useDComp,
+      &docHandle, aBridge, &maxTextureSize, &useANGLE, &useDComp,
-                                       &useTripleBuffering, std::move(aWidget),
+      &useTripleBuffering, &supportsExternalBufferTextures, std::move(aWidget),
       &task, aSize, &syncHandle, &aError);
   RenderThread::Get()->RunEvent(aWindowId, std::move(event));
 
@@ -365,7 +371,8 @@ already_AddRefed<WebRenderAPI> WebRenderAPI::Create(
 
   return RefPtr<WebRenderAPI>(
              new WebRenderAPI(docHandle, aWindowId, maxTextureSize, useANGLE,
-                              useDComp, useTripleBuffering, syncHandle))
+                              useDComp, useTripleBuffering,
+                              supportsExternalBufferTextures, syncHandle))
       .forget();
 }
 
@@ -373,9 +380,9 @@ already_AddRefed<WebRenderAPI> WebRenderAPI::Clone() {
   wr::DocumentHandle* docHandle = nullptr;
   wr_api_clone(mDocHandle, &docHandle);
 
-  RefPtr<WebRenderAPI> renderApi =
+  RefPtr<WebRenderAPI> renderApi = new WebRenderAPI(
-      new WebRenderAPI(docHandle, mId, mMaxTextureSize, mUseANGLE, mUseDComp,
+      docHandle, mId, mMaxTextureSize, mUseANGLE, mUseDComp,
-                       mUseTripleBuffering, mSyncHandle);
+      mUseTripleBuffering, mSupportsExternalBufferTextures, mSyncHandle);
   renderApi->mRootApi = this;  // Hold root api
   renderApi->mRootDocumentApi = this;
 
@@ -389,6 +396,7 @@ wr::WrIdNamespace WebRenderAPI::GetNamespace() {
 WebRenderAPI::WebRenderAPI(wr::DocumentHandle* aHandle, wr::WindowId aId,
                            uint32_t aMaxTextureSize, bool aUseANGLE,
                            bool aUseDComp, bool aUseTripleBuffering,
+                           bool aSupportsExternalBufferTextures,
                            layers::SyncHandle aSyncHandle)
     : mDocHandle(aHandle),
       mId(aId),
@@ -396,6 +404,7 @@ WebRenderAPI::WebRenderAPI(wr::DocumentHandle* aHandle, wr::WindowId aId,
       mUseANGLE(aUseANGLE),
       mUseDComp(aUseDComp),
       mUseTripleBuffering(aUseTripleBuffering),
+      mSupportsExternalBufferTextures(aSupportsExternalBufferTextures),
       mCaptureSequence(false),
       mSyncHandle(aSyncHandle) {}
 

gfx/webrender_bindings/WebRenderAPI.h

@@ -273,6 +273,9 @@ class WebRenderAPI final {
   bool GetUseANGLE() const { return mUseANGLE; }
   bool GetUseDComp() const { return mUseDComp; }
   bool GetUseTripleBuffering() const { return mUseTripleBuffering; }
+  bool SupportsExternalBufferTextures() const {
+    return mSupportsExternalBufferTextures;
+  }
   layers::SyncHandle GetSyncHandle() const { return mSyncHandle; }
 
   void Capture();
@@ -305,7 +308,8 @@ class WebRenderAPI final {
  protected:
   WebRenderAPI(wr::DocumentHandle* aHandle, wr::WindowId aId,
                uint32_t aMaxTextureSize, bool aUseANGLE, bool aUseDComp,
-               bool aUseTripleBuffering, layers::SyncHandle aSyncHandle);
+               bool aUseTripleBuffering, bool aSupportsExternalBufferTextures,
+               layers::SyncHandle aSyncHandle);
 
   ~WebRenderAPI();
   // Should be used only for shutdown handling
@@ -319,6 +323,7 @@ class WebRenderAPI final {
   bool mUseANGLE;
   bool mUseDComp;
   bool mUseTripleBuffering;
+  bool mSupportsExternalBufferTextures;
   bool mCaptureSequence;
   layers::SyncHandle mSyncHandle;