Bug 1688096 - Part 1. Merge SW-WR and WR render texture host paths to allow mixed compositors. r=mattwoodrow

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

gfx/layers/composite/GPUVideoTextureHost.cpp

@@ -269,11 +269,12 @@ void GPUVideoTextureHost::PushDisplayItems(
                                                aFilter, aImageKeys, aFlags);
 }
 
-bool GPUVideoTextureHost::SupportsExternalCompositing() {
+bool GPUVideoTextureHost::SupportsExternalCompositing(
+    WebRenderBackend aBackend) {
   if (!EnsureWrappedTextureHost()) {
     return false;
   }
-  return EnsureWrappedTextureHost()->SupportsExternalCompositing();
+  return EnsureWrappedTextureHost()->SupportsExternalCompositing(aBackend);
 }
 
 void GPUVideoTextureHost::UnbindTextureSource() {

gfx/layers/composite/GPUVideoTextureHost.h

@@ -71,7 +71,7 @@ class GPUVideoTextureHost : public TextureHost {
                         const Range<wr::ImageKey>& aImageKeys,
                         PushDisplayItemFlagSet aFlags) override;
 
-  bool SupportsExternalCompositing() override;
+  bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 
   void UnbindTextureSource() override;
   void NotifyNotUsed() override;

gfx/layers/composite/TextureHost.cpp

@@ -31,7 +31,6 @@
 #include "mozilla/StaticPrefs_layers.h"
 #include "mozilla/StaticPrefs_gfx.h"
 #include "mozilla/webrender/RenderBufferTextureHost.h"
-#include "mozilla/webrender/RenderBufferTextureHostSWGL.h"
 #include "mozilla/webrender/RenderExternalTextureHost.h"
 #include "mozilla/webrender/RenderThread.h"
 #include "mozilla/webrender/WebRenderAPI.h"
@@ -677,10 +676,7 @@ void BufferTextureHost::CreateRenderTexture(
     const wr::ExternalImageId& aExternalImageId) {
   RefPtr<wr::RenderTextureHost> texture;
 
-  if (gfx::gfxVars::UseSoftwareWebRender()) {
+  if (UseExternalTextures()) {
-    texture =
-        new wr::RenderBufferTextureHostSWGL(GetBuffer(), GetBufferDescriptor());
-  } else if (UseExternalTextures()) {
     texture =
         new wr::RenderExternalTextureHost(GetBuffer(), GetBufferDescriptor());
   } else {
@@ -707,7 +703,12 @@ void BufferTextureHost::PushResourceUpdates(
                     ? &wr::TransactionBuilder::AddExternalImage
                     : &wr::TransactionBuilder::UpdateExternalImage;
 
-  auto imageType = UseExternalTextures() || gfx::gfxVars::UseSoftwareWebRender()
+  // Even if we cannot use external textures, if the backend is Software
+  // WebRender, we need to ensure that we use external texture style updates.
+  // This is because we always represent mapped buffers as external "native"
+  // textures for that backend.
+  auto imageType = UseExternalTextures() || aResources.GetBackendType() ==
+                                                WebRenderBackend::SOFTWARE
                        ? wr::ExternalImageType::TextureHandle(
                              wr::ImageBufferKind::TextureRect)
                        : wr::ExternalImageType::Buffer();

gfx/layers/composite/TextureHost.h

@@ -740,7 +740,9 @@ class TextureHost : public AtomicRefCountedWithFinalize<TextureHost> {
     return nullptr;
   }
 
-  virtual bool SupportsExternalCompositing() { return false; }
+  virtual bool SupportsExternalCompositing(WebRenderBackend aBackend) {
+    return false;
+  }
 
  protected:
   virtual void ReadUnlock();

gfx/layers/d3d11/TextureD3D11.cpp

@@ -1012,7 +1012,7 @@ void DXGITextureHostD3D11::PushResourceUpdates(
       MOZ_ASSERT(aImageKeys.length() == 1);
 
       wr::ImageDescriptor descriptor(mSize, GetFormat());
-      auto imageType = gfx::gfxVars::UseSoftwareWebRender()
+      auto imageType = aResources.GetBackendType() == WebRenderBackend::SOFTWARE
                            ? wr::ExternalImageType::TextureHandle(
                                  wr::ImageBufferKind::TextureRect)
                            : wr::ExternalImageType::TextureHandle(
@@ -1034,7 +1034,7 @@ void DXGITextureHostD3D11::PushResourceUpdates(
                                       mFormat == gfx::SurfaceFormat::NV12
                                           ? gfx::SurfaceFormat::R8G8
                                           : gfx::SurfaceFormat::R16G16);
-      auto imageType = gfx::gfxVars::UseSoftwareWebRender()
+      auto imageType = aResources.GetBackendType() == WebRenderBackend::SOFTWARE
                            ? wr::ExternalImageType::TextureHandle(
                                  wr::ImageBufferKind::TextureRect)
                            : wr::ExternalImageType::TextureHandle(
@@ -1066,11 +1066,11 @@ void DXGITextureHostD3D11::PushDisplayItems(
     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},
+          wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f}, preferCompositorSurface,
-                         preferCompositorSurface,
+          SupportsExternalCompositing(aBuilder.GetBackendType()));
-                         SupportsExternalCompositing());
       break;
     }
     case gfx::SurfaceFormat::P010:
@@ -1083,7 +1083,7 @@ void DXGITextureHostD3D11::PushDisplayItems(
                                                   : wr::ColorDepth::Color16,
           wr::ToWrYuvColorSpace(mYUVColorSpace),
           wr::ToWrColorRange(mColorRange), aFilter, preferCompositorSurface,
-          SupportsExternalCompositing());
+          SupportsExternalCompositing(aBuilder.GetBackendType()));
       break;
     }
     default: {
@@ -1092,8 +1092,9 @@ void DXGITextureHostD3D11::PushDisplayItems(
   }
 }
 
-bool DXGITextureHostD3D11::SupportsExternalCompositing() {
+bool DXGITextureHostD3D11::SupportsExternalCompositing(
-  if (gfx::gfxVars::UseSoftwareWebRender()) {
+    WebRenderBackend aBackend) {
+  if (aBackend == WebRenderBackend::SOFTWARE) {
     return true;
   }
   // XXX Add P010 and P016 support.
@@ -1288,7 +1289,7 @@ void DXGIYCbCrTextureHostD3D11::PushResourceUpdates(
   auto method = aOp == TextureHost::ADD_IMAGE
                     ? &wr::TransactionBuilder::AddExternalImage
                     : &wr::TransactionBuilder::UpdateExternalImage;
-  auto imageType = gfx::gfxVars::UseSoftwareWebRender()
+  auto imageType = aResources.GetBackendType() == WebRenderBackend::SOFTWARE
                        ? wr::ExternalImageType::TextureHandle(
                              wr::ImageBufferKind::TextureRect)
                        : wr::ExternalImageType::TextureHandle(
@@ -1319,14 +1320,12 @@ void DXGIYCbCrTextureHostD3D11::PushDisplayItems(
       wr::ToWrColorDepth(mColorDepth), wr::ToWrYuvColorSpace(mYUVColorSpace),
       wr::ToWrColorRange(mColorRange), aFilter,
       aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE),
-      SupportsExternalCompositing());
+      SupportsExternalCompositing(aBuilder.GetBackendType()));
 }
 
-bool DXGIYCbCrTextureHostD3D11::SupportsExternalCompositing() {
+bool DXGIYCbCrTextureHostD3D11::SupportsExternalCompositing(
-  if (gfx::gfxVars::UseSoftwareWebRender()) {
+    WebRenderBackend aBackend) {
-    return true;
+  return aBackend == WebRenderBackend::SOFTWARE;
-  }
-  return false;
 }
 
 bool DXGIYCbCrTextureHostD3D11::AcquireTextureSource(

gfx/layers/d3d11/TextureD3D11.h

@@ -364,7 +364,7 @@ class DXGITextureHostD3D11 : public TextureHost {
                         const Range<wr::ImageKey>& aImageKeys,
                         PushDisplayItemFlagSet aFlags) override;
 
-  bool SupportsExternalCompositing() override;
+  bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 
  protected:
   bool LockInternal();
@@ -435,7 +435,7 @@ class DXGIYCbCrTextureHostD3D11 : public TextureHost {
                         const Range<wr::ImageKey>& aImageKeys,
                         PushDisplayItemFlagSet aFlags) override;
 
-  bool SupportsExternalCompositing() override;
+  bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 
  private:
   bool EnsureTextureSource();

gfx/layers/ipc/CompositorBridgeParent.cpp

@@ -1795,7 +1795,7 @@ PWebRenderBridgeParent* CompositorBridgeParent::AllocPWebRenderBridgeParent(
     return mWrBridge;
   }
 
-  wr::TransactionBuilder txn;
+  wr::TransactionBuilder txn(api);
   txn.SetRootPipeline(aPipelineId);
   api->SendTransaction(txn);
 

gfx/layers/ipc/KnowsCompositor.h

@@ -139,6 +139,13 @@ class KnowsCompositor {
     return lock.ref().mTextureFactoryIdentifier.mUseCompositorWnd;
   }
 
+  WebRenderBackend GetWebRenderBackend() const {
+    auto lock = mData.Lock();
+    MOZ_ASSERT(lock.ref().mTextureFactoryIdentifier.mParentBackend ==
+               layers::LayersBackend::LAYERS_WR);
+    return lock.ref().mTextureFactoryIdentifier.mWebRenderBackend;
+  }
+
   bool UsingSoftwareWebRender() const {
     auto lock = mData.Lock();
     return lock.ref().mTextureFactoryIdentifier.mParentBackend ==

gfx/layers/ipc/SharedSurfacesParent.cpp

@@ -13,7 +13,6 @@
 #include "mozilla/layers/SourceSurfaceSharedData.h"
 #include "mozilla/layers/CompositorThread.h"
 #include "mozilla/webrender/RenderSharedSurfaceTextureHost.h"
-#include "mozilla/webrender/RenderSharedSurfaceTextureHostSWGL.h"
 #include "mozilla/webrender/RenderThread.h"
 
 namespace mozilla {
@@ -132,12 +131,7 @@ void SharedSurfacesParent::AddSameProcess(const wr::ExternalImageId& aId,
   uint64_t id = wr::AsUint64(aId);
   MOZ_ASSERT(!sInstance->mSurfaces.Contains(id));
 
-  RefPtr<wr::RenderTextureHost> texture;
+  auto texture = MakeRefPtr<wr::RenderSharedSurfaceTextureHost>(surface);
-  if (gfx::gfxVars::UseSoftwareWebRender()) {
-    texture = new wr::RenderSharedSurfaceTextureHostSWGL(surface);
-  } else {
-    texture = new wr::RenderSharedSurfaceTextureHost(surface);
-  }
   wr::RenderThread::Get()->RegisterExternalImage(id, texture.forget());
 
   surface->AddConsumer();
@@ -187,12 +181,7 @@ void SharedSurfacesParent::Add(const wr::ExternalImageId& aId,
   uint64_t id = wr::AsUint64(aId);
   MOZ_ASSERT(!sInstance->mSurfaces.Contains(id));
 
-  RefPtr<wr::RenderTextureHost> texture;
+  auto texture = MakeRefPtr<wr::RenderSharedSurfaceTextureHost>(surface);
-  if (gfx::gfxVars::UseSoftwareWebRender()) {
-    texture = new wr::RenderSharedSurfaceTextureHostSWGL(surface);
-  } else {
-    texture = new wr::RenderSharedSurfaceTextureHost(surface);
-  }
   wr::RenderThread::Get()->RegisterExternalImage(id, texture.forget());
 
   surface->AddConsumer();

gfx/layers/opengl/TextureHostOGL.cpp

@@ -673,7 +673,7 @@ void SurfaceTextureHost::PushResourceUpdates(
                     ? &wr::TransactionBuilder::AddExternalImage
                     : &wr::TransactionBuilder::UpdateExternalImage;
 
-  auto imageType = gfx::gfxVars::UseSoftwareWebRender()
+  auto imageType = aResources.GetBackendType() == WebRenderBackend::SOFTWARE
                        ? wr::ExternalImageType::TextureHandle(
                              wr::ImageBufferKind::TextureRect)
                        : wr::ExternalImageType::TextureHandle(
@@ -707,10 +707,8 @@ void SurfaceTextureHost::PushDisplayItems(wr::DisplayListBuilder& aBuilder,
                                           PushDisplayItemFlagSet aFlags) {
   bool preferCompositorSurface =
       aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE);
-  bool supportsExternalCompositing = false;
+  bool supportsExternalCompositing =
-  if (gfx::gfxVars::UseSoftwareWebRender()) {
+      SupportsExternalCompositing(aBuilder.GetBackendType());
-    supportsExternalCompositing = true;
-  }
 
   switch (GetFormat()) {
     case gfx::SurfaceFormat::R8G8B8X8:

gfx/layers/wr/AsyncImagePipelineManager.cpp

@@ -247,12 +247,13 @@ Maybe<TextureHost::ResourceUpdateOp> AsyncImagePipelineManager::UpdateImageKeys(
 
   // If we already had a texture and the format hasn't changed, better to reuse
   // the image keys than create new ones.
+  auto backend = aSceneBuilderTxn.GetBackendType();
   bool canUpdate = !!previousTexture &&
                    previousTexture->GetSize() == texture->GetSize() &&
                    previousTexture->GetFormat() == texture->GetFormat() &&
                    previousTexture->NeedsYFlip() == texture->NeedsYFlip() &&
-                   previousTexture->SupportsExternalCompositing() ==
+                   previousTexture->SupportsExternalCompositing(backend) ==
-                       texture->SupportsExternalCompositing() &&
+                       texture->SupportsExternalCompositing(backend) &&
                    aPipeline->mKeys.Length() == numKeys;
 
   if (!canUpdate) {
@@ -405,7 +406,7 @@ void AsyncImagePipelineManager::ApplyAsyncImageForPipeline(
 
   aPipeline->mIsChanged = false;
 
-  wr::DisplayListBuilder builder(aPipelineId);
+  wr::DisplayListBuilder builder(aPipelineId, mApi->GetBackendType());
 
   float opacity = 1.0f;
   wr::StackingContextParams params;
@@ -477,7 +478,7 @@ void AsyncImagePipelineManager::ApplyAsyncImageForPipeline(
   if (!pipeline) {
     return;
   }
-  wr::TransactionBuilder fastTxn(/* aUseSceneBuilderThread */ false);
+  wr::TransactionBuilder fastTxn(mApi, /* aUseSceneBuilderThread */ false);
   wr::AutoTransactionSender sender(mApi, &fastTxn);
 
   // Transaction for async image pipeline that uses ImageBridge always need to
@@ -514,7 +515,7 @@ void AsyncImagePipelineManager::SetEmptyDisplayList(
   auto& txn = pipeline->mImageHost->GetAsyncRef() ? aTxnForImageBridge : aTxn;
 
   wr::Epoch epoch = GetNextImageEpoch();
-  wr::DisplayListBuilder builder(aPipelineId);
+  wr::DisplayListBuilder builder(aPipelineId, mApi->GetBackendType());
 
   wr::BuiltDisplayList dl;
   builder.Finalize(dl);

gfx/layers/wr/WebRenderBridgeParent.cpp

@@ -906,7 +906,7 @@ mozilla::ipc::IPCResult WebRenderBridgeParent::RecvUpdateResources(
     return IPC_OK();
   }
 
-  wr::TransactionBuilder txn;
+  wr::TransactionBuilder txn(mApi);
   txn.SetLowPriority(!IsRootWebRenderBridgeParent());
 
   Unused << GetNextWrEpoch();
@@ -1141,7 +1141,7 @@ bool WebRenderBridgeParent::ProcessDisplayListData(
     DisplayListData& aDisplayList, wr::Epoch aWrEpoch,
     const TimeStamp& aTxnStartTime, bool aValidTransaction,
     bool aObserveLayersUpdate) {
-  wr::TransactionBuilder txn;
+  wr::TransactionBuilder txn(mApi);
   Maybe<wr::AutoTransactionSender> sender;
 
   // Note that this needs to happen before the display list transaction is
@@ -1251,7 +1251,7 @@ mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSetDisplayList(
 bool WebRenderBridgeParent::ProcessEmptyTransactionUpdates(
     TransactionData& aData, bool* aScheduleComposite) {
   *aScheduleComposite = false;
-  wr::TransactionBuilder txn;
+  wr::TransactionBuilder txn(mApi);
   txn.SetLowPriority(!IsRootWebRenderBridgeParent());
 
   if (!aData.mScrollUpdates.IsEmpty()) {
@@ -1404,7 +1404,7 @@ mozilla::ipc::IPCResult WebRenderBridgeParent::RecvParentCommands(
     return IPC_OK();
   }
 
-  wr::TransactionBuilder txn;
+  wr::TransactionBuilder txn(mApi);
   txn.SetLowPriority(!IsRootWebRenderBridgeParent());
   if (!ProcessWebRenderParentCommands(aCommands, txn)) {
     return IPC_FAIL(this, "Invalid parent command found");
@@ -1419,7 +1419,7 @@ bool WebRenderBridgeParent::ProcessWebRenderParentCommands(
     wr::TransactionBuilder& aTxn) {
   // Transaction for async image pipeline that uses ImageBridge always need to
   // be non low priority.
-  wr::TransactionBuilder txnForImageBridge;
+  wr::TransactionBuilder txnForImageBridge(mApi);
   wr::AutoTransactionSender sender(mApi, &txnForImageBridge);
 
   for (nsTArray<WebRenderParentCommand>::index_type i = 0;
@@ -1563,7 +1563,7 @@ void WebRenderBridgeParent::DisableNativeCompositor() {
 }
 
 void WebRenderBridgeParent::UpdateQualitySettings() {
-  wr::TransactionBuilder txn;
+  wr::TransactionBuilder txn(mApi);
   txn.UpdateQualitySettings(gfxVars::ForceSubpixelAAWherePossible());
   mApi->SendTransaction(txn);
 }
@@ -1807,7 +1807,7 @@ mozilla::ipc::IPCResult WebRenderBridgeParent::RecvClearCachedResources() {
   }
 
   // Clear resources
-  wr::TransactionBuilder txn;
+  wr::TransactionBuilder txn(mApi);
   txn.SetLowPriority(true);
   txn.ClearDisplayList(GetNextWrEpoch(), mPipelineId);
   txn.Notify(
@@ -1886,7 +1886,7 @@ void WebRenderBridgeParent::InvalidateRenderedFrame() {
     return;
   }
 
-  wr::TransactionBuilder fastTxn(/* aUseSceneBuilderThread */ false);
+  wr::TransactionBuilder fastTxn(mApi, /* aUseSceneBuilderThread */ false);
   fastTxn.InvalidateRenderedFrame();
   mApi->SendTransaction(fastTxn);
 }
@@ -2133,9 +2133,9 @@ void WebRenderBridgeParent::MaybeGenerateFrame(VsyncId aId,
   // Ensure GenerateFrame is handled on the render backend thread rather
   // than going through the scene builder thread. That way we continue
   // generating frames with the old scene even during slow scene builds.
-  wr::TransactionBuilder fastTxn(false /* useSceneBuilderThread */);
+  wr::TransactionBuilder fastTxn(mApi, false /* useSceneBuilderThread */);
   // Handle transaction that is related to DisplayList.
-  wr::TransactionBuilder sceneBuilderTxn;
+  wr::TransactionBuilder sceneBuilderTxn(mApi);
   wr::AutoTransactionSender sender(mApi, &sceneBuilderTxn);
 
   mAsyncImageManager->SetCompositionInfo(start, mCompositionOpportunityId);
@@ -2436,7 +2436,7 @@ void WebRenderBridgeParent::ClearResources() {
 
   mAsyncImageManager->RemovePipeline(mPipelineId, wrEpoch);
 
-  wr::TransactionBuilder txn;
+  wr::TransactionBuilder txn(mApi);
   txn.SetLowPriority(true);
   txn.ClearDisplayList(wrEpoch, mPipelineId);
 

gfx/layers/wr/WebRenderLayerManager.cpp

@@ -339,7 +339,8 @@ void WebRenderLayerManager::EndTransactionWithoutLayer(
   size_t preallocate =
       mLastDisplayListSize < kMaxPrealloc ? mLastDisplayListSize : kMaxPrealloc;
 
-  wr::DisplayListBuilder builder(WrBridge()->GetPipeline(), preallocate,
+  wr::DisplayListBuilder builder(WrBridge()->GetPipeline(),
+                                 WrBridge()->GetWebRenderBackend(), preallocate,
                                  &mDisplayItemCache);
 
   wr::IpcResourceUpdateQueue resourceUpdates(WrBridge());

gfx/layers/wr/WebRenderTextureHost.cpp

@@ -215,8 +215,9 @@ void WebRenderTextureHost::PushDisplayItems(
                                         aImageKeys, aFlags);
 }
 
-bool WebRenderTextureHost::SupportsExternalCompositing() {
+bool WebRenderTextureHost::SupportsExternalCompositing(
-  return mWrappedTextureHost->SupportsExternalCompositing();
+    WebRenderBackend aBackend) {
+  return mWrappedTextureHost->SupportsExternalCompositing(aBackend);
 }
 
 bool WebRenderTextureHost::NeedsYFlip() const {

gfx/layers/wr/WebRenderTextureHost.h

@@ -87,7 +87,7 @@ class WebRenderTextureHost : public TextureHost {
                         const Range<wr::ImageKey>& aImageKeys,
                         PushDisplayItemFlagSet aFlags) override;
 
-  bool SupportsExternalCompositing() override;
+  bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 
   bool NeedsYFlip() const override;
 

gfx/webrender_bindings/RenderBufferTextureHost.cpp

@@ -156,5 +156,88 @@ RenderBufferTextureHost::GetBufferDataForRender(uint8_t aChannelIndex) {
   }
 }
 
+size_t RenderBufferTextureHost::GetPlaneCount() const {
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor:
+      return 3;
+    default:
+      return 1;
+  }
+}
+
+gfx::SurfaceFormat RenderBufferTextureHost::GetFormat() const {
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor:
+      return gfx::SurfaceFormat::YUV;
+    default:
+      return mDescriptor.get_RGBDescriptor().format();
+  }
+}
+
+gfx::ColorDepth RenderBufferTextureHost::GetColorDepth() const {
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor:
+      return mDescriptor.get_YCbCrDescriptor().colorDepth();
+    default:
+      return gfx::ColorDepth::COLOR_8;
+  }
+}
+
+gfx::YUVColorSpace RenderBufferTextureHost::GetYUVColorSpace() const {
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor:
+      return mDescriptor.get_YCbCrDescriptor().yUVColorSpace();
+    default:
+      return gfx::YUVColorSpace::UNKNOWN;
+  }
+}
+
+bool RenderBufferTextureHost::MapPlane(RenderCompositor* aCompositor,
+                                       uint8_t aChannelIndex,
+                                       PlaneInfo& aPlaneInfo) {
+  if (!mBuffer) {
+    // We hit some problems to get the shmem.
+    gfxCriticalNote << "GetBuffer Failed";
+    return false;
+  }
+
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor: {
+      const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
+      switch (aChannelIndex) {
+        case 0:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetYChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.yStride();
+          aPlaneInfo.mSize = desc.ySize();
+          break;
+        case 1:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetCbChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.cbCrStride();
+          aPlaneInfo.mSize = desc.cbCrSize();
+          break;
+        case 2:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetCrChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.cbCrStride();
+          aPlaneInfo.mSize = desc.cbCrSize();
+          break;
+      }
+      break;
+    }
+    default: {
+      const layers::RGBDescriptor& desc = mDescriptor.get_RGBDescriptor();
+      aPlaneInfo.mData = mBuffer;
+      aPlaneInfo.mStride = layers::ImageDataSerializer::GetRGBStride(desc);
+      aPlaneInfo.mSize = desc.size();
+      break;
+    }
+  }
+  return true;
+}
+
+void RenderBufferTextureHost::UnmapPlanes() {}
+
 }  // namespace wr
 }  // namespace mozilla

gfx/webrender_bindings/RenderBufferTextureHost.h

@@ -7,16 +7,17 @@
 #ifndef MOZILLA_GFX_RENDERBUFFERTEXTUREHOST_H
 #define MOZILLA_GFX_RENDERBUFFERTEXTUREHOST_H
 
-#include "RenderTextureHost.h"
+#include "RenderTextureHostSWGL.h"
 
 namespace mozilla {
 namespace wr {
 
-class RenderBufferTextureHost final : public RenderTextureHost {
+class RenderBufferTextureHost final : public RenderTextureHostSWGL {
  public:
   RenderBufferTextureHost(uint8_t* aBuffer,
                           const layers::BufferDescriptor& aDescriptor);
 
+  // RenderTextureHost
   wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL,
                            wr::ImageRendering aRendering) override;
   void Unlock() override;
@@ -34,6 +35,20 @@ class RenderBufferTextureHost final : public RenderTextureHost {
 
   RenderBufferData GetBufferDataForRender(uint8_t aChannelIndex);
 
+  // RenderTextureHostSWGL
+  size_t GetPlaneCount() const override;
+
+  gfx::SurfaceFormat GetFormat() const override;
+
+  gfx::ColorDepth GetColorDepth() const override;
+
+  gfx::YUVColorSpace GetYUVColorSpace() const override;
+
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+
+  void UnmapPlanes() override;
+
  private:
   virtual ~RenderBufferTextureHost();
 

gfx/webrender_bindings/RenderBufferTextureHostSWGL.cpp

@@ -1,119 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "RenderBufferTextureHostSWGL.h"
-
-#include "mozilla/gfx/Logging.h"
-#include "mozilla/layers/ImageDataSerializer.h"
-
-namespace mozilla {
-namespace wr {
-
-RenderBufferTextureHostSWGL::RenderBufferTextureHostSWGL(
-    uint8_t* aBuffer, const layers::BufferDescriptor& aDescriptor)
-    : mBuffer(aBuffer), mDescriptor(aDescriptor) {
-  MOZ_COUNT_CTOR_INHERITED(RenderBufferTextureHostSWGL, RenderTextureHostSWGL);
-
-  switch (mDescriptor.type()) {
-    case layers::BufferDescriptor::TYCbCrDescriptor:
-    case layers::BufferDescriptor::TRGBDescriptor:
-      break;
-    default:
-      gfxCriticalError() << "Bad buffer host descriptor "
-                         << (int)mDescriptor.type();
-      MOZ_CRASH("GFX: Bad descriptor");
-  }
-}
-
-RenderBufferTextureHostSWGL::~RenderBufferTextureHostSWGL() {
-  MOZ_COUNT_DTOR_INHERITED(RenderBufferTextureHostSWGL, RenderTextureHostSWGL);
-}
-
-size_t RenderBufferTextureHostSWGL::GetPlaneCount() const {
-  switch (mDescriptor.type()) {
-    case layers::BufferDescriptor::TYCbCrDescriptor:
-      return 3;
-    default:
-      return 1;
-  }
-}
-
-gfx::SurfaceFormat RenderBufferTextureHostSWGL::GetFormat() const {
-  switch (mDescriptor.type()) {
-    case layers::BufferDescriptor::TYCbCrDescriptor:
-      return gfx::SurfaceFormat::YUV;
-    default:
-      return mDescriptor.get_RGBDescriptor().format();
-  }
-}
-
-gfx::ColorDepth RenderBufferTextureHostSWGL::GetColorDepth() const {
-  switch (mDescriptor.type()) {
-    case layers::BufferDescriptor::TYCbCrDescriptor:
-      return mDescriptor.get_YCbCrDescriptor().colorDepth();
-    default:
-      return gfx::ColorDepth::COLOR_8;
-  }
-}
-
-gfx::YUVColorSpace RenderBufferTextureHostSWGL::GetYUVColorSpace() const {
-  switch (mDescriptor.type()) {
-    case layers::BufferDescriptor::TYCbCrDescriptor:
-      return mDescriptor.get_YCbCrDescriptor().yUVColorSpace();
-    default:
-      return gfx::YUVColorSpace::UNKNOWN;
-  }
-}
-
-bool RenderBufferTextureHostSWGL::MapPlane(RenderCompositor* aCompositor,
-                                           uint8_t aChannelIndex,
-                                           PlaneInfo& aPlaneInfo) {
-  if (!mBuffer) {
-    // We hit some problems to get the shmem.
-    gfxCriticalNote << "GetBuffer Failed";
-    return false;
-  }
-
-  switch (mDescriptor.type()) {
-    case layers::BufferDescriptor::TYCbCrDescriptor: {
-      const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
-      switch (aChannelIndex) {
-        case 0:
-          aPlaneInfo.mData =
-              layers::ImageDataSerializer::GetYChannel(mBuffer, desc);
-          aPlaneInfo.mStride = desc.yStride();
-          aPlaneInfo.mSize = desc.ySize();
-          break;
-        case 1:
-          aPlaneInfo.mData =
-              layers::ImageDataSerializer::GetCbChannel(mBuffer, desc);
-          aPlaneInfo.mStride = desc.cbCrStride();
-          aPlaneInfo.mSize = desc.cbCrSize();
-          break;
-        case 2:
-          aPlaneInfo.mData =
-              layers::ImageDataSerializer::GetCrChannel(mBuffer, desc);
-          aPlaneInfo.mStride = desc.cbCrStride();
-          aPlaneInfo.mSize = desc.cbCrSize();
-          break;
-      }
-      break;
-    }
-    default: {
-      const layers::RGBDescriptor& desc = mDescriptor.get_RGBDescriptor();
-      aPlaneInfo.mData = mBuffer;
-      aPlaneInfo.mStride = layers::ImageDataSerializer::GetRGBStride(desc);
-      aPlaneInfo.mSize = desc.size();
-      break;
-    }
-  }
-  return true;
-}
-
-void RenderBufferTextureHostSWGL::UnmapPlanes() {}
-
-}  // namespace wr
-}  // namespace mozilla

gfx/webrender_bindings/RenderBufferTextureHostSWGL.h

@@ -1,45 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef MOZILLA_GFX_RENDERBUFFERTEXTUREHOSTSWGL_H
-#define MOZILLA_GFX_RENDERBUFFERTEXTUREHOSTSWGL_H
-
-#include "RenderTextureHostSWGL.h"
-
-namespace mozilla {
-namespace wr {
-
-class RenderBufferTextureHostSWGL final : public RenderTextureHostSWGL {
- public:
-  RenderBufferTextureHostSWGL(uint8_t* aBuffer,
-                              const layers::BufferDescriptor& aDescriptor);
-
-  size_t GetPlaneCount() const override;
-
-  gfx::SurfaceFormat GetFormat() const override;
-
-  gfx::ColorDepth GetColorDepth() const override;
-
-  gfx::YUVColorSpace GetYUVColorSpace() const override;
-
-  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
-                PlaneInfo& aPlaneInfo) override;
-
-  void UnmapPlanes() override;
-
-  size_t Bytes() override { return BytesFromPlanes(); }
-
- private:
-  virtual ~RenderBufferTextureHostSWGL();
-
-  uint8_t* mBuffer;
-  layers::BufferDescriptor mDescriptor;
-};
-
-}  // namespace wr
-}  // namespace mozilla
-
-#endif  // MOZILLA_GFX_RENDERBUFFERTEXTUREHOSTSWGL_H

gfx/webrender_bindings/RenderExternalTextureHost.cpp

@@ -198,5 +198,76 @@ void RenderExternalTextureHost::UpdateTextures(wr::ImageRendering aRendering) {
   mTextureUpdateNeeded = false;
 }
 
+size_t RenderExternalTextureHost::GetPlaneCount() const { return PlaneCount(); }
+
+gfx::SurfaceFormat RenderExternalTextureHost::GetFormat() const {
+  return mFormat;
+}
+
+gfx::ColorDepth RenderExternalTextureHost::GetColorDepth() const {
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor:
+      return mDescriptor.get_YCbCrDescriptor().colorDepth();
+    default:
+      return gfx::ColorDepth::COLOR_8;
+  }
+}
+
+gfx::YUVColorSpace RenderExternalTextureHost::GetYUVColorSpace() const {
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor:
+      return mDescriptor.get_YCbCrDescriptor().yUVColorSpace();
+    default:
+      return gfx::YUVColorSpace::UNKNOWN;
+  }
+}
+
+bool RenderExternalTextureHost::MapPlane(RenderCompositor* aCompositor,
+                                         uint8_t aChannelIndex,
+                                         PlaneInfo& aPlaneInfo) {
+  if (!mBuffer) {
+    // We hit some problems to get the shmem.
+    gfxCriticalNote << "GetBuffer Failed";
+    return false;
+  }
+
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor: {
+      const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
+      switch (aChannelIndex) {
+        case 0:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetYChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.yStride();
+          aPlaneInfo.mSize = desc.ySize();
+          break;
+        case 1:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetCbChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.cbCrStride();
+          aPlaneInfo.mSize = desc.cbCrSize();
+          break;
+        case 2:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetCrChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.cbCrStride();
+          aPlaneInfo.mSize = desc.cbCrSize();
+          break;
+      }
+      break;
+    }
+    default: {
+      const layers::RGBDescriptor& desc = mDescriptor.get_RGBDescriptor();
+      aPlaneInfo.mData = mBuffer;
+      aPlaneInfo.mStride = layers::ImageDataSerializer::GetRGBStride(desc);
+      aPlaneInfo.mSize = desc.size();
+      break;
+    }
+  }
+  return true;
+}
+
+void RenderExternalTextureHost::UnmapPlanes() {}
+
 }  // namespace wr
 }  // namespace mozilla

gfx/webrender_bindings/RenderExternalTextureHost.h

@@ -8,7 +8,7 @@
 #define MOZILLA_GFX_RENDEREXTERNALTEXTUREHOST_H
 
 #include "mozilla/layers/TextureHostOGL.h"
-#include "RenderTextureHost.h"
+#include "RenderTextureHostSWGL.h"
 
 namespace mozilla {
 namespace wr {
@@ -19,7 +19,7 @@ namespace wr {
  * extension, which makes it possible to avoid some copies during texture
  * upload. This is especially helpful for high resolution video.
  */
-class RenderExternalTextureHost final : public RenderTextureHost {
+class RenderExternalTextureHost final : public RenderTextureHostSWGL {
  public:
   RenderExternalTextureHost(uint8_t* aBuffer,
                             const layers::BufferDescriptor& aDescriptor);
@@ -32,6 +32,20 @@ class RenderExternalTextureHost final : public RenderTextureHost {
     return mSize.width * mSize.height * BytesPerPixel(mFormat);
   }
 
+  // RenderTextureHostSWGL
+  size_t GetPlaneCount() const override;
+
+  gfx::SurfaceFormat GetFormat() const override;
+
+  gfx::ColorDepth GetColorDepth() const override;
+
+  gfx::YUVColorSpace GetYUVColorSpace() const override;
+
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+
+  void UnmapPlanes() override;
+
  private:
   ~RenderExternalTextureHost();
 

gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp

@@ -49,5 +49,30 @@ size_t RenderSharedSurfaceTextureHost::Bytes() {
   return mSurface->Stride() * mSurface->GetSize().height;
 }
 
+size_t RenderSharedSurfaceTextureHost::GetPlaneCount() const { return 1; }
+
+gfx::SurfaceFormat RenderSharedSurfaceTextureHost::GetFormat() const {
+  return mSurface->GetFormat();
+}
+
+gfx::ColorDepth RenderSharedSurfaceTextureHost::GetColorDepth() const {
+  return gfx::ColorDepth::COLOR_8;
+}
+
+bool RenderSharedSurfaceTextureHost::MapPlane(RenderCompositor* aCompositor,
+                                              uint8_t aChannelIndex,
+                                              PlaneInfo& aPlaneInfo) {
+  if (NS_WARN_IF(
+          !mSurface->Map(gfx::DataSourceSurface::MapType::READ, &mMap))) {
+    return false;
+  }
+  aPlaneInfo.mData = mMap.mData;
+  aPlaneInfo.mStride = mMap.mStride;
+  aPlaneInfo.mSize = mSurface->GetSize();
+  return true;
+}
+
+void RenderSharedSurfaceTextureHost::UnmapPlanes() { mSurface->Unmap(); }
+
 }  // namespace wr
 }  // namespace mozilla

gfx/webrender_bindings/RenderSharedSurfaceTextureHost.h

@@ -7,7 +7,7 @@
 #ifndef MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOST_H
 #define MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOST_H
 
-#include "RenderTextureHost.h"
+#include "RenderTextureHostSWGL.h"
 
 namespace mozilla {
 namespace gfx {
@@ -21,16 +21,29 @@ namespace wr {
  * into the render texture cache by wrapping an existing surface wrapper. These
  * surfaces are backed by BGRA/X shared memory buffers.
  */
-class RenderSharedSurfaceTextureHost final : public RenderTextureHost {
+class RenderSharedSurfaceTextureHost final : public RenderTextureHostSWGL {
  public:
   explicit RenderSharedSurfaceTextureHost(
       gfx::SourceSurfaceSharedDataWrapper* aSurface);
 
+  // RenderTextureHost
   wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL,
                            wr::ImageRendering aRendering) override;
   void Unlock() override;
   size_t Bytes() override;
 
+  // RenderTextureHostSWGL
+  size_t GetPlaneCount() const override;
+
+  gfx::SurfaceFormat GetFormat() const override;
+
+  gfx::ColorDepth GetColorDepth() const override;
+
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+
+  void UnmapPlanes() override;
+
  private:
   virtual ~RenderSharedSurfaceTextureHost();
 

gfx/webrender_bindings/RenderSharedSurfaceTextureHostSWGL.cpp

@@ -1,53 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "RenderSharedSurfaceTextureHostSWGL.h"
-
-#include "mozilla/layers/SourceSurfaceSharedData.h"
-
-namespace mozilla {
-namespace wr {
-
-RenderSharedSurfaceTextureHostSWGL::RenderSharedSurfaceTextureHostSWGL(
-    gfx::SourceSurfaceSharedDataWrapper* aSurface)
-    : mSurface(aSurface) {
-  MOZ_COUNT_CTOR_INHERITED(RenderSharedSurfaceTextureHostSWGL,
-                           RenderTextureHostSWGL);
-  MOZ_ASSERT(aSurface);
-}
-
-RenderSharedSurfaceTextureHostSWGL::~RenderSharedSurfaceTextureHostSWGL() {
-  MOZ_COUNT_DTOR_INHERITED(RenderSharedSurfaceTextureHostSWGL,
-                           RenderTextureHostSWGL);
-}
-
-size_t RenderSharedSurfaceTextureHostSWGL::GetPlaneCount() const { return 1; }
-
-gfx::SurfaceFormat RenderSharedSurfaceTextureHostSWGL::GetFormat() const {
-  return mSurface->GetFormat();
-}
-
-gfx::ColorDepth RenderSharedSurfaceTextureHostSWGL::GetColorDepth() const {
-  return gfx::ColorDepth::COLOR_8;
-}
-
-bool RenderSharedSurfaceTextureHostSWGL::MapPlane(RenderCompositor* aCompositor,
-                                                  uint8_t aChannelIndex,
-                                                  PlaneInfo& aPlaneInfo) {
-  if (NS_WARN_IF(
-          !mSurface->Map(gfx::DataSourceSurface::MapType::READ, &mMap))) {
-    return false;
-  }
-  aPlaneInfo.mData = mMap.mData;
-  aPlaneInfo.mStride = mMap.mStride;
-  aPlaneInfo.mSize = mSurface->GetSize();
-  return true;
-}
-
-void RenderSharedSurfaceTextureHostSWGL::UnmapPlanes() { mSurface->Unmap(); }
-
-}  // namespace wr
-}  // namespace mozilla

gfx/webrender_bindings/RenderSharedSurfaceTextureHostSWGL.h

@@ -1,52 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOSTSWGL_H
-#define MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOSTSWGL_H
-
-#include "RenderTextureHostSWGL.h"
-
-namespace mozilla {
-namespace gfx {
-class SourceSurfaceSharedDataWrapper;
-}
-
-namespace wr {
-
-/**
- * This class allows for surfaces managed by SharedSurfacesParent to be inserted
- * into the render texture cache by wrapping an existing surface wrapper. These
- * surfaces are backed by BGRA/X shared memory buffers.
- */
-class RenderSharedSurfaceTextureHostSWGL final : public RenderTextureHostSWGL {
- public:
-  explicit RenderSharedSurfaceTextureHostSWGL(
-      gfx::SourceSurfaceSharedDataWrapper* aSurface);
-
-  size_t GetPlaneCount() const override;
-
-  gfx::SurfaceFormat GetFormat() const override;
-
-  gfx::ColorDepth GetColorDepth() const override;
-
-  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
-                PlaneInfo& aPlaneInfo) override;
-
-  void UnmapPlanes() override;
-
-  size_t Bytes() override { return BytesFromPlanes(); }
-
- private:
-  virtual ~RenderSharedSurfaceTextureHostSWGL();
-
-  RefPtr<gfx::SourceSurfaceSharedDataWrapper> mSurface;
-  gfx::DataSourceSurface::MappedSurface mMap;
-};
-
-}  // namespace wr
-}  // namespace mozilla
-
-#endif  // MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOSTSWGL_H

gfx/webrender_bindings/WebRenderAPI.cpp

@@ -217,8 +217,10 @@ class RemoveRenderer : public RendererEvent {
   layers::SynchronousTask* mTask;
 };
 
-TransactionBuilder::TransactionBuilder(bool aUseSceneBuilderThread)
+TransactionBuilder::TransactionBuilder(WebRenderAPI* aApi,
-    : mUseSceneBuilderThread(aUseSceneBuilderThread) {
+                                       bool aUseSceneBuilderThread)
+    : mUseSceneBuilderThread(aUseSceneBuilderThread),
+      mApiBackend(aApi->GetBackendType()) {
   mTxn = wr_transaction_new(mUseSceneBuilderThread);
 }
 
@@ -924,11 +926,14 @@ void WebRenderAPI::RunOnRenderThread(UniquePtr<RendererEvent> aEvent) {
   wr_api_send_external_event(mDocHandle, event);
 }
 
-DisplayListBuilder::DisplayListBuilder(PipelineId aId, size_t aCapacity,
+DisplayListBuilder::DisplayListBuilder(PipelineId aId,
+                                       WebRenderBackend aBackend,
+                                       size_t aCapacity,
                                        layers::DisplayItemCache* aCache)
     : mCurrentSpaceAndClipChain(wr::RootScrollNodeWithChain()),
       mActiveFixedPosTracker(nullptr),
       mPipelineId(aId),
+      mBackend(aBackend),
       mDisplayItemCache(aCache) {
   MOZ_COUNT_CTOR(DisplayListBuilder);
   mWrState = wr_state_new(aId, aCapacity);

gfx/webrender_bindings/WebRenderAPI.h

@@ -58,6 +58,7 @@ namespace wr {
 class DisplayListBuilder;
 class RendererOGL;
 class RendererEvent;
+class WebRenderAPI;
 
 // This isn't part of WR's API, but we define it here to simplify layout's
 // logic and data plumbing.
@@ -91,7 +92,8 @@ struct WrHitResult {
 
 class TransactionBuilder final {
  public:
-  explicit TransactionBuilder(bool aUseSceneBuilderThread = true);
+  explicit TransactionBuilder(WebRenderAPI* aApi,
+                              bool aUseSceneBuilderThread = true);
 
   ~TransactionBuilder();
 
@@ -198,10 +200,12 @@ class TransactionBuilder final {
   void Clear();
 
   bool UseSceneBuilderThread() const { return mUseSceneBuilderThread; }
+  layers::WebRenderBackend GetBackendType() { return mApiBackend; }
   Transaction* Raw() { return mTxn; }
 
  protected:
   bool mUseSceneBuilderThread;
+  layers::WebRenderBackend mApiBackend;
   Transaction* mTxn;
 };
 
@@ -414,7 +418,9 @@ struct MOZ_STACK_CLASS StackingContextParams : public WrStackingContextParams {
 /// WebRenderFrameBuilder instead, so the interface may change a bit.
 class DisplayListBuilder final {
  public:
-  explicit DisplayListBuilder(wr::PipelineId aId, size_t aCapacity = 0,
+  explicit DisplayListBuilder(wr::PipelineId aId,
+                              layers::WebRenderBackend aBackend,
+                              size_t aCapacity = 0,
                               layers::DisplayItemCache* aCache = nullptr);
   DisplayListBuilder(DisplayListBuilder&&) = default;
 
@@ -649,6 +655,7 @@ class DisplayListBuilder final {
   }
 
   const wr::PipelineId& CurrentPipelineId() const { return mPipelineId; }
+  layers::WebRenderBackend GetBackendType() const { return mBackend; }
 
   // Checks to see if the innermost enclosing fixed pos item has the same
   // ASR. If so, it returns the scroll target for that fixed-pos item.
@@ -731,6 +738,7 @@ class DisplayListBuilder final {
   FixedPosScrollTargetTracker* mActiveFixedPosTracker;
 
   wr::PipelineId mPipelineId;
+  layers::WebRenderBackend mBackend;
   wr::LayoutSize mContentSize;
 
   nsTArray<wr::PipelineId> mRemotePipelineIds;

gfx/webrender_bindings/moz.build

@@ -9,7 +9,6 @@ with Files("**"):
 
 EXPORTS.mozilla.webrender += [
     "RenderBufferTextureHost.h",
-    "RenderBufferTextureHostSWGL.h",
     "RenderCompositor.h",
     "RenderCompositorEGL.h",
     "RenderCompositorOGL.h",
@@ -19,7 +18,6 @@ EXPORTS.mozilla.webrender += [
     "RendererScreenshotGrabber.h",
     "RenderExternalTextureHost.h",
     "RenderSharedSurfaceTextureHost.h",
-    "RenderSharedSurfaceTextureHostSWGL.h",
     "RenderTextureHost.h",
     "RenderTextureHostSWGL.h",
     "RenderTextureHostWrapper.h",
@@ -32,7 +30,6 @@ EXPORTS.mozilla.webrender += [
 UNIFIED_SOURCES += [
     "Moz2DImageRenderer.cpp",
     "RenderBufferTextureHost.cpp",
-    "RenderBufferTextureHostSWGL.cpp",
     "RenderCompositor.cpp",
     "RenderCompositorEGL.cpp",
     "RenderCompositorOGL.cpp",
@@ -42,7 +39,6 @@ UNIFIED_SOURCES += [
     "RendererScreenshotGrabber.cpp",
     "RenderExternalTextureHost.cpp",
     "RenderSharedSurfaceTextureHost.cpp",
-    "RenderSharedSurfaceTextureHostSWGL.cpp",
     "RenderTextureHost.cpp",
     "RenderTextureHostSWGL.cpp",
     "RenderTextureHostWrapper.cpp",