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
2020-10-14 07:56:47 +00:00
parent 5e6d4a7772
commit d517b70ca2
21 changed files with 117 additions and 76 deletions
--- a/gfx/layers/composite/GPUVideoTextureHost.cpp
+++ b/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 bool aPreferCompositorSurface) {
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
  MOZ_ASSERT(EnsureWrappedTextureHost(), "Image isn't valid yet");
  MOZ_ASSERT(aImageKeys.length() > 0);
  if (!EnsureWrappedTextureHost()) {
    return;
  }

-  EnsureWrappedTextureHost()->PushDisplayItems(
-      aBuilder, aBounds, aClip, aFilter, aImageKeys, aPreferCompositorSurface);
+  EnsureWrappedTextureHost()->PushDisplayItems(aBuilder, aBounds, aClip,
+                                               aFilter, aImageKeys, aFlags);
 }

 void GPUVideoTextureHost::UnbindTextureSource() {
--- a/gfx/layers/composite/GPUVideoTextureHost.h
+++ b/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;
--- a/gfx/layers/composite/TextureHost.cpp
+++ b/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,
-        aPreferCompositorSurface, useExternalSurface);
+        wr::ToWrColorRange(desc.colorRange()), aFilter, preferCompositorSurface,
+        useExternalSurface);
  }
 }

--- a/gfx/layers/composite/TextureHost.h
+++ b/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 {
--- a/gfx/layers/d3d11/TextureD3D11.cpp
+++ b/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 bool aPreferCompositorSurface) {
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
+  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 bool aPreferCompositorSurface) {
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
  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(
--- a/gfx/layers/d3d11/TextureD3D11.h
+++ b/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();
--- a/gfx/layers/ipc/ImageBridgeParent.cpp
+++ b/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;
--- a/gfx/layers/opengl/DMABUFTextureHostOGL.cpp
+++ b/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 bool aPreferCompositorSurface) {
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
+  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: {
--- a/gfx/layers/opengl/DMABUFTextureHostOGL.h
+++ b/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);
--- a/gfx/layers/opengl/MacIOSurfaceTextureHostOGL.cpp
+++ b/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 bool aPreferCompositorSurface) {
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
+  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,
-          aPreferCompositorSurface, /* aSupportsExternalCompositing */ true);
+          wr::ToWrColorRange(GetColorRange()), aFilter, preferCompositorSurface,
+          /* 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,
-          aPreferCompositorSurface, /* aSupportsExternalCompositing */ true);
+          wr::ToWrColorRange(GetColorRange()), aFilter, preferCompositorSurface,
+          /* aSupportsExternalCompositing */ true);
      break;
    }
    default: {
--- a/gfx/layers/opengl/MacIOSurfaceTextureHostOGL.h
+++ b/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;
--- a/gfx/layers/opengl/TextureHostOGL.cpp
+++ b/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 bool aPreferCompositorSurface) {
+    const Range<wr::ImageKey>& aImageKeys, 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: {
@@ -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 bool aPreferCompositorSurface) {
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
  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));
 }

 //
--- a/gfx/layers/opengl/TextureHostOGL.h
+++ b/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;
--- a/gfx/layers/wr/AsyncImagePipelineManager.cpp
+++ b/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 =
-          IsOpaque(aPipeline->mCurrentTexture->GetFormat()) ||
+      TextureHost::PushDisplayItemFlagSet flags;
+      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,
-          /* aPreferCompositorSurface */ prefer_compositor_surface);
+          aPipeline->mFilter, range_keys, flags);
      HoldExternalImage(aPipelineId, aEpoch, aPipeline->mCurrentTexture);
    } else {
      MOZ_ASSERT(keys.Length() == 1);
--- a/gfx/layers/wr/WebRenderTextureHost.cpp
+++ b/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 bool aPreferCompositorSurface) {
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
  MOZ_ASSERT(aImageKeys.length() > 0);

  mWrappedTextureHost->PushDisplayItems(aBuilder, aBounds, aClip, aFilter,
-                                        aImageKeys, aPreferCompositorSurface);
+                                        aImageKeys, aFlags);
 }

 bool WebRenderTextureHost::NeedsYFlip() const {
--- a/gfx/layers/wr/WebRenderTextureHost.h
+++ b/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;

--- a/gfx/webrender_bindings/RenderCompositor.h
+++ b/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; }
--- a/gfx/webrender_bindings/RenderCompositorSWGL.h
+++ b/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;

--- a/gfx/webrender_bindings/RenderThread.cpp
+++ b/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
--- a/gfx/webrender_bindings/WebRenderAPI.cpp
+++ b/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,
-                                       &useANGLE, &useDComp,
-                                       &useTripleBuffering, std::move(aWidget),
+  auto event = MakeUnique<NewRenderer>(
+      &docHandle, aBridge, &maxTextureSize, &useANGLE, &useDComp,
+      &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 =
-      new WebRenderAPI(docHandle, mId, mMaxTextureSize, mUseANGLE, mUseDComp,
-                       mUseTripleBuffering, mSyncHandle);
+  RefPtr<WebRenderAPI> renderApi = new WebRenderAPI(
+      docHandle, mId, mMaxTextureSize, mUseANGLE, mUseDComp,
+      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) {}

--- a/gfx/webrender_bindings/WebRenderAPI.h
+++ b/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;