Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

69 files changed, 25135 insertions, 0 deletions

diff --git a/gfx/webrender_bindings/Cargo.toml b/gfx/webrender_bindings/Cargo.toml
new file mode 100644
index 0000000000..f6b3fd637f
--- /dev/null
+++ b/gfx/webrender_bindings/Cargo.toml
@@ -0,0 +1,40 @@
+[package]
+name = "webrender_bindings"
+version = "0.1.0"
+authors = ["The Mozilla Project Developers"]
+license = "MPL-2.0"
+
+[dependencies]
+dirs = "4"
+rayon = "1"
+num_cpus = "1.7.0"
+tracy-rs = "0.1"
+euclid = { version = "0.22.5", features = ["serde"] }
+app_units = "0.7"
+gleam = "0.15"
+log = "0.4"
+nsstring = { path = "../../xpcom/rust/nsstring" }
+bincode = "1.0"
+uuid = { version = "1.0", features = ["v4"] }
+fxhash = "0.2.1"
+thin-vec = { version = "0.2.1", features = ["gecko-ffi"] }
+swgl = { path = "../wr/swgl" }
+wr_malloc_size_of = { path = "../wr/wr_malloc_size_of" }
+gecko-profiler = { path = "../../tools/profiler/rust-api" }
+remove_dir_all = "0.5.3"
+
+[dependencies.webrender]
+path = "../wr/webrender"
+version = "0.62.0"
+default-features = false
+features = ["capture", "serialize_program", "gecko", "sw_compositor"]
+
+[target.'cfg(target_os = "windows")'.dependencies]
+dwrote = "0.11"
+winapi = "0.3"
+
+[target.'cfg(target_os = "macos")'.dependencies]
+core-foundation = "0.9"
+core-graphics = "0.23"
+foreign-types = "0.5.0"
+objc = "0.2"
diff --git a/gfx/webrender_bindings/DCLayerTree.cpp b/gfx/webrender_bindings/DCLayerTree.cpp
new file mode 100644
index 0000000000..eee5601182
--- /dev/null
+++ b/gfx/webrender_bindings/DCLayerTree.cpp
@@ -0,0 +1,2080 @@
+/* -*- 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 "DCLayerTree.h"
+
+// -
+
+#include <d3d11.h>
+#include <dcomp.h>
+#include <d3d11_1.h>
+#include <dxgi1_2.h>
+
+// -
+
+#include "gfxWindowsPlatform.h"
+#include "GLContext.h"
+#include "GLContextEGL.h"
+#include "mozilla/gfx/DeviceManagerDx.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/GPUParent.h"
+#include "mozilla/gfx/Matrix.h"
+#include "mozilla/layers/HelpersD3D11.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/webrender/RenderD3D11TextureHost.h"
+#include "mozilla/webrender/RenderDcompSurfaceTextureHost.h"
+#include "mozilla/webrender/RenderTextureHost.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/WindowsVersion.h"
+#include "mozilla/Telemetry.h"
+#include "nsPrintfCString.h"
+#include "WinUtils.h"
+
+// -
+
+#if defined(__MINGW32__)  // 64 defines both 32 and 64
+// We need to fake some things, while we wait on updates to mingw's dcomp.h
+// header. Just enough that we can successfully fail to work there.
+#  define MOZ_MINGW_DCOMP_H_INCOMPLETE
+struct IDCompositionColorMatrixEffect : public IDCompositionFilterEffect {};
+struct IDCompositionTableTransferEffect : public IDCompositionFilterEffect {};
+#endif  // defined(__MINGW32__)
+
+namespace mozilla {
+namespace wr {
+
+extern LazyLogModule gRenderThreadLog;
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+#define LOG_H(msg, ...)                   \
+  MOZ_LOG(gDcompSurface, LogLevel::Debug, \
+          ("DCSurfaceHandle=%p, " msg, this, ##__VA_ARGS__))
+
+StaticAutoPtr<GpuOverlayInfo> DCLayerTree::sGpuOverlayInfo;
+
+/* static */
+UniquePtr<DCLayerTree> DCLayerTree::Create(gl::GLContext* aGL,
+                                           EGLConfig aEGLConfig,
+                                           ID3D11Device* aDevice,
+                                           ID3D11DeviceContext* aCtx,
+                                           HWND aHwnd, nsACString& aError) {
+  RefPtr<IDCompositionDevice2> dCompDevice =
+      gfx::DeviceManagerDx::Get()->GetDirectCompositionDevice();
+  if (!dCompDevice) {
+    aError.Assign("DCLayerTree(no device)"_ns);
+    return nullptr;
+  }
+
+  auto layerTree =
+      MakeUnique<DCLayerTree>(aGL, aEGLConfig, aDevice, aCtx, dCompDevice);
+  if (!layerTree->Initialize(aHwnd, aError)) {
+    return nullptr;
+  }
+
+  return layerTree;
+}
+
+void DCLayerTree::Shutdown() { DCLayerTree::sGpuOverlayInfo = nullptr; }
+
+DCLayerTree::DCLayerTree(gl::GLContext* aGL, EGLConfig aEGLConfig,
+                         ID3D11Device* aDevice, ID3D11DeviceContext* aCtx,
+                         IDCompositionDevice2* aCompositionDevice)
+    : mGL(aGL),
+      mEGLConfig(aEGLConfig),
+      mDevice(aDevice),
+      mCtx(aCtx),
+      mCompositionDevice(aCompositionDevice),
+      mDebugCounter(false),
+      mDebugVisualRedrawRegions(false),
+      mEGLImage(EGL_NO_IMAGE),
+      mColorRBO(0),
+      mPendingCommit(false) {
+  LOG("DCLayerTree::DCLayerTree()");
+}
+
+DCLayerTree::~DCLayerTree() {
+  LOG("DCLayerTree::~DCLayerTree()");
+
+  ReleaseNativeCompositorResources();
+}
+
+void DCLayerTree::ReleaseNativeCompositorResources() {
+  const auto gl = GetGLContext();
+
+  DestroyEGLSurface();
+
+  // Delete any cached FBO objects
+  for (auto it = mFrameBuffers.begin(); it != mFrameBuffers.end(); ++it) {
+    gl->fDeleteRenderbuffers(1, &it->depthRboId);
+    gl->fDeleteFramebuffers(1, &it->fboId);
+  }
+}
+
+bool DCLayerTree::Initialize(HWND aHwnd, nsACString& aError) {
+  HRESULT hr;
+
+  RefPtr<IDCompositionDesktopDevice> desktopDevice;
+  hr = mCompositionDevice->QueryInterface(
+      (IDCompositionDesktopDevice**)getter_AddRefs(desktopDevice));
+  if (FAILED(hr)) {
+    aError.Assign(nsPrintfCString(
+        "DCLayerTree(get IDCompositionDesktopDevice failed %lx)", hr));
+    return false;
+  }
+
+  hr = desktopDevice->CreateTargetForHwnd(aHwnd, TRUE,
+                                          getter_AddRefs(mCompositionTarget));
+  if (FAILED(hr)) {
+    aError.Assign(nsPrintfCString(
+        "DCLayerTree(create DCompositionTarget failed %lx)", hr));
+    return false;
+  }
+
+  hr = mCompositionDevice->CreateVisual(getter_AddRefs(mRootVisual));
+  if (FAILED(hr)) {
+    aError.Assign(nsPrintfCString(
+        "DCLayerTree(create root DCompositionVisual failed %lx)", hr));
+    return false;
+  }
+
+  hr =
+      mCompositionDevice->CreateVisual(getter_AddRefs(mDefaultSwapChainVisual));
+  if (FAILED(hr)) {
+    aError.Assign(nsPrintfCString(
+        "DCLayerTree(create swap chain DCompositionVisual failed %lx)", hr));
+    return false;
+  }
+
+  if (gfx::gfxVars::UseWebRenderDCompVideoHwOverlayWin() ||
+      gfx::gfxVars::UseWebRenderDCompVideoSwOverlayWin()) {
+    if (!InitializeVideoOverlaySupport()) {
+      RenderThread::Get()->HandleWebRenderError(WebRenderError::VIDEO_OVERLAY);
+    }
+  }
+  if (!sGpuOverlayInfo) {
+    // Set default if sGpuOverlayInfo was not set.
+    sGpuOverlayInfo = new GpuOverlayInfo();
+  }
+
+  // Initialize SwapChainInfo
+  SupportsSwapChainTearing();
+
+  mCompositionTarget->SetRoot(mRootVisual);
+  // Set interporation mode to nearest, to ensure 1:1 sampling.
+  // By default, a visual inherits the interpolation mode of the parent visual.
+  // If no visuals set the interpolation mode, the default for the entire visual
+  // tree is nearest neighbor interpolation.
+  mRootVisual->SetBitmapInterpolationMode(
+      DCOMPOSITION_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
+  return true;
+}
+
+bool FlagsSupportsOverlays(UINT flags) {
+  return (flags & (DXGI_OVERLAY_SUPPORT_FLAG_DIRECT |
+                   DXGI_OVERLAY_SUPPORT_FLAG_SCALING));
+}
+
+// A warpper of IDXGIOutput4::CheckOverlayColorSpaceSupport()
+bool CheckOverlayColorSpaceSupport(DXGI_FORMAT aDxgiFormat,
+                                   DXGI_COLOR_SPACE_TYPE aDxgiColorSpace,
+                                   RefPtr<IDXGIOutput> aOutput,
+                                   RefPtr<ID3D11Device> aD3d11Device) {
+  UINT colorSpaceSupportFlags = 0;
+  RefPtr<IDXGIOutput4> output4;
+
+  if (FAILED(aOutput->QueryInterface(__uuidof(IDXGIOutput4),
+                                     getter_AddRefs(output4)))) {
+    return false;
+  }
+
+  if (FAILED(output4->CheckOverlayColorSpaceSupport(
+          aDxgiFormat, aDxgiColorSpace, aD3d11Device,
+          &colorSpaceSupportFlags))) {
+    return false;
+  }
+
+  return (colorSpaceSupportFlags &
+          DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG_PRESENT);
+}
+
+bool DCLayerTree::InitializeVideoOverlaySupport() {
+  MOZ_ASSERT(IsWin10AnniversaryUpdateOrLater());
+
+  HRESULT hr;
+
+  hr = mDevice->QueryInterface(
+      (ID3D11VideoDevice**)getter_AddRefs(mVideoDevice));
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to get D3D11VideoDevice: " << gfx::hexa(hr);
+    return false;
+  }
+
+  hr =
+      mCtx->QueryInterface((ID3D11VideoContext**)getter_AddRefs(mVideoContext));
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to get D3D11VideoContext: " << gfx::hexa(hr);
+    return false;
+  }
+
+  if (sGpuOverlayInfo) {
+    return true;
+  }
+
+  UniquePtr<GpuOverlayInfo> info = MakeUnique<GpuOverlayInfo>();
+
+  RefPtr<IDXGIDevice> dxgiDevice;
+  RefPtr<IDXGIAdapter> adapter;
+  mDevice->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice));
+  dxgiDevice->GetAdapter(getter_AddRefs(adapter));
+
+  unsigned int i = 0;
+  while (true) {
+    RefPtr<IDXGIOutput> output;
+    if (FAILED(adapter->EnumOutputs(i++, getter_AddRefs(output)))) {
+      break;
+    }
+    RefPtr<IDXGIOutput3> output3;
+    if (FAILED(output->QueryInterface(__uuidof(IDXGIOutput3),
+                                      getter_AddRefs(output3)))) {
+      break;
+    }
+
+    output3->CheckOverlaySupport(DXGI_FORMAT_NV12, mDevice,
+                                 &info->mNv12OverlaySupportFlags);
+    output3->CheckOverlaySupport(DXGI_FORMAT_YUY2, mDevice,
+                                 &info->mYuy2OverlaySupportFlags);
+    output3->CheckOverlaySupport(DXGI_FORMAT_B8G8R8A8_UNORM, mDevice,
+                                 &info->mBgra8OverlaySupportFlags);
+    output3->CheckOverlaySupport(DXGI_FORMAT_R10G10B10A2_UNORM, mDevice,
+                                 &info->mRgb10a2OverlaySupportFlags);
+
+    if (FlagsSupportsOverlays(info->mNv12OverlaySupportFlags)) {
+      // NV12 format is preferred if it's supported.
+      info->mOverlayFormatUsed = DXGI_FORMAT_NV12;
+      info->mSupportsHardwareOverlays = true;
+    }
+
+    if (!info->mSupportsHardwareOverlays &&
+        FlagsSupportsOverlays(info->mYuy2OverlaySupportFlags)) {
+      // If NV12 isn't supported, fallback to YUY2 if it's supported.
+      info->mOverlayFormatUsed = DXGI_FORMAT_YUY2;
+      info->mSupportsHardwareOverlays = true;
+    }
+
+    // RGB10A2 overlay is used for displaying HDR content. In Intel's
+    // platform, RGB10A2 overlay is enabled only when
+    // DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 is supported.
+    if (FlagsSupportsOverlays(info->mRgb10a2OverlaySupportFlags)) {
+      if (!CheckOverlayColorSpaceSupport(
+              DXGI_FORMAT_R10G10B10A2_UNORM,
+              DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020, output, mDevice))
+        info->mRgb10a2OverlaySupportFlags = 0;
+    }
+
+    // Early out after the first output that reports overlay support. All
+    // outputs are expected to report the same overlay support according to
+    // Microsoft's WDDM documentation:
+    // https://docs.microsoft.com/en-us/windows-hardware/drivers/display/multiplane-overlay-hardware-requirements
+    if (info->mSupportsHardwareOverlays) {
+      break;
+    }
+  }
+
+  if (!StaticPrefs::gfx_webrender_dcomp_video_yuv_overlay_win_AtStartup()) {
+    info->mOverlayFormatUsed = DXGI_FORMAT_B8G8R8A8_UNORM;
+    info->mSupportsHardwareOverlays = false;
+  }
+
+  info->mSupportsOverlays = info->mSupportsHardwareOverlays;
+
+  // Note: "UniquePtr::release" here is saying "release your ownership stake
+  // on your pointer, so that our StaticAutoPtr can take over ownership".
+  // (StaticAutoPtr doesn't have a move constructor that could directly steal
+  // the contents of a UniquePtr via std::move().)
+  sGpuOverlayInfo = info.release();
+
+  if (auto* gpuParent = gfx::GPUParent::GetSingleton()) {
+    gpuParent->NotifyOverlayInfo(GetOverlayInfo());
+  }
+
+  return true;
+}
+
+DCSurface* DCLayerTree::GetSurface(wr::NativeSurfaceId aId) const {
+  auto surface_it = mDCSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surface_it != mDCSurfaces.end());
+  return surface_it->second.get();
+}
+
+void DCLayerTree::SetDefaultSwapChain(IDXGISwapChain1* aSwapChain) {
+  LOG("DCLayerTree::SetDefaultSwapChain()");
+
+  mRootVisual->AddVisual(mDefaultSwapChainVisual, TRUE, nullptr);
+  mDefaultSwapChainVisual->SetContent(aSwapChain);
+  // Default SwapChain's visual does not need linear interporation.
+  mDefaultSwapChainVisual->SetBitmapInterpolationMode(
+      DCOMPOSITION_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
+  mPendingCommit = true;
+}
+
+void DCLayerTree::MaybeUpdateDebug() {
+  bool updated = false;
+  updated |= MaybeUpdateDebugCounter();
+  updated |= MaybeUpdateDebugVisualRedrawRegions();
+  if (updated) {
+    mPendingCommit = true;
+  }
+}
+
+void DCLayerTree::MaybeCommit() {
+  if (!mPendingCommit) {
+    return;
+  }
+  mCompositionDevice->Commit();
+}
+
+void DCLayerTree::WaitForCommitCompletion() {
+  mCompositionDevice->WaitForCommitCompletion();
+}
+
+void DCLayerTree::DisableNativeCompositor() {
+  MOZ_ASSERT(mCurrentSurface.isNothing());
+  MOZ_ASSERT(mCurrentLayers.empty());
+
+  ReleaseNativeCompositorResources();
+  mPrevLayers.clear();
+  mRootVisual->RemoveAllVisuals();
+}
+
+bool DCLayerTree::MaybeUpdateDebugCounter() {
+  bool debugCounter = StaticPrefs::gfx_webrender_debug_dcomp_counter();
+  if (mDebugCounter == debugCounter) {
+    return false;
+  }
+
+  RefPtr<IDCompositionDeviceDebug> debugDevice;
+  HRESULT hr = mCompositionDevice->QueryInterface(
+      (IDCompositionDeviceDebug**)getter_AddRefs(debugDevice));
+  if (FAILED(hr)) {
+    return false;
+  }
+
+  if (debugCounter) {
+    debugDevice->EnableDebugCounters();
+  } else {
+    debugDevice->DisableDebugCounters();
+  }
+
+  mDebugCounter = debugCounter;
+  return true;
+}
+
+bool DCLayerTree::MaybeUpdateDebugVisualRedrawRegions() {
+  bool debugVisualRedrawRegions =
+      StaticPrefs::gfx_webrender_debug_dcomp_redraw_regions();
+  if (mDebugVisualRedrawRegions == debugVisualRedrawRegions) {
+    return false;
+  }
+
+  RefPtr<IDCompositionVisualDebug> visualDebug;
+  HRESULT hr = mRootVisual->QueryInterface(
+      (IDCompositionVisualDebug**)getter_AddRefs(visualDebug));
+  if (FAILED(hr)) {
+    return false;
+  }
+
+  if (debugVisualRedrawRegions) {
+    visualDebug->EnableRedrawRegions();
+  } else {
+    visualDebug->DisableRedrawRegions();
+  }
+
+  mDebugVisualRedrawRegions = debugVisualRedrawRegions;
+  return true;
+}
+
+void DCLayerTree::CompositorBeginFrame() {
+  mCurrentFrame++;
+  mUsedOverlayTypesInFrame = DCompOverlayTypes::NO_OVERLAY;
+}
+
+void DCLayerTree::CompositorEndFrame() {
+  auto start = TimeStamp::Now();
+  // Check if the visual tree of surfaces is the same as last frame.
+  bool same = mPrevLayers == mCurrentLayers;
+
+  if (!same) {
+    // If not, we need to rebuild the visual tree. Note that addition or
+    // removal of tiles no longer needs to rebuild the main visual tree
+    // here, since they are added as children of the surface visual.
+    mRootVisual->RemoveAllVisuals();
+  }
+
+  for (auto it = mCurrentLayers.begin(); it != mCurrentLayers.end(); ++it) {
+    auto surface_it = mDCSurfaces.find(*it);
+    MOZ_RELEASE_ASSERT(surface_it != mDCSurfaces.end());
+    const auto surface = surface_it->second.get();
+    // Ensure surface is trimmed to updated tile valid rects
+    surface->UpdateAllocatedRect();
+    if (!same) {
+      // Add surfaces in z-order they were added to the scene.
+      const auto visual = surface->GetVisual();
+      mRootVisual->AddVisual(visual, false, nullptr);
+    }
+  }
+
+  mPrevLayers.swap(mCurrentLayers);
+  mCurrentLayers.clear();
+
+  mCompositionDevice->Commit();
+
+  auto end = TimeStamp::Now();
+  mozilla::Telemetry::Accumulate(mozilla::Telemetry::COMPOSITE_SWAP_TIME,
+                                 (end - start).ToMilliseconds() * 10.);
+
+  // Remove any framebuffers that haven't been
+  // used in the last 60 frames.
+  //
+  // This should use nsTArray::RemoveElementsBy once
+  // CachedFrameBuffer is able to properly destroy
+  // itself in the destructor.
+  const auto gl = GetGLContext();
+  for (uint32_t i = 0, len = mFrameBuffers.Length(); i < len; ++i) {
+    auto& fb = mFrameBuffers[i];
+    if ((mCurrentFrame - fb.lastFrameUsed) > 60) {
+      gl->fDeleteRenderbuffers(1, &fb.depthRboId);
+      gl->fDeleteFramebuffers(1, &fb.fboId);
+      mFrameBuffers.UnorderedRemoveElementAt(i);
+      --i;  // Examine the element again, if necessary.
+      --len;
+    }
+  }
+
+  if (!StaticPrefs::gfx_webrender_dcomp_video_check_slow_present()) {
+    return;
+  }
+
+  // Disable video overlay if mCompositionDevice->Commit() with video overlay is
+  // too slow. It drops fps.
+
+  const auto maxCommitWaitDurationMs = 20;
+  const auto maxSlowCommitCount = 5;
+  const auto commitDurationMs =
+      static_cast<uint32_t>((end - start).ToMilliseconds());
+
+  nsPrintfCString marker("CommitWait overlay %u %ums ",
+                         (uint8_t)mUsedOverlayTypesInFrame, commitDurationMs);
+  PROFILER_MARKER_TEXT("CommitWait", GRAPHICS, {}, marker);
+
+  if (mUsedOverlayTypesInFrame != DCompOverlayTypes::NO_OVERLAY &&
+      commitDurationMs > maxCommitWaitDurationMs) {
+    mSlowCommitCount++;
+  } else {
+    mSlowCommitCount = 0;
+  }
+
+  if (mSlowCommitCount <= maxSlowCommitCount) {
+    return;
+  }
+
+  if (mUsedOverlayTypesInFrame & DCompOverlayTypes::SOFTWARE_DECODED_VIDEO) {
+    gfxCriticalNoteOnce << "Sw video swapchain present is slow";
+    RenderThread::Get()->NotifyWebRenderError(
+        wr::WebRenderError::VIDEO_SW_OVERLAY);
+  }
+  if (mUsedOverlayTypesInFrame & DCompOverlayTypes::HARDWARE_DECODED_VIDEO) {
+    gfxCriticalNoteOnce << "Hw video swapchain present is slow";
+    RenderThread::Get()->NotifyWebRenderError(
+        wr::WebRenderError::VIDEO_HW_OVERLAY);
+  }
+}
+
+void DCLayerTree::Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset,
+                       uint32_t* aFboId, wr::DeviceIntRect aDirtyRect,
+                       wr::DeviceIntRect aValidRect) {
+  auto surface = GetSurface(aId.surface_id);
+  auto tile = surface->GetTile(aId.x, aId.y);
+  wr::DeviceIntPoint targetOffset{0, 0};
+
+  // If tile owns an IDCompositionSurface we use it, otherwise we're using an
+  // IDCompositionVirtualSurface owned by the DCSurface.
+  RefPtr<IDCompositionSurface> compositionSurface;
+  if (surface->mIsVirtualSurface) {
+    gfx::IntRect validRect(aValidRect.min.x, aValidRect.min.y,
+                           aValidRect.width(), aValidRect.height());
+    if (!tile->mValidRect.IsEqualEdges(validRect)) {
+      tile->mValidRect = validRect;
+      surface->DirtyAllocatedRect();
+    }
+    wr::DeviceIntSize tileSize = surface->GetTileSize();
+    compositionSurface = surface->GetCompositionSurface();
+    wr::DeviceIntPoint virtualOffset = surface->GetVirtualOffset();
+    targetOffset.x = virtualOffset.x + tileSize.width * aId.x;
+    targetOffset.y = virtualOffset.y + tileSize.height * aId.y;
+  } else {
+    compositionSurface = tile->Bind(aValidRect);
+  }
+
+  if (tile->mNeedsFullDraw) {
+    // dcomp requires that the first BeginDraw on a non-virtual surface is the
+    // full size of the pixel buffer.
+    auto tileSize = surface->GetTileSize();
+    aDirtyRect.min.x = 0;
+    aDirtyRect.min.y = 0;
+    aDirtyRect.max.x = tileSize.width;
+    aDirtyRect.max.y = tileSize.height;
+    tile->mNeedsFullDraw = false;
+  }
+
+  *aFboId = CreateEGLSurfaceForCompositionSurface(
+      aDirtyRect, aOffset, compositionSurface, targetOffset);
+  mCurrentSurface = Some(compositionSurface);
+}
+
+void DCLayerTree::Unbind() {
+  if (mCurrentSurface.isNothing()) {
+    return;
+  }
+
+  RefPtr<IDCompositionSurface> surface = mCurrentSurface.ref();
+  surface->EndDraw();
+
+  DestroyEGLSurface();
+  mCurrentSurface = Nothing();
+}
+
+void DCLayerTree::CreateSurface(wr::NativeSurfaceId aId,
+                                wr::DeviceIntPoint aVirtualOffset,
+                                wr::DeviceIntSize aTileSize, bool aIsOpaque) {
+  auto it = mDCSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(it == mDCSurfaces.end());
+  if (it != mDCSurfaces.end()) {
+    // DCSurface already exists.
+    return;
+  }
+
+  // Tile size needs to be positive.
+  if (aTileSize.width <= 0 || aTileSize.height <= 0) {
+    gfxCriticalNote << "TileSize is not positive aId: " << wr::AsUint64(aId)
+                    << " aTileSize(" << aTileSize.width << ","
+                    << aTileSize.height << ")";
+  }
+
+  bool isVirtualSurface =
+      StaticPrefs::gfx_webrender_dcomp_use_virtual_surfaces_AtStartup();
+  auto surface = MakeUnique<DCSurface>(aTileSize, aVirtualOffset,
+                                       isVirtualSurface, aIsOpaque, this);
+  if (!surface->Initialize()) {
+    gfxCriticalNote << "Failed to initialize DCSurface: " << wr::AsUint64(aId);
+    return;
+  }
+
+  mDCSurfaces[aId] = std::move(surface);
+}
+
+void DCLayerTree::CreateExternalSurface(wr::NativeSurfaceId aId,
+                                        bool aIsOpaque) {
+  auto it = mDCSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(it == mDCSurfaces.end());
+
+  auto surface = MakeUnique<DCExternalSurfaceWrapper>(aIsOpaque, this);
+  if (!surface->Initialize()) {
+    gfxCriticalNote << "Failed to initialize DCExternalSurfaceWrapper: "
+                    << wr::AsUint64(aId);
+    return;
+  }
+
+  mDCSurfaces[aId] = std::move(surface);
+}
+
+void DCLayerTree::DestroySurface(NativeSurfaceId aId) {
+  auto surface_it = mDCSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surface_it != mDCSurfaces.end());
+  auto surface = surface_it->second.get();
+
+  mRootVisual->RemoveVisual(surface->GetVisual());
+  mDCSurfaces.erase(surface_it);
+}
+
+void DCLayerTree::CreateTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) {
+  auto surface = GetSurface(aId);
+  surface->CreateTile(aX, aY);
+}
+
+void DCLayerTree::DestroyTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) {
+  auto surface = GetSurface(aId);
+  surface->DestroyTile(aX, aY);
+}
+
+void DCLayerTree::AttachExternalImage(wr::NativeSurfaceId aId,
+                                      wr::ExternalImageId aExternalImage) {
+  auto surface_it = mDCSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surface_it != mDCSurfaces.end());
+  surface_it->second->AttachExternalImage(aExternalImage);
+}
+
+void DCExternalSurfaceWrapper::AttachExternalImage(
+    wr::ExternalImageId aExternalImage) {
+  if (auto* surface = EnsureSurfaceForExternalImage(aExternalImage)) {
+    surface->AttachExternalImage(aExternalImage);
+  }
+}
+
+template <class ToT>
+struct QI {
+  template <class FromT>
+  [[nodiscard]] static inline RefPtr<ToT> From(FromT* const from) {
+    RefPtr<ToT> to;
+    (void)from->QueryInterface(static_cast<ToT**>(getter_AddRefs(to)));
+    return to;
+  }
+};
+
+DCSurface* DCExternalSurfaceWrapper::EnsureSurfaceForExternalImage(
+    wr::ExternalImageId aExternalImage) {
+  if (mSurface) {
+    return mSurface.get();
+  }
+
+  // Create a new surface based on the texture type.
+  RenderTextureHost* texture =
+      RenderThread::Get()->GetRenderTexture(aExternalImage);
+  if (texture && texture->AsRenderDXGITextureHost()) {
+    mSurface.reset(new DCSurfaceVideo(mIsOpaque, mDCLayerTree));
+    if (!mSurface->Initialize()) {
+      gfxCriticalNote << "Failed to initialize DCSurfaceVideo: "
+                      << wr::AsUint64(aExternalImage);
+      mSurface = nullptr;
+    }
+  } else if (texture && texture->AsRenderDcompSurfaceTextureHost()) {
+    mSurface.reset(new DCSurfaceHandle(mIsOpaque, mDCLayerTree));
+    if (!mSurface->Initialize()) {
+      gfxCriticalNote << "Failed to initialize DCSurfaceHandle: "
+                      << wr::AsUint64(aExternalImage);
+      mSurface = nullptr;
+    }
+  }
+  if (!mSurface) {
+    gfxCriticalNote << "Failed to create a surface for external image: "
+                    << gfx::hexa(texture);
+    return nullptr;
+  }
+
+  // Add surface's visual which will contain video data to our root visual.
+  const auto surfaceVisual = mSurface->GetVisual();
+  mVisual->AddVisual(surfaceVisual, true, nullptr);
+
+  // -
+  // Apply color management.
+
+  [&]() {
+    const auto cmsMode = GfxColorManagementMode();
+    if (cmsMode == CMSMode::Off) return;
+
+    const auto dcomp = mDCLayerTree->GetCompositionDevice();
+    const auto dcomp3 = QI<IDCompositionDevice3>::From(dcomp);
+    if (!dcomp3) {
+      NS_WARNING(
+          "No IDCompositionDevice3, cannot use dcomp for color management.");
+      return;
+    }
+
+    // -
+
+    const auto cspace = [&]() {
+      const auto rangedCspace = texture->GetYUVColorSpace();
+      const auto info = FromYUVRangedColorSpace(rangedCspace);
+      auto ret = ToColorSpace2(info.space);
+      if (ret == gfx::ColorSpace2::Display && cmsMode == CMSMode::All) {
+        ret = gfx::ColorSpace2::SRGB;
+      }
+      return ret;
+    }();
+
+    const bool rec709GammaAsSrgb =
+        StaticPrefs::gfx_color_management_rec709_gamma_as_srgb();
+    const bool rec2020GammaAsRec709 =
+        StaticPrefs::gfx_color_management_rec2020_gamma_as_rec709();
+
+    auto cspaceDesc = color::ColorspaceDesc{};
+    switch (cspace) {
+      case gfx::ColorSpace2::Display:
+        return;  // No color management needed!
+      case gfx::ColorSpace2::SRGB:
+        cspaceDesc.chrom = color::Chromaticities::Srgb();
+        cspaceDesc.tf = color::PiecewiseGammaDesc::Srgb();
+        break;
+
+      case gfx::ColorSpace2::DISPLAY_P3:
+        cspaceDesc.chrom = color::Chromaticities::DisplayP3();
+        cspaceDesc.tf = color::PiecewiseGammaDesc::DisplayP3();
+        break;
+
+      case gfx::ColorSpace2::BT601_525:
+        cspaceDesc.chrom = color::Chromaticities::Rec601_525_Ntsc();
+        if (rec709GammaAsSrgb) {
+          cspaceDesc.tf = color::PiecewiseGammaDesc::Srgb();
+        } else {
+          cspaceDesc.tf = color::PiecewiseGammaDesc::Rec709();
+        }
+        break;
+
+      case gfx::ColorSpace2::BT709:
+        cspaceDesc.chrom = color::Chromaticities::Rec709();
+        if (rec709GammaAsSrgb) {
+          cspaceDesc.tf = color::PiecewiseGammaDesc::Srgb();
+        } else {
+          cspaceDesc.tf = color::PiecewiseGammaDesc::Rec709();
+        }
+        break;
+
+      case gfx::ColorSpace2::BT2020:
+        cspaceDesc.chrom = color::Chromaticities::Rec2020();
+        if (rec2020GammaAsRec709 && rec709GammaAsSrgb) {
+          cspaceDesc.tf = color::PiecewiseGammaDesc::Srgb();
+        } else if (rec2020GammaAsRec709) {
+          cspaceDesc.tf = color::PiecewiseGammaDesc::Rec709();
+        } else {
+          // Just Rec709 with slightly more precision.
+          cspaceDesc.tf = color::PiecewiseGammaDesc::Rec2020_12bit();
+        }
+        break;
+    }
+
+    const auto cprofileIn = color::ColorProfileDesc::From(cspaceDesc);
+    auto cprofileOut = mDCLayerTree->OutputColorProfile();
+    bool pretendSrgb = true;
+    if (pretendSrgb) {
+      cprofileOut = color::ColorProfileDesc::From({
+          color::Chromaticities::Srgb(),
+          color::PiecewiseGammaDesc::Srgb(),
+      });
+    }
+    const auto conversion = color::ColorProfileConversionDesc::From({
+        .src = cprofileIn,
+        .dst = cprofileOut,
+    });
+
+    // -
+
+    auto chain = ColorManagementChain::From(*dcomp3, conversion);
+    mCManageChain = Some(chain);
+
+    surfaceVisual->SetEffect(mCManageChain->last.get());
+  }();
+
+  return mSurface.get();
+}
+
+void DCExternalSurfaceWrapper::PresentExternalSurface(gfx::Matrix& aTransform) {
+  MOZ_ASSERT(mSurface);
+  if (auto* surface = mSurface->AsDCSurfaceVideo()) {
+    if (surface->CalculateSwapChainSize(aTransform)) {
+      surface->PresentVideo();
+    }
+  } else if (auto* surface = mSurface->AsDCSurfaceHandle()) {
+    surface->PresentSurfaceHandle();
+  }
+}
+
+template <typename T>
+static inline D2D1_RECT_F D2DRect(const T& aRect) {
+  return D2D1::RectF(aRect.X(), aRect.Y(), aRect.XMost(), aRect.YMost());
+}
+
+static inline D2D1_MATRIX_3X2_F D2DMatrix(const gfx::Matrix& aTransform) {
+  return D2D1::Matrix3x2F(aTransform._11, aTransform._12, aTransform._21,
+                          aTransform._22, aTransform._31, aTransform._32);
+}
+
+void DCLayerTree::AddSurface(wr::NativeSurfaceId aId,
+                             const wr::CompositorSurfaceTransform& aTransform,
+                             wr::DeviceIntRect aClipRect,
+                             wr::ImageRendering aImageRendering) {
+  auto it = mDCSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(it != mDCSurfaces.end());
+  const auto surface = it->second.get();
+  const auto visual = surface->GetVisual();
+
+  wr::DeviceIntPoint virtualOffset = surface->GetVirtualOffset();
+
+  float sx = aTransform.scale.x;
+  float sy = aTransform.scale.y;
+  float tx = aTransform.offset.x;
+  float ty = aTransform.offset.y;
+  gfx::Matrix transform(sx, 0.0, 0.0, sy, tx, ty);
+
+  surface->PresentExternalSurface(transform);
+
+  transform.PreTranslate(-virtualOffset.x, -virtualOffset.y);
+
+  // The DirectComposition API applies clipping *before* any
+  // transforms/offset, whereas we want the clip applied after. Right now, we
+  // only support rectilinear transforms, and then we transform our clip into
+  // pre-transform coordinate space for it to be applied there.
+  // DirectComposition does have an option for pre-transform clipping, if you
+  // create an explicit IDCompositionEffectGroup object and set a 3D transform
+  // on that. I suspect that will perform worse though, so we should only do
+  // that for complex transforms (which are never provided right now).
+  MOZ_ASSERT(transform.IsRectilinear());
+  gfx::Rect clip = transform.Inverse().TransformBounds(gfx::Rect(
+      aClipRect.min.x, aClipRect.min.y, aClipRect.width(), aClipRect.height()));
+  // Set the clip rect - converting from world space to the pre-offset space
+  // that DC requires for rectangle clips.
+  visual->SetClip(D2DRect(clip));
+
+  // TODO: The input matrix is a 4x4, but we only support a 3x2 at
+  // the D3D API level (unless we QI to IDCompositionVisual3, which might
+  // not be available?).
+  // Should we assert here, or restrict at the WR API level.
+  visual->SetTransform(D2DMatrix(transform));
+
+  if (aImageRendering == wr::ImageRendering::Auto) {
+    visual->SetBitmapInterpolationMode(
+        DCOMPOSITION_BITMAP_INTERPOLATION_MODE_LINEAR);
+  } else {
+    visual->SetBitmapInterpolationMode(
+        DCOMPOSITION_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
+  }
+
+  mCurrentLayers.push_back(aId);
+}
+
+GLuint DCLayerTree::GetOrCreateFbo(int aWidth, int aHeight) {
+  const auto gl = GetGLContext();
+  GLuint fboId = 0;
+
+  // Check if we have a cached FBO with matching dimensions
+  for (auto it = mFrameBuffers.begin(); it != mFrameBuffers.end(); ++it) {
+    if (it->width == aWidth && it->height == aHeight) {
+      fboId = it->fboId;
+      it->lastFrameUsed = mCurrentFrame;
+      break;
+    }
+  }
+
+  // If not, create a new FBO with attached depth buffer
+  if (fboId == 0) {
+    // Create the depth buffer
+    GLuint depthRboId;
+    gl->fGenRenderbuffers(1, &depthRboId);
+    gl->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, depthRboId);
+    gl->fRenderbufferStorage(LOCAL_GL_RENDERBUFFER, LOCAL_GL_DEPTH_COMPONENT24,
+                             aWidth, aHeight);
+
+    // Create the framebuffer and attach the depth buffer to it
+    gl->fGenFramebuffers(1, &fboId);
+    gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fboId);
+    gl->fFramebufferRenderbuffer(LOCAL_GL_DRAW_FRAMEBUFFER,
+                                 LOCAL_GL_DEPTH_ATTACHMENT,
+                                 LOCAL_GL_RENDERBUFFER, depthRboId);
+
+    // Store this in the cache for future calls.
+    // TODO(gw): Maybe we should periodically scan this list and remove old
+    // entries that
+    //           haven't been used for some time?
+    DCLayerTree::CachedFrameBuffer frame_buffer_info;
+    frame_buffer_info.width = aWidth;
+    frame_buffer_info.height = aHeight;
+    frame_buffer_info.fboId = fboId;
+    frame_buffer_info.depthRboId = depthRboId;
+    frame_buffer_info.lastFrameUsed = mCurrentFrame;
+    mFrameBuffers.AppendElement(frame_buffer_info);
+  }
+
+  return fboId;
+}
+
+bool DCLayerTree::EnsureVideoProcessor(const gfx::IntSize& aInputSize,
+                                       const gfx::IntSize& aOutputSize) {
+  HRESULT hr;
+
+  if (!mVideoDevice || !mVideoContext) {
+    return false;
+  }
+
+  if (mVideoProcessor && (aInputSize <= mVideoInputSize) &&
+      (aOutputSize <= mVideoOutputSize)) {
+    return true;
+  }
+
+  mVideoProcessor = nullptr;
+  mVideoProcessorEnumerator = nullptr;
+
+  D3D11_VIDEO_PROCESSOR_CONTENT_DESC desc = {};
+  desc.InputFrameFormat = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
+  desc.InputFrameRate.Numerator = 60;
+  desc.InputFrameRate.Denominator = 1;
+  desc.InputWidth = aInputSize.width;
+  desc.InputHeight = aInputSize.height;
+  desc.OutputFrameRate.Numerator = 60;
+  desc.OutputFrameRate.Denominator = 1;
+  desc.OutputWidth = aOutputSize.width;
+  desc.OutputHeight = aOutputSize.height;
+  desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL;
+
+  hr = mVideoDevice->CreateVideoProcessorEnumerator(
+      &desc, getter_AddRefs(mVideoProcessorEnumerator));
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to create VideoProcessorEnumerator: "
+                    << gfx::hexa(hr);
+    return false;
+  }
+
+  hr = mVideoDevice->CreateVideoProcessor(mVideoProcessorEnumerator, 0,
+                                          getter_AddRefs(mVideoProcessor));
+  if (FAILED(hr)) {
+    mVideoProcessor = nullptr;
+    mVideoProcessorEnumerator = nullptr;
+    gfxCriticalNote << "Failed to create VideoProcessor: " << gfx::hexa(hr);
+    return false;
+  }
+
+  // Reduce power cosumption
+  // By default, the driver might perform certain processing tasks
+  // automatically
+  mVideoContext->VideoProcessorSetStreamAutoProcessingMode(mVideoProcessor, 0,
+                                                           FALSE);
+
+  mVideoInputSize = aInputSize;
+  mVideoOutputSize = aOutputSize;
+
+  return true;
+}
+
+bool DCLayerTree::SupportsHardwareOverlays() {
+  return sGpuOverlayInfo->mSupportsHardwareOverlays;
+}
+
+bool DCLayerTree::SupportsSwapChainTearing() {
+  RefPtr<ID3D11Device> device = mDevice;
+  static const bool supported = [device] {
+    RefPtr<IDXGIDevice> dxgiDevice;
+    RefPtr<IDXGIAdapter> adapter;
+    device->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice));
+    dxgiDevice->GetAdapter(getter_AddRefs(adapter));
+
+    RefPtr<IDXGIFactory5> dxgiFactory;
+    HRESULT hr = adapter->GetParent(
+        IID_PPV_ARGS((IDXGIFactory5**)getter_AddRefs(dxgiFactory)));
+    if (FAILED(hr)) {
+      return false;
+    }
+
+    BOOL presentAllowTearing = FALSE;
+    hr = dxgiFactory->CheckFeatureSupport(DXGI_FEATURE_PRESENT_ALLOW_TEARING,
+                                          &presentAllowTearing,
+                                          sizeof(presentAllowTearing));
+    if (FAILED(hr)) {
+      return false;
+    }
+
+    if (auto* gpuParent = gfx::GPUParent::GetSingleton()) {
+      gpuParent->NotifySwapChainInfo(
+          layers::SwapChainInfo(!!presentAllowTearing));
+    } else if (XRE_IsParentProcess()) {
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    }
+    return !!presentAllowTearing;
+  }();
+  return supported;
+}
+
+DXGI_FORMAT DCLayerTree::GetOverlayFormatForSDR() {
+  return sGpuOverlayInfo->mOverlayFormatUsed;
+}
+
+static layers::OverlaySupportType FlagsToOverlaySupportType(
+    UINT aFlags, bool aSoftwareOverlaySupported) {
+  if (aFlags & DXGI_OVERLAY_SUPPORT_FLAG_SCALING) {
+    return layers::OverlaySupportType::Scaling;
+  }
+  if (aFlags & DXGI_OVERLAY_SUPPORT_FLAG_DIRECT) {
+    return layers::OverlaySupportType::Direct;
+  }
+  if (aSoftwareOverlaySupported) {
+    return layers::OverlaySupportType::Software;
+  }
+  return layers::OverlaySupportType::None;
+}
+
+layers::OverlayInfo DCLayerTree::GetOverlayInfo() {
+  layers::OverlayInfo info;
+
+  info.mSupportsOverlays = sGpuOverlayInfo->mSupportsHardwareOverlays;
+  info.mNv12Overlay =
+      FlagsToOverlaySupportType(sGpuOverlayInfo->mNv12OverlaySupportFlags,
+                                /* aSoftwareOverlaySupported */ false);
+  info.mYuy2Overlay =
+      FlagsToOverlaySupportType(sGpuOverlayInfo->mYuy2OverlaySupportFlags,
+                                /* aSoftwareOverlaySupported */ false);
+  info.mBgra8Overlay =
+      FlagsToOverlaySupportType(sGpuOverlayInfo->mBgra8OverlaySupportFlags,
+                                /* aSoftwareOverlaySupported */ true);
+  info.mRgb10a2Overlay =
+      FlagsToOverlaySupportType(sGpuOverlayInfo->mRgb10a2OverlaySupportFlags,
+                                /* aSoftwareOverlaySupported */ false);
+
+  return info;
+}
+
+void DCLayerTree::SetUsedOverlayTypeInFrame(DCompOverlayTypes aTypes) {
+  mUsedOverlayTypesInFrame |= aTypes;
+}
+
+DCSurface::DCSurface(wr::DeviceIntSize aTileSize,
+                     wr::DeviceIntPoint aVirtualOffset, bool aIsVirtualSurface,
+                     bool aIsOpaque, DCLayerTree* aDCLayerTree)
+    : mIsVirtualSurface(aIsVirtualSurface),
+      mDCLayerTree(aDCLayerTree),
+      mTileSize(aTileSize),
+      mIsOpaque(aIsOpaque),
+      mAllocatedRectDirty(true),
+      mVirtualOffset(aVirtualOffset) {}
+
+DCSurface::~DCSurface() {}
+
+bool DCSurface::Initialize() {
+  // Create a visual for tiles to attach to, whether virtual or not.
+  HRESULT hr;
+  const auto dCompDevice = mDCLayerTree->GetCompositionDevice();
+  hr = dCompDevice->CreateVisual(getter_AddRefs(mVisual));
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to create DCompositionVisual: " << gfx::hexa(hr);
+    return false;
+  }
+
+  // If virtual surface is enabled, create and attach to visual, in this case
+  // the tiles won't own visuals or surfaces.
+  if (mIsVirtualSurface) {
+    DXGI_ALPHA_MODE alpha_mode =
+        mIsOpaque ? DXGI_ALPHA_MODE_IGNORE : DXGI_ALPHA_MODE_PREMULTIPLIED;
+
+    hr = dCompDevice->CreateVirtualSurface(
+        VIRTUAL_SURFACE_SIZE, VIRTUAL_SURFACE_SIZE, DXGI_FORMAT_R8G8B8A8_UNORM,
+        alpha_mode, getter_AddRefs(mVirtualSurface));
+    MOZ_ASSERT(SUCCEEDED(hr));
+
+    // Bind the surface memory to this visual
+    hr = mVisual->SetContent(mVirtualSurface);
+    MOZ_ASSERT(SUCCEEDED(hr));
+  }
+
+  return true;
+}
+
+void DCSurface::CreateTile(int32_t aX, int32_t aY) {
+  TileKey key(aX, aY);
+  MOZ_RELEASE_ASSERT(mDCTiles.find(key) == mDCTiles.end());
+
+  auto tile = MakeUnique<DCTile>(mDCLayerTree);
+  if (!tile->Initialize(aX, aY, mTileSize, mIsVirtualSurface, mIsOpaque,
+                        mVisual)) {
+    gfxCriticalNote << "Failed to initialize DCTile: " << aX << aY;
+    return;
+  }
+
+  if (mIsVirtualSurface) {
+    mAllocatedRectDirty = true;
+  } else {
+    mVisual->AddVisual(tile->GetVisual(), false, nullptr);
+  }
+
+  mDCTiles[key] = std::move(tile);
+}
+
+void DCSurface::DestroyTile(int32_t aX, int32_t aY) {
+  TileKey key(aX, aY);
+  if (mIsVirtualSurface) {
+    mAllocatedRectDirty = true;
+  } else {
+    auto tile = GetTile(aX, aY);
+    mVisual->RemoveVisual(tile->GetVisual());
+  }
+  mDCTiles.erase(key);
+}
+
+void DCSurface::DirtyAllocatedRect() { mAllocatedRectDirty = true; }
+
+void DCSurface::UpdateAllocatedRect() {
+  if (mAllocatedRectDirty) {
+    if (mVirtualSurface) {
+      // The virtual surface may have holes in it (for example, an empty tile
+      // that has no primitives). Instead of trimming to a single bounding
+      // rect, supply the rect of each valid tile to handle this case.
+      std::vector<RECT> validRects;
+
+      for (auto it = mDCTiles.begin(); it != mDCTiles.end(); ++it) {
+        auto tile = GetTile(it->first.mX, it->first.mY);
+        RECT rect;
+
+        rect.left = (LONG)(mVirtualOffset.x + it->first.mX * mTileSize.width +
+                           tile->mValidRect.x);
+        rect.top = (LONG)(mVirtualOffset.y + it->first.mY * mTileSize.height +
+                          tile->mValidRect.y);
+        rect.right = rect.left + tile->mValidRect.width;
+        rect.bottom = rect.top + tile->mValidRect.height;
+
+        validRects.push_back(rect);
+      }
+
+      mVirtualSurface->Trim(validRects.data(), validRects.size());
+    }
+    // When not using a virtual surface, we still want to reset this
+    mAllocatedRectDirty = false;
+  }
+}
+
+DCTile* DCSurface::GetTile(int32_t aX, int32_t aY) const {
+  TileKey key(aX, aY);
+  auto tile_it = mDCTiles.find(key);
+  MOZ_RELEASE_ASSERT(tile_it != mDCTiles.end());
+  return tile_it->second.get();
+}
+
+DCSurfaceVideo::DCSurfaceVideo(bool aIsOpaque, DCLayerTree* aDCLayerTree)
+    : DCSurface(wr::DeviceIntSize{}, wr::DeviceIntPoint{}, false, aIsOpaque,
+                aDCLayerTree),
+      mSwapChainBufferCount(
+          StaticPrefs::gfx_webrender_dcomp_video_force_triple_buffering() ? 3
+                                                                          : 2) {
+}
+
+DCSurfaceVideo::~DCSurfaceVideo() {
+  ReleaseDecodeSwapChainResources();
+  MOZ_ASSERT(!mSwapChainSurfaceHandle);
+}
+
+bool IsYUVSwapChainFormat(DXGI_FORMAT aFormat) {
+  if (aFormat == DXGI_FORMAT_NV12 || aFormat == DXGI_FORMAT_YUY2) {
+    return true;
+  }
+  return false;
+}
+
+void DCSurfaceVideo::AttachExternalImage(wr::ExternalImageId aExternalImage) {
+  RenderTextureHost* texture =
+      RenderThread::Get()->GetRenderTexture(aExternalImage);
+  MOZ_RELEASE_ASSERT(texture);
+
+  if (mPrevTexture == texture) {
+    return;
+  }
+
+  // XXX if software decoded video frame format is nv12, it could be used as
+  // video overlay.
+  if (!texture || !texture->AsRenderDXGITextureHost() ||
+      texture->GetFormat() != gfx::SurfaceFormat::NV12) {
+    gfxCriticalNote << "Unsupported RenderTexture for overlay: "
+                    << gfx::hexa(texture);
+    return;
+  }
+
+  mRenderTextureHost = texture;
+}
+
+bool DCSurfaceVideo::CalculateSwapChainSize(gfx::Matrix& aTransform) {
+  if (!mRenderTextureHost) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return false;
+  }
+
+  const auto overlayType = mRenderTextureHost->IsSoftwareDecodedVideo()
+                               ? DCompOverlayTypes::SOFTWARE_DECODED_VIDEO
+                               : DCompOverlayTypes::HARDWARE_DECODED_VIDEO;
+  mDCLayerTree->SetUsedOverlayTypeInFrame(overlayType);
+
+  mVideoSize = mRenderTextureHost->AsRenderDXGITextureHost()->GetSize(0);
+
+  // When RenderTextureHost, swapChainSize or VideoSwapChain are updated,
+  // DCSurfaceVideo::PresentVideo() needs to be called.
+  bool needsToPresent = mPrevTexture != mRenderTextureHost;
+  gfx::IntSize swapChainSize = mVideoSize;
+  gfx::Matrix transform = aTransform;
+  const bool isDRM = mRenderTextureHost->IsFromDRMSource();
+
+  // When video is rendered to axis aligned integer rectangle, video scaling
+  // could be done by VideoProcessor
+  bool scaleVideoAtVideoProcessor = false;
+  if (StaticPrefs::gfx_webrender_dcomp_video_vp_scaling_win_AtStartup() &&
+      aTransform.PreservesAxisAlignedRectangles()) {
+    gfx::Size scaledSize = gfx::Size(mVideoSize) * aTransform.ScaleFactors();
+    gfx::IntSize size(int32_t(std::round(scaledSize.width)),
+                      int32_t(std::round(scaledSize.height)));
+    if (gfx::FuzzyEqual(scaledSize.width, size.width, 0.1f) &&
+        gfx::FuzzyEqual(scaledSize.height, size.height, 0.1f)) {
+      scaleVideoAtVideoProcessor = true;
+      swapChainSize = size;
+    }
+  }
+
+  if (scaleVideoAtVideoProcessor) {
+    // 4:2:2 subsampled formats like YUY2 must have an even width, and 4:2:0
+    // subsampled formats like NV12 must have an even width and height.
+    if (swapChainSize.width % 2 == 1) {
+      swapChainSize.width += 1;
+    }
+    if (swapChainSize.height % 2 == 1) {
+      swapChainSize.height += 1;
+    }
+    transform = gfx::Matrix::Translation(aTransform.GetTranslation());
+  }
+
+  if (!mVideoSwapChain || mSwapChainSize != swapChainSize || mIsDRM != isDRM) {
+    needsToPresent = true;
+    ReleaseDecodeSwapChainResources();
+    // Update mSwapChainSize before creating SwapChain
+    mSwapChainSize = swapChainSize;
+    mIsDRM = isDRM;
+
+    auto swapChainFormat = GetSwapChainFormat();
+    bool useYUVSwapChain = IsYUVSwapChainFormat(swapChainFormat);
+    if (useYUVSwapChain) {
+      // Tries to create YUV SwapChain
+      CreateVideoSwapChain();
+      if (!mVideoSwapChain) {
+        mFailedYuvSwapChain = true;
+        ReleaseDecodeSwapChainResources();
+
+        gfxCriticalNote << "Fallback to RGB SwapChain";
+      }
+    }
+    // Tries to create RGB SwapChain
+    if (!mVideoSwapChain) {
+      CreateVideoSwapChain();
+    }
+  }
+
+  aTransform = transform;
+
+  return needsToPresent;
+}
+
+void DCSurfaceVideo::PresentVideo() {
+  if (!mRenderTextureHost) {
+    return;
+  }
+
+  if (!mVideoSwapChain) {
+    gfxCriticalNote << "Failed to create VideoSwapChain";
+    RenderThread::Get()->NotifyWebRenderError(
+        wr::WebRenderError::VIDEO_OVERLAY);
+    return;
+  }
+
+  mVisual->SetContent(mVideoSwapChain);
+
+  if (!CallVideoProcessorBlt()) {
+    auto swapChainFormat = GetSwapChainFormat();
+    bool useYUVSwapChain = IsYUVSwapChainFormat(swapChainFormat);
+    if (useYUVSwapChain) {
+      mFailedYuvSwapChain = true;
+      ReleaseDecodeSwapChainResources();
+      return;
+    }
+    RenderThread::Get()->NotifyWebRenderError(
+        wr::WebRenderError::VIDEO_OVERLAY);
+    return;
+  }
+
+  const auto device = mDCLayerTree->GetDevice();
+  HRESULT hr;
+  if (mFirstPresent) {
+    mFirstPresent = false;
+    UINT flags = DXGI_PRESENT_USE_DURATION;
+    // DirectComposition can display black for a swap chain between the first
+    // and second time it's presented to - maybe the first Present can get lost
+    // somehow and it shows the wrong buffer. In that case copy the buffers so
+    // all have the correct contents, which seems to help. The first Present()
+    // after this needs to have SyncInterval > 0, or else the workaround doesn't
+    // help.
+    for (size_t i = 0; i < mSwapChainBufferCount - 1; ++i) {
+      hr = mVideoSwapChain->Present(0, flags);
+      // Ignore DXGI_STATUS_OCCLUDED since that's not an error but only
+      // indicates that the window is occluded and we can stop rendering.
+      if (FAILED(hr) && hr != DXGI_STATUS_OCCLUDED) {
+        gfxCriticalNoteOnce << "video Present failed during first present: "
+                            << gfx::hexa(hr);
+        return;
+      }
+
+      RefPtr<ID3D11Texture2D> destTexture;
+      mVideoSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+                                 (void**)getter_AddRefs(destTexture));
+      MOZ_ASSERT(destTexture);
+      RefPtr<ID3D11Texture2D> srcTexture;
+      hr = mVideoSwapChain->GetBuffer(1, __uuidof(ID3D11Texture2D),
+                                      (void**)getter_AddRefs(srcTexture));
+      MOZ_ASSERT(srcTexture);
+      RefPtr<ID3D11DeviceContext> context;
+      device->GetImmediateContext(getter_AddRefs(context));
+      MOZ_ASSERT(context);
+      context->CopyResource(destTexture, srcTexture);
+    }
+
+    // Additionally wait for the GPU to finish executing its commands, or
+    // there still may be a black flicker when presenting expensive content
+    // (e.g. 4k video).
+
+    RefPtr<IDXGIDevice2> dxgiDevice2;
+    device->QueryInterface((IDXGIDevice2**)getter_AddRefs(dxgiDevice2));
+    MOZ_ASSERT(dxgiDevice2);
+
+    HANDLE event = ::CreateEvent(nullptr, false, false, nullptr);
+    hr = dxgiDevice2->EnqueueSetEvent(event);
+    if (SUCCEEDED(hr)) {
+      DebugOnly<DWORD> result = ::WaitForSingleObject(event, INFINITE);
+      MOZ_ASSERT(result == WAIT_OBJECT_0);
+    } else {
+      gfxCriticalNoteOnce << "EnqueueSetEvent failed: " << gfx::hexa(hr);
+    }
+    ::CloseHandle(event);
+  }
+
+  UINT flags = DXGI_PRESENT_USE_DURATION;
+  UINT interval = 1;
+  if (StaticPrefs::gfx_webrender_dcomp_video_swap_chain_present_interval_0()) {
+    interval = 0;
+  }
+
+  auto start = TimeStamp::Now();
+  hr = mVideoSwapChain->Present(interval, flags);
+  auto end = TimeStamp::Now();
+
+  if (FAILED(hr) && hr != DXGI_STATUS_OCCLUDED) {
+    gfxCriticalNoteOnce << "video Present failed: " << gfx::hexa(hr);
+  }
+
+  mPrevTexture = mRenderTextureHost;
+
+  // Disable video overlay if mVideoSwapChain->Present() is too slow. It drops
+  // fps.
+
+  if (!StaticPrefs::gfx_webrender_dcomp_video_check_slow_present()) {
+    return;
+  }
+
+  const auto maxPresentWaitDurationMs = 2;
+  const auto maxSlowPresentCount = 5;
+  const auto presentDurationMs =
+      static_cast<uint32_t>((end - start).ToMilliseconds());
+  const auto overlayType = mRenderTextureHost->IsSoftwareDecodedVideo()
+                               ? DCompOverlayTypes::SOFTWARE_DECODED_VIDEO
+                               : DCompOverlayTypes::HARDWARE_DECODED_VIDEO;
+
+  nsPrintfCString marker("PresentWait overlay %u %ums ", (uint8_t)overlayType,
+                         presentDurationMs);
+  PROFILER_MARKER_TEXT("PresentWait", GRAPHICS, {}, marker);
+
+  if (presentDurationMs > maxPresentWaitDurationMs) {
+    mSlowPresentCount++;
+  } else {
+    mSlowPresentCount = 0;
+  }
+
+  if (mSlowPresentCount <= maxSlowPresentCount) {
+    return;
+  }
+
+  if (overlayType == DCompOverlayTypes::SOFTWARE_DECODED_VIDEO) {
+    gfxCriticalNoteOnce << "Sw video swapchain present is slow";
+    RenderThread::Get()->NotifyWebRenderError(
+        wr::WebRenderError::VIDEO_SW_OVERLAY);
+  } else {
+    gfxCriticalNoteOnce << "Hw video swapchain present is slow";
+    RenderThread::Get()->NotifyWebRenderError(
+        wr::WebRenderError::VIDEO_HW_OVERLAY);
+  }
+}
+
+DXGI_FORMAT DCSurfaceVideo::GetSwapChainFormat() {
+  if (mFailedYuvSwapChain || !mDCLayerTree->SupportsHardwareOverlays()) {
+    return DXGI_FORMAT_B8G8R8A8_UNORM;
+  }
+  return mDCLayerTree->GetOverlayFormatForSDR();
+}
+
+bool DCSurfaceVideo::CreateVideoSwapChain() {
+  MOZ_ASSERT(mRenderTextureHost);
+
+  mFirstPresent = true;
+
+  const auto device = mDCLayerTree->GetDevice();
+
+  RefPtr<IDXGIDevice> dxgiDevice;
+  device->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice));
+
+  RefPtr<IDXGIFactoryMedia> dxgiFactoryMedia;
+  {
+    RefPtr<IDXGIAdapter> adapter;
+    dxgiDevice->GetAdapter(getter_AddRefs(adapter));
+    adapter->GetParent(
+        IID_PPV_ARGS((IDXGIFactoryMedia**)getter_AddRefs(dxgiFactoryMedia)));
+  }
+
+  mSwapChainSurfaceHandle = gfx::DeviceManagerDx::CreateDCompSurfaceHandle();
+  if (!mSwapChainSurfaceHandle) {
+    gfxCriticalNote << "Failed to create DCompSurfaceHandle";
+    return false;
+  }
+
+  auto swapChainFormat = GetSwapChainFormat();
+
+  DXGI_SWAP_CHAIN_DESC1 desc = {};
+  desc.Width = mSwapChainSize.width;
+  desc.Height = mSwapChainSize.height;
+  desc.Format = swapChainFormat;
+  desc.Stereo = FALSE;
+  desc.SampleDesc.Count = 1;
+  desc.BufferCount = mSwapChainBufferCount;
+  desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+  desc.Scaling = DXGI_SCALING_STRETCH;
+  desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
+  desc.Flags = DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO;
+  if (IsYUVSwapChainFormat(swapChainFormat)) {
+    desc.Flags |= DXGI_SWAP_CHAIN_FLAG_YUV_VIDEO;
+  }
+  if (mIsDRM) {
+    desc.Flags |= DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY;
+  }
+  desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
+
+  HRESULT hr;
+  hr = dxgiFactoryMedia->CreateSwapChainForCompositionSurfaceHandle(
+      device, mSwapChainSurfaceHandle, &desc, nullptr,
+      getter_AddRefs(mVideoSwapChain));
+
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to create video SwapChain: " << gfx::hexa(hr)
+                    << " " << mSwapChainSize;
+    return false;
+  }
+
+  mSwapChainFormat = swapChainFormat;
+  return true;
+}
+
+// TODO: Replace with YUVRangedColorSpace
+static Maybe<DXGI_COLOR_SPACE_TYPE> GetSourceDXGIColorSpace(
+    const gfx::YUVColorSpace aYUVColorSpace,
+    const gfx::ColorRange aColorRange) {
+  if (aYUVColorSpace == gfx::YUVColorSpace::BT601) {
+    if (aColorRange == gfx::ColorRange::FULL) {
+      return Some(DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601);
+    } else {
+      return Some(DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601);
+    }
+  } else if (aYUVColorSpace == gfx::YUVColorSpace::BT709) {
+    if (aColorRange == gfx::ColorRange::FULL) {
+      return Some(DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709);
+    } else {
+      return Some(DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709);
+    }
+  } else if (aYUVColorSpace == gfx::YUVColorSpace::BT2020) {
+    if (aColorRange == gfx::ColorRange::FULL) {
+      // XXX Add SMPTEST2084 handling. HDR content is not handled yet by
+      // video overlay.
+      return Some(DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020);
+    } else {
+      return Some(DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020);
+    }
+  }
+
+  return Nothing();
+}
+
+static Maybe<DXGI_COLOR_SPACE_TYPE> GetSourceDXGIColorSpace(
+    const gfx::YUVRangedColorSpace aYUVColorSpace) {
+  const auto info = FromYUVRangedColorSpace(aYUVColorSpace);
+  return GetSourceDXGIColorSpace(info.space, info.range);
+}
+
+static void SetNvidiaVideoSuperRes(ID3D11VideoContext* videoContext,
+                                   ID3D11VideoProcessor* videoProcessor,
+                                   bool enabled) {
+  LOG("SetNvidiaVideoSuperRes() enabled=%d", enabled);
+
+  // Undocumented NVIDIA driver constants
+  constexpr GUID nvGUID = {0xD43CE1B3,
+                           0x1F4B,
+                           0x48AC,
+                           {0xBA, 0xEE, 0xC3, 0xC2, 0x53, 0x75, 0xE6, 0xF7}};
+
+  constexpr UINT nvExtensionVersion = 0x1;
+  constexpr UINT nvExtensionMethodSuperResolution = 0x2;
+  struct {
+    UINT version;
+    UINT method;
+    UINT enable;
+  } streamExtensionInfo = {nvExtensionVersion, nvExtensionMethodSuperResolution,
+                           enabled ? 1u : 0};
+
+  HRESULT hr;
+  hr = videoContext->VideoProcessorSetStreamExtension(
+      videoProcessor, 0, &nvGUID, sizeof(streamExtensionInfo),
+      &streamExtensionInfo);
+
+  // Ignore errors as could be unsupported
+  if (FAILED(hr)) {
+    LOG("SetNvidiaVideoSuperRes() error: %lx", hr);
+    return;
+  }
+}
+
+static UINT GetVendorId(ID3D11VideoDevice* const videoDevice) {
+  RefPtr<IDXGIDevice> dxgiDevice;
+  RefPtr<IDXGIAdapter> adapter;
+  videoDevice->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice));
+  dxgiDevice->GetAdapter(getter_AddRefs(adapter));
+
+  DXGI_ADAPTER_DESC adapterDesc;
+  adapter->GetDesc(&adapterDesc);
+
+  return adapterDesc.VendorId;
+}
+
+bool DCSurfaceVideo::CallVideoProcessorBlt() {
+  MOZ_ASSERT(mRenderTextureHost);
+
+  HRESULT hr;
+  const auto videoDevice = mDCLayerTree->GetVideoDevice();
+  const auto videoContext = mDCLayerTree->GetVideoContext();
+  const auto texture = mRenderTextureHost->AsRenderDXGITextureHost();
+
+  Maybe<DXGI_COLOR_SPACE_TYPE> sourceColorSpace =
+      GetSourceDXGIColorSpace(texture->GetYUVColorSpace());
+  if (sourceColorSpace.isNothing()) {
+    gfxCriticalNote << "Unsupported color space";
+    return false;
+  }
+
+  RefPtr<ID3D11Texture2D> texture2D = texture->GetD3D11Texture2DWithGL();
+  if (!texture2D) {
+    gfxCriticalNote << "Failed to get D3D11Texture2D";
+    return false;
+  }
+
+  if (!mVideoSwapChain) {
+    return false;
+  }
+
+  auto query = texture->GetQuery();
+  if (query) {
+    // Wait ID3D11Query of D3D11Texture2D copy complete just before blitting for
+    // video overlay with non Intel GPUs. See Bug 1817617.
+    BOOL result;
+    bool ret = layers::WaitForFrameGPUQuery(mDCLayerTree->GetDevice(),
+                                            mDCLayerTree->GetDeviceContext(),
+                                            query, &result);
+    if (!ret) {
+      gfxCriticalNoteOnce << "WaitForFrameGPUQuery() failed";
+    }
+  }
+
+  if (!mDCLayerTree->EnsureVideoProcessor(mVideoSize, mSwapChainSize)) {
+    gfxCriticalNote << "EnsureVideoProcessor Failed";
+    return false;
+  }
+
+  RefPtr<IDXGISwapChain3> swapChain3;
+  mVideoSwapChain->QueryInterface(
+      (IDXGISwapChain3**)getter_AddRefs(swapChain3));
+  if (!swapChain3) {
+    gfxCriticalNote << "Failed to get IDXGISwapChain3";
+    return false;
+  }
+
+  RefPtr<ID3D11VideoContext1> videoContext1;
+  videoContext->QueryInterface(
+      (ID3D11VideoContext1**)getter_AddRefs(videoContext1));
+  if (!videoContext1) {
+    gfxCriticalNote << "Failed to get ID3D11VideoContext1";
+    return false;
+  }
+
+  const auto videoProcessor = mDCLayerTree->GetVideoProcessor();
+  const auto videoProcessorEnumerator =
+      mDCLayerTree->GetVideoProcessorEnumerator();
+
+  DXGI_COLOR_SPACE_TYPE inputColorSpace = sourceColorSpace.ref();
+  videoContext1->VideoProcessorSetStreamColorSpace1(videoProcessor, 0,
+                                                    inputColorSpace);
+
+  DXGI_COLOR_SPACE_TYPE outputColorSpace =
+      IsYUVSwapChainFormat(mSwapChainFormat)
+          ? inputColorSpace
+          : DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709;
+  hr = swapChain3->SetColorSpace1(outputColorSpace);
+  if (FAILED(hr)) {
+    gfxCriticalNoteOnce << "SetColorSpace1 failed: " << gfx::hexa(hr);
+    RenderThread::Get()->NotifyWebRenderError(
+        wr::WebRenderError::VIDEO_OVERLAY);
+    return false;
+  }
+  videoContext1->VideoProcessorSetOutputColorSpace1(videoProcessor,
+                                                    outputColorSpace);
+
+  D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC inputDesc = {};
+  inputDesc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
+  inputDesc.Texture2D.ArraySlice = texture->ArrayIndex();
+
+  RefPtr<ID3D11VideoProcessorInputView> inputView;
+  hr = videoDevice->CreateVideoProcessorInputView(
+      texture2D, videoProcessorEnumerator, &inputDesc,
+      getter_AddRefs(inputView));
+  if (FAILED(hr)) {
+    gfxCriticalNote << "ID3D11VideoProcessorInputView creation failed: "
+                    << gfx::hexa(hr);
+    return false;
+  }
+
+  D3D11_VIDEO_PROCESSOR_STREAM stream = {};
+  stream.Enable = true;
+  stream.OutputIndex = 0;
+  stream.InputFrameOrField = 0;
+  stream.PastFrames = 0;
+  stream.FutureFrames = 0;
+  stream.pInputSurface = inputView.get();
+
+  RECT destRect;
+  destRect.left = 0;
+  destRect.top = 0;
+  destRect.right = mSwapChainSize.width;
+  destRect.bottom = mSwapChainSize.height;
+
+  videoContext->VideoProcessorSetOutputTargetRect(videoProcessor, TRUE,
+                                                  &destRect);
+  videoContext->VideoProcessorSetStreamDestRect(videoProcessor, 0, TRUE,
+                                                &destRect);
+  RECT sourceRect;
+  sourceRect.left = 0;
+  sourceRect.top = 0;
+  sourceRect.right = mVideoSize.width;
+  sourceRect.bottom = mVideoSize.height;
+  videoContext->VideoProcessorSetStreamSourceRect(videoProcessor, 0, TRUE,
+                                                  &sourceRect);
+
+  if (!mOutputView) {
+    RefPtr<ID3D11Texture2D> backBuf;
+    mVideoSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+                               (void**)getter_AddRefs(backBuf));
+
+    D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC outputDesc = {};
+    outputDesc.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D;
+    outputDesc.Texture2D.MipSlice = 0;
+
+    hr = videoDevice->CreateVideoProcessorOutputView(
+        backBuf, videoProcessorEnumerator, &outputDesc,
+        getter_AddRefs(mOutputView));
+    if (FAILED(hr)) {
+      gfxCriticalNote << "ID3D11VideoProcessorOutputView creation failed: "
+                      << gfx::hexa(hr);
+      return false;
+    }
+  }
+
+  const UINT vendorId = GetVendorId(videoDevice);
+  if (vendorId == 0x10DE &&
+      StaticPrefs::gfx_webrender_super_resolution_nvidia_AtStartup()) {
+    SetNvidiaVideoSuperRes(videoContext, videoProcessor, true);
+  }
+
+  hr = videoContext->VideoProcessorBlt(videoProcessor, mOutputView, 0, 1,
+                                       &stream);
+  if (FAILED(hr)) {
+    gfxCriticalNote << "VideoProcessorBlt failed: " << gfx::hexa(hr);
+    return false;
+  }
+
+  return true;
+}
+
+void DCSurfaceVideo::ReleaseDecodeSwapChainResources() {
+  mOutputView = nullptr;
+  mVideoSwapChain = nullptr;
+  mDecodeSwapChain = nullptr;
+  mDecodeResource = nullptr;
+  if (mSwapChainSurfaceHandle) {
+    ::CloseHandle(mSwapChainSurfaceHandle);
+    mSwapChainSurfaceHandle = 0;
+  }
+}
+
+DCSurfaceHandle::DCSurfaceHandle(bool aIsOpaque, DCLayerTree* aDCLayerTree)
+    : DCSurface(wr::DeviceIntSize{}, wr::DeviceIntPoint{}, false, aIsOpaque,
+                aDCLayerTree) {}
+
+void DCSurfaceHandle::AttachExternalImage(wr::ExternalImageId aExternalImage) {
+  RenderTextureHost* texture =
+      RenderThread::Get()->GetRenderTexture(aExternalImage);
+  RenderDcompSurfaceTextureHost* renderTexture =
+      texture ? texture->AsRenderDcompSurfaceTextureHost() : nullptr;
+  if (!renderTexture) {
+    gfxCriticalNote << "Unsupported RenderTexture for DCSurfaceHandle: "
+                    << gfx::hexa(texture);
+    return;
+  }
+
+  const auto handle = renderTexture->GetDcompSurfaceHandle();
+  if (GetSurfaceHandle() == handle) {
+    return;
+  }
+
+  LOG_H("AttachExternalImage, ext-image=%" PRIu64 ", texture=%p, handle=%p",
+        wr::AsUint64(aExternalImage), renderTexture, handle);
+  mDcompTextureHost = renderTexture;
+}
+
+HANDLE DCSurfaceHandle::GetSurfaceHandle() const {
+  if (mDcompTextureHost) {
+    return mDcompTextureHost->GetDcompSurfaceHandle();
+  }
+  return nullptr;
+}
+
+IDCompositionSurface* DCSurfaceHandle::EnsureSurface() {
+  if (auto* surface = mDcompTextureHost->GetSurface()) {
+    return surface;
+  }
+
+  // Texture host hasn't created the surface yet, ask it to create a new one.
+  RefPtr<IDCompositionDevice> device;
+  HRESULT hr = mDCLayerTree->GetCompositionDevice()->QueryInterface(
+      (IDCompositionDevice**)getter_AddRefs(device));
+  if (FAILED(hr)) {
+    gfxCriticalNote
+        << "Failed to convert IDCompositionDevice2 to IDCompositionDevice: "
+        << gfx::hexa(hr);
+    return nullptr;
+  }
+
+  return mDcompTextureHost->CreateSurfaceFromDevice(device);
+}
+
+void DCSurfaceHandle::PresentSurfaceHandle() {
+  LOG_H("PresentSurfaceHandle");
+  if (IDCompositionSurface* surface = EnsureSurface()) {
+    LOG_H("Set surface %p to visual", surface);
+    mVisual->SetContent(surface);
+  } else {
+    mVisual->SetContent(nullptr);
+  }
+}
+
+DCTile::DCTile(DCLayerTree* aDCLayerTree) : mDCLayerTree(aDCLayerTree) {}
+
+DCTile::~DCTile() {}
+
+bool DCTile::Initialize(int aX, int aY, wr::DeviceIntSize aSize,
+                        bool aIsVirtualSurface, bool aIsOpaque,
+                        RefPtr<IDCompositionVisual2> mSurfaceVisual) {
+  if (aSize.width <= 0 || aSize.height <= 0) {
+    return false;
+  }
+
+  mSize = aSize;
+  mIsOpaque = aIsOpaque;
+  mIsVirtualSurface = aIsVirtualSurface;
+  mNeedsFullDraw = !aIsVirtualSurface;
+
+  if (aIsVirtualSurface) {
+    // Initially, the entire tile is considered valid, unless it is set by
+    // the SetTileProperties method.
+    mValidRect.x = 0;
+    mValidRect.y = 0;
+    mValidRect.width = aSize.width;
+    mValidRect.height = aSize.height;
+  } else {
+    HRESULT hr;
+    const auto dCompDevice = mDCLayerTree->GetCompositionDevice();
+    // Create the visual and put it in the tree under the surface visual
+    hr = dCompDevice->CreateVisual(getter_AddRefs(mVisual));
+    if (FAILED(hr)) {
+      gfxCriticalNote << "Failed to CreateVisual for DCTile: " << gfx::hexa(hr);
+      return false;
+    }
+    mSurfaceVisual->AddVisual(mVisual, false, nullptr);
+    // Position the tile relative to the surface visual
+    mVisual->SetOffsetX(aX * aSize.width);
+    mVisual->SetOffsetY(aY * aSize.height);
+    // Clip the visual so it doesn't show anything until we update it
+    D2D_RECT_F clip = {0, 0, 0, 0};
+    mVisual->SetClip(clip);
+    // Create the underlying pixel buffer.
+    mCompositionSurface = CreateCompositionSurface(aSize, aIsOpaque);
+    if (!mCompositionSurface) {
+      return false;
+    }
+    hr = mVisual->SetContent(mCompositionSurface);
+    if (FAILED(hr)) {
+      gfxCriticalNote << "Failed to SetContent for DCTile: " << gfx::hexa(hr);
+      return false;
+    }
+  }
+
+  return true;
+}
+
+RefPtr<IDCompositionSurface> DCTile::CreateCompositionSurface(
+    wr::DeviceIntSize aSize, bool aIsOpaque) {
+  HRESULT hr;
+  const auto dCompDevice = mDCLayerTree->GetCompositionDevice();
+  const auto alphaMode =
+      aIsOpaque ? DXGI_ALPHA_MODE_IGNORE : DXGI_ALPHA_MODE_PREMULTIPLIED;
+  RefPtr<IDCompositionSurface> compositionSurface;
+
+  hr = dCompDevice->CreateSurface(aSize.width, aSize.height,
+                                  DXGI_FORMAT_R8G8B8A8_UNORM, alphaMode,
+                                  getter_AddRefs(compositionSurface));
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to CreateSurface for DCTile: " << gfx::hexa(hr);
+    return nullptr;
+  }
+  return compositionSurface;
+}
+
+RefPtr<IDCompositionSurface> DCTile::Bind(wr::DeviceIntRect aValidRect) {
+  if (mVisual != nullptr) {
+    // Tile owns a visual, set the size of the visual to match the portion we
+    // want to be visible.
+    D2D_RECT_F clip_rect;
+    clip_rect.left = aValidRect.min.x;
+    clip_rect.top = aValidRect.min.y;
+    clip_rect.right = aValidRect.max.x;
+    clip_rect.bottom = aValidRect.max.y;
+    mVisual->SetClip(clip_rect);
+  }
+  return mCompositionSurface;
+}
+
+GLuint DCLayerTree::CreateEGLSurfaceForCompositionSurface(
+    wr::DeviceIntRect aDirtyRect, wr::DeviceIntPoint* aOffset,
+    RefPtr<IDCompositionSurface> aCompositionSurface,
+    wr::DeviceIntPoint aSurfaceOffset) {
+  MOZ_ASSERT(aCompositionSurface.get());
+
+  HRESULT hr;
+  const auto gl = GetGLContext();
+  RefPtr<ID3D11Texture2D> backBuf;
+  POINT offset;
+
+  RECT update_rect;
+  update_rect.left = aSurfaceOffset.x + aDirtyRect.min.x;
+  update_rect.top = aSurfaceOffset.y + aDirtyRect.min.y;
+  update_rect.right = aSurfaceOffset.x + aDirtyRect.max.x;
+  update_rect.bottom = aSurfaceOffset.y + aDirtyRect.max.y;
+  hr = aCompositionSurface->BeginDraw(&update_rect, __uuidof(ID3D11Texture2D),
+                                      (void**)getter_AddRefs(backBuf), &offset);
+
+  if (FAILED(hr)) {
+    LayoutDeviceIntRect rect = widget::WinUtils::ToIntRect(update_rect);
+
+    gfxCriticalNote << "DCompositionSurface::BeginDraw failed: "
+                    << gfx::hexa(hr) << " " << rect;
+    RenderThread::Get()->HandleWebRenderError(WebRenderError::BEGIN_DRAW);
+    return false;
+  }
+
+  // DC includes the origin of the dirty / update rect in the draw offset,
+  // undo that here since WR expects it to be an absolute offset.
+  offset.x -= aDirtyRect.min.x;
+  offset.y -= aDirtyRect.min.y;
+
+  D3D11_TEXTURE2D_DESC desc;
+  backBuf->GetDesc(&desc);
+
+  const auto& gle = gl::GLContextEGL::Cast(gl);
+  const auto& egl = gle->mEgl;
+
+  const auto buffer = reinterpret_cast<EGLClientBuffer>(backBuf.get());
+
+  // Construct an EGLImage wrapper around the D3D texture for ANGLE.
+  const EGLint attribs[] = {LOCAL_EGL_NONE};
+  mEGLImage = egl->fCreateImage(EGL_NO_CONTEXT, LOCAL_EGL_D3D11_TEXTURE_ANGLE,
+                                buffer, attribs);
+
+  // Get the current FBO and RBO id, so we can restore them later
+  GLint currentFboId, currentRboId;
+  gl->fGetIntegerv(LOCAL_GL_DRAW_FRAMEBUFFER_BINDING, &currentFboId);
+  gl->fGetIntegerv(LOCAL_GL_RENDERBUFFER_BINDING, &currentRboId);
+
+  // Create a render buffer object that is backed by the EGL image.
+  gl->fGenRenderbuffers(1, &mColorRBO);
+  gl->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, mColorRBO);
+  gl->fEGLImageTargetRenderbufferStorage(LOCAL_GL_RENDERBUFFER, mEGLImage);
+
+  // Get or create an FBO for the specified dimensions
+  GLuint fboId = GetOrCreateFbo(desc.Width, desc.Height);
+
+  // Attach the new renderbuffer to the FBO
+  gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fboId);
+  gl->fFramebufferRenderbuffer(LOCAL_GL_DRAW_FRAMEBUFFER,
+                               LOCAL_GL_COLOR_ATTACHMENT0,
+                               LOCAL_GL_RENDERBUFFER, mColorRBO);
+
+  // Restore previous FBO and RBO bindings
+  gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, currentFboId);
+  gl->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, currentRboId);
+
+  aOffset->x = offset.x;
+  aOffset->y = offset.y;
+
+  return fboId;
+}
+
+void DCLayerTree::DestroyEGLSurface() {
+  const auto gl = GetGLContext();
+
+  if (mColorRBO) {
+    gl->fDeleteRenderbuffers(1, &mColorRBO);
+    mColorRBO = 0;
+  }
+
+  if (mEGLImage) {
+    const auto& gle = gl::GLContextEGL::Cast(gl);
+    const auto& egl = gle->mEgl;
+    egl->fDestroyImage(mEGLImage);
+    mEGLImage = EGL_NO_IMAGE;
+  }
+}
+
+// -
+
+color::ColorProfileDesc DCLayerTree::QueryOutputColorProfile() {
+  // GPU process can't simply init gfxPlatform, (and we don't need most of it)
+  // but we do need gfxPlatform::GetCMSOutputProfile().
+  // So we steal what we need through the window:
+  const auto outputProfileData =
+      gfxWindowsPlatform::GetPlatformCMSOutputProfileData_Impl();
+
+  const auto qcmsProfile = qcms_profile_from_memory(
+      outputProfileData.Elements(), outputProfileData.Length());
+  const auto release = MakeScopeExit([&]() {
+    if (qcmsProfile) {
+      qcms_profile_release(qcmsProfile);
+    }
+  });
+
+  const bool print = gfxEnv::MOZ_GL_SPEW();
+
+  const auto ret = [&]() {
+    if (qcmsProfile) {
+      return color::ColorProfileDesc::From(*qcmsProfile);
+    }
+    if (print) {
+      printf_stderr(
+          "Missing or failed to load display color profile, defaulting to "
+          "sRGB.\n");
+    }
+    const auto MISSING_PROFILE_DEFAULT_SPACE = color::ColorspaceDesc{
+        color::Chromaticities::Srgb(),
+        color::PiecewiseGammaDesc::Srgb(),
+    };
+    return color::ColorProfileDesc::From(MISSING_PROFILE_DEFAULT_SPACE);
+  }();
+
+  if (print) {
+    const auto gammaGuess = color::GuessGamma(ret.linearFromTf.r);
+    printf_stderr(
+        "Display profile:\n"
+        "  Approx Gamma: %f\n"
+        "  XYZ-D65 Red  : %f, %f, %f\n"
+        "  XYZ-D65 Green: %f, %f, %f\n"
+        "  XYZ-D65 Blue : %f, %f, %f\n",
+        gammaGuess, ret.xyzd65FromLinearRgb.at(0, 0),
+        ret.xyzd65FromLinearRgb.at(0, 1), ret.xyzd65FromLinearRgb.at(0, 2),
+
+        ret.xyzd65FromLinearRgb.at(1, 0), ret.xyzd65FromLinearRgb.at(1, 1),
+        ret.xyzd65FromLinearRgb.at(1, 2),
+
+        ret.xyzd65FromLinearRgb.at(2, 0), ret.xyzd65FromLinearRgb.at(2, 1),
+        ret.xyzd65FromLinearRgb.at(2, 2));
+  }
+
+  return ret;
+}
+
+inline D2D1_MATRIX_5X4_F to_D2D1_MATRIX_5X4_F(const color::mat4& m) {
+  return D2D1_MATRIX_5X4_F{{{
+      m.rows[0][0],
+      m.rows[1][0],
+      m.rows[2][0],
+      m.rows[3][0],
+      m.rows[0][1],
+      m.rows[1][1],
+      m.rows[2][1],
+      m.rows[3][1],
+      m.rows[0][2],
+      m.rows[1][2],
+      m.rows[2][2],
+      m.rows[3][2],
+      m.rows[0][3],
+      m.rows[1][3],
+      m.rows[2][3],
+      m.rows[3][3],
+      0,
+      0,
+      0,
+      0,
+  }}};
+}
+
+ColorManagementChain ColorManagementChain::From(
+    IDCompositionDevice3& dcomp,
+    const color::ColorProfileConversionDesc& conv) {
+  auto ret = ColorManagementChain{};
+
+#if !defined(MOZ_MINGW_DCOMP_H_INCOMPLETE)
+
+  const auto Append = [&](const RefPtr<IDCompositionFilterEffect>& afterLast) {
+    if (ret.last) {
+      afterLast->SetInput(0, ret.last, 0);
+    }
+    ret.last = afterLast;
+  };
+
+  const auto MaybeAppendColorMatrix = [&](const color::mat4& m) {
+    RefPtr<IDCompositionColorMatrixEffect> e;
+    if (approx(m, color::mat4::Identity())) return e;
+    dcomp.CreateColorMatrixEffect(getter_AddRefs(e));
+    MOZ_ASSERT(e);
+    if (!e) return e;
+    e->SetMatrix(to_D2D1_MATRIX_5X4_F(m));
+    Append(e);
+    return e;
+  };
+  const auto MaybeAppendTableTransfer = [&](const color::RgbTransferTables& t) {
+    RefPtr<IDCompositionTableTransferEffect> e;
+    if (!t.r.size() && !t.g.size() && !t.b.size()) return e;
+    dcomp.CreateTableTransferEffect(getter_AddRefs(e));
+    MOZ_ASSERT(e);
+    if (!e) return e;
+    e->SetRedTable(t.r.data(), t.r.size());
+    e->SetGreenTable(t.g.data(), t.g.size());
+    e->SetBlueTable(t.b.data(), t.b.size());
+    Append(e);
+    return e;
+  };
+
+  ret.srcRgbFromSrcYuv = MaybeAppendColorMatrix(conv.srcRgbFromSrcYuv);
+  ret.srcLinearFromSrcTf = MaybeAppendTableTransfer(conv.srcLinearFromSrcTf);
+  ret.dstLinearFromSrcLinear =
+      MaybeAppendColorMatrix(color::mat4(conv.dstLinearFromSrcLinear));
+  ret.dstTfFromDstLinear = MaybeAppendTableTransfer(conv.dstTfFromDstLinear);
+
+#endif  // !defined(MOZ_MINGW_DCOMP_H_INCOMPLETE)
+
+  return ret;
+}
+
+ColorManagementChain::~ColorManagementChain() = default;
+
+}  // namespace wr
+}  // namespace mozilla
+
+#undef LOG_H
diff --git a/gfx/webrender_bindings/DCLayerTree.h b/gfx/webrender_bindings/DCLayerTree.h
new file mode 100644
index 0000000000..babd1112fb
--- /dev/null
+++ b/gfx/webrender_bindings/DCLayerTree.h
@@ -0,0 +1,480 @@
+/* -*- 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_DCLAYER_TREE_H
+#define MOZILLA_GFX_DCLAYER_TREE_H
+
+#include <dxgiformat.h>
+#include <unordered_map>
+#include <vector>
+#include <windows.h>
+
+#include "Colorspaces.h"
+#include "GLTypes.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/layers/OverlayInfo.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+
+struct ID3D11Device;
+struct ID3D11DeviceContext;
+struct ID3D11VideoDevice;
+struct ID3D11VideoContext;
+struct ID3D11VideoProcessor;
+struct ID3D11VideoProcessorEnumerator;
+struct ID3D11VideoProcessorOutputView;
+struct IDCompositionColorMatrixEffect;
+struct IDCompositionFilterEffect;
+struct IDCompositionTableTransferEffect;
+struct IDCompositionDevice2;
+struct IDCompositionDevice3;
+struct IDCompositionSurface;
+struct IDCompositionTarget;
+struct IDCompositionVisual2;
+struct IDXGIDecodeSwapChain;
+struct IDXGIResource;
+struct IDXGISwapChain1;
+struct IDCompositionVirtualSurface;
+
+namespace mozilla {
+
+namespace gl {
+class GLContext;
+}
+
+namespace wr {
+
+// The size of the virtual surface. This is large enough such that we
+// will never render a surface larger than this.
+#define VIRTUAL_SURFACE_SIZE (1024 * 1024)
+
+class DCTile;
+class DCSurface;
+class DCSurfaceVideo;
+class DCSurfaceHandle;
+class RenderTextureHost;
+class RenderDcompSurfaceTextureHost;
+
+struct GpuOverlayInfo {
+  bool mSupportsOverlays = false;
+  bool mSupportsHardwareOverlays = false;
+  DXGI_FORMAT mOverlayFormatUsed = DXGI_FORMAT_B8G8R8A8_UNORM;
+  DXGI_FORMAT mOverlayFormatUsedHdr = DXGI_FORMAT_R10G10B10A2_UNORM;
+  UINT mNv12OverlaySupportFlags = 0;
+  UINT mYuy2OverlaySupportFlags = 0;
+  UINT mBgra8OverlaySupportFlags = 0;
+  UINT mRgb10a2OverlaySupportFlags = 0;
+};
+
+// -
+
+struct ColorManagementChain {
+  RefPtr<IDCompositionColorMatrixEffect> srcRgbFromSrcYuv;
+  RefPtr<IDCompositionTableTransferEffect> srcLinearFromSrcTf;
+  RefPtr<IDCompositionColorMatrixEffect> dstLinearFromSrcLinear;
+  RefPtr<IDCompositionTableTransferEffect> dstTfFromDstLinear;
+  RefPtr<IDCompositionFilterEffect> last;
+
+  static ColorManagementChain From(IDCompositionDevice3& dcomp,
+                                   const color::ColorProfileConversionDesc&);
+
+  ~ColorManagementChain();
+};
+
+// -
+
+enum class DCompOverlayTypes : uint8_t {
+  NO_OVERLAY = 0,
+  HARDWARE_DECODED_VIDEO = 1 << 0,
+  SOFTWARE_DECODED_VIDEO = 1 << 1,
+};
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(DCompOverlayTypes)
+
+// -
+
+/**
+ * DCLayerTree manages direct composition layers.
+ * It does not manage gecko's layers::Layer.
+ */
+class DCLayerTree {
+ public:
+  static UniquePtr<DCLayerTree> Create(gl::GLContext* aGL, EGLConfig aEGLConfig,
+                                       ID3D11Device* aDevice,
+                                       ID3D11DeviceContext* aCtx, HWND aHwnd,
+                                       nsACString& aError);
+
+  static void Shutdown();
+
+  explicit DCLayerTree(gl::GLContext* aGL, EGLConfig aEGLConfig,
+                       ID3D11Device* aDevice, ID3D11DeviceContext* aCtx,
+                       IDCompositionDevice2* aCompositionDevice);
+  ~DCLayerTree();
+
+  void SetDefaultSwapChain(IDXGISwapChain1* aSwapChain);
+  void MaybeUpdateDebug();
+  void MaybeCommit();
+  void WaitForCommitCompletion();
+  void DisableNativeCompositor();
+
+  // Interface for wr::Compositor
+  void CompositorBeginFrame();
+  void CompositorEndFrame();
+  void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId,
+            wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect);
+  void Unbind();
+  void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset,
+                     wr::DeviceIntSize aTileSize, bool aIsOpaque);
+  void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque);
+  void DestroySurface(NativeSurfaceId aId);
+  void CreateTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY);
+  void DestroyTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY);
+  void AttachExternalImage(wr::NativeSurfaceId aId,
+                           wr::ExternalImageId aExternalImage);
+  void AddSurface(wr::NativeSurfaceId aId,
+                  const wr::CompositorSurfaceTransform& aTransform,
+                  wr::DeviceIntRect aClipRect,
+                  wr::ImageRendering aImageRendering);
+
+  gl::GLContext* GetGLContext() const { return mGL; }
+  EGLConfig GetEGLConfig() const { return mEGLConfig; }
+  ID3D11Device* GetDevice() const { return mDevice; }
+  ID3D11DeviceContext* GetDeviceContext() const { return mCtx; }
+  IDCompositionDevice2* GetCompositionDevice() const {
+    return mCompositionDevice;
+  }
+  ID3D11VideoDevice* GetVideoDevice() const { return mVideoDevice; }
+  ID3D11VideoContext* GetVideoContext() const { return mVideoContext; }
+  ID3D11VideoProcessor* GetVideoProcessor() const { return mVideoProcessor; }
+  ID3D11VideoProcessorEnumerator* GetVideoProcessorEnumerator() const {
+    return mVideoProcessorEnumerator;
+  }
+  bool EnsureVideoProcessor(const gfx::IntSize& aInputSize,
+                            const gfx::IntSize& aOutputSize);
+
+  DCSurface* GetSurface(wr::NativeSurfaceId aId) const;
+
+  // Get or create an FBO with depth buffer suitable for specified dimensions
+  GLuint GetOrCreateFbo(int aWidth, int aHeight);
+
+  bool SupportsHardwareOverlays();
+  DXGI_FORMAT GetOverlayFormatForSDR();
+
+  bool SupportsSwapChainTearing();
+
+  void SetUsedOverlayTypeInFrame(DCompOverlayTypes aTypes);
+
+ protected:
+  bool Initialize(HWND aHwnd, nsACString& aError);
+  bool InitializeVideoOverlaySupport();
+  bool MaybeUpdateDebugCounter();
+  bool MaybeUpdateDebugVisualRedrawRegions();
+  void DestroyEGLSurface();
+  GLuint CreateEGLSurfaceForCompositionSurface(
+      wr::DeviceIntRect aDirtyRect, wr::DeviceIntPoint* aOffset,
+      RefPtr<IDCompositionSurface> aCompositionSurface,
+      wr::DeviceIntPoint aSurfaceOffset);
+  void ReleaseNativeCompositorResources();
+  layers::OverlayInfo GetOverlayInfo();
+
+  RefPtr<gl::GLContext> mGL;
+  EGLConfig mEGLConfig;
+
+  RefPtr<ID3D11Device> mDevice;
+  RefPtr<ID3D11DeviceContext> mCtx;
+
+  RefPtr<IDCompositionDevice2> mCompositionDevice;
+  RefPtr<IDCompositionTarget> mCompositionTarget;
+  RefPtr<IDCompositionVisual2> mRootVisual;
+  RefPtr<IDCompositionVisual2> mDefaultSwapChainVisual;
+
+  RefPtr<ID3D11VideoDevice> mVideoDevice;
+  RefPtr<ID3D11VideoContext> mVideoContext;
+  RefPtr<ID3D11VideoProcessor> mVideoProcessor;
+  RefPtr<ID3D11VideoProcessorEnumerator> mVideoProcessorEnumerator;
+  gfx::IntSize mVideoInputSize;
+  gfx::IntSize mVideoOutputSize;
+
+  bool mDebugCounter;
+  bool mDebugVisualRedrawRegions;
+
+  Maybe<RefPtr<IDCompositionSurface>> mCurrentSurface;
+
+  // The EGL image that is bound to the D3D texture provided by
+  // DirectComposition.
+  EGLImage mEGLImage;
+
+  // The GL render buffer ID that maps the EGLImage to an RBO for attaching to
+  // an FBO.
+  GLuint mColorRBO;
+
+  struct SurfaceIdHashFn {
+    std::size_t operator()(const wr::NativeSurfaceId& aId) const {
+      return HashGeneric(wr::AsUint64(aId));
+    }
+  };
+
+  std::unordered_map<wr::NativeSurfaceId, UniquePtr<DCSurface>, SurfaceIdHashFn>
+      mDCSurfaces;
+
+  // A list of layer IDs as they are added to the visual tree this frame.
+  std::vector<wr::NativeSurfaceId> mCurrentLayers;
+
+  // The previous frame's list of layer IDs in visual order.
+  std::vector<wr::NativeSurfaceId> mPrevLayers;
+
+  // Information about a cached FBO that is retained between frames.
+  struct CachedFrameBuffer {
+    int width;
+    int height;
+    GLuint fboId;
+    GLuint depthRboId;
+    int lastFrameUsed;
+  };
+
+  // A cache of FBOs, containing a depth buffer allocated to a specific size.
+  // TODO(gw): Might be faster as a hashmap? The length is typically much less
+  // than 10.
+  nsTArray<CachedFrameBuffer> mFrameBuffers;
+  int mCurrentFrame = 0;
+
+  bool mPendingCommit;
+
+  static color::ColorProfileDesc QueryOutputColorProfile();
+
+  mutable Maybe<color::ColorProfileDesc> mOutputColorProfile;
+
+  DCompOverlayTypes mUsedOverlayTypesInFrame = DCompOverlayTypes::NO_OVERLAY;
+  int mSlowCommitCount = 0;
+
+ public:
+  const color::ColorProfileDesc& OutputColorProfile() const {
+    if (!mOutputColorProfile) {
+      mOutputColorProfile = Some(QueryOutputColorProfile());
+    }
+    return *mOutputColorProfile;
+  }
+
+ protected:
+  static StaticAutoPtr<GpuOverlayInfo> sGpuOverlayInfo;
+};
+
+/**
+ Represents a single picture cache slice. Each surface contains some
+ number of tiles. An implementation may choose to allocate individual
+ tiles to render in to (as the current impl does), or allocate a large
+ single virtual surface to draw into (e.g. the DirectComposition virtual
+ surface API in future).
+ */
+class DCSurface {
+ public:
+  const bool mIsVirtualSurface;
+
+  explicit DCSurface(wr::DeviceIntSize aTileSize,
+                     wr::DeviceIntPoint aVirtualOffset, bool aIsVirtualSurface,
+                     bool aIsOpaque, DCLayerTree* aDCLayerTree);
+  virtual ~DCSurface();
+
+  bool Initialize();
+  void CreateTile(int32_t aX, int32_t aY);
+  void DestroyTile(int32_t aX, int32_t aY);
+
+  IDCompositionVisual2* GetVisual() const { return mVisual; }
+  DCTile* GetTile(int32_t aX, int32_t aY) const;
+
+  struct TileKey {
+    TileKey(int32_t aX, int32_t aY) : mX(aX), mY(aY) {}
+
+    int32_t mX;
+    int32_t mY;
+  };
+
+  wr::DeviceIntSize GetTileSize() const { return mTileSize; }
+  wr::DeviceIntPoint GetVirtualOffset() const { return mVirtualOffset; }
+
+  IDCompositionVirtualSurface* GetCompositionSurface() const {
+    return mVirtualSurface;
+  }
+
+  void UpdateAllocatedRect();
+  void DirtyAllocatedRect();
+
+  // Implement these if the inherited surface supports attaching external image.
+  virtual void AttachExternalImage(wr::ExternalImageId aExternalImage) {
+    MOZ_RELEASE_ASSERT(true, "Not support attaching external image");
+  }
+  virtual void PresentExternalSurface(gfx::Matrix& aTransform) {
+    MOZ_RELEASE_ASSERT(true, "Not support presenting external surface");
+  }
+
+  virtual DCSurfaceVideo* AsDCSurfaceVideo() { return nullptr; }
+  virtual DCSurfaceHandle* AsDCSurfaceHandle() { return nullptr; }
+
+ protected:
+  DCLayerTree* mDCLayerTree;
+
+  struct TileKeyHashFn {
+    std::size_t operator()(const TileKey& aId) const {
+      return HashGeneric(aId.mX, aId.mY);
+    }
+  };
+
+  // The visual for this surface. No content is attached to here, but tiles
+  // that belong to this surface are added as children. In this way, we can
+  // set the clip and scroll offset once, on this visual, to affect all
+  // children.
+  //
+  // However when using a virtual surface, it is directly attached to this
+  // visual and the tiles do not own visuals.
+  //
+  // Whether mIsVirtualSurface is enabled is decided at DCSurface creation
+  // time based on the pref gfx.webrender.dcomp-use-virtual-surfaces
+  RefPtr<IDCompositionVisual2> mVisual;
+
+  wr::DeviceIntSize mTileSize;
+  bool mIsOpaque;
+  bool mAllocatedRectDirty;
+  std::unordered_map<TileKey, UniquePtr<DCTile>, TileKeyHashFn> mDCTiles;
+  wr::DeviceIntPoint mVirtualOffset;
+  RefPtr<IDCompositionVirtualSurface> mVirtualSurface;
+};
+
+/**
+ * A wrapper surface which can contain either a DCVideo or a DCSurfaceHandle.
+ */
+class DCExternalSurfaceWrapper : public DCSurface {
+ public:
+  DCExternalSurfaceWrapper(bool aIsOpaque, DCLayerTree* aDCLayerTree)
+      : DCSurface(wr::DeviceIntSize{}, wr::DeviceIntPoint{},
+                  false /* virtual surface */, false /* opaque */,
+                  aDCLayerTree),
+        mIsOpaque(aIsOpaque) {}
+  ~DCExternalSurfaceWrapper() = default;
+
+  void AttachExternalImage(wr::ExternalImageId aExternalImage) override;
+
+  void PresentExternalSurface(gfx::Matrix& aTransform) override;
+
+  DCSurfaceVideo* AsDCSurfaceVideo() override {
+    return mSurface ? mSurface->AsDCSurfaceVideo() : nullptr;
+  }
+
+  DCSurfaceHandle* AsDCSurfaceHandle() override {
+    return mSurface ? mSurface->AsDCSurfaceHandle() : nullptr;
+  }
+
+ private:
+  DCSurface* EnsureSurfaceForExternalImage(wr::ExternalImageId aExternalImage);
+
+  UniquePtr<DCSurface> mSurface;
+  const bool mIsOpaque;
+  Maybe<ColorManagementChain> mCManageChain;
+};
+
+class DCSurfaceVideo : public DCSurface {
+ public:
+  DCSurfaceVideo(bool aIsOpaque, DCLayerTree* aDCLayerTree);
+
+  void AttachExternalImage(wr::ExternalImageId aExternalImage) override;
+  bool CalculateSwapChainSize(gfx::Matrix& aTransform);
+  void PresentVideo();
+
+  DCSurfaceVideo* AsDCSurfaceVideo() override { return this; }
+
+ protected:
+  virtual ~DCSurfaceVideo();
+
+  DXGI_FORMAT GetSwapChainFormat();
+  bool CreateVideoSwapChain();
+  bool CallVideoProcessorBlt();
+  void ReleaseDecodeSwapChainResources();
+
+  RefPtr<ID3D11VideoProcessorOutputView> mOutputView;
+  RefPtr<IDXGIResource> mDecodeResource;
+  RefPtr<IDXGISwapChain1> mVideoSwapChain;
+  RefPtr<IDXGIDecodeSwapChain> mDecodeSwapChain;
+  HANDLE mSwapChainSurfaceHandle = 0;
+  gfx::IntSize mVideoSize;
+  gfx::IntSize mSwapChainSize;
+  DXGI_FORMAT mSwapChainFormat = DXGI_FORMAT_B8G8R8A8_UNORM;
+  bool mIsDRM = false;
+  bool mFailedYuvSwapChain = false;
+  RefPtr<RenderTextureHost> mRenderTextureHost;
+  RefPtr<RenderTextureHost> mPrevTexture;
+  int mSlowPresentCount = 0;
+  bool mFirstPresent = true;
+  const UINT mSwapChainBufferCount;
+};
+
+/**
+ * A DC surface contains a IDCompositionSurface that is directly constructed by
+ * a handle. This is used by the Media Foundataion media engine, which would
+ * store the decoded video content in the surface.
+ */
+class DCSurfaceHandle : public DCSurface {
+ public:
+  DCSurfaceHandle(bool aIsOpaque, DCLayerTree* aDCLayerTree);
+  ~DCSurfaceHandle() = default;
+
+  void AttachExternalImage(wr::ExternalImageId aExternalImage) override;
+  void PresentSurfaceHandle();
+
+  DCSurfaceHandle* AsDCSurfaceHandle() override { return this; }
+
+ protected:
+  HANDLE GetSurfaceHandle() const;
+  IDCompositionSurface* EnsureSurface();
+
+  RefPtr<RenderDcompSurfaceTextureHost> mDcompTextureHost;
+};
+
+class DCTile {
+ public:
+  gfx::IntRect mValidRect;
+
+  DCLayerTree* mDCLayerTree;
+  // Indicates that when the first BeginDraw occurs on the surface it must be
+  // full size - required by dcomp on non-virtual surfaces.
+  bool mNeedsFullDraw;
+
+  explicit DCTile(DCLayerTree* aDCLayerTree);
+  ~DCTile();
+  bool Initialize(int aX, int aY, wr::DeviceIntSize aSize,
+                  bool aIsVirtualSurface, bool aIsOpaque,
+                  RefPtr<IDCompositionVisual2> mSurfaceVisual);
+  RefPtr<IDCompositionSurface> Bind(wr::DeviceIntRect aValidRect);
+  IDCompositionVisual2* GetVisual() { return mVisual; }
+
+ protected:
+  // Size in pixels of this tile, some may be unused.  Set by Initialize.
+  wr::DeviceIntSize mSize;
+  // Whether the tile is composited as opaque (ignores alpha) or transparent.
+  // Set by Initialize.
+  bool mIsOpaque;
+  // Some code paths differ based on whether parent surface is virtual.
+  bool mIsVirtualSurface;
+  // Visual that displays the composition surface, or NULL if the tile belongs
+  // to a virtual surface.
+  RefPtr<IDCompositionVisual2> mVisual;
+  // Surface for the visual, or NULL if the tile has not had its first Bind or
+  // belongs to a virtual surface.
+  RefPtr<IDCompositionSurface> mCompositionSurface;
+
+  RefPtr<IDCompositionSurface> CreateCompositionSurface(wr::DeviceIntSize aSize,
+                                                        bool aIsOpaque);
+};
+
+static inline bool operator==(const DCSurface::TileKey& a0,
+                              const DCSurface::TileKey& a1) {
+  return a0.mX == a1.mX && a0.mY == a1.mY;
+}
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/Moz2DImageRenderer.cpp b/gfx/webrender_bindings/Moz2DImageRenderer.cpp
new file mode 100644
index 0000000000..66f61d719e
--- /dev/null
+++ b/gfx/webrender_bindings/Moz2DImageRenderer.cpp
@@ -0,0 +1,481 @@
+/* -*- 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 "mozilla/StaticPrefs_gfx.h"
+#include "gfxUtils.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/Range.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/RectAbsolute.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/RecordedEvent.h"
+#include "mozilla/layers/WebRenderDrawEventRecorder.h"
+#include "WebRenderTypes.h"
+#include "webrender_ffi.h"
+#include "GeckoProfiler.h"
+
+#include <unordered_map>
+
+#ifdef XP_DARWIN
+#  include "mozilla/gfx/UnscaledFontMac.h"
+#elif defined(XP_WIN)
+#  include "mozilla/gfx/UnscaledFontDWrite.h"
+#else
+#  include "mozilla/gfx/UnscaledFontFreeType.h"
+#endif
+
+namespace std {
+template <>
+struct hash<mozilla::wr::FontKey> {
+  size_t operator()(const mozilla::wr::FontKey& key) const {
+    return hash<size_t>()(mozilla::wr::AsUint64(key));
+  }
+};
+
+template <>
+struct hash<mozilla::wr::FontInstanceKey> {
+  size_t operator()(const mozilla::wr::FontInstanceKey& key) const {
+    return hash<size_t>()(mozilla::wr::AsUint64(key));
+  }
+};
+};  // namespace std
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace wr {
+
+struct FontTemplate {
+  const uint8_t* mData;
+  size_t mSize;
+  uint32_t mIndex;
+  const VecU8* mVec;
+  RefPtr<UnscaledFont> mUnscaledFont;
+
+  FontTemplate() : mData(nullptr), mSize(0), mIndex(0), mVec(nullptr) {}
+
+  ~FontTemplate() {
+    if (mVec) {
+      wr_dec_ref_arc(mVec);
+    }
+  }
+};
+
+struct FontInstanceData {
+  WrFontKey mFontKey;
+  float mSize;
+  Maybe<FontInstanceOptions> mOptions;
+  Maybe<FontInstancePlatformOptions> mPlatformOptions;
+  UniquePtr<gfx::FontVariation[]> mVariations;
+  size_t mNumVariations;
+  RefPtr<ScaledFont> mScaledFont;
+
+  FontInstanceData() : mSize(0), mNumVariations(0) {}
+};
+
+StaticMutex sFontDataTableLock;
+std::unordered_map<WrFontKey, FontTemplate> sFontDataTable;
+std::unordered_map<WrFontInstanceKey, FontInstanceData> sBlobFontTable;
+
+// Fixed-size ring buffer logging font deletion events to aid debugging.
+static struct FontDeleteLog {
+  static const size_t MAX_ENTRIES = 256;
+
+  uint64_t mEntries[MAX_ENTRIES] = {0};
+  size_t mNextEntry = 0;
+
+  void AddEntry(uint64_t aEntry) {
+    mEntries[mNextEntry] = aEntry;
+    mNextEntry = (mNextEntry + 1) % MAX_ENTRIES;
+  }
+
+  void Add(WrFontKey aKey) { AddEntry(AsUint64(aKey)); }
+
+  // Store namespace clears as font id 0, since this will never be allocated.
+  void Add(WrIdNamespace aNamespace) {
+    AddEntry(AsUint64(WrFontKey{aNamespace, 0}));
+  }
+
+  void AddAll() { AddEntry(~0); }
+
+  // Find a matching entry in the log, searching backwards starting at the
+  // newest entry and finishing with the oldest entry. Returns a brief
+  // description of why the font was deleted, if known.
+  const char* Find(WrFontKey aKey) {
+    uint64_t keyEntry = AsUint64(aKey);
+    uint64_t namespaceEntry = AsUint64(WrFontKey{aKey.mNamespace, 0});
+    size_t offset = mNextEntry;
+    do {
+      offset = (offset + MAX_ENTRIES - 1) % MAX_ENTRIES;
+      if (mEntries[offset] == keyEntry) {
+        return "deleted font";
+      } else if (mEntries[offset] == namespaceEntry) {
+        return "cleared namespace";
+      } else if (mEntries[offset] == (uint64_t)~0) {
+        return "cleared all";
+      }
+    } while (offset != mNextEntry);
+    return "unknown font";
+  }
+} sFontDeleteLog;
+
+void ClearAllBlobImageResources() {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  sFontDeleteLog.AddAll();
+  sBlobFontTable.clear();
+  sFontDataTable.clear();
+}
+
+extern "C" {
+void ClearBlobImageResources(WrIdNamespace aNamespace) {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  sFontDeleteLog.Add(aNamespace);
+  for (auto i = sBlobFontTable.begin(); i != sBlobFontTable.end();) {
+    if (i->first.mNamespace == aNamespace) {
+      i = sBlobFontTable.erase(i);
+    } else {
+      i++;
+    }
+  }
+  for (auto i = sFontDataTable.begin(); i != sFontDataTable.end();) {
+    if (i->first.mNamespace == aNamespace) {
+      i = sFontDataTable.erase(i);
+    } else {
+      i++;
+    }
+  }
+}
+
+bool HasFontData(WrFontKey aKey) {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  return sFontDataTable.find(aKey) != sFontDataTable.end();
+}
+
+void AddFontData(WrFontKey aKey, const uint8_t* aData, size_t aSize,
+                 uint32_t aIndex, const ArcVecU8* aVec) {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  auto i = sFontDataTable.find(aKey);
+  if (i == sFontDataTable.end()) {
+    FontTemplate& font = sFontDataTable[aKey];
+    font.mData = aData;
+    font.mSize = aSize;
+    font.mIndex = aIndex;
+    font.mVec = wr_add_ref_arc(aVec);
+  }
+}
+
+void AddNativeFontHandle(WrFontKey aKey, void* aHandle, uint32_t aIndex) {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  auto i = sFontDataTable.find(aKey);
+  if (i == sFontDataTable.end()) {
+    FontTemplate& font = sFontDataTable[aKey];
+#ifdef XP_DARWIN
+    font.mUnscaledFont =
+        new UnscaledFontMac(reinterpret_cast<CGFontRef>(aHandle), false);
+#elif defined(XP_WIN)
+    font.mUnscaledFont = new UnscaledFontDWrite(
+        reinterpret_cast<IDWriteFontFace*>(aHandle), nullptr);
+#elif defined(ANDROID)
+    font.mUnscaledFont = new UnscaledFontFreeType(
+        reinterpret_cast<const char*>(aHandle), aIndex);
+#else
+    font.mUnscaledFont = new UnscaledFontFontconfig(
+        reinterpret_cast<const char*>(aHandle), aIndex);
+#endif
+  }
+}
+
+void DeleteFontData(WrFontKey aKey) {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  sFontDeleteLog.Add(aKey);
+  auto i = sFontDataTable.find(aKey);
+  if (i != sFontDataTable.end()) {
+    sFontDataTable.erase(i);
+  }
+}
+
+void AddBlobFont(WrFontInstanceKey aInstanceKey, WrFontKey aFontKey,
+                 float aSize, const FontInstanceOptions* aOptions,
+                 const FontInstancePlatformOptions* aPlatformOptions,
+                 const FontVariation* aVariations, size_t aNumVariations) {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  auto i = sBlobFontTable.find(aInstanceKey);
+  if (i == sBlobFontTable.end()) {
+    FontInstanceData& font = sBlobFontTable[aInstanceKey];
+    font.mFontKey = aFontKey;
+    font.mSize = aSize;
+    if (aOptions) {
+      font.mOptions = Some(*aOptions);
+    }
+    if (aPlatformOptions) {
+      font.mPlatformOptions = Some(*aPlatformOptions);
+    }
+    if (aNumVariations) {
+      font.mNumVariations = aNumVariations;
+      font.mVariations.reset(new gfx::FontVariation[aNumVariations]);
+      PodCopy(font.mVariations.get(),
+              reinterpret_cast<const gfx::FontVariation*>(aVariations),
+              aNumVariations);
+    }
+  }
+}
+
+void DeleteBlobFont(WrFontInstanceKey aKey) {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  auto i = sBlobFontTable.find(aKey);
+  if (i != sBlobFontTable.end()) {
+    sBlobFontTable.erase(i);
+  }
+}
+
+}  // extern
+
+static RefPtr<UnscaledFont> GetUnscaledFont(Translator* aTranslator,
+                                            WrFontKey aKey) {
+  auto i = sFontDataTable.find(aKey);
+  if (i == sFontDataTable.end()) {
+    gfxDevCrash(LogReason::UnscaledFontNotFound)
+        << "Failed to get UnscaledFont entry for FontKey " << aKey.mHandle
+        << " because " << sFontDeleteLog.Find(aKey);
+    return nullptr;
+  }
+  FontTemplate& data = i->second;
+  if (data.mUnscaledFont) {
+    return data.mUnscaledFont;
+  }
+  MOZ_ASSERT(data.mData);
+  FontType type =
+#ifdef XP_DARWIN
+      FontType::MAC;
+#elif defined(XP_WIN)
+      FontType::DWRITE;
+#elif defined(ANDROID)
+      FontType::FREETYPE;
+#else
+      FontType::FONTCONFIG;
+#endif
+  // makes a copy of the data
+  RefPtr<NativeFontResource> fontResource = Factory::CreateNativeFontResource(
+      (uint8_t*)data.mData, data.mSize, type, aTranslator->GetFontContext());
+  RefPtr<UnscaledFont> unscaledFont;
+  if (!fontResource) {
+    gfxDevCrash(LogReason::NativeFontResourceNotFound)
+        << "Failed to create NativeFontResource for FontKey " << aKey.mHandle;
+  } else {
+    // Instance data is only needed for GDI fonts which webrender does not
+    // support.
+    unscaledFont = fontResource->CreateUnscaledFont(data.mIndex, nullptr, 0);
+    if (!unscaledFont) {
+      gfxDevCrash(LogReason::UnscaledFontNotFound)
+          << "Failed to create UnscaledFont for FontKey " << aKey.mHandle;
+    }
+  }
+  data.mUnscaledFont = unscaledFont;
+  return unscaledFont;
+}
+
+static RefPtr<ScaledFont> GetScaledFont(Translator* aTranslator,
+                                        WrFontInstanceKey aKey) {
+  StaticMutexAutoLock lock(sFontDataTableLock);
+  auto i = sBlobFontTable.find(aKey);
+  if (i == sBlobFontTable.end()) {
+    gfxDevCrash(LogReason::ScaledFontNotFound)
+        << "Failed to get ScaledFont entry for FontInstanceKey "
+        << aKey.mHandle;
+    return nullptr;
+  }
+  FontInstanceData& data = i->second;
+  if (data.mScaledFont) {
+    return data.mScaledFont;
+  }
+  RefPtr<UnscaledFont> unscaled = GetUnscaledFont(aTranslator, data.mFontKey);
+  if (!unscaled) {
+    return nullptr;
+  }
+  RefPtr<ScaledFont> scaled = unscaled->CreateScaledFontFromWRFont(
+      data.mSize, data.mOptions.ptrOr(nullptr),
+      data.mPlatformOptions.ptrOr(nullptr), data.mVariations.get(),
+      data.mNumVariations);
+  if (!scaled) {
+    gfxDevCrash(LogReason::ScaledFontNotFound)
+        << "Failed to create ScaledFont for FontKey " << aKey.mHandle;
+  }
+  data.mScaledFont = scaled;
+  return data.mScaledFont;
+}
+
+template <typename T>
+T ConvertFromBytes(const uint8_t* bytes) {
+  T t;
+  memcpy(&t, bytes, sizeof(T));
+  return t;
+}
+
+struct Reader {
+  const uint8_t* buf;
+  size_t len;
+  size_t pos;
+
+  Reader(const uint8_t* buf, size_t len) : buf(buf), len(len), pos(0) {}
+
+  template <typename T>
+  T Read() {
+    MOZ_RELEASE_ASSERT(pos + sizeof(T) <= len);
+    T ret = ConvertFromBytes<T>(buf + pos);
+    pos += sizeof(T);
+    return ret;
+  }
+
+  size_t ReadSize() { return Read<size_t>(); }
+  int ReadInt() { return Read<int>(); }
+
+  IntRectAbsolute ReadBounds() { return Read<IntRectAbsolute>(); }
+
+  layers::BlobFont ReadBlobFont() { return Read<layers::BlobFont>(); }
+};
+
+static bool Moz2DRenderCallback(const Range<const uint8_t> aBlob,
+                                gfx::SurfaceFormat aFormat,
+                                const mozilla::wr::DeviceIntRect* aVisibleRect,
+                                const mozilla::wr::LayoutIntRect* aRenderRect,
+                                const uint16_t aTileSize,
+                                const mozilla::wr::TileOffset* aTileOffset,
+                                const mozilla::wr::LayoutIntRect* aDirtyRect,
+                                Range<uint8_t> aOutput) {
+  IntSize size(aRenderRect->width(), aRenderRect->height());
+  AUTO_PROFILER_TRACING_MARKER("WebRender", "RasterizeSingleBlob", GRAPHICS);
+  MOZ_RELEASE_ASSERT(size.width > 0 && size.height > 0);
+  if (size.width <= 0 || size.height <= 0) {
+    return false;
+  }
+
+  auto stride = size.width * gfx::BytesPerPixel(aFormat);
+
+  if (aOutput.length() < static_cast<size_t>(size.height * stride)) {
+    return false;
+  }
+
+  // In bindings.rs we allocate a buffer filled with opaque white.
+  bool uninitialized = false;
+
+  RefPtr<gfx::DrawTarget> dt = gfx::Factory::CreateDrawTargetForData(
+      gfx::BackendType::SKIA, aOutput.begin().get(), size, stride, aFormat,
+      uninitialized);
+
+  if (!dt) {
+    return false;
+  }
+
+  // aRenderRect is the part of the blob that we are currently rendering
+  // (for example a tile) in the same coordinate space as aVisibleRect.
+  IntPoint origin = gfx::IntPoint(aRenderRect->min.x, aRenderRect->min.y);
+
+  dt = gfx::Factory::CreateOffsetDrawTarget(dt, origin);
+  if (!dt) {
+    return false;
+  }
+
+  // We try hard to not have empty blobs but we can end up with
+  // them because of CompositorHitTestInfo and merging.
+  size_t footerSize = sizeof(size_t);
+  MOZ_RELEASE_ASSERT(aBlob.length() >= footerSize);
+  size_t indexOffset = ConvertFromBytes<size_t>(aBlob.end().get() - footerSize);
+
+  MOZ_RELEASE_ASSERT(indexOffset <= aBlob.length() - footerSize);
+  Reader reader(aBlob.begin().get() + indexOffset,
+                aBlob.length() - footerSize - indexOffset);
+
+  auto bounds = gfx::IntRect(origin, size);
+
+  if (aDirtyRect) {
+    gfx::Rect dirty(aDirtyRect->min.x, aDirtyRect->min.y, aDirtyRect->width(),
+                    aDirtyRect->height());
+    dt->PushClipRect(dirty);
+    bounds =
+        bounds.Intersect(IntRect(aDirtyRect->min.x, aDirtyRect->min.y,
+                                 aDirtyRect->width(), aDirtyRect->height()));
+  }
+
+  bool ret = true;
+  size_t offset = 0;
+  auto absBounds = IntRectAbsolute::FromRect(bounds);
+  while (reader.pos < reader.len) {
+    size_t end = reader.ReadSize();
+    size_t extra_end = reader.ReadSize();
+    MOZ_RELEASE_ASSERT(extra_end >= end);
+    MOZ_RELEASE_ASSERT(extra_end < aBlob.length());
+
+    auto combinedBounds = absBounds.Intersect(reader.ReadBounds());
+    if (combinedBounds.IsEmpty()) {
+      offset = extra_end;
+      continue;
+    }
+
+    layers::WebRenderTranslator translator(dt);
+    Reader fontReader(aBlob.begin().get() + end, extra_end - end);
+    size_t count = fontReader.ReadSize();
+    for (size_t i = 0; i < count; i++) {
+      layers::BlobFont blobFont = fontReader.ReadBlobFont();
+      RefPtr<ScaledFont> scaledFont =
+          GetScaledFont(&translator, blobFont.mFontInstanceKey);
+      translator.AddScaledFont(blobFont.mScaledFontPtr, scaledFont);
+    }
+
+    Range<const uint8_t> blob(aBlob.begin() + offset, aBlob.begin() + end);
+    ret =
+        translator.TranslateRecording((char*)blob.begin().get(), blob.length());
+    if (!ret) {
+      gfxCriticalNote << "Replay failure: " << translator.GetError();
+      MOZ_RELEASE_ASSERT(false);
+    }
+    offset = extra_end;
+  }
+
+  if (StaticPrefs::gfx_webrender_debug_blob_paint_flashing()) {
+    dt->SetTransform(gfx::Matrix());
+    float r = float(rand()) / float(RAND_MAX);
+    float g = float(rand()) / float(RAND_MAX);
+    float b = float(rand()) / float(RAND_MAX);
+    dt->FillRect(gfx::Rect(origin.x, origin.y, size.width, size.height),
+                 gfx::ColorPattern(gfx::DeviceColor(r, g, b, 0.5)));
+  }
+
+  if (aDirtyRect) {
+    dt->PopClip();
+  }
+
+#if 0
+  static int i = 0;
+  char filename[40];
+  sprintf(filename, "out%d.png", i++);
+  gfxUtils::WriteAsPNG(dt, filename);
+#endif
+
+  return ret;
+}
+
+}  // namespace wr
+}  // namespace mozilla
+
+extern "C" {
+
+bool wr_moz2d_render_cb(const mozilla::wr::ByteSlice blob,
+                        mozilla::wr::ImageFormat aFormat,
+                        const mozilla::wr::LayoutIntRect* aRenderRect,
+                        const mozilla::wr::DeviceIntRect* aVisibleRect,
+                        const uint16_t aTileSize,
+                        const mozilla::wr::TileOffset* aTileOffset,
+                        const mozilla::wr::LayoutIntRect* aDirtyRect,
+                        mozilla::wr::MutByteSlice output) {
+  return mozilla::wr::Moz2DRenderCallback(
+      mozilla::wr::ByteSliceToRange(blob),
+      mozilla::wr::ImageFormatToSurfaceFormat(aFormat), aVisibleRect,
+      aRenderRect, aTileSize, aTileOffset, aDirtyRect,
+      mozilla::wr::MutByteSliceToRange(output));
+}
+
+}  // extern
diff --git a/gfx/webrender_bindings/README.webrender b/gfx/webrender_bindings/README.webrender
new file mode 100644
index 0000000000..e4c0d5f60b
--- /dev/null
+++ b/gfx/webrender_bindings/README.webrender
@@ -0,0 +1,23 @@
+To build and run WebRender in Gecko:
+1. Install Rust if you don't have it already
+   If you are doing gecko builds already, you should already have Rust as it is a build requirement.
+   If not, you can install it using |mach bootstrap| (recommended) or from https://www.rust-lang.org/
+       Note: If installing manually, use the stable 64-bit release - on Windows make sure to use the MSVC ABI installer.
+   Ensure that rustc and cargo are in your $PATH (adding $HOME/.cargo/bin/ should be sufficient)
+2. Build using |mach build|.
+   You don't need anything special in your mozconfig for local builds; webrender will be built by default.
+3. Run with |MOZ_WEBRENDER=1| in your environment. e.g. |MOZ_WEBRENDER=1 ./mach run|.
+   Alternatively, you can set the gfx.webrender.all pref to true (browser restart required).
+   Note that on Linux, acceleration is disabled by default and it needs to be enabled for WebRender to work.
+   On Linux you can enable acceleration by putting |MOZ_ACCELERATED=1| in your environment, or setting layers.acceleration.force-enabled to true in about:config.
+4. Verify WebRender is enabled. You can do this by going to about:support and checking the "Compositing" line in the Graphics section. It should say "WebRender".
+   There should also be a WebRender section under "Decision Log" in about:support, which will provide some more detail on what caused it to be enabled/disabled.
+
+When making changes:
+    - Make the changes you want.
+    - Run |mach build| or |mach build binaries| as desired.
+
+For a debug webrender build:
+    Use a debug mozconfig (ac_add_options --enable-debug)
+    You can also use an opt build but make webrender less optimized by putting opt-level=0 in the [profile.release] section of your toolkit/library/rust/Cargo.toml file
+    See also https://groups.google.com/forum/#!topic/mozilla.dev.servo/MbeMcqqO1fs
diff --git a/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp
new file mode 100644
index 0000000000..779b376290
--- /dev/null
+++ b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp
@@ -0,0 +1,248 @@
+/* -*- 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 "RenderAndroidHardwareBufferTextureHost.h"
+
+#include "mozilla/layers/AndroidHardwareBuffer.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/gfx/2D.h"
+#include "GLContextEGL.h"
+#include "GLLibraryEGL.h"
+#include "GLReadTexImageHelper.h"
+#include "OGLShaderConfig.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderAndroidHardwareBufferTextureHost::RenderAndroidHardwareBufferTextureHost(
+    layers::AndroidHardwareBuffer* aAndroidHardwareBuffer)
+    : mAndroidHardwareBuffer(aAndroidHardwareBuffer),
+      mEGLImage(EGL_NO_IMAGE),
+      mTextureHandle(0) {
+  MOZ_ASSERT(mAndroidHardwareBuffer);
+  MOZ_COUNT_CTOR_INHERITED(RenderAndroidHardwareBufferTextureHost,
+                           RenderTextureHost);
+}
+
+RenderAndroidHardwareBufferTextureHost::
+    ~RenderAndroidHardwareBufferTextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderAndroidHardwareBufferTextureHost,
+                           RenderTextureHost);
+  DeleteTextureHandle();
+  DestroyEGLImage();
+}
+
+gfx::IntSize RenderAndroidHardwareBufferTextureHost::GetSize() const {
+  if (mAndroidHardwareBuffer) {
+    return mAndroidHardwareBuffer->mSize;
+  }
+  return gfx::IntSize();
+}
+
+bool RenderAndroidHardwareBufferTextureHost::EnsureLockable() {
+  if (!mAndroidHardwareBuffer) {
+    return false;
+  }
+
+  auto fenceFd = mAndroidHardwareBuffer->GetAndResetAcquireFence();
+  if (fenceFd.IsValid()) {
+    const auto& gle = gl::GLContextEGL::Cast(mGL);
+    const auto& egl = gle->mEgl;
+
+    auto rawFD = fenceFd.TakePlatformHandle();
+    const EGLint attribs[] = {LOCAL_EGL_SYNC_NATIVE_FENCE_FD_ANDROID,
+                              rawFD.get(), LOCAL_EGL_NONE};
+
+    EGLSync sync =
+        egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
+    if (sync) {
+      // Release fd here, since it is owned by EGLSync
+      Unused << rawFD.release();
+
+      if (egl->IsExtensionSupported(gl::EGLExtension::KHR_wait_sync)) {
+        egl->fWaitSync(sync, 0);
+      } else {
+        egl->fClientWaitSync(sync, 0, LOCAL_EGL_FOREVER);
+      }
+      egl->fDestroySync(sync);
+    } else {
+      gfxCriticalNote << "Failed to create EGLSync from acquire fence fd";
+    }
+  }
+
+  if (mTextureHandle) {
+    return true;
+  }
+
+  if (!mEGLImage) {
+    // XXX add crop handling for video
+    // Should only happen the first time.
+    const auto& gle = gl::GLContextEGL::Cast(mGL);
+    const auto& egl = gle->mEgl;
+
+    const EGLint attrs[] = {
+        LOCAL_EGL_IMAGE_PRESERVED,
+        LOCAL_EGL_TRUE,
+        LOCAL_EGL_NONE,
+        LOCAL_EGL_NONE,
+    };
+
+    EGLClientBuffer clientBuffer = egl->mLib->fGetNativeClientBufferANDROID(
+        mAndroidHardwareBuffer->GetNativeBuffer());
+    mEGLImage = egl->fCreateImage(
+        EGL_NO_CONTEXT, LOCAL_EGL_NATIVE_BUFFER_ANDROID, clientBuffer, attrs);
+  }
+  MOZ_ASSERT(mEGLImage);
+
+  mGL->fGenTextures(1, &mTextureHandle);
+  mGL->fBindTexture(LOCAL_GL_TEXTURE_EXTERNAL, mTextureHandle);
+  mGL->fTexParameteri(LOCAL_GL_TEXTURE_EXTERNAL, LOCAL_GL_TEXTURE_WRAP_T,
+                      LOCAL_GL_CLAMP_TO_EDGE);
+  mGL->fTexParameteri(LOCAL_GL_TEXTURE_EXTERNAL, LOCAL_GL_TEXTURE_WRAP_S,
+                      LOCAL_GL_CLAMP_TO_EDGE);
+  mGL->fEGLImageTargetTexture2D(LOCAL_GL_TEXTURE_EXTERNAL, mEGLImage);
+
+  ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0,
+                               LOCAL_GL_TEXTURE_EXTERNAL_OES, mTextureHandle);
+  return true;
+}
+
+wr::WrExternalImage RenderAndroidHardwareBufferTextureHost::Lock(
+    uint8_t aChannelIndex, gl::GLContext* aGL) {
+  MOZ_ASSERT(aChannelIndex == 0);
+
+  if (mGL.get() != aGL) {
+    if (mGL) {
+      // This should not happen.
+      MOZ_ASSERT_UNREACHABLE("Unexpected GL context");
+      return InvalidToWrExternalImage();
+    }
+    mGL = aGL;
+  }
+
+  if (!mGL || !mGL->MakeCurrent()) {
+    return InvalidToWrExternalImage();
+  }
+
+  if (!EnsureLockable()) {
+    return InvalidToWrExternalImage();
+  }
+
+  const auto uvs = GetUvCoords(GetSize());
+  return NativeTextureToWrExternalImage(
+      mTextureHandle, uvs.first.x, uvs.first.y, uvs.second.x, uvs.second.y);
+}
+
+void RenderAndroidHardwareBufferTextureHost::Unlock() {}
+
+size_t RenderAndroidHardwareBufferTextureHost::Bytes() {
+  return GetSize().width * GetSize().height *
+         BytesPerPixel(mAndroidHardwareBuffer->mFormat);
+}
+
+void RenderAndroidHardwareBufferTextureHost::DeleteTextureHandle() {
+  if (!mTextureHandle) {
+    return;
+  }
+  MOZ_ASSERT(mGL);
+  mGL->fDeleteTextures(1, &mTextureHandle);
+  mTextureHandle = 0;
+}
+
+void RenderAndroidHardwareBufferTextureHost::DestroyEGLImage() {
+  if (!mEGLImage) {
+    return;
+  }
+  MOZ_ASSERT(mGL);
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+  egl->fDestroyImage(mEGLImage);
+  mEGLImage = EGL_NO_IMAGE;
+}
+
+gfx::SurfaceFormat RenderAndroidHardwareBufferTextureHost::GetFormat() const {
+  MOZ_ASSERT(mAndroidHardwareBuffer->mFormat == gfx::SurfaceFormat::R8G8B8A8 ||
+             mAndroidHardwareBuffer->mFormat == gfx::SurfaceFormat::R8G8B8X8);
+
+  if (mAndroidHardwareBuffer->mFormat == gfx::SurfaceFormat::R8G8B8A8) {
+    return gfx::SurfaceFormat::B8G8R8A8;
+  }
+
+  if (mAndroidHardwareBuffer->mFormat == gfx::SurfaceFormat::R8G8B8X8) {
+    return gfx::SurfaceFormat::B8G8R8X8;
+  }
+
+  gfxCriticalNoteOnce
+      << "Unexpected color format of RenderAndroidSurfaceTextureHost";
+
+  return gfx::SurfaceFormat::UNKNOWN;
+}
+
+already_AddRefed<gfx::DataSourceSurface>
+RenderAndroidHardwareBufferTextureHost::ReadTexImage() {
+  if (!mGL) {
+    mGL = RenderThread::Get()->SingletonGL();
+    if (!mGL) {
+      return nullptr;
+    }
+  }
+
+  if (!EnsureLockable()) {
+    return nullptr;
+  }
+
+  /* Allocate resulting image surface */
+  int32_t stride = GetSize().width * BytesPerPixel(GetFormat());
+  RefPtr<gfx::DataSourceSurface> surf =
+      gfx::Factory::CreateDataSourceSurfaceWithStride(GetSize(), GetFormat(),
+                                                      stride);
+  if (!surf) {
+    return nullptr;
+  }
+
+  layers::ShaderConfigOGL config = layers::ShaderConfigFromTargetAndFormat(
+      LOCAL_GL_TEXTURE_EXTERNAL, mAndroidHardwareBuffer->mFormat);
+  int shaderConfig = config.mFeatures;
+
+  bool ret = mGL->ReadTexImageHelper()->ReadTexImage(
+      surf, mTextureHandle, LOCAL_GL_TEXTURE_EXTERNAL, GetSize(), shaderConfig,
+      /* aYInvert */ false);
+  if (!ret) {
+    return nullptr;
+  }
+
+  return surf.forget();
+}
+
+bool RenderAndroidHardwareBufferTextureHost::MapPlane(
+    RenderCompositor* aCompositor, uint8_t aChannelIndex,
+    PlaneInfo& aPlaneInfo) {
+  RefPtr<gfx::DataSourceSurface> readback = ReadTexImage();
+  if (!readback) {
+    return false;
+  }
+
+  gfx::DataSourceSurface::MappedSurface map;
+  if (!readback->Map(gfx::DataSourceSurface::MapType::READ, &map)) {
+    return false;
+  }
+
+  mReadback = readback;
+  aPlaneInfo.mSize = GetSize();
+  aPlaneInfo.mStride = map.mStride;
+  aPlaneInfo.mData = map.mData;
+  return true;
+}
+
+void RenderAndroidHardwareBufferTextureHost::UnmapPlanes() {
+  if (mReadback) {
+    mReadback->Unmap();
+    mReadback = nullptr;
+  }
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.h b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.h
new file mode 100644
index 0000000000..cd79c791ed
--- /dev/null
+++ b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.h
@@ -0,0 +1,73 @@
+/* -*- 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_RenderAndroidHardwareBufferTextureHost_H
+#define MOZILLA_GFX_RenderAndroidHardwareBufferTextureHost_H
+
+#include "GLContextTypes.h"
+#include "GLTypes.h"
+#include "RenderTextureHostSWGL.h"
+
+namespace mozilla {
+
+namespace layers {
+class AndroidHardwareBuffer;
+}
+
+namespace wr {
+
+class RenderAndroidHardwareBufferTextureHost final
+    : public RenderTextureHostSWGL {
+ public:
+  explicit RenderAndroidHardwareBufferTextureHost(
+      layers::AndroidHardwareBuffer* aAndroidHardwareBuffer);
+
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+
+  size_t Bytes() override;
+
+  RenderAndroidHardwareBufferTextureHost*
+  AsRenderAndroidHardwareBufferTextureHost() override {
+    return this;
+  }
+
+  // RenderTextureHostSWGL
+  gfx::SurfaceFormat GetFormat() const override;
+  gfx::ColorDepth GetColorDepth() const override {
+    return gfx::ColorDepth::COLOR_8;
+  }
+  size_t GetPlaneCount() const override { return 1; }
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+  void UnmapPlanes() override;
+
+  layers::AndroidHardwareBuffer* GetAndroidHardwareBuffer() {
+    return mAndroidHardwareBuffer;
+  }
+
+  gfx::IntSize GetSize() const;
+
+ private:
+  virtual ~RenderAndroidHardwareBufferTextureHost();
+  bool EnsureLockable();
+  void DestroyEGLImage();
+  void DeleteTextureHandle();
+  already_AddRefed<gfx::DataSourceSurface> ReadTexImage();
+
+  const RefPtr<layers::AndroidHardwareBuffer> mAndroidHardwareBuffer;
+
+  RefPtr<gl::GLContext> mGL;
+  EGLImage mEGLImage;
+  GLuint mTextureHandle;
+
+  RefPtr<gfx::DataSourceSurface> mReadback;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RenderAndroidHardwareBufferTextureHost_H
diff --git a/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp
new file mode 100644
index 0000000000..2293babf2e
--- /dev/null
+++ b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp
@@ -0,0 +1,326 @@
+/* -*- 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 "RenderAndroidSurfaceTextureHost.h"
+
+#include "GLReadTexImageHelper.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "GLContext.h"
+#include "AndroidSurfaceTexture.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderAndroidSurfaceTextureHost::RenderAndroidSurfaceTextureHost(
+    const java::GeckoSurfaceTexture::GlobalRef& aSurfTex, gfx::IntSize aSize,
+    gfx::SurfaceFormat aFormat, bool aContinuousUpdate,
+    Maybe<gfx::Matrix4x4> aTransformOverride, bool aIsRemoteTexture)
+    : mSurfTex(aSurfTex),
+      mSize(aSize),
+      mFormat(aFormat),
+      mContinuousUpdate(aContinuousUpdate),
+      mTransformOverride(aTransformOverride),
+      mPrepareStatus(STATUS_NONE),
+      mAttachedToGLContext(false),
+      mIsRemoteTexture(aIsRemoteTexture) {
+  MOZ_COUNT_CTOR_INHERITED(RenderAndroidSurfaceTextureHost, RenderTextureHost);
+
+  if (mSurfTex) {
+    mSurfTex->IncrementUse();
+  }
+}
+
+RenderAndroidSurfaceTextureHost::~RenderAndroidSurfaceTextureHost() {
+  MOZ_ASSERT(RenderThread::IsInRenderThread());
+  MOZ_COUNT_DTOR_INHERITED(RenderAndroidSurfaceTextureHost, RenderTextureHost);
+  // The SurfaceTexture gets destroyed when its use count reaches zero.
+  if (mSurfTex) {
+    mSurfTex->DecrementUse();
+  }
+}
+
+wr::WrExternalImage RenderAndroidSurfaceTextureHost::Lock(uint8_t aChannelIndex,
+                                                          gl::GLContext* aGL) {
+  MOZ_ASSERT(aChannelIndex == 0);
+  MOZ_ASSERT((mPrepareStatus == STATUS_PREPARED) ||
+             (!mSurfTex->IsSingleBuffer() &&
+              mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) ||
+             mIsRemoteTexture);
+
+  if (mIsRemoteTexture) {
+    EnsureAttachedToGLContext();
+  }
+
+  if (mGL.get() != aGL) {
+    // This should not happen. On android, SingletonGL is used.
+    MOZ_ASSERT_UNREACHABLE("Unexpected GL context");
+    return InvalidToWrExternalImage();
+  }
+
+  if (!mSurfTex || !mGL || !mGL->MakeCurrent()) {
+    return InvalidToWrExternalImage();
+  }
+
+  MOZ_ASSERT(mAttachedToGLContext);
+  if (!mAttachedToGLContext) {
+    return InvalidToWrExternalImage();
+  }
+
+  UpdateTexImageIfNecessary();
+
+  const auto uvs = GetUvCoords(mSize);
+  return NativeTextureToWrExternalImage(mSurfTex->GetTexName(), uvs.first.x,
+                                        uvs.first.y, uvs.second.x,
+                                        uvs.second.y);
+}
+
+void RenderAndroidSurfaceTextureHost::Unlock() {}
+
+bool RenderAndroidSurfaceTextureHost::EnsureAttachedToGLContext() {
+  // During handling WebRenderError, GeckoSurfaceTexture should not be attached
+  // to GLContext.
+  if (RenderThread::Get()->IsHandlingWebRenderError()) {
+    return false;
+  }
+
+  if (mAttachedToGLContext) {
+    return true;
+  }
+
+  if (!mGL) {
+    mGL = RenderThread::Get()->SingletonGL();
+  }
+
+  if (!mSurfTex || !mGL || !mGL->MakeCurrent()) {
+    return false;
+  }
+
+  if (!mSurfTex->IsAttachedToGLContext((int64_t)mGL.get())) {
+    GLuint texName;
+    mGL->fGenTextures(1, &texName);
+    ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0,
+                                 LOCAL_GL_TEXTURE_EXTERNAL_OES, texName);
+
+    if (NS_FAILED(mSurfTex->AttachToGLContext((int64_t)mGL.get(), texName))) {
+      MOZ_ASSERT(0);
+      mGL->fDeleteTextures(1, &texName);
+      return false;
+    }
+  }
+
+  mAttachedToGLContext = true;
+  return true;
+}
+
+void RenderAndroidSurfaceTextureHost::PrepareForUse() {
+  // When SurfaceTexture is single buffer mode, UpdateTexImage needs to be
+  // called only once for each publish. If UpdateTexImage is called more
+  // than once, it causes hang on puglish side. And UpdateTexImage needs to
+  // be called on render thread, since the SurfaceTexture is consumed on render
+  // thread.
+  MOZ_ASSERT(RenderThread::IsInRenderThread());
+  MOZ_ASSERT(mPrepareStatus == STATUS_NONE);
+
+  if (mContinuousUpdate || !mSurfTex) {
+    return;
+  }
+
+  mPrepareStatus = STATUS_MIGHT_BE_USED_BY_WR;
+
+  if (mSurfTex->IsSingleBuffer()) {
+    EnsureAttachedToGLContext();
+    // When SurfaceTexture is single buffer mode, it is OK to call
+    // UpdateTexImage() here.
+    mSurfTex->UpdateTexImage();
+    mPrepareStatus = STATUS_PREPARED;
+  }
+}
+
+void RenderAndroidSurfaceTextureHost::NotifyForUse() {
+  MOZ_ASSERT(RenderThread::IsInRenderThread());
+
+  if (mPrepareStatus == STATUS_MIGHT_BE_USED_BY_WR) {
+    // This happens when SurfaceTexture of video is rendered on WebRender.
+    // There is a case that SurfaceTexture is not rendered on WebRender, instead
+    // it is rendered to WebGL and the SurfaceTexture should not be attached to
+    // gl context of WebRender. It is ugly. But it is same as Compositor
+    // rendering.
+    MOZ_ASSERT(!mSurfTex->IsSingleBuffer());
+    if (!EnsureAttachedToGLContext()) {
+      return;
+    }
+    mPrepareStatus = STATUS_UPDATE_TEX_IMAGE_NEEDED;
+  }
+}
+
+void RenderAndroidSurfaceTextureHost::NotifyNotUsed() {
+  MOZ_ASSERT(RenderThread::IsInRenderThread());
+
+  if (!mSurfTex) {
+    MOZ_ASSERT(mPrepareStatus == STATUS_NONE);
+    return;
+  }
+
+  if (mIsRemoteTexture) {
+    UpdateTexImageIfNecessary();
+  }
+
+  if (mSurfTex->IsSingleBuffer()) {
+    MOZ_ASSERT(mPrepareStatus == STATUS_PREPARED);
+    MOZ_ASSERT(mAttachedToGLContext);
+    // Release SurfaceTexture's buffer to client side.
+    mGL->MakeCurrent();
+    mSurfTex->ReleaseTexImage();
+  } else if (mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) {
+    MOZ_ASSERT(mAttachedToGLContext);
+    // This could happen when video frame was skipped. UpdateTexImage() neeeds
+    // to be called for adjusting SurfaceTexture's buffer status.
+    mSurfTex->UpdateTexImage();
+  }
+
+  mPrepareStatus = STATUS_NONE;
+}
+
+void RenderAndroidSurfaceTextureHost::UpdateTexImageIfNecessary() {
+  if (mIsRemoteTexture) {
+    EnsureAttachedToGLContext();
+    if (mPrepareStatus == STATUS_NONE) {
+      PrepareForUse();
+    }
+    if (mPrepareStatus == STATUS_MIGHT_BE_USED_BY_WR) {
+      NotifyForUse();
+    }
+  }
+
+  if (mContinuousUpdate) {
+    MOZ_ASSERT(!mSurfTex->IsSingleBuffer());
+    mSurfTex->UpdateTexImage();
+  } else if (mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) {
+    MOZ_ASSERT(!mSurfTex->IsSingleBuffer());
+    // When SurfaceTexture is not single buffer mode, call UpdateTexImage() once
+    // just before rendering. During playing video, one SurfaceTexture is used
+    // for all RenderAndroidSurfaceTextureHosts of video.
+    mSurfTex->UpdateTexImage();
+    mPrepareStatus = STATUS_PREPARED;
+  }
+}
+
+gfx::SurfaceFormat RenderAndroidSurfaceTextureHost::GetFormat() const {
+  MOZ_ASSERT(mFormat == gfx::SurfaceFormat::R8G8B8A8 ||
+             mFormat == gfx::SurfaceFormat::R8G8B8X8);
+
+  if (mFormat == gfx::SurfaceFormat::R8G8B8A8) {
+    return gfx::SurfaceFormat::B8G8R8A8;
+  }
+
+  if (mFormat == gfx::SurfaceFormat::R8G8B8X8) {
+    return gfx::SurfaceFormat::B8G8R8X8;
+  }
+
+  gfxCriticalNoteOnce
+      << "Unexpected color format of RenderAndroidSurfaceTextureHost";
+
+  return gfx::SurfaceFormat::UNKNOWN;
+}
+
+already_AddRefed<gfx::DataSourceSurface>
+RenderAndroidSurfaceTextureHost::ReadTexImage() {
+  if (!mGL) {
+    mGL = RenderThread::Get()->SingletonGL();
+    if (!mGL) {
+      return nullptr;
+    }
+  }
+
+  /* Allocate resulting image surface */
+  int32_t stride = mSize.width * BytesPerPixel(GetFormat());
+  RefPtr<gfx::DataSourceSurface> surf =
+      gfx::Factory::CreateDataSourceSurfaceWithStride(mSize, GetFormat(),
+                                                      stride);
+  if (!surf) {
+    return nullptr;
+  }
+
+  layers::ShaderConfigOGL config = layers::ShaderConfigFromTargetAndFormat(
+      LOCAL_GL_TEXTURE_EXTERNAL, mFormat);
+  int shaderConfig = config.mFeatures;
+
+  bool ret = mGL->ReadTexImageHelper()->ReadTexImage(
+      surf, mSurfTex->GetTexName(), LOCAL_GL_TEXTURE_EXTERNAL, mSize,
+      shaderConfig, /* aYInvert */ false);
+  if (!ret) {
+    return nullptr;
+  }
+
+  return surf.forget();
+}
+
+bool RenderAndroidSurfaceTextureHost::MapPlane(RenderCompositor* aCompositor,
+                                               uint8_t aChannelIndex,
+                                               PlaneInfo& aPlaneInfo) {
+  UpdateTexImageIfNecessary();
+
+  RefPtr<gfx::DataSourceSurface> readback = ReadTexImage();
+  if (!readback) {
+    return false;
+  }
+
+  gfx::DataSourceSurface::MappedSurface map;
+  if (!readback->Map(gfx::DataSourceSurface::MapType::READ, &map)) {
+    return false;
+  }
+
+  mReadback = readback;
+  aPlaneInfo.mSize = mSize;
+  aPlaneInfo.mStride = map.mStride;
+  aPlaneInfo.mData = map.mData;
+  return true;
+}
+
+void RenderAndroidSurfaceTextureHost::UnmapPlanes() {
+  if (mReadback) {
+    mReadback->Unmap();
+    mReadback = nullptr;
+  }
+}
+
+std::pair<gfx::Point, gfx::Point> RenderAndroidSurfaceTextureHost::GetUvCoords(
+    gfx::IntSize aTextureSize) const {
+  gfx::Matrix4x4 transform;
+
+  // GetTransformMatrix() returns the transform set by the producer side of the
+  // SurfaceTexture that must be applied to texture coordinates when
+  // sampling. In some cases we may have set an override value, such as in
+  // AndroidNativeWindowTextureData where we own the producer side, or for
+  // MediaCodec output on devices where where we know the value is incorrect.
+  if (mTransformOverride) {
+    transform = *mTransformOverride;
+  } else if (mSurfTex) {
+    const auto& surf = java::sdk::SurfaceTexture::LocalRef(
+        java::sdk::SurfaceTexture::Ref::From(mSurfTex));
+    gl::AndroidSurfaceTexture::GetTransformMatrix(surf, &transform);
+  }
+
+  // We expect this transform to always be rectilinear, usually just a
+  // y-flip and sometimes an x and y scale. This allows this function
+  // to simply transform and return 2 points here instead of 4.
+  MOZ_ASSERT(transform.IsRectilinear(),
+             "Unexpected non-rectilinear transform returned from "
+             "SurfaceTexture.GetTransformMatrix()");
+
+  transform.PostScale(aTextureSize.width, aTextureSize.height, 0.0);
+
+  gfx::Point uv0 = gfx::Point(0.0, 0.0);
+  gfx::Point uv1 = gfx::Point(1.0, 1.0);
+  uv0 = transform.TransformPoint(uv0);
+  uv1 = transform.TransformPoint(uv1);
+
+  return std::make_pair(uv0, uv1);
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.h b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.h
new file mode 100644
index 0000000000..1a6238a72f
--- /dev/null
+++ b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.h
@@ -0,0 +1,96 @@
+/* -*- 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_RENDERANDROIDSURFACETEXTUREHOST_H
+#define MOZILLA_GFX_RENDERANDROIDSURFACETEXTUREHOST_H
+
+#include "mozilla/java/GeckoSurfaceTextureWrappers.h"
+#include "mozilla/layers/TextureHostOGL.h"
+#include "RenderTextureHostSWGL.h"
+
+namespace mozilla {
+
+namespace gfx {
+class DataSourceSurface;
+}
+
+namespace wr {
+
+class RenderAndroidSurfaceTextureHost final : public RenderTextureHostSWGL {
+ public:
+  explicit RenderAndroidSurfaceTextureHost(
+      const java::GeckoSurfaceTexture::GlobalRef& aSurfTex, gfx::IntSize aSize,
+      gfx::SurfaceFormat aFormat, bool aContinuousUpdate,
+      Maybe<gfx::Matrix4x4> aTransformOverride, bool aIsRemoteTexture);
+
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+
+  size_t Bytes() override {
+    return mSize.width * mSize.height * BytesPerPixel(mFormat);
+  }
+
+  void PrepareForUse() override;
+  void NotifyForUse() override;
+  void NotifyNotUsed() override;
+
+  // RenderTextureHostSWGL
+  gfx::SurfaceFormat GetFormat() const override;
+  gfx::ColorDepth GetColorDepth() const override {
+    return gfx::ColorDepth::COLOR_8;
+  }
+  size_t GetPlaneCount() const override { return 1; }
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+  void UnmapPlanes() override;
+
+  RenderAndroidSurfaceTextureHost* AsRenderAndroidSurfaceTextureHost()
+      override {
+    return this;
+  }
+
+  void UpdateTexImageIfNecessary();
+
+  mozilla::java::GeckoSurfaceTexture::GlobalRef mSurfTex;
+  const gfx::IntSize mSize;
+  const gfx::SurfaceFormat mFormat;
+  // mContinuousUpdate was used for rendering video in the past.
+  // It is not used on current gecko.
+  const bool mContinuousUpdate;
+  const Maybe<gfx::Matrix4x4> mTransformOverride;
+
+ private:
+  virtual ~RenderAndroidSurfaceTextureHost();
+  bool EnsureAttachedToGLContext();
+
+  already_AddRefed<gfx::DataSourceSurface> ReadTexImage();
+
+  // Returns the UV coordinates to be used when sampling the texture, taking in
+  // to account the SurfaceTexture's transform if applicable.
+  std::pair<gfx::Point, gfx::Point> GetUvCoords(
+      gfx::IntSize aTextureSize) const override;
+
+  enum PrepareStatus {
+    STATUS_NONE,
+    STATUS_MIGHT_BE_USED_BY_WR,
+    STATUS_UPDATE_TEX_IMAGE_NEEDED,
+    STATUS_PREPARED
+  };
+
+  PrepareStatus mPrepareStatus;
+  bool mAttachedToGLContext;
+
+  RefPtr<gl::GLContext> mGL;
+
+  RefPtr<gfx::DataSourceSurface> mReadback;
+
+  bool mIsRemoteTexture;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERANDROIDSURFACETEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderBufferTextureHost.cpp b/gfx/webrender_bindings/RenderBufferTextureHost.cpp
new file mode 100644
index 0000000000..920556c7ef
--- /dev/null
+++ b/gfx/webrender_bindings/RenderBufferTextureHost.cpp
@@ -0,0 +1,254 @@
+/* -*- 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 "RenderBufferTextureHost.h"
+
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/ImageDataSerializer.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderBufferTextureHost::RenderBufferTextureHost(
+    uint8_t* aBuffer, const layers::BufferDescriptor& aDescriptor)
+    : mBuffer(aBuffer),
+      mDescriptor(aDescriptor),
+      mMap(),
+      mYMap(),
+      mCbMap(),
+      mCrMap(),
+      mLocked(false) {
+  MOZ_COUNT_CTOR_INHERITED(RenderBufferTextureHost, RenderTextureHost);
+
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor: {
+      const layers::YCbCrDescriptor& ycbcr = mDescriptor.get_YCbCrDescriptor();
+      mSize = ycbcr.display().Size();
+      mFormat = gfx::SurfaceFormat::YUV;
+      break;
+    }
+    case layers::BufferDescriptor::TRGBDescriptor: {
+      const layers::RGBDescriptor& rgb = mDescriptor.get_RGBDescriptor();
+      mSize = rgb.size();
+      mFormat = rgb.format();
+      break;
+    }
+    default:
+      gfxCriticalError() << "Bad buffer host descriptor "
+                         << (int)mDescriptor.type();
+      MOZ_CRASH("GFX: Bad descriptor");
+  }
+}
+
+RenderBufferTextureHost::~RenderBufferTextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderBufferTextureHost, RenderTextureHost);
+}
+
+wr::WrExternalImage RenderBufferTextureHost::Lock(uint8_t aChannelIndex,
+                                                  gl::GLContext* aGL) {
+  if (!mLocked) {
+    if (!GetBuffer()) {
+      if (!mDestroyed) {
+        // We hit some problems to get the shmem.
+        gfxCriticalNote << "GetBuffer Failed";
+      }
+      return InvalidToWrExternalImage();
+    }
+    if (mFormat != gfx::SurfaceFormat::YUV) {
+      mSurface = gfx::Factory::CreateWrappingDataSourceSurface(
+          GetBuffer(),
+          layers::ImageDataSerializer::GetRGBStride(
+              mDescriptor.get_RGBDescriptor()),
+          mSize, mFormat);
+      if (NS_WARN_IF(!mSurface)) {
+        gfxCriticalNote << "DataSourceSurface is null";
+        return InvalidToWrExternalImage();
+      }
+      if (NS_WARN_IF(
+              !mSurface->Map(gfx::DataSourceSurface::MapType::READ, &mMap))) {
+        mSurface = nullptr;
+        gfxCriticalNote << "Failed to map Surface";
+        return InvalidToWrExternalImage();
+      }
+    } else {
+      const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
+      auto cbcrSize = layers::ImageDataSerializer::GetCroppedCbCrSize(desc);
+
+      mYSurface = gfx::Factory::CreateWrappingDataSourceSurface(
+          layers::ImageDataSerializer::GetYChannel(GetBuffer(), desc),
+          desc.yStride(), desc.display().Size(), gfx::SurfaceFormat::A8);
+      mCbSurface = gfx::Factory::CreateWrappingDataSourceSurface(
+          layers::ImageDataSerializer::GetCbChannel(GetBuffer(), desc),
+          desc.cbCrStride(), cbcrSize, gfx::SurfaceFormat::A8);
+      mCrSurface = gfx::Factory::CreateWrappingDataSourceSurface(
+          layers::ImageDataSerializer::GetCrChannel(GetBuffer(), desc),
+          desc.cbCrStride(), cbcrSize, gfx::SurfaceFormat::A8);
+      if (NS_WARN_IF(!mYSurface || !mCbSurface || !mCrSurface)) {
+        mYSurface = mCbSurface = mCrSurface = nullptr;
+        gfxCriticalNote << "YCbCr Surface is null";
+        return InvalidToWrExternalImage();
+      }
+      if (NS_WARN_IF(
+              !mYSurface->Map(gfx::DataSourceSurface::MapType::READ, &mYMap) ||
+              !mCbSurface->Map(gfx::DataSourceSurface::MapType::READ,
+                               &mCbMap) ||
+              !mCrSurface->Map(gfx::DataSourceSurface::MapType::READ,
+                               &mCrMap))) {
+        mYSurface = mCbSurface = mCrSurface = nullptr;
+        gfxCriticalNote << "Failed to map YCbCr Surface";
+        return InvalidToWrExternalImage();
+      }
+    }
+    mLocked = true;
+  }
+
+  RenderBufferData data = GetBufferDataForRender(aChannelIndex);
+  return RawDataToWrExternalImage(data.mData, data.mBufferSize);
+}
+
+void RenderBufferTextureHost::Unlock() {
+  if (mLocked) {
+    if (mSurface) {
+      mSurface->Unmap();
+      mSurface = nullptr;
+    } else if (mYSurface) {
+      mYSurface->Unmap();
+      mCbSurface->Unmap();
+      mCrSurface->Unmap();
+      mYSurface = mCbSurface = mCrSurface = nullptr;
+    }
+    mLocked = false;
+  }
+}
+
+RenderBufferTextureHost::RenderBufferData
+RenderBufferTextureHost::GetBufferDataForRender(uint8_t aChannelIndex) {
+  MOZ_ASSERT(mFormat != gfx::SurfaceFormat::YUV || aChannelIndex < 3);
+  MOZ_ASSERT(mFormat == gfx::SurfaceFormat::YUV || aChannelIndex < 1);
+  MOZ_ASSERT(mLocked);
+
+  if (mFormat != gfx::SurfaceFormat::YUV) {
+    MOZ_ASSERT(mSurface);
+
+    return RenderBufferData(mMap.mData,
+                            mMap.mStride * mSurface->GetSize().height);
+  } else {
+    MOZ_ASSERT(mYSurface && mCbSurface && mCrSurface);
+
+    switch (aChannelIndex) {
+      case 0:
+        return RenderBufferData(mYMap.mData,
+                                mYMap.mStride * mYSurface->GetSize().height);
+        break;
+      case 1:
+        return RenderBufferData(mCbMap.mData,
+                                mCbMap.mStride * mCbSurface->GetSize().height);
+        break;
+      case 2:
+        return RenderBufferData(mCrMap.mData,
+                                mCrMap.mStride * mCrSurface->GetSize().height);
+        break;
+      default:
+        MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+        return RenderBufferData(nullptr, 0);
+    }
+  }
+}
+
+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::YUVRangedColorSpace RenderBufferTextureHost::GetYUVColorSpace() const {
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor:
+      return gfx::GetYUVRangedColorSpace(mDescriptor.get_YCbCrDescriptor());
+    default:
+      return gfx::YUVRangedColorSpace::Default;
+  }
+}
+
+bool RenderBufferTextureHost::MapPlane(RenderCompositor* aCompositor,
+                                       uint8_t aChannelIndex,
+                                       PlaneInfo& aPlaneInfo) {
+  if (!mBuffer) {
+    if (!mDestroyed) {
+      // 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.display().Size();
+          break;
+        case 1:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetCbChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.cbCrStride();
+          aPlaneInfo.mSize =
+              layers::ImageDataSerializer::GetCroppedCbCrSize(desc);
+          break;
+        case 2:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetCrChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.cbCrStride();
+          aPlaneInfo.mSize =
+              layers::ImageDataSerializer::GetCroppedCbCrSize(desc);
+          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() {}
+
+void RenderBufferTextureHost::Destroy() {
+  mBuffer = nullptr;
+  mDestroyed = true;
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderBufferTextureHost.h b/gfx/webrender_bindings/RenderBufferTextureHost.h
new file mode 100644
index 0000000000..0fd2ef26b7
--- /dev/null
+++ b/gfx/webrender_bindings/RenderBufferTextureHost.h
@@ -0,0 +1,81 @@
+/* -*- 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_RENDERBUFFERTEXTUREHOST_H
+#define MOZILLA_GFX_RENDERBUFFERTEXTUREHOST_H
+
+#include "RenderTextureHostSWGL.h"
+
+namespace mozilla {
+namespace wr {
+
+class RenderBufferTextureHost final : public RenderTextureHostSWGL {
+ public:
+  RenderBufferTextureHost(uint8_t* aBuffer,
+                          const layers::BufferDescriptor& aDescriptor);
+
+  // RenderTextureHost
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+
+  size_t Bytes() override {
+    return mSize.width * mSize.height * BytesPerPixel(mFormat);
+  }
+  class RenderBufferData {
+   public:
+    RenderBufferData(uint8_t* aData, size_t aBufferSize)
+        : mData(aData), mBufferSize(aBufferSize) {}
+    const uint8_t* mData;
+    size_t mBufferSize;
+  };
+
+  RenderBufferData GetBufferDataForRender(uint8_t aChannelIndex);
+
+  // RenderTextureHostSWGL
+  size_t GetPlaneCount() const override;
+
+  gfx::SurfaceFormat GetFormat() const override;
+
+  gfx::ColorDepth GetColorDepth() const override;
+
+  gfx::YUVRangedColorSpace GetYUVColorSpace() const override;
+
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+
+  void UnmapPlanes() override;
+
+  void Destroy() override;
+
+ private:
+  virtual ~RenderBufferTextureHost();
+
+  uint8_t* GetBuffer() const { return mBuffer; }
+
+  uint8_t* mBuffer;
+  layers::BufferDescriptor mDescriptor;
+  gfx::IntSize mSize;
+  gfx::SurfaceFormat mFormat;
+
+  RefPtr<gfx::DataSourceSurface> mSurface;
+  gfx::DataSourceSurface::MappedSurface mMap;
+
+  RefPtr<gfx::DataSourceSurface> mYSurface;
+  RefPtr<gfx::DataSourceSurface> mCbSurface;
+  RefPtr<gfx::DataSourceSurface> mCrSurface;
+  gfx::DataSourceSurface::MappedSurface mYMap;
+  gfx::DataSourceSurface::MappedSurface mCbMap;
+  gfx::DataSourceSurface::MappedSurface mCrMap;
+
+  bool mLocked;
+
+  bool mDestroyed = false;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERBUFFERTEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderCompositor.cpp b/gfx/webrender_bindings/RenderCompositor.cpp
new file mode 100644
index 0000000000..8dd6e8ff00
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositor.cpp
@@ -0,0 +1,286 @@
+/* -*- 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 "RenderCompositor.h"
+
+#include "gfxConfig.h"
+#include "gfxPlatform.h"
+#include "GLContext.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/SyncObject.h"
+#include "mozilla/webrender/RenderCompositorLayersSWGL.h"
+#include "mozilla/webrender/RenderCompositorOGL.h"
+#include "mozilla/webrender/RenderCompositorSWGL.h"
+#include "mozilla/widget/CompositorWidget.h"
+
+#ifdef XP_WIN
+#  include "mozilla/webrender/RenderCompositorANGLE.h"
+#  include "mozilla/widget/WinCompositorWidget.h"
+#endif
+
+#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK)
+#  include "mozilla/webrender/RenderCompositorEGL.h"
+#endif
+
+#ifdef MOZ_WAYLAND
+#  include "mozilla/webrender/RenderCompositorNative.h"
+#endif
+
+#ifdef XP_MACOSX
+#  include "mozilla/webrender/RenderCompositorNative.h"
+#endif
+
+namespace mozilla::wr {
+
+void wr_compositor_add_surface(void* aCompositor, wr::NativeSurfaceId aId,
+                               const wr::CompositorSurfaceTransform* aTransform,
+                               wr::DeviceIntRect aClipRect,
+                               wr::ImageRendering aImageRendering) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->AddSurface(aId, *aTransform, aClipRect, aImageRendering);
+}
+
+void wr_compositor_begin_frame(void* aCompositor) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->CompositorBeginFrame();
+}
+
+void wr_compositor_bind(void* aCompositor, wr::NativeTileId aId,
+                        wr::DeviceIntPoint* aOffset, uint32_t* aFboId,
+                        wr::DeviceIntRect aDirtyRect,
+                        wr::DeviceIntRect aValidRect) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->Bind(aId, aOffset, aFboId, aDirtyRect, aValidRect);
+}
+
+void wr_compositor_create_surface(void* aCompositor, wr::NativeSurfaceId aId,
+                                  wr::DeviceIntPoint aVirtualOffset,
+                                  wr::DeviceIntSize aTileSize, bool aIsOpaque) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->CreateSurface(aId, aVirtualOffset, aTileSize, aIsOpaque);
+}
+
+void wr_compositor_create_external_surface(void* aCompositor,
+                                           wr::NativeSurfaceId aId,
+                                           bool aIsOpaque) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->CreateExternalSurface(aId, aIsOpaque);
+}
+
+void wr_compositor_create_backdrop_surface(void* aCompositor,
+                                           wr::NativeSurfaceId aId,
+                                           wr::ColorF aColor) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->CreateBackdropSurface(aId, aColor);
+}
+
+void wr_compositor_create_tile(void* aCompositor, wr::NativeSurfaceId aId,
+                               int32_t aX, int32_t aY) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->CreateTile(aId, aX, aY);
+}
+
+void wr_compositor_destroy_tile(void* aCompositor, wr::NativeSurfaceId aId,
+                                int32_t aX, int32_t aY) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->DestroyTile(aId, aX, aY);
+}
+
+void wr_compositor_destroy_surface(void* aCompositor, NativeSurfaceId aId) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->DestroySurface(aId);
+}
+
+void wr_compositor_attach_external_image(void* aCompositor,
+                                         wr::NativeSurfaceId aId,
+                                         wr::ExternalImageId aExternalImage) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->AttachExternalImage(aId, aExternalImage);
+}
+
+void wr_compositor_start_compositing(void* aCompositor, wr::ColorF aClearColor,
+                                     const wr::DeviceIntRect* aDirtyRects,
+                                     size_t aNumDirtyRects,
+                                     const wr::DeviceIntRect* aOpaqueRects,
+                                     size_t aNumOpaqueRects) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->StartCompositing(aClearColor, aDirtyRects, aNumDirtyRects,
+                               aOpaqueRects, aNumOpaqueRects);
+}
+
+void wr_compositor_end_frame(void* aCompositor) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->CompositorEndFrame();
+}
+
+void wr_compositor_enable_native_compositor(void* aCompositor, bool aEnable) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->EnableNativeCompositor(aEnable);
+}
+
+void wr_compositor_get_capabilities(void* aCompositor,
+                                    CompositorCapabilities* aCaps) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->GetCompositorCapabilities(aCaps);
+}
+
+void wr_compositor_get_window_visibility(void* aCompositor,
+                                         WindowVisibility* aVisibility) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->GetWindowVisibility(aVisibility);
+}
+
+void wr_compositor_unbind(void* aCompositor) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->Unbind();
+}
+
+void wr_compositor_deinit(void* aCompositor) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->DeInit();
+}
+
+void wr_compositor_map_tile(void* aCompositor, wr::NativeTileId aId,
+                            wr::DeviceIntRect aDirtyRect,
+                            wr::DeviceIntRect aValidRect, void** aData,
+                            int32_t* aStride) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->MapTile(aId, aDirtyRect, aValidRect, aData, aStride);
+}
+
+void wr_compositor_unmap_tile(void* aCompositor) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->UnmapTile();
+}
+
+void wr_partial_present_compositor_set_buffer_damage_region(
+    void* aCompositor, const wr::DeviceIntRect* aRects, size_t aNRects) {
+  RenderCompositor* compositor = static_cast<RenderCompositor*>(aCompositor);
+  compositor->SetBufferDamageRegion(aRects, aNRects);
+}
+
+/* static */
+UniquePtr<RenderCompositor> RenderCompositor::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  if (aWidget->GetCompositorOptions().UseSoftwareWebRender()) {
+#ifdef XP_MACOSX
+    // Mac uses NativeLayerCA
+    if (!gfxPlatform::IsHeadless()) {
+      return RenderCompositorNativeSWGL::Create(aWidget, aError);
+    }
+#elif defined(MOZ_WAYLAND)
+    if (gfx::gfxVars::UseWebRenderCompositor()) {
+      return RenderCompositorNativeSWGL::Create(aWidget, aError);
+    }
+#endif
+    UniquePtr<RenderCompositor> comp =
+        RenderCompositorLayersSWGL::Create(aWidget, aError);
+    if (comp) {
+      return comp;
+    }
+#if defined(MOZ_WIDGET_ANDROID)
+    // On Android, we do not want to fallback from RenderCompositorOGLSWGL to
+    // RenderCompositorSWGL.
+    if (aWidget->GetCompositorOptions().AllowSoftwareWebRenderOGL()) {
+      return nullptr;
+    }
+#endif
+    return RenderCompositorSWGL::Create(aWidget, aError);
+  }
+
+#ifdef XP_WIN
+  if (gfx::gfxVars::UseWebRenderANGLE()) {
+    return RenderCompositorANGLE::Create(aWidget, aError);
+  }
+#endif
+
+#if defined(MOZ_WAYLAND)
+  if (gfx::gfxVars::UseWebRenderCompositor()) {
+    return RenderCompositorNativeOGL::Create(aWidget, aError);
+  }
+#endif
+
+#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK)
+  UniquePtr<RenderCompositor> eglCompositor =
+      RenderCompositorEGL::Create(aWidget, aError);
+  if (eglCompositor) {
+    return eglCompositor;
+  }
+#endif
+
+#if defined(MOZ_WIDGET_ANDROID)
+  // RenderCompositorOGL is not used on android
+  return nullptr;
+#elif defined(XP_MACOSX)
+  // Mac uses NativeLayerCA
+  return RenderCompositorNativeOGL::Create(aWidget, aError);
+#else
+  return RenderCompositorOGL::Create(aWidget, aError);
+#endif
+}
+
+RenderCompositor::RenderCompositor(
+    const RefPtr<widget::CompositorWidget>& aWidget)
+    : mWidget(aWidget) {}
+
+RenderCompositor::~RenderCompositor() = default;
+
+bool RenderCompositor::MakeCurrent() { return gl()->MakeCurrent(); }
+
+void RenderCompositor::GetCompositorCapabilities(
+    CompositorCapabilities* aCaps) {
+  if (StaticPrefs::gfx_webrender_compositor_max_update_rects_AtStartup() > 0) {
+    aCaps->max_update_rects = 1;
+  } else {
+    aCaps->max_update_rects = 0;
+  }
+}
+
+void RenderCompositor::GetWindowVisibility(WindowVisibility* aVisibility) {
+#ifdef XP_WIN
+  auto* widget = mWidget->AsWindows();
+  if (!widget) {
+    return;
+  }
+  aVisibility->size_mode = ToWrWindowSizeMode(widget->GetWindowSizeMode());
+  aVisibility->is_fully_occluded = widget->GetWindowIsFullyOccluded();
+#endif
+}
+
+GLenum RenderCompositor::IsContextLost(bool aForce) {
+  auto* glc = gl();
+  // GetGraphicsResetStatus may trigger an implicit MakeCurrent if robustness
+  // is not supported, so unless we are forcing, pass on the check.
+  if (!glc || (!aForce && !glc->IsSupported(gl::GLFeature::robustness))) {
+    return LOCAL_GL_NO_ERROR;
+  }
+  auto resetStatus = glc->fGetGraphicsResetStatus();
+  switch (resetStatus) {
+    case LOCAL_GL_NO_ERROR:
+      break;
+    case LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB:
+      NS_WARNING("Device reset due to system / different context");
+      break;
+    case LOCAL_GL_PURGED_CONTEXT_RESET_NV:
+      NS_WARNING("Device reset due to NV video memory purged");
+      break;
+    case LOCAL_GL_GUILTY_CONTEXT_RESET_ARB:
+      gfxCriticalError() << "Device reset due to WR context";
+      break;
+    case LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB:
+      gfxCriticalNote << "Device reset may be due to WR context";
+      break;
+    default:
+      gfxCriticalError() << "Device reset with WR context unexpected status: "
+                         << gfx::hexa(resetStatus);
+      break;
+  }
+  return resetStatus;
+}
+
+}  // namespace mozilla::wr
diff --git a/gfx/webrender_bindings/RenderCompositor.h b/gfx/webrender_bindings/RenderCompositor.h
new file mode 100644
index 0000000000..89b06395c1
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositor.h
@@ -0,0 +1,222 @@
+/* -*- 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_RENDERCOMPOSITOR_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_H
+
+#include "mozilla/ipc/FileDescriptor.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "Units.h"
+
+#include "GLTypes.h"
+
+namespace mozilla {
+
+namespace gl {
+class GLContext;
+}
+
+namespace layers {
+class CompositionRecorder;
+class SyncObjectHost;
+}  // namespace layers
+
+namespace widget {
+class CompositorWidget;
+}
+
+namespace wr {
+
+class RenderCompositorLayersSWGL;
+class RenderCompositorD3D11SWGL;
+
+class RenderCompositor {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositor(const RefPtr<widget::CompositorWidget>& aWidget);
+  virtual ~RenderCompositor();
+
+  virtual bool BeginFrame() = 0;
+
+  // Optional handler in case the frame was aborted allowing the compositor
+  // to clean up relevant resources if required.
+  virtual void CancelFrame() {}
+
+  // Called to notify the RenderCompositor that all of the commands for a frame
+  // have been pushed to the queue.
+  // @return a RenderedFrameId for the frame
+  virtual RenderedFrameId EndFrame(
+      const nsTArray<DeviceIntRect>& aDirtyRects) = 0;
+  // Returns false when waiting gpu tasks is failed.
+  // It might happen when rendering context is lost.
+  virtual bool WaitForGPU() { return true; }
+
+  // Check for and return the last completed frame.
+  // @return the last (highest) completed RenderedFrameId
+  virtual RenderedFrameId GetLastCompletedFrameId() {
+    return mLatestRenderFrameId.Prev();
+  }
+
+  // Update FrameId when WR rendering does not happen.
+  virtual RenderedFrameId UpdateFrameId() { return GetNextRenderFrameId(); }
+
+  virtual void Pause() = 0;
+  virtual bool Resume() = 0;
+  // Called when WR rendering is skipped
+  virtual void Update() {}
+
+  virtual gl::GLContext* gl() const { return nullptr; }
+  virtual void* swgl() const { return nullptr; }
+
+  virtual bool MakeCurrent();
+
+  virtual bool UseANGLE() const { return false; }
+
+  virtual bool UseDComp() const { return false; }
+
+  virtual bool UseTripleBuffering() const { return false; }
+
+  virtual layers::WebRenderBackend BackendType() const {
+    return layers::WebRenderBackend::HARDWARE;
+  }
+  virtual layers::WebRenderCompositor CompositorType() const {
+    return layers::WebRenderCompositor::DRAW;
+  }
+
+  virtual RenderCompositorD3D11SWGL* AsRenderCompositorD3D11SWGL() {
+    return nullptr;
+  }
+
+  virtual RenderCompositorLayersSWGL* AsRenderCompositorLayersSWGL() {
+    return nullptr;
+  }
+
+  // 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; }
+
+  layers::SyncObjectHost* GetSyncObject() const { return mSyncObject.get(); }
+
+  virtual GLenum IsContextLost(bool aForce);
+
+  virtual bool SupportAsyncScreenshot() { return true; }
+
+  virtual bool ShouldUseNativeCompositor() { return false; }
+
+  // Interface for wr::Compositor
+  virtual void CompositorBeginFrame() {}
+  virtual void CompositorEndFrame() {}
+  virtual void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset,
+                    uint32_t* aFboId, wr::DeviceIntRect aDirtyRect,
+                    wr::DeviceIntRect aValidRect) {}
+  virtual void Unbind() {}
+  virtual bool MapTile(wr::NativeTileId aId, wr::DeviceIntRect aDirtyRect,
+                       wr::DeviceIntRect aValidRect, void** aData,
+                       int32_t* aStride) {
+    return false;
+  }
+  virtual void UnmapTile() {}
+  virtual void CreateSurface(wr::NativeSurfaceId aId,
+                             wr::DeviceIntPoint aVirtualOffset,
+                             wr::DeviceIntSize aTileSize, bool aIsOpaque) {}
+  virtual void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) {}
+  virtual void CreateBackdropSurface(wr::NativeSurfaceId aId,
+                                     wr::ColorF aColor) {}
+  virtual void DestroySurface(NativeSurfaceId aId) {}
+  virtual void CreateTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) {}
+  virtual void DestroyTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) {}
+  virtual void AttachExternalImage(wr::NativeSurfaceId aId,
+                                   wr::ExternalImageId aExternalImage) {}
+  virtual void AddSurface(wr::NativeSurfaceId aId,
+                          const wr::CompositorSurfaceTransform& aTransform,
+                          wr::DeviceIntRect aClipRect,
+                          wr::ImageRendering aImageRendering) {}
+  // Called in the middle of a frame after all surfaces have been added but
+  // before tiles are updated to signal that early compositing can start
+  virtual void StartCompositing(wr::ColorF aClearColor,
+                                const wr::DeviceIntRect* aDirtyRects,
+                                size_t aNumDirtyRects,
+                                const wr::DeviceIntRect* aOpaqueRects,
+                                size_t aNumOpaqueRects) {}
+  virtual void EnableNativeCompositor(bool aEnable) {}
+  virtual void DeInit() {}
+  // Overrides any of the default compositor capabilities for behavior this
+  // compositor might require.
+  virtual void GetCompositorCapabilities(CompositorCapabilities* aCaps);
+
+  virtual void GetWindowVisibility(WindowVisibility* aVisibility);
+
+  // Interface for partial present
+  virtual bool UsePartialPresent() { return false; }
+  virtual bool RequestFullRender() { return false; }
+  virtual uint32_t GetMaxPartialPresentRects() { return 0; }
+  virtual bool ShouldDrawPreviousPartialPresentRegions() { return false; }
+  // Returns the age of the current backbuffer., This should be used, if
+  // ShouldDrawPreviousPartialPresentRegions() returns true, to determine the
+  // region which must be rendered in addition to the current frame's dirty
+  // rect.
+  virtual size_t GetBufferAge() const { return 0; }
+  // Allows webrender to specify the total region that will be rendered to this
+  // frame, ie the frame's dirty region and some previous frames' dirty regions,
+  // if applicable (calculated using the buffer age). Must be called before
+  // anything has been rendered to the main framebuffer.
+  virtual void SetBufferDamageRegion(const wr::DeviceIntRect* aRects,
+                                     size_t aNumRects) {}
+
+  // Whether the surface origin is top-left.
+  virtual bool SurfaceOriginIsTopLeft() { return false; }
+
+  // Does readback if wr_renderer_readback() could not get correct WR rendered
+  // result. It could happen when WebRender renders to multiple overlay layers.
+  virtual bool MaybeReadback(const gfx::IntSize& aReadbackSize,
+                             const wr::ImageFormat& aReadbackFormat,
+                             const Range<uint8_t>& aReadbackBuffer,
+                             bool* aNeedsYFlip) {
+    return false;
+  }
+  virtual void MaybeRequestAllowFrameRecording(bool aWillRecord) {}
+  virtual bool MaybeRecordFrame(layers::CompositionRecorder& aRecorder) {
+    return false;
+  }
+  virtual bool MaybeGrabScreenshot(const gfx::IntSize& aWindowSize) {
+    return false;
+  }
+  virtual bool MaybeProcessScreenshotQueue() { return false; }
+
+  // Returns FileDescriptor of release fence.
+  // Release fence is a fence that is used for waiting until usage/composite of
+  // AHardwareBuffer is ended. The fence is delivered to client side via
+  // ImageBridge. It is used only on android.
+  virtual ipc::FileDescriptor GetAndResetReleaseFence() {
+    return ipc::FileDescriptor();
+  }
+
+  virtual bool IsPaused() { return false; }
+
+ protected:
+  // We default this to 2, so that mLatestRenderFrameId.Prev() is always valid.
+  RenderedFrameId mLatestRenderFrameId = RenderedFrameId{2};
+  RenderedFrameId GetNextRenderFrameId() {
+    mLatestRenderFrameId = mLatestRenderFrameId.Next();
+    return mLatestRenderFrameId;
+  }
+
+  RefPtr<widget::CompositorWidget> mWidget;
+  RefPtr<layers::SyncObjectHost> mSyncObject;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderCompositorANGLE.cpp b/gfx/webrender_bindings/RenderCompositorANGLE.cpp
new file mode 100644
index 0000000000..e01ac6a187
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorANGLE.cpp
@@ -0,0 +1,1025 @@
+/* -*- 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 "RenderCompositorANGLE.h"
+
+#include "GLContext.h"
+#include "GLContextEGL.h"
+#include "GLContextProvider.h"
+#include "mozilla/gfx/DeviceManagerDx.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/StackArray.h"
+#include "mozilla/layers/HelpersD3D11.h"
+#include "mozilla/layers/SyncObject.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/webrender/DCLayerTree.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "mozilla/widget/WinCompositorWidget.h"
+#include "mozilla/WindowsVersion.h"
+#include "mozilla/Telemetry.h"
+#include "nsPrintfCString.h"
+#include "FxROutputHandler.h"
+
+#include <d3d11.h>
+#include <dcomp.h>
+#include <dxgi1_2.h>
+
+// Flag for PrintWindow() that is defined in Winuser.h. It is defined since
+// Windows 8.1. This allows PrintWindow to capture window content that is
+// rendered with DirectComposition.
+#undef PW_RENDERFULLCONTENT
+#define PW_RENDERFULLCONTENT 0x00000002
+
+namespace mozilla {
+namespace wr {
+
+extern LazyLogModule gRenderThreadLog;
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+/* static */
+UniquePtr<RenderCompositor> RenderCompositorANGLE::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  RefPtr<gl::GLContext> gl = RenderThread::Get()->SingletonGL(aError);
+  if (!gl) {
+    if (aError.IsEmpty()) {
+      aError.Assign("RcANGLE(no shared GL)"_ns);
+    } else {
+      aError.Append("(Create)"_ns);
+    }
+    return nullptr;
+  }
+
+  UniquePtr<RenderCompositorANGLE> compositor =
+      MakeUnique<RenderCompositorANGLE>(aWidget, std::move(gl));
+  if (!compositor->Initialize(aError)) {
+    return nullptr;
+  }
+  return compositor;
+}
+
+RenderCompositorANGLE::RenderCompositorANGLE(
+    const RefPtr<widget::CompositorWidget>& aWidget,
+    RefPtr<gl::GLContext>&& aGL)
+    : RenderCompositor(aWidget), mGL(aGL) {
+  MOZ_ASSERT(mGL);
+  LOG("RenderCompositorANGLE::RenderCompositorANGLE()");
+}
+
+RenderCompositorANGLE::~RenderCompositorANGLE() {
+  LOG("RenderCompositorANGLE::~RenderCompositorANGLE()");
+
+  DestroyEGLSurface();
+  MOZ_ASSERT(!mEGLSurface);
+}
+
+ID3D11Device* RenderCompositorANGLE::GetDeviceOfEGLDisplay(nsACString& aError) {
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+  MOZ_ASSERT(egl);
+  if (!egl ||
+      !egl->mLib->IsExtensionSupported(gl::EGLLibExtension::EXT_device_query)) {
+    aError.Assign("RcANGLE(no EXT_device_query support)"_ns);
+    return nullptr;
+  }
+
+  // Fetch the D3D11 device.
+  EGLDeviceEXT eglDevice = nullptr;
+  egl->fQueryDisplayAttribEXT(LOCAL_EGL_DEVICE_EXT, (EGLAttrib*)&eglDevice);
+  MOZ_ASSERT(eglDevice);
+  ID3D11Device* device = nullptr;
+  egl->mLib->fQueryDeviceAttribEXT(eglDevice, LOCAL_EGL_D3D11_DEVICE_ANGLE,
+                                   (EGLAttrib*)&device);
+  if (!device) {
+    aError.Assign("RcANGLE(get D3D11Device from EGLDisplay failed)"_ns);
+    return nullptr;
+  }
+  return device;
+}
+
+bool RenderCompositorANGLE::Initialize(nsACString& aError) {
+  // TODO(aosmond): This causes us to lose WebRender because it is unable to
+  // distinguish why we failed and retry once the reset is complete. This does
+  // appear to happen in the wild, so we really should try to do something
+  // differently here.
+  if (RenderThread::Get()->IsHandlingDeviceReset()) {
+    aError.Assign("RcANGLE(waiting device reset)"_ns);
+    return false;
+  }
+
+  // Force enable alpha channel to make sure ANGLE use correct framebuffer
+  // formart
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+  if (!gl::CreateConfig(*egl, &mEGLConfig, /* bpp */ 32,
+                        /* enableDepthBuffer */ false, mGL->IsGLES())) {
+    aError.Assign("RcANGLE(create EGLConfig failed)"_ns);
+    return false;
+  }
+  MOZ_ASSERT(mEGLConfig);
+
+  mDevice = GetDeviceOfEGLDisplay(aError);
+
+  if (!mDevice) {
+    return false;
+  }
+
+  mDevice->GetImmediateContext(getter_AddRefs(mCtx));
+  if (!mCtx) {
+    aError.Assign("RcANGLE(get immediate context failed)"_ns);
+    return false;
+  }
+
+  // Disable native compositor when fast snapshot is needed.
+  // Taking snapshot of native compositor is very slow on Windows.
+  if (mWidget->GetCompositorOptions().NeedFastSnaphot()) {
+    mUseNativeCompositor = false;
+  }
+
+  // Create DCLayerTree when DirectComposition is used.
+  if (gfx::gfxVars::UseWebRenderDCompWin()) {
+    HWND compositorHwnd = GetCompositorHwnd();
+    if (compositorHwnd) {
+      mDCLayerTree = DCLayerTree::Create(mGL, mEGLConfig, mDevice, mCtx,
+                                         compositorHwnd, aError);
+      if (!mDCLayerTree) {
+        return false;
+      }
+    } else {
+      aError.Assign("RcANGLE(no compositor window)"_ns);
+      return false;
+    }
+  }
+
+  // Create SwapChain when compositor is not used
+  if (!UseCompositor()) {
+    if (!CreateSwapChain(aError)) {
+      // SwapChain creation failed.
+      return false;
+    }
+  }
+
+  mSyncObject = layers::SyncObjectHost::CreateSyncObjectHost(mDevice);
+  if (!mSyncObject->Init()) {
+    // Some errors occur. Clear the mSyncObject here.
+    // Then, there will be no texture synchronization.
+    aError.Assign("RcANGLE(create SyncObject failed)"_ns);
+    return false;
+  }
+
+  InitializeUsePartialPresent();
+
+  return true;
+}
+
+HWND RenderCompositorANGLE::GetCompositorHwnd() {
+  HWND hwnd = 0;
+
+  if (XRE_IsGPUProcess()) {
+    hwnd = mWidget->AsWindows()->GetCompositorHwnd();
+  } else if (
+      StaticPrefs::
+          gfx_webrender_enabled_no_gpu_process_with_angle_win_AtStartup()) {
+    MOZ_ASSERT(XRE_IsParentProcess());
+
+    // When GPU process does not exist, we do not need to use compositor window.
+    hwnd = mWidget->AsWindows()->GetHwnd();
+  }
+
+  return hwnd;
+}
+
+bool RenderCompositorANGLE::CreateSwapChain(nsACString& aError) {
+  MOZ_ASSERT(!UseCompositor());
+
+  mFirstPresent = true;
+  HWND hwnd = mWidget->AsWindows()->GetHwnd();
+
+  RefPtr<IDXGIDevice> dxgiDevice;
+  mDevice->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice));
+
+  RefPtr<IDXGIFactory> dxgiFactory;
+  {
+    RefPtr<IDXGIAdapter> adapter;
+    dxgiDevice->GetAdapter(getter_AddRefs(adapter));
+
+    adapter->GetParent(
+        IID_PPV_ARGS((IDXGIFactory**)getter_AddRefs(dxgiFactory)));
+  }
+
+  RefPtr<IDXGIFactory2> dxgiFactory2;
+  HRESULT hr = dxgiFactory->QueryInterface(
+      (IDXGIFactory2**)getter_AddRefs(dxgiFactory2));
+  if (FAILED(hr)) {
+    dxgiFactory2 = nullptr;
+  }
+
+  CreateSwapChainForDCompIfPossible(dxgiFactory2);
+  if (gfx::gfxVars::UseWebRenderDCompWin() && !mSwapChain) {
+    MOZ_ASSERT(GetCompositorHwnd());
+    aError.Assign("RcANGLE(create swapchain for dcomp failed)"_ns);
+    return false;
+  }
+
+  if (!mSwapChain && dxgiFactory2) {
+    RefPtr<IDXGISwapChain1> swapChain1;
+    bool useTripleBuffering = false;
+
+    DXGI_SWAP_CHAIN_DESC1 desc{};
+    desc.Width = 0;
+    desc.Height = 0;
+    desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+    desc.SampleDesc.Count = 1;
+    desc.SampleDesc.Quality = 0;
+    desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+
+    bool useFlipSequential = gfx::gfxVars::UseWebRenderFlipSequentialWin();
+    if (useFlipSequential && !mWidget->AsWindows()->GetCompositorHwnd()) {
+      useFlipSequential = false;
+      gfxCriticalNoteOnce << "FLIP_SEQUENTIAL needs CompositorHwnd. Fallback";
+    }
+
+    if (useFlipSequential) {
+      useTripleBuffering = gfx::gfxVars::UseWebRenderTripleBufferingWin();
+      if (useTripleBuffering) {
+        desc.BufferCount = 3;
+      } else {
+        desc.BufferCount = 2;
+      }
+      desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
+      desc.Scaling = DXGI_SCALING_NONE;
+    } else {
+      desc.BufferCount = 1;
+      desc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
+      desc.Scaling = DXGI_SCALING_STRETCH;
+    }
+    desc.Flags = 0;
+
+    hr = dxgiFactory2->CreateSwapChainForHwnd(
+        mDevice, hwnd, &desc, nullptr, nullptr, getter_AddRefs(swapChain1));
+    if (SUCCEEDED(hr) && swapChain1) {
+      DXGI_RGBA color = {1.0f, 1.0f, 1.0f, 1.0f};
+      swapChain1->SetBackgroundColor(&color);
+      mSwapChain = swapChain1;
+      mSwapChain1 = swapChain1;
+      mUseTripleBuffering = useTripleBuffering;
+    } else if (useFlipSequential) {
+      gfxCriticalNoteOnce << "FLIP_SEQUENTIAL is not supported. Fallback";
+    }
+  }
+
+  if (!mSwapChain) {
+    if (mWidget->AsWindows()->GetCompositorHwnd()) {
+      // Destroy compositor window.
+      mWidget->AsWindows()->DestroyCompositorWindow();
+      hwnd = mWidget->AsWindows()->GetHwnd();
+    }
+
+    DXGI_SWAP_CHAIN_DESC swapDesc{};
+    swapDesc.BufferDesc.Width = 0;
+    swapDesc.BufferDesc.Height = 0;
+    swapDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+    swapDesc.BufferDesc.RefreshRate.Numerator = 60;
+    swapDesc.BufferDesc.RefreshRate.Denominator = 1;
+    swapDesc.SampleDesc.Count = 1;
+    swapDesc.SampleDesc.Quality = 0;
+    swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    swapDesc.BufferCount = 1;
+    swapDesc.OutputWindow = hwnd;
+    swapDesc.Windowed = TRUE;
+    swapDesc.Flags = 0;
+    swapDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
+
+    HRESULT hr = dxgiFactory->CreateSwapChain(dxgiDevice, &swapDesc,
+                                              getter_AddRefs(mSwapChain));
+    if (FAILED(hr)) {
+      aError.Assign(
+          nsPrintfCString("RcANGLE(swap chain create failed %lx)", hr));
+      return false;
+    }
+
+    RefPtr<IDXGISwapChain1> swapChain1;
+    hr = mSwapChain->QueryInterface(
+        (IDXGISwapChain1**)getter_AddRefs(swapChain1));
+    if (SUCCEEDED(hr)) {
+      mSwapChain1 = swapChain1;
+    }
+  }
+
+  // We need this because we don't want DXGI to respond to Alt+Enter.
+  dxgiFactory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_WINDOW_CHANGES);
+
+  if (!ResizeBufferIfNeeded()) {
+    aError.Assign("RcANGLE(resize buffer failed)"_ns);
+    return false;
+  }
+
+  return true;
+}
+
+void RenderCompositorANGLE::CreateSwapChainForDCompIfPossible(
+    IDXGIFactory2* aDXGIFactory2) {
+  if (!aDXGIFactory2 || !mDCLayerTree) {
+    return;
+  }
+
+  HWND hwnd = GetCompositorHwnd();
+  if (!hwnd) {
+    // When DirectComposition or DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL is used,
+    // compositor window needs to exist.
+    if (gfx::gfxVars::UseWebRenderDCompWin() ||
+        gfx::gfxVars::UseWebRenderFlipSequentialWin()) {
+      gfxCriticalNote << "Compositor window was not created";
+    }
+    return;
+  }
+
+  // When compositor is enabled, CompositionSurface is used for rendering.
+  // It does not support triple buffering.
+  bool useTripleBuffering =
+      gfx::gfxVars::UseWebRenderTripleBufferingWin() && !UseCompositor();
+  RefPtr<IDXGISwapChain1> swapChain1 =
+      CreateSwapChainForDComp(useTripleBuffering);
+  if (swapChain1) {
+    mSwapChain = swapChain1;
+    mSwapChain1 = swapChain1;
+    mUseTripleBuffering = useTripleBuffering;
+    mDCLayerTree->SetDefaultSwapChain(swapChain1);
+  } else {
+    // Clear CLayerTree on falire
+    mDCLayerTree = nullptr;
+  }
+}
+
+RefPtr<IDXGISwapChain1> RenderCompositorANGLE::CreateSwapChainForDComp(
+    bool aUseTripleBuffering) {
+  HRESULT hr;
+  RefPtr<IDXGIDevice> dxgiDevice;
+  mDevice->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice));
+
+  RefPtr<IDXGIFactory> dxgiFactory;
+  {
+    RefPtr<IDXGIAdapter> adapter;
+    dxgiDevice->GetAdapter(getter_AddRefs(adapter));
+
+    adapter->GetParent(
+        IID_PPV_ARGS((IDXGIFactory**)getter_AddRefs(dxgiFactory)));
+  }
+
+  RefPtr<IDXGIFactory2> dxgiFactory2;
+  hr = dxgiFactory->QueryInterface(
+      (IDXGIFactory2**)getter_AddRefs(dxgiFactory2));
+  if (FAILED(hr)) {
+    return nullptr;
+  }
+
+  RefPtr<IDXGISwapChain1> swapChain1;
+  DXGI_SWAP_CHAIN_DESC1 desc{};
+  // DXGI does not like 0x0 swapchains. Swap chain creation failed when 0x0 was
+  // set.
+  desc.Width = 1;
+  desc.Height = 1;
+  desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+  desc.SampleDesc.Count = 1;
+  desc.SampleDesc.Quality = 0;
+  desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+  if (aUseTripleBuffering) {
+    desc.BufferCount = 3;
+  } else {
+    desc.BufferCount = 2;
+  }
+  // DXGI_SCALING_NONE caused swap chain creation failure.
+  desc.Scaling = DXGI_SCALING_STRETCH;
+  desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
+  desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
+  desc.Flags = 0;
+
+  hr = dxgiFactory2->CreateSwapChainForComposition(mDevice, &desc, nullptr,
+                                                   getter_AddRefs(swapChain1));
+  if (SUCCEEDED(hr) && swapChain1) {
+    DXGI_RGBA color = {1.0f, 1.0f, 1.0f, 1.0f};
+    swapChain1->SetBackgroundColor(&color);
+    return swapChain1;
+  }
+
+  return nullptr;
+}
+
+bool RenderCompositorANGLE::BeginFrame() {
+  mWidget->AsWindows()->UpdateCompositorWndSizeIfNecessary();
+
+  if (!UseCompositor() && !ResizeBufferIfNeeded()) {
+    return false;
+  }
+
+  if (!MakeCurrent()) {
+    gfxCriticalNote << "Failed to make render context current, can't draw.";
+    return false;
+  }
+
+  if (RenderThread::Get()->SyncObjectNeeded() && mSyncObject) {
+    if (!mSyncObject->Synchronize(/* aFallible */ true)) {
+      // It's timeout or other error. Handle the device-reset here.
+      RenderThread::Get()->HandleDeviceReset(
+          "SyncObject", LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB);
+      return false;
+    }
+  }
+  return true;
+}
+
+RenderedFrameId RenderCompositorANGLE::EndFrame(
+    const nsTArray<DeviceIntRect>& aDirtyRects) {
+  RenderedFrameId frameId = GetNextRenderFrameId();
+  InsertGraphicsCommandsFinishedWaitQuery(frameId);
+
+  if (!UseCompositor()) {
+    auto start = TimeStamp::Now();
+    if (mWidget->AsWindows()->HasFxrOutputHandler()) {
+      // There is a Firefox Reality handler for this swapchain. Update this
+      // window's contents to the VR window.
+      FxROutputHandler* fxrHandler =
+          mWidget->AsWindows()->GetFxrOutputHandler();
+      if (fxrHandler->TryInitialize(mSwapChain, mDevice)) {
+        fxrHandler->UpdateOutput(mCtx);
+      }
+    }
+
+    const UINT interval =
+        mFirstPresent ||
+                StaticPrefs::
+                    gfx_webrender_dcomp_video_swap_chain_present_interval_0()
+            ? 0
+            : 1;
+    const UINT flags = 0;
+
+    const LayoutDeviceIntSize& bufferSize = mBufferSize.ref();
+    if (mUsePartialPresent && mSwapChain1) {
+      // Clear full render flag.
+      mFullRender = false;
+      // If there is no diry rect, we skip SwapChain present.
+      if (!aDirtyRects.IsEmpty()) {
+        int rectsCount = 0;
+        StackArray<RECT, 1> rects(aDirtyRects.Length());
+
+        for (size_t i = 0; i < aDirtyRects.Length(); ++i) {
+          const DeviceIntRect& rect = aDirtyRects[i];
+          // Clip rect to bufferSize
+          int left = std::max(0, std::min(rect.min.x, bufferSize.width));
+          int top = std::max(0, std::min(rect.min.y, bufferSize.height));
+          int right = std::max(0, std::min(rect.max.x, bufferSize.width));
+          int bottom = std::max(0, std::min(rect.max.y, bufferSize.height));
+
+          // When rect is not empty, the rect could be passed to Present1().
+          if (left < right && top < bottom) {
+            rects[rectsCount].left = left;
+            rects[rectsCount].top = top;
+            rects[rectsCount].right = right;
+            rects[rectsCount].bottom = bottom;
+            rectsCount++;
+          }
+        }
+
+        if (rectsCount > 0) {
+          DXGI_PRESENT_PARAMETERS params;
+          PodZero(&params);
+          params.DirtyRectsCount = rectsCount;
+          params.pDirtyRects = rects.data();
+
+          HRESULT hr;
+          hr = mSwapChain1->Present1(interval, flags, &params);
+          if (FAILED(hr) && hr != DXGI_STATUS_OCCLUDED) {
+            gfxCriticalNote << "Present1 failed: " << gfx::hexa(hr);
+            mFullRender = true;
+          }
+        }
+      }
+    } else {
+      mSwapChain->Present(interval, flags);
+    }
+    auto end = TimeStamp::Now();
+    mozilla::Telemetry::Accumulate(mozilla::Telemetry::COMPOSITE_SWAP_TIME,
+                                   (end - start).ToMilliseconds() * 10.);
+
+    if (mFirstPresent && mDCLayerTree) {
+      // Wait for the GPU to finish executing its commands before
+      // committing the DirectComposition tree, or else the swapchain
+      // may flicker black when it's first presented.
+      RefPtr<IDXGIDevice2> dxgiDevice2;
+      mDevice->QueryInterface((IDXGIDevice2**)getter_AddRefs(dxgiDevice2));
+      MOZ_ASSERT(dxgiDevice2);
+
+      HANDLE event = ::CreateEvent(nullptr, false, false, nullptr);
+      HRESULT hr = dxgiDevice2->EnqueueSetEvent(event);
+      if (SUCCEEDED(hr)) {
+        DebugOnly<DWORD> result = ::WaitForSingleObject(event, INFINITE);
+        MOZ_ASSERT(result == WAIT_OBJECT_0);
+      } else {
+        gfxCriticalNoteOnce << "EnqueueSetEvent failed: " << gfx::hexa(hr);
+      }
+      ::CloseHandle(event);
+    }
+    mFirstPresent = false;
+  }
+
+  if (mDisablingNativeCompositor) {
+    // During disabling native compositor, we need to wait all gpu tasks
+    // complete. Otherwise, rendering window could cause white flash.
+    WaitForPreviousGraphicsCommandsFinishedQuery(/* aWaitAll */ true);
+    mDisablingNativeCompositor = false;
+  }
+
+  if (mDCLayerTree) {
+    mDCLayerTree->MaybeUpdateDebug();
+    mDCLayerTree->MaybeCommit();
+  }
+
+  return frameId;
+}
+
+bool RenderCompositorANGLE::WaitForGPU() {
+  // Note: this waits on the query we inserted in the previous frame,
+  // not the one we just inserted now. Example:
+  //   Insert query #1
+  //   Present #1
+  //   (first frame, no wait)
+  //   Insert query #2
+  //   Present #2
+  //   Wait for query #1.
+  //   Insert query #3
+  //   Present #3
+  //   Wait for query #2.
+  //
+  // This ensures we're done reading textures before swapping buffers.
+  if (!StaticPrefs::gfx_webrender_wait_gpu_finished_disabled_AtStartup()) {
+    return WaitForPreviousGraphicsCommandsFinishedQuery();
+  }
+  return true;
+}
+
+bool RenderCompositorANGLE::ResizeBufferIfNeeded() {
+  MOZ_ASSERT(mSwapChain);
+
+  LayoutDeviceIntSize size = mWidget->GetClientSize();
+
+  // DXGI does not like 0x0 swapchains. ResizeBuffers() failed when 0x0 was set
+  // when DComp is used.
+  size.width = std::max(size.width, 1);
+  size.height = std::max(size.height, 1);
+
+  if (mBufferSize.isSome() && mBufferSize.ref() == size) {
+    MOZ_ASSERT(mEGLSurface);
+    return true;
+  }
+
+  // Release EGLSurface of back buffer before calling ResizeBuffers().
+  DestroyEGLSurface();
+
+  mBufferSize = Some(size);
+
+  if (!CreateEGLSurface()) {
+    mBufferSize.reset();
+    return false;
+  }
+
+  if (mUsePartialPresent) {
+    mFullRender = true;
+  }
+  return true;
+}
+
+bool RenderCompositorANGLE::CreateEGLSurface() {
+  MOZ_ASSERT(mBufferSize.isSome());
+  MOZ_ASSERT(mEGLSurface == EGL_NO_SURFACE);
+
+  HRESULT hr;
+  RefPtr<ID3D11Texture2D> backBuf;
+
+  if (mBufferSize.isNothing()) {
+    gfxCriticalNote << "Buffer size is invalid";
+    return false;
+  }
+
+  const LayoutDeviceIntSize& size = mBufferSize.ref();
+
+  // Resize swap chain
+  DXGI_SWAP_CHAIN_DESC desc;
+  hr = mSwapChain->GetDesc(&desc);
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to read swap chain description: "
+                    << gfx::hexa(hr) << " Size : " << size;
+    return false;
+  }
+  hr = mSwapChain->ResizeBuffers(desc.BufferCount, size.width, size.height,
+                                 DXGI_FORMAT_B8G8R8A8_UNORM, 0);
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to resize swap chain buffers: " << gfx::hexa(hr)
+                    << " Size : " << size;
+    return false;
+  }
+
+  hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+                             (void**)getter_AddRefs(backBuf));
+  if (hr == DXGI_ERROR_INVALID_CALL) {
+    // This happens on some GPUs/drivers when there's a TDR.
+    if (mDevice->GetDeviceRemovedReason() != S_OK) {
+      gfxCriticalError() << "GetBuffer returned invalid call: " << gfx::hexa(hr)
+                         << " Size : " << size;
+      return false;
+    }
+  }
+
+  const EGLint pbuffer_attribs[]{LOCAL_EGL_WIDTH, size.width, LOCAL_EGL_HEIGHT,
+                                 size.height, LOCAL_EGL_NONE};
+
+  const auto buffer = reinterpret_cast<EGLClientBuffer>(backBuf.get());
+
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+  const EGLSurface surface = egl->fCreatePbufferFromClientBuffer(
+      LOCAL_EGL_D3D_TEXTURE_ANGLE, buffer, mEGLConfig, pbuffer_attribs);
+
+  if (!surface) {
+    EGLint err = egl->mLib->fGetError();
+    gfxCriticalError() << "Failed to create Pbuffer of back buffer error: "
+                       << gfx::hexa(err) << " Size : " << size;
+    return false;
+  }
+
+  mEGLSurface = surface;
+
+  return true;
+}
+
+void RenderCompositorANGLE::DestroyEGLSurface() {
+  // Release EGLSurface of back buffer before calling ResizeBuffers().
+  if (mEGLSurface) {
+    const auto& gle = gl::GLContextEGL::Cast(gl());
+    const auto& egl = gle->mEgl;
+    gle->SetEGLSurfaceOverride(EGL_NO_SURFACE);
+    egl->fDestroySurface(mEGLSurface);
+    mEGLSurface = nullptr;
+  }
+}
+
+void RenderCompositorANGLE::Pause() {}
+
+bool RenderCompositorANGLE::Resume() { return true; }
+
+void RenderCompositorANGLE::Update() {
+  // Update compositor window's size if it exists.
+  // It needs to be called here, since OS might update compositor
+  // window's size at unexpected timing.
+  mWidget->AsWindows()->UpdateCompositorWndSizeIfNecessary();
+}
+
+bool RenderCompositorANGLE::MakeCurrent() {
+  gl::GLContextEGL::Cast(gl())->SetEGLSurfaceOverride(mEGLSurface);
+  return gl()->MakeCurrent();
+}
+
+LayoutDeviceIntSize RenderCompositorANGLE::GetBufferSize() {
+  if (!UseCompositor()) {
+    MOZ_ASSERT(mBufferSize.isSome());
+    if (mBufferSize.isNothing()) {
+      return LayoutDeviceIntSize();
+    }
+    return mBufferSize.ref();
+  } else {
+    auto size = mWidget->GetClientSize();
+    // This size is used for WR DEBUG_OVERLAY. Its DCTile does not like 0.
+    size.width = std::max(size.width, 1);
+    size.height = std::max(size.height, 1);
+    return size;
+  }
+}
+
+RefPtr<ID3D11Query> RenderCompositorANGLE::GetD3D11Query() {
+  RefPtr<ID3D11Query> query;
+
+  if (mRecycledQuery) {
+    query = mRecycledQuery.forget();
+    return query;
+  }
+
+  CD3D11_QUERY_DESC desc(D3D11_QUERY_EVENT);
+  HRESULT hr = mDevice->CreateQuery(&desc, getter_AddRefs(query));
+  if (FAILED(hr) || !query) {
+    gfxWarning() << "Could not create D3D11_QUERY_EVENT: " << gfx::hexa(hr);
+    return nullptr;
+  }
+  return query;
+}
+
+void RenderCompositorANGLE::InsertGraphicsCommandsFinishedWaitQuery(
+    RenderedFrameId aFrameId) {
+  RefPtr<ID3D11Query> query;
+  query = GetD3D11Query();
+  if (!query) {
+    return;
+  }
+
+  mCtx->End(query);
+  mCtx->Flush();
+  mWaitForPresentQueries.emplace(aFrameId, query);
+}
+
+bool RenderCompositorANGLE::WaitForPreviousGraphicsCommandsFinishedQuery(
+    bool aWaitAll) {
+  size_t waitLatency = mUseTripleBuffering ? 3 : 2;
+  if (aWaitAll) {
+    waitLatency = 1;
+  }
+
+  while (mWaitForPresentQueries.size() >= waitLatency) {
+    auto queryPair = mWaitForPresentQueries.front();
+    BOOL result;
+    bool ret =
+        layers::WaitForFrameGPUQuery(mDevice, mCtx, queryPair.second, &result);
+
+    if (!ret) {
+      mWaitForPresentQueries.pop();
+      return false;
+    }
+
+    // Recycle query for later use.
+    mRecycledQuery = queryPair.second;
+    mLastCompletedFrameId = queryPair.first;
+    mWaitForPresentQueries.pop();
+  }
+  return true;
+}
+
+RenderedFrameId RenderCompositorANGLE::GetLastCompletedFrameId() {
+  while (!mWaitForPresentQueries.empty()) {
+    auto queryPair = mWaitForPresentQueries.front();
+    if (mCtx->GetData(queryPair.second, nullptr, 0,
+                      D3D11_ASYNC_GETDATA_DONOTFLUSH) != S_OK) {
+      break;
+    }
+
+    mRecycledQuery = queryPair.second;
+    mLastCompletedFrameId = queryPair.first;
+    mWaitForPresentQueries.pop();
+  }
+
+  nsPrintfCString marker("Pending frames %u",
+                         (uint32_t)mWaitForPresentQueries.size());
+  PROFILER_MARKER_TEXT("GetLastCompletedFrameId", GRAPHICS, {}, marker);
+
+  return mLastCompletedFrameId;
+}
+
+RenderedFrameId RenderCompositorANGLE::UpdateFrameId() {
+  RenderedFrameId frameId = GetNextRenderFrameId();
+  InsertGraphicsCommandsFinishedWaitQuery(frameId);
+  return frameId;
+}
+
+GLenum RenderCompositorANGLE::IsContextLost(bool aForce) {
+  // glGetGraphicsResetStatus does not always work to detect timeout detection
+  // and recovery (TDR). On Windows, ANGLE itself is just relying upon the same
+  // API, so we should not need to check it separately.
+  auto reason = mDevice->GetDeviceRemovedReason();
+  switch (reason) {
+    case S_OK:
+      return LOCAL_GL_NO_ERROR;
+    case DXGI_ERROR_DEVICE_REMOVED:
+    case DXGI_ERROR_DRIVER_INTERNAL_ERROR:
+      NS_WARNING("Device reset due to system / different device");
+      return LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB;
+    case DXGI_ERROR_DEVICE_HUNG:
+    case DXGI_ERROR_DEVICE_RESET:
+    case DXGI_ERROR_INVALID_CALL:
+      gfxCriticalError() << "Device reset due to WR device: "
+                         << gfx::hexa(reason);
+      return LOCAL_GL_GUILTY_CONTEXT_RESET_ARB;
+    default:
+      gfxCriticalError() << "Device reset with WR device unexpected reason: "
+                         << gfx::hexa(reason);
+      return LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB;
+  }
+}
+
+bool RenderCompositorANGLE::UseCompositor() {
+  if (!mUseNativeCompositor) {
+    return false;
+  }
+
+  if (!mDCLayerTree || !gfx::gfxVars::UseWebRenderCompositor()) {
+    return false;
+  }
+  return true;
+}
+
+bool RenderCompositorANGLE::SupportAsyncScreenshot() {
+  return !UseCompositor() && !mDisablingNativeCompositor;
+}
+
+bool RenderCompositorANGLE::ShouldUseNativeCompositor() {
+  return UseCompositor();
+}
+
+void RenderCompositorANGLE::CompositorBeginFrame() {
+  mDCLayerTree->CompositorBeginFrame();
+}
+
+void RenderCompositorANGLE::CompositorEndFrame() {
+  mDCLayerTree->CompositorEndFrame();
+}
+
+void RenderCompositorANGLE::Bind(wr::NativeTileId aId,
+                                 wr::DeviceIntPoint* aOffset, uint32_t* aFboId,
+                                 wr::DeviceIntRect aDirtyRect,
+                                 wr::DeviceIntRect aValidRect) {
+  mDCLayerTree->Bind(aId, aOffset, aFboId, aDirtyRect, aValidRect);
+}
+
+void RenderCompositorANGLE::Unbind() { mDCLayerTree->Unbind(); }
+
+void RenderCompositorANGLE::CreateSurface(wr::NativeSurfaceId aId,
+                                          wr::DeviceIntPoint aVirtualOffset,
+                                          wr::DeviceIntSize aTileSize,
+                                          bool aIsOpaque) {
+  mDCLayerTree->CreateSurface(aId, aVirtualOffset, aTileSize, aIsOpaque);
+}
+
+void RenderCompositorANGLE::CreateExternalSurface(wr::NativeSurfaceId aId,
+                                                  bool aIsOpaque) {
+  mDCLayerTree->CreateExternalSurface(aId, aIsOpaque);
+}
+
+void RenderCompositorANGLE::DestroySurface(NativeSurfaceId aId) {
+  mDCLayerTree->DestroySurface(aId);
+}
+
+void RenderCompositorANGLE::CreateTile(wr::NativeSurfaceId aId, int aX,
+                                       int aY) {
+  mDCLayerTree->CreateTile(aId, aX, aY);
+}
+
+void RenderCompositorANGLE::DestroyTile(wr::NativeSurfaceId aId, int aX,
+                                        int aY) {
+  mDCLayerTree->DestroyTile(aId, aX, aY);
+}
+
+void RenderCompositorANGLE::AttachExternalImage(
+    wr::NativeSurfaceId aId, wr::ExternalImageId aExternalImage) {
+  mDCLayerTree->AttachExternalImage(aId, aExternalImage);
+}
+
+void RenderCompositorANGLE::AddSurface(
+    wr::NativeSurfaceId aId, const wr::CompositorSurfaceTransform& aTransform,
+    wr::DeviceIntRect aClipRect, wr::ImageRendering aImageRendering) {
+  mDCLayerTree->AddSurface(aId, aTransform, aClipRect, aImageRendering);
+}
+
+void RenderCompositorANGLE::GetCompositorCapabilities(
+    CompositorCapabilities* aCaps) {
+  RenderCompositor::GetCompositorCapabilities(aCaps);
+
+  if (StaticPrefs::gfx_webrender_dcomp_use_virtual_surfaces_AtStartup()) {
+    aCaps->virtual_surface_size = VIRTUAL_SURFACE_SIZE;
+  } else {
+    aCaps->virtual_surface_size = 0;
+  }
+  // DComp video overlay does not support negative scaling. See Bug 1831820
+  aCaps->supports_external_compositor_surface_negative_scaling = false;
+}
+
+void RenderCompositorANGLE::EnableNativeCompositor(bool aEnable) {
+  // XXX Re-enable native compositor is not handled yet.
+  MOZ_RELEASE_ASSERT(!mDisablingNativeCompositor);
+  MOZ_RELEASE_ASSERT(!aEnable);
+  LOG("RenderCompositorANGLE::EnableNativeCompositor() aEnable %d", aEnable);
+
+  if (!UseCompositor()) {
+    return;
+  }
+
+  mUseNativeCompositor = false;
+  mDCLayerTree->DisableNativeCompositor();
+
+  DestroyEGLSurface();
+  mBufferSize.reset();
+
+  RefPtr<IDXGISwapChain1> swapChain1 =
+      CreateSwapChainForDComp(mUseTripleBuffering);
+  if (swapChain1) {
+    mSwapChain = swapChain1;
+    mDCLayerTree->SetDefaultSwapChain(swapChain1);
+    ResizeBufferIfNeeded();
+  } else {
+    gfxCriticalNote << "Failed to re-create SwapChain";
+    RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE);
+    return;
+  }
+  mDisablingNativeCompositor = true;
+}
+
+void RenderCompositorANGLE::InitializeUsePartialPresent() {
+  // Even when mSwapChain1 is null, we could enable WR partial present, since
+  // when mSwapChain1 is null, SwapChain is blit model swap chain with one
+  // buffer.
+  if (UseCompositor() || mWidget->AsWindows()->HasFxrOutputHandler() ||
+      gfx::gfxVars::WebRenderMaxPartialPresentRects() <= 0) {
+    mUsePartialPresent = false;
+  } else {
+    mUsePartialPresent = true;
+  }
+}
+
+bool RenderCompositorANGLE::UsePartialPresent() { return mUsePartialPresent; }
+
+bool RenderCompositorANGLE::RequestFullRender() { return mFullRender; }
+
+uint32_t RenderCompositorANGLE::GetMaxPartialPresentRects() {
+  if (!mUsePartialPresent) {
+    return 0;
+  }
+  return gfx::gfxVars::WebRenderMaxPartialPresentRects();
+}
+
+bool RenderCompositorANGLE::MaybeReadback(
+    const gfx::IntSize& aReadbackSize, const wr::ImageFormat& aReadbackFormat,
+    const Range<uint8_t>& aReadbackBuffer, bool* aNeedsYFlip) {
+  MOZ_ASSERT(aReadbackFormat == wr::ImageFormat::BGRA8);
+
+  if (!UseCompositor()) {
+    return false;
+  }
+
+  auto start = TimeStamp::Now();
+
+  HDC nulldc = ::GetDC(NULL);
+  HDC dc = ::CreateCompatibleDC(nulldc);
+  ::ReleaseDC(nullptr, nulldc);
+  if (!dc) {
+    gfxCriticalError() << "CreateCompatibleDC failed";
+    return false;
+  }
+
+  BITMAPV4HEADER header;
+  memset(&header, 0, sizeof(BITMAPV4HEADER));
+  header.bV4Size = sizeof(BITMAPV4HEADER);
+  header.bV4Width = aReadbackSize.width;
+  header.bV4Height = -LONG(aReadbackSize.height);  // top-to-buttom DIB
+  header.bV4Planes = 1;
+  header.bV4BitCount = 32;
+  header.bV4V4Compression = BI_BITFIELDS;
+  header.bV4RedMask = 0x00FF0000;
+  header.bV4GreenMask = 0x0000FF00;
+  header.bV4BlueMask = 0x000000FF;
+  header.bV4AlphaMask = 0xFF000000;
+
+  void* readbackBits = nullptr;
+  HBITMAP bitmap =
+      ::CreateDIBSection(dc, reinterpret_cast<BITMAPINFO*>(&header),
+                         DIB_RGB_COLORS, &readbackBits, nullptr, 0);
+  if (!bitmap) {
+    ::DeleteDC(dc);
+    gfxCriticalError() << "CreateDIBSection failed";
+    return false;
+  }
+
+  ::SelectObject(dc, bitmap);
+
+  UINT flags = PW_CLIENTONLY | PW_RENDERFULLCONTENT;
+  HWND hwnd = mWidget->AsWindows()->GetHwnd();
+
+  mDCLayerTree->WaitForCommitCompletion();
+
+  BOOL result = ::PrintWindow(hwnd, dc, flags);
+  if (!result) {
+    ::DeleteObject(bitmap);
+    ::DeleteDC(dc);
+    gfxCriticalError() << "PrintWindow failed";
+    return false;
+  }
+
+  ::GdiFlush();
+
+  memcpy(&aReadbackBuffer[0], readbackBits, aReadbackBuffer.length());
+
+  ::DeleteObject(bitmap);
+  ::DeleteDC(dc);
+
+  uint32_t latencyMs = round((TimeStamp::Now() - start).ToMilliseconds());
+  if (latencyMs > 500) {
+    gfxCriticalNote << "Readback took too long: " << latencyMs << " ms";
+  }
+
+  if (aNeedsYFlip) {
+    *aNeedsYFlip = false;
+  }
+
+  return true;
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderCompositorANGLE.h b/gfx/webrender_bindings/RenderCompositorANGLE.h
new file mode 100644
index 0000000000..29f5652b3e
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorANGLE.h
@@ -0,0 +1,160 @@
+/* -*- 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_RENDERCOMPOSITOR_ANGLE_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_ANGLE_H
+
+#include <queue>
+
+#include "GLTypes.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/webrender/RenderCompositor.h"
+#include "mozilla/webrender/RenderThread.h"
+
+struct ID3D11DeviceContext;
+struct ID3D11Device;
+struct ID3D11Query;
+struct IDXGIFactory2;
+struct IDXGISwapChain;
+struct IDXGISwapChain1;
+
+namespace mozilla {
+namespace gl {
+class GLLibraryEGL;
+}  // namespace gl
+
+namespace wr {
+
+class DCLayerTree;
+
+class RenderCompositorANGLE : public RenderCompositor {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  explicit RenderCompositorANGLE(
+      const RefPtr<widget::CompositorWidget>& aWidget,
+      RefPtr<gl::GLContext>&& aGL);
+  virtual ~RenderCompositorANGLE();
+  bool Initialize(nsACString& aError);
+
+  bool BeginFrame() override;
+  RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) final;
+  bool WaitForGPU() override;
+  RenderedFrameId GetLastCompletedFrameId() final;
+  RenderedFrameId UpdateFrameId() final;
+  void Pause() override;
+  bool Resume() override;
+  void Update() override;
+
+  gl::GLContext* gl() const override { return mGL; }
+
+  bool MakeCurrent() override;
+
+  bool UseANGLE() const override { return true; }
+
+  bool UseDComp() const override { return !!mDCLayerTree; }
+
+  bool UseTripleBuffering() const override { return mUseTripleBuffering; }
+
+  layers::WebRenderCompositor CompositorType() const override {
+    if (UseDComp()) {
+      return layers::WebRenderCompositor::DIRECT_COMPOSITION;
+    }
+    return layers::WebRenderCompositor::DRAW;
+  }
+
+  LayoutDeviceIntSize GetBufferSize() override;
+
+  GLenum IsContextLost(bool aForce) override;
+
+  bool SurfaceOriginIsTopLeft() override { return true; }
+
+  bool SupportAsyncScreenshot() override;
+
+  bool ShouldUseNativeCompositor() override;
+
+  // Interface for wr::Compositor
+  void CompositorBeginFrame() override;
+  void CompositorEndFrame() override;
+  void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId,
+            wr::DeviceIntRect aDirtyRect,
+            wr::DeviceIntRect aValidRect) override;
+  void Unbind() override;
+  void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset,
+                     wr::DeviceIntSize aTileSize, bool aIsOpaque) override;
+  void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) override;
+  void DestroySurface(NativeSurfaceId aId) override;
+  void CreateTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) override;
+  void DestroyTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) override;
+  void AttachExternalImage(wr::NativeSurfaceId aId,
+                           wr::ExternalImageId aExternalImage) override;
+  void AddSurface(wr::NativeSurfaceId aId,
+                  const wr::CompositorSurfaceTransform& aTransform,
+                  wr::DeviceIntRect aClipRect,
+                  wr::ImageRendering aImageRendering) override;
+  void EnableNativeCompositor(bool aEnable) override;
+  void GetCompositorCapabilities(CompositorCapabilities* aCaps) override;
+
+  // Interface for partial present
+  bool UsePartialPresent() override;
+  bool RequestFullRender() override;
+  uint32_t GetMaxPartialPresentRects() override;
+
+  bool MaybeReadback(const gfx::IntSize& aReadbackSize,
+                     const wr::ImageFormat& aReadbackFormat,
+                     const Range<uint8_t>& aReadbackBuffer,
+                     bool* aNeedsYFlip) override;
+
+ protected:
+  bool UseCompositor();
+  void InitializeUsePartialPresent();
+  void InsertGraphicsCommandsFinishedWaitQuery(
+      RenderedFrameId aRenderedFrameId);
+  bool WaitForPreviousGraphicsCommandsFinishedQuery(bool aWaitAll = false);
+  bool ResizeBufferIfNeeded();
+  bool CreateEGLSurface();
+  void DestroyEGLSurface();
+  ID3D11Device* GetDeviceOfEGLDisplay(nsACString& aError);
+  bool CreateSwapChain(nsACString& aError);
+  void CreateSwapChainForDCompIfPossible(IDXGIFactory2* aDXGIFactory2);
+  RefPtr<IDXGISwapChain1> CreateSwapChainForDComp(bool aUseTripleBuffering);
+  RefPtr<ID3D11Query> GetD3D11Query();
+  void ReleaseNativeCompositorResources();
+  HWND GetCompositorHwnd();
+
+  RefPtr<gl::GLContext> mGL;
+
+  EGLConfig mEGLConfig = nullptr;
+  EGLSurface mEGLSurface = nullptr;
+
+  bool mUseTripleBuffering = false;
+
+  RefPtr<ID3D11Device> mDevice;
+  RefPtr<ID3D11DeviceContext> mCtx;
+  RefPtr<IDXGISwapChain> mSwapChain;
+  RefPtr<IDXGISwapChain1> mSwapChain1;
+
+  UniquePtr<DCLayerTree> mDCLayerTree;
+
+  std::queue<std::pair<RenderedFrameId, RefPtr<ID3D11Query>>>
+      mWaitForPresentQueries;
+  RefPtr<ID3D11Query> mRecycledQuery;
+  RenderedFrameId mLastCompletedFrameId;
+
+  Maybe<LayoutDeviceIntSize> mBufferSize;
+  bool mUseNativeCompositor = true;
+  bool mUsePartialPresent = false;
+  bool mFullRender = false;
+  // Used to know a timing of disabling native compositor.
+  bool mDisablingNativeCompositor = false;
+  bool mFirstPresent = true;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderCompositorD3D11SWGL.cpp b/gfx/webrender_bindings/RenderCompositorD3D11SWGL.cpp
new file mode 100644
index 0000000000..d95074e901
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorD3D11SWGL.cpp
@@ -0,0 +1,488 @@
+/* -*- 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 "RenderCompositorD3D11SWGL.h"
+
+#include "gfxConfig.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "mozilla/layers/Effects.h"
+#include "mozilla/webrender/RenderD3D11TextureHost.h"
+#include "RenderCompositorRecordedFrame.h"
+#include "RenderThread.h"
+
+namespace mozilla {
+using namespace layers;
+
+namespace wr {
+
+extern LazyLogModule gRenderThreadLog;
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+RenderCompositorD3D11SWGL::UploadMode
+RenderCompositorD3D11SWGL::GetUploadMode() {
+  int mode = StaticPrefs::gfx_webrender_software_d3d11_upload_mode();
+  switch (mode) {
+    case 1:
+      return Upload_Immediate;
+    case 2:
+      return Upload_Staging;
+    case 3:
+      return Upload_StagingNoBlock;
+    case 4:
+      return Upload_StagingPooled;
+    default:
+      return Upload_Staging;
+  }
+}
+
+UniquePtr<RenderCompositor> RenderCompositorD3D11SWGL::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  if (!aWidget->GetCompositorOptions().AllowSoftwareWebRenderD3D11() ||
+      !gfx::gfxConfig::IsEnabled(gfx::Feature::D3D11_COMPOSITING)) {
+    return nullptr;
+  }
+
+  void* ctx = wr_swgl_create_context();
+  if (!ctx) {
+    gfxCriticalNote << "Failed SWGL context creation for WebRender";
+    return nullptr;
+  }
+
+  RefPtr<CompositorD3D11> compositor = MakeAndAddRef<CompositorD3D11>(aWidget);
+  nsCString log;
+  if (!compositor->Initialize(&log)) {
+    gfxCriticalNote << "Failed to initialize CompositorD3D11 for SWGL: "
+                    << log.get();
+    return nullptr;
+  }
+  return MakeUnique<RenderCompositorD3D11SWGL>(compositor, aWidget, ctx);
+}
+
+RenderCompositorD3D11SWGL::RenderCompositorD3D11SWGL(
+    CompositorD3D11* aCompositor,
+    const RefPtr<widget::CompositorWidget>& aWidget, void* aContext)
+    : RenderCompositorLayersSWGL(aCompositor, aWidget, aContext) {
+  LOG("RenderCompositorD3D11SWGL::RenderCompositorD3D11SWGL()");
+
+  mSyncObject = GetCompositorD3D11()->GetSyncObject();
+}
+
+RenderCompositorD3D11SWGL::~RenderCompositorD3D11SWGL() {
+  LOG("RenderCompositorD3D11SWGL::~RenderCompositorD3D11SWGL()");
+}
+
+bool RenderCompositorD3D11SWGL::BeginFrame() {
+  if (!RenderCompositorLayersSWGL::BeginFrame()) {
+    return false;
+  }
+
+  mUploadMode = GetUploadMode();
+  return true;
+}
+
+void RenderCompositorD3D11SWGL::HandleExternalImage(
+    RenderTextureHost* aExternalImage, FrameSurface& aFrameSurface) {
+  // We need to hold the texture source separately from the effect,
+  // since the effect doesn't hold a strong reference.
+  RefPtr<DataTextureSourceD3D11> layer;
+  RefPtr<TexturedEffect> texturedEffect;
+  gfx::IntSize size;
+  if (auto* host = aExternalImage->AsRenderDXGITextureHost()) {
+    if (!host->EnsureD3D11Texture2D(GetDevice())) {
+      return;
+    }
+
+    layer = new DataTextureSourceD3D11(GetDevice(), host->GetFormat(),
+                                       host->GetD3D11Texture2D());
+    if (host->GetFormat() == gfx::SurfaceFormat::NV12 ||
+        host->GetFormat() == gfx::SurfaceFormat::P010 ||
+        host->GetFormat() == gfx::SurfaceFormat::P016) {
+      const auto yuv = FromYUVRangedColorSpace(host->GetYUVColorSpace());
+      texturedEffect =
+          new EffectNV12(layer, yuv.space, yuv.range, host->GetColorDepth(),
+                         aFrameSurface.mFilter);
+    } else {
+      MOZ_ASSERT(host->GetFormat() == gfx::SurfaceFormat::B8G8R8X8 ||
+                 host->GetFormat() == gfx::SurfaceFormat::B8G8R8A8);
+      texturedEffect = CreateTexturedEffect(host->GetFormat(), layer,
+                                            aFrameSurface.mFilter, true);
+    }
+    size = host->GetSize(0);
+    host->LockInternal();
+  } else if (auto* host = aExternalImage->AsRenderDXGIYCbCrTextureHost()) {
+    if (!host->EnsureD3D11Texture2D(GetDevice())) {
+      return;
+    }
+
+    layer = new DataTextureSourceD3D11(GetDevice(), gfx::SurfaceFormat::A8,
+                                       host->GetD3D11Texture2D(0));
+    RefPtr<DataTextureSourceD3D11> u = new DataTextureSourceD3D11(
+        GetDevice(), gfx::SurfaceFormat::A8, host->GetD3D11Texture2D(1));
+    layer->SetNextSibling(u);
+    RefPtr<DataTextureSourceD3D11> v = new DataTextureSourceD3D11(
+        GetDevice(), gfx::SurfaceFormat::A8, host->GetD3D11Texture2D(2));
+    u->SetNextSibling(v);
+
+    const auto yuv = FromYUVRangedColorSpace(host->GetYUVColorSpace());
+    texturedEffect =
+        new EffectYCbCr(layer, yuv.space, yuv.range, host->GetColorDepth(),
+                        aFrameSurface.mFilter);
+    size = host->GetSize(0);
+    host->LockInternal();
+  }
+
+  gfx::Rect drawRect(0, 0, size.width, size.height);
+
+  EffectChain effect;
+  effect.mPrimaryEffect = texturedEffect;
+  mCompositor->DrawQuad(drawRect, aFrameSurface.mClipRect, effect, 1.0,
+                        aFrameSurface.mTransform, drawRect);
+
+  if (auto* host = aExternalImage->AsRenderDXGITextureHost()) {
+    host->Unlock();
+  } else if (auto* host = aExternalImage->AsRenderDXGIYCbCrTextureHost()) {
+    host->Unlock();
+  }
+}
+
+void RenderCompositorD3D11SWGL::Pause() {}
+
+bool RenderCompositorD3D11SWGL::Resume() { return true; }
+
+GLenum RenderCompositorD3D11SWGL::IsContextLost(bool aForce) {
+  // CompositorD3D11 uses ID3D11Device for composite. The device status needs to
+  // be checked.
+  auto reason = GetDevice()->GetDeviceRemovedReason();
+  switch (reason) {
+    case S_OK:
+      return LOCAL_GL_NO_ERROR;
+    case DXGI_ERROR_DEVICE_REMOVED:
+    case DXGI_ERROR_DRIVER_INTERNAL_ERROR:
+      NS_WARNING("Device reset due to system / different device");
+      return LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB;
+    case DXGI_ERROR_DEVICE_HUNG:
+    case DXGI_ERROR_DEVICE_RESET:
+    case DXGI_ERROR_INVALID_CALL:
+      gfxCriticalError() << "Device reset due to WR device: "
+                         << gfx::hexa(reason);
+      return LOCAL_GL_GUILTY_CONTEXT_RESET_ARB;
+    default:
+      gfxCriticalError() << "Device reset with WR device unexpected reason: "
+                         << gfx::hexa(reason);
+      return LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB;
+  }
+}
+
+UniquePtr<RenderCompositorLayersSWGL::Surface>
+RenderCompositorD3D11SWGL::DoCreateSurface(wr::DeviceIntSize aTileSize,
+                                           bool aIsOpaque) {
+  return MakeUnique<SurfaceD3D11SWGL>(aTileSize, aIsOpaque);
+}
+
+SurfaceD3D11SWGL::SurfaceD3D11SWGL(wr::DeviceIntSize aTileSize, bool aIsOpaque)
+    : Surface(aTileSize, aIsOpaque) {}
+
+RenderCompositorD3D11SWGL::TileD3D11::TileD3D11(
+    layers::DataTextureSourceD3D11* aTexture, ID3D11Texture2D* aStagingTexture,
+    gfx::DataSourceSurface* aDataSourceSurface, Surface* aOwner,
+    RenderCompositorD3D11SWGL* aRenderCompositor)
+    : Tile(),
+      mTexture(aTexture),
+      mStagingTexture(aStagingTexture),
+      mSurface(aDataSourceSurface),
+      mOwner(aOwner->AsSurfaceD3D11SWGL()),
+      mRenderCompositor(aRenderCompositor) {}
+
+bool RenderCompositorD3D11SWGL::TileD3D11::Map(wr::DeviceIntRect aDirtyRect,
+                                               wr::DeviceIntRect aValidRect,
+                                               void** aData, int32_t* aStride) {
+  const UploadMode uploadMode = mRenderCompositor->GetUploadMode();
+  const gfx::IntSize tileSize = mOwner->TileSize();
+
+  if (!IsValid()) {
+    return false;
+  }
+
+  // Check if this tile's upload method matches what we're using for this frame,
+  // and if not then reallocate to fix it. Do this before we copy the struct
+  // into mCurrentTile.
+  if (uploadMode == Upload_Immediate) {
+    if (mStagingTexture) {
+      MOZ_ASSERT(!mSurface);
+      mStagingTexture = nullptr;
+      mSurface = mRenderCompositor->CreateStagingSurface(tileSize);
+    }
+  } else {
+    if (mSurface) {
+      MOZ_ASSERT(!mStagingTexture);
+      mSurface = nullptr;
+      mStagingTexture = mRenderCompositor->CreateStagingTexture(tileSize);
+    }
+  }
+
+  mRenderCompositor->mCurrentStagingTexture = mStagingTexture;
+  mRenderCompositor->mCurrentStagingTextureIsTemp = false;
+
+  if (uploadMode == Upload_Immediate) {
+    gfx::DataSourceSurface::MappedSurface map;
+    if (!mSurface->Map(gfx::DataSourceSurface::READ_WRITE, &map)) {
+      return false;
+    }
+
+    *aData = map.mData + aValidRect.min.y * map.mStride + aValidRect.min.x * 4;
+    *aStride = map.mStride;
+    // Ensure our mapped data is accessible by writing to the beginning and end
+    // of the dirty region. See bug 1717519
+    if (aDirtyRect.width() > 0 && aDirtyRect.height() > 0) {
+      uint32_t* probeData = (uint32_t*)map.mData +
+                            aDirtyRect.min.y * (map.mStride / 4) +
+                            aDirtyRect.min.x;
+      *probeData = 0;
+      uint32_t* probeDataEnd = (uint32_t*)map.mData +
+                               (aDirtyRect.max.y - 1) * (map.mStride / 4) +
+                               (aDirtyRect.max.x - 1);
+      *probeDataEnd = 0;
+    }
+
+    mValidRect = gfx::Rect(aValidRect.min.x, aValidRect.min.y,
+                           aValidRect.width(), aValidRect.height());
+    return true;
+  }
+
+  if (!mRenderCompositor->mCurrentStagingTexture) {
+    return false;
+  }
+
+  RefPtr<ID3D11DeviceContext> context;
+  mRenderCompositor->GetDevice()->GetImmediateContext(getter_AddRefs(context));
+
+  D3D11_MAPPED_SUBRESOURCE mappedSubresource;
+
+  bool shouldBlock = uploadMode == Upload_Staging;
+
+  HRESULT hr = context->Map(
+      mRenderCompositor->mCurrentStagingTexture, 0, D3D11_MAP_READ_WRITE,
+      shouldBlock ? 0 : D3D11_MAP_FLAG_DO_NOT_WAIT, &mappedSubresource);
+  if (hr == DXGI_ERROR_WAS_STILL_DRAWING) {
+    // mCurrentTile is a copy of the real tile data, so we can just replace the
+    // staging one with a temporary for this draw. The staging texture for the
+    // real tile remains untouched, so we'll go back to using that for future
+    // frames and discard the new one. In the future we could improve this by
+    // having a pool of shared staging textures for all the tiles.
+
+    // Mark the tile as having a temporary staging texture.
+    mRenderCompositor->mCurrentStagingTextureIsTemp = true;
+
+    // Try grabbing a texture from the staging pool and see if we can use that.
+    if (uploadMode == Upload_StagingPooled && mOwner->mStagingPool.Length()) {
+      mRenderCompositor->mCurrentStagingTexture =
+          mOwner->mStagingPool.ElementAt(0);
+      mOwner->mStagingPool.RemoveElementAt(0);
+      hr = context->Map(mRenderCompositor->mCurrentStagingTexture, 0,
+                        D3D11_MAP_READ_WRITE, D3D11_MAP_FLAG_DO_NOT_WAIT,
+                        &mappedSubresource);
+
+      // If that failed, put it back into the pool (but at the end).
+      if (hr == DXGI_ERROR_WAS_STILL_DRAWING) {
+        mOwner->mStagingPool.AppendElement(
+            mRenderCompositor->mCurrentStagingTexture);
+      }
+    }
+
+    // No staging textures, or we tried one and it was busy. Allocate a brand
+    // new one instead.
+    if (hr == DXGI_ERROR_WAS_STILL_DRAWING) {
+      mRenderCompositor->mCurrentStagingTexture =
+          mRenderCompositor->CreateStagingTexture(tileSize);
+      if (!mRenderCompositor->mCurrentStagingTexture) {
+        return false;
+      }
+      hr = context->Map(mRenderCompositor->mCurrentStagingTexture, 0,
+                        D3D11_MAP_READ_WRITE, 0, &mappedSubresource);
+    }
+  }
+  if (!SUCCEEDED(hr)) {
+    gfxCriticalError() << "Failed to map tile: " << gfx::hexa(hr);
+    // This is only expected to fail if we hit a device reset.
+    MOZ_RELEASE_ASSERT(
+        mRenderCompositor->GetDevice()->GetDeviceRemovedReason() != S_OK);
+    return false;
+  }
+
+  // aData is expected to contain a pointer to the first pixel within the valid
+  // rect, so take the mapped resource's data (which covers the full tile size)
+  // and offset it by the top/left of the valid rect.
+  *aData = (uint8_t*)mappedSubresource.pData +
+           aValidRect.min.y * mappedSubresource.RowPitch + aValidRect.min.x * 4;
+  *aStride = mappedSubresource.RowPitch;
+
+  // Ensure our mapped data is accessible by writing to the beginning and end
+  // of the dirty region. See bug 1717519
+  if (aDirtyRect.width() > 0 && aDirtyRect.height() > 0) {
+    uint32_t* probeData = (uint32_t*)mappedSubresource.pData +
+                          aDirtyRect.min.y * (mappedSubresource.RowPitch / 4) +
+                          aDirtyRect.min.x;
+    *probeData = 0;
+    uint32_t* probeDataEnd =
+        (uint32_t*)mappedSubresource.pData +
+        (aDirtyRect.max.y - 1) * (mappedSubresource.RowPitch / 4) +
+        (aDirtyRect.max.x - 1);
+    *probeDataEnd = 0;
+  }
+
+  // Store the new valid rect, so that we can composite only those pixels
+  mValidRect = gfx::Rect(aValidRect.min.x, aValidRect.min.y, aValidRect.width(),
+                         aValidRect.height());
+
+  return true;
+}
+
+void RenderCompositorD3D11SWGL::TileD3D11::Unmap(
+    const gfx::IntRect& aDirtyRect) {
+  const UploadMode uploadMode = mRenderCompositor->GetUploadMode();
+
+  if (!IsValid()) {
+    return;
+  }
+
+  if (mSurface) {
+    MOZ_ASSERT(uploadMode == Upload_Immediate);
+    mSurface->Unmap();
+    nsIntRegion dirty(aDirtyRect);
+    // This uses UpdateSubresource, which blocks, so is likely implemented as a
+    // memcpy into driver owned memory, followed by an async upload. The staging
+    // method should avoid this extra copy, and is likely to be faster usually.
+    // We could possible do this call on a background thread so that sw-wr can
+    // start drawing the next tile while the memcpy is in progress.
+    mTexture->Update(mSurface, &dirty);
+    return;
+  }
+
+  if (!mRenderCompositor->mCurrentStagingTexture) {
+    return;
+  }
+
+  RefPtr<ID3D11DeviceContext> context;
+  mRenderCompositor->GetDevice()->GetImmediateContext(getter_AddRefs(context));
+
+  context->Unmap(mRenderCompositor->mCurrentStagingTexture, 0);
+
+  D3D11_BOX box;
+  box.front = 0;
+  box.back = 1;
+  box.left = aDirtyRect.X();
+  box.top = aDirtyRect.Y();
+  box.right = aDirtyRect.XMost();
+  box.bottom = aDirtyRect.YMost();
+
+  context->CopySubresourceRegion(
+      mTexture->GetD3D11Texture(), 0, aDirtyRect.x, aDirtyRect.y, 0,
+      mRenderCompositor->mCurrentStagingTexture, 0, &box);
+
+  // If we allocated a temp staging texture for this tile, and we're running
+  // in pooled mode, then consider adding it to the pool for later.
+  if (mRenderCompositor->mCurrentStagingTextureIsTemp &&
+      uploadMode == Upload_StagingPooled) {
+    static const uint32_t kMaxPoolSize = 5;
+    if (mOwner->mStagingPool.Length() < kMaxPoolSize) {
+      mOwner->mStagingPool.AppendElement(
+          mRenderCompositor->mCurrentStagingTexture);
+    }
+  }
+
+  mRenderCompositor->mCurrentStagingTexture = nullptr;
+  mRenderCompositor->mCurrentStagingTextureIsTemp = false;
+}
+
+bool RenderCompositorD3D11SWGL::TileD3D11::IsValid() { return !!mTexture; }
+
+already_AddRefed<ID3D11Texture2D>
+RenderCompositorD3D11SWGL::CreateStagingTexture(const gfx::IntSize aSize) {
+  CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, aSize.width,
+                             aSize.height, 1, 1);
+
+  desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
+  desc.Usage = D3D11_USAGE_STAGING;
+  desc.BindFlags = 0;
+
+  RefPtr<ID3D11Texture2D> cpuTexture;
+  DebugOnly<HRESULT> hr =
+      GetDevice()->CreateTexture2D(&desc, nullptr, getter_AddRefs(cpuTexture));
+  MOZ_ASSERT(SUCCEEDED(hr));
+  if (!cpuTexture) {
+    gfxCriticalNote << "Failed to create StagingTexture: " << aSize;
+    RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE);
+  }
+  return cpuTexture.forget();
+}
+
+already_AddRefed<gfx::DataSourceSurface>
+RenderCompositorD3D11SWGL::CreateStagingSurface(const gfx::IntSize aSize) {
+  return gfx::Factory::CreateDataSourceSurface(aSize,
+                                               gfx::SurfaceFormat::B8G8R8A8);
+}
+
+UniquePtr<RenderCompositorLayersSWGL::Tile>
+RenderCompositorD3D11SWGL::DoCreateTile(Surface* aSurface) {
+  MOZ_RELEASE_ASSERT(aSurface);
+
+  const auto tileSize = aSurface->TileSize();
+
+  if (mUploadMode == Upload_Immediate) {
+    RefPtr<DataTextureSourceD3D11> source =
+        new DataTextureSourceD3D11(gfx::SurfaceFormat::B8G8R8A8, mCompositor,
+                                   layers::TextureFlags::NO_FLAGS);
+    RefPtr<gfx::DataSourceSurface> surf = CreateStagingSurface(tileSize);
+    return MakeUnique<TileD3D11>(source, nullptr, surf, aSurface, this);
+  }
+
+  MOZ_ASSERT(mUploadMode == Upload_Staging ||
+             mUploadMode == Upload_StagingNoBlock ||
+             mUploadMode == Upload_StagingPooled);
+
+  CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, tileSize.width,
+                             tileSize.height, 1, 1);
+
+  RefPtr<ID3D11Texture2D> texture;
+  DebugOnly<HRESULT> hr =
+      GetDevice()->CreateTexture2D(&desc, nullptr, getter_AddRefs(texture));
+  MOZ_ASSERT(SUCCEEDED(hr));
+  if (!texture) {
+    gfxCriticalNote << "Failed to allocate Texture2D: " << aSurface->TileSize();
+    RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE);
+    return MakeUnique<TileD3D11>(nullptr, nullptr, nullptr, aSurface, this);
+  }
+
+  RefPtr<DataTextureSourceD3D11> source = new DataTextureSourceD3D11(
+      GetDevice(), gfx::SurfaceFormat::B8G8R8A8, texture);
+
+  RefPtr<ID3D11Texture2D> cpuTexture = CreateStagingTexture(tileSize);
+  return MakeUnique<TileD3D11>(source, cpuTexture, nullptr, aSurface, this);
+}
+
+bool RenderCompositorD3D11SWGL::MaybeReadback(
+    const gfx::IntSize& aReadbackSize, const wr::ImageFormat& aReadbackFormat,
+    const Range<uint8_t>& aReadbackBuffer, bool* aNeedsYFlip) {
+  MOZ_ASSERT(aReadbackFormat == wr::ImageFormat::BGRA8);
+
+  auto stride =
+      aReadbackSize.width * gfx::BytesPerPixel(gfx::SurfaceFormat::B8G8R8A8);
+  RefPtr<gfx::DrawTarget> dt = gfx::Factory::CreateDrawTargetForData(
+      gfx::BackendType::SKIA, &aReadbackBuffer[0], aReadbackSize, stride,
+      gfx::SurfaceFormat::B8G8R8A8, false);
+  if (!dt) {
+    return false;
+  }
+
+  GetCompositorD3D11()->Readback(dt);
+  return true;
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderCompositorD3D11SWGL.h b/gfx/webrender_bindings/RenderCompositorD3D11SWGL.h
new file mode 100644
index 0000000000..2365230f66
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorD3D11SWGL.h
@@ -0,0 +1,118 @@
+/* -*- 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_RENDERCOMPOSITOR_D3D11_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_D3D11_H
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/layers/ScreenshotGrabber.h"
+#include "mozilla/layers/TextureD3D11.h"
+#include "mozilla/layers/CompositorD3D11.h"
+#include "mozilla/webrender/RenderCompositorLayersSWGL.h"
+
+namespace mozilla {
+
+namespace wr {
+
+class SurfaceD3D11SWGL;
+
+class RenderCompositorD3D11SWGL : public RenderCompositorLayersSWGL {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositorD3D11SWGL(layers::CompositorD3D11* aCompositor,
+                            const RefPtr<widget::CompositorWidget>& aWidget,
+                            void* aContext);
+  virtual ~RenderCompositorD3D11SWGL();
+
+  void Pause() override;
+  bool Resume() override;
+
+  GLenum IsContextLost(bool aForce) override;
+
+  layers::WebRenderCompositor CompositorType() const override {
+    return layers::WebRenderCompositor::D3D11;
+  }
+  RenderCompositorD3D11SWGL* AsRenderCompositorD3D11SWGL() override {
+    return this;
+  }
+
+  bool BeginFrame() override;
+
+  bool MaybeReadback(const gfx::IntSize& aReadbackSize,
+                     const wr::ImageFormat& aReadbackFormat,
+                     const Range<uint8_t>& aReadbackBuffer,
+                     bool* aNeedsYFlip) override;
+
+  layers::CompositorD3D11* GetCompositorD3D11() {
+    return mCompositor->AsCompositorD3D11();
+  }
+
+  ID3D11Device* GetDevice() { return GetCompositorD3D11()->GetDevice(); }
+
+ private:
+  already_AddRefed<ID3D11Texture2D> CreateStagingTexture(
+      const gfx::IntSize aSize);
+  already_AddRefed<gfx::DataSourceSurface> CreateStagingSurface(
+      const gfx::IntSize aSize);
+
+  void HandleExternalImage(RenderTextureHost* aExternalImage,
+                           FrameSurface& aFrameSurface) override;
+  UniquePtr<RenderCompositorLayersSWGL::Surface> DoCreateSurface(
+      wr::DeviceIntSize aTileSize, bool aIsOpaque) override;
+  UniquePtr<RenderCompositorLayersSWGL::Tile> DoCreateTile(
+      Surface* aSurface) override;
+
+  class TileD3D11 : public RenderCompositorLayersSWGL::Tile {
+   public:
+    TileD3D11(layers::DataTextureSourceD3D11* aTexture,
+              ID3D11Texture2D* aStagingTexture,
+              gfx::DataSourceSurface* aDataSourceSurface, Surface* aOwner,
+              RenderCompositorD3D11SWGL* aRenderCompositor);
+    virtual ~TileD3D11() {}
+
+    bool Map(wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect,
+             void** aData, int32_t* aStride) override;
+    void Unmap(const gfx::IntRect& aDirtyRect) override;
+    layers::DataTextureSource* GetTextureSource() override { return mTexture; }
+    bool IsValid() override;
+
+   private:
+    RefPtr<layers::DataTextureSourceD3D11> mTexture;
+    RefPtr<ID3D11Texture2D> mStagingTexture;
+    RefPtr<gfx::DataSourceSurface> mSurface;
+    SurfaceD3D11SWGL* mOwner;
+    RenderCompositorD3D11SWGL* mRenderCompositor;
+  };
+
+  enum UploadMode {
+    Upload_Immediate,
+    Upload_Staging,
+    Upload_StagingNoBlock,
+    Upload_StagingPooled
+  };
+  UploadMode GetUploadMode();
+  UploadMode mUploadMode = Upload_Staging;
+
+  RefPtr<ID3D11Texture2D> mCurrentStagingTexture;
+  bool mCurrentStagingTextureIsTemp = false;
+};
+
+class SurfaceD3D11SWGL : public RenderCompositorLayersSWGL::Surface {
+ public:
+  SurfaceD3D11SWGL(wr::DeviceIntSize aTileSize, bool aIsOpaque);
+  virtual ~SurfaceD3D11SWGL() {}
+
+  SurfaceD3D11SWGL* AsSurfaceD3D11SWGL() override { return this; }
+
+  nsTArray<RefPtr<ID3D11Texture2D>> mStagingPool;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderCompositorEGL.cpp b/gfx/webrender_bindings/RenderCompositorEGL.cpp
new file mode 100644
index 0000000000..ccabfd375f
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorEGL.cpp
@@ -0,0 +1,325 @@
+/* -*- 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 "RenderCompositorEGL.h"
+
+#include "GLContext.h"
+#include "GLContextEGL.h"
+#include "GLContextProvider.h"
+#include "GLLibraryEGL.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/BuildConstants.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/widget/CompositorWidget.h"
+
+#ifdef MOZ_WIDGET_GTK
+#  include "mozilla/WidgetUtilsGtk.h"
+#  include "mozilla/widget/GtkCompositorWidget.h"
+#endif
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "mozilla/java/GeckoSurfaceTextureWrappers.h"
+#  include "mozilla/layers/AndroidHardwareBuffer.h"
+#  include "mozilla/widget/AndroidCompositorWidget.h"
+#  include <android/native_window.h>
+#  include <android/native_window_jni.h>
+#endif
+
+namespace mozilla::wr {
+
+extern LazyLogModule gRenderThreadLog;
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+/* static */
+UniquePtr<RenderCompositor> RenderCompositorEGL::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  if (kIsLinux && !gfx::gfxVars::UseEGL()) {
+    return nullptr;
+  }
+  RefPtr<gl::GLContext> gl = RenderThread::Get()->SingletonGL(aError);
+  if (!gl) {
+    if (aError.IsEmpty()) {
+      aError.Assign("RcANGLE(no shared GL)"_ns);
+    } else {
+      aError.Append("(Create)"_ns);
+    }
+    return nullptr;
+  }
+  return MakeUnique<RenderCompositorEGL>(aWidget, std::move(gl));
+}
+
+EGLSurface RenderCompositorEGL::CreateEGLSurface() {
+  EGLSurface surface = EGL_NO_SURFACE;
+  surface = gl::GLContextEGL::CreateEGLSurfaceForCompositorWidget(
+      mWidget, gl::GLContextEGL::Cast(gl())->mSurfaceConfig);
+  if (surface == EGL_NO_SURFACE) {
+    const auto* renderThread = RenderThread::Get();
+    gfxCriticalNote << "Failed to create EGLSurface. "
+                    << renderThread->RendererCount() << " renderers, "
+                    << renderThread->ActiveRendererCount() << " active.";
+  }
+  return surface;
+}
+
+RenderCompositorEGL::RenderCompositorEGL(
+    const RefPtr<widget::CompositorWidget>& aWidget,
+    RefPtr<gl::GLContext>&& aGL)
+    : RenderCompositor(aWidget), mGL(aGL), mEGLSurface(EGL_NO_SURFACE) {
+  MOZ_ASSERT(mGL);
+  LOG("RenderCompositorEGL::RenderCompositorEGL()");
+}
+
+RenderCompositorEGL::~RenderCompositorEGL() {
+  LOG("RenderCompositorEGL::~RenderCompositorEGL()");
+#ifdef MOZ_WIDGET_ANDROID
+  java::GeckoSurfaceTexture::DestroyUnused((int64_t)gl());
+#endif
+  DestroyEGLSurface();
+}
+
+bool RenderCompositorEGL::BeginFrame() {
+  if (kIsLinux && mEGLSurface == EGL_NO_SURFACE) {
+    gfxCriticalNote
+        << "We don't have EGLSurface to draw into. Called too early?";
+    return false;
+  }
+#ifdef MOZ_WIDGET_GTK
+  if (mWidget->AsGTK()) {
+    if (!mWidget->AsGTK()->SetEGLNativeWindowSize(GetBufferSize())) {
+      // It's possible that GtkWidget is hidden on Wayland; e.g. maybe it's
+      // just been closed. So, we can't draw into it right now.
+      return false;
+    }
+  }
+#endif
+  if (!MakeCurrent()) {
+    gfxCriticalNote << "Failed to make render context current, can't draw.";
+    return false;
+  }
+
+#ifdef MOZ_WIDGET_ANDROID
+  java::GeckoSurfaceTexture::DestroyUnused((int64_t)gl());
+  gl()->MakeCurrent();  // DestroyUnused can change the current context!
+#endif
+
+  return true;
+}
+
+RenderedFrameId RenderCompositorEGL::EndFrame(
+    const nsTArray<DeviceIntRect>& aDirtyRects) {
+#ifdef MOZ_WIDGET_ANDROID
+  const auto& gle = gl::GLContextEGL::Cast(gl());
+  const auto& egl = gle->mEgl;
+
+  EGLSync sync = nullptr;
+  if (layers::AndroidHardwareBufferApi::Get()) {
+    sync = egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
+  }
+  if (sync) {
+    int fenceFd = egl->fDupNativeFenceFDANDROID(sync);
+    if (fenceFd >= 0) {
+      mReleaseFenceFd = ipc::FileDescriptor(UniqueFileHandle(fenceFd));
+    }
+    egl->fDestroySync(sync);
+    sync = nullptr;
+  }
+#endif
+
+  RenderedFrameId frameId = GetNextRenderFrameId();
+#ifdef MOZ_WIDGET_GTK
+  if (mWidget->IsHidden()) {
+    return frameId;
+  }
+#endif
+  if (mEGLSurface != EGL_NO_SURFACE && aDirtyRects.Length() > 0) {
+    gfx::IntRegion bufferInvalid;
+    const auto bufferSize = GetBufferSize();
+    for (const DeviceIntRect& rect : aDirtyRects) {
+      const auto left = std::max(0, std::min(bufferSize.width, rect.min.x));
+      const auto top = std::max(0, std::min(bufferSize.height, rect.min.y));
+
+      const auto right = std::min(bufferSize.width, std::max(0, rect.max.x));
+      const auto bottom = std::min(bufferSize.height, std::max(0, rect.max.y));
+
+      const auto width = right - left;
+      const auto height = bottom - top;
+
+      bufferInvalid.OrWith(
+          gfx::IntRect(left, (GetBufferSize().height - bottom), width, height));
+    }
+    gl()->SetDamage(bufferInvalid);
+  }
+  gl()->SwapBuffers();
+  return frameId;
+}
+
+void RenderCompositorEGL::Pause() { DestroyEGLSurface(); }
+
+bool RenderCompositorEGL::Resume() {
+  if (kIsAndroid) {
+    // Destroy EGLSurface if it exists.
+    DestroyEGLSurface();
+
+    auto size = GetBufferSize();
+    GLint maxTextureSize = 0;
+    gl()->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, (GLint*)&maxTextureSize);
+
+    // When window size is too big, hardware buffer allocation could fail.
+    if (maxTextureSize < size.width || maxTextureSize < size.height) {
+      gfxCriticalNote << "Too big ANativeWindow size(" << size.width << ", "
+                      << size.height << ") MaxTextureSize " << maxTextureSize;
+      return false;
+    }
+
+    mEGLSurface = CreateEGLSurface();
+    if (mEGLSurface == EGL_NO_SURFACE) {
+      // Often when we fail to create an EGL surface it is because the Java
+      // Surface we have been provided is invalid. Therefore the on the first
+      // occurence we don't raise a WebRenderError and instead just return
+      // failure. This allows the widget a chance to request a new Java
+      // Surface. On subsequent failures, raising the WebRenderError will
+      // result in the compositor being recreated, falling back through
+      // webrender configurations, and eventually crashing if we still do not
+      // succeed.
+      if (!mHandlingNewSurfaceError) {
+        mHandlingNewSurfaceError = true;
+      } else {
+        RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE);
+      }
+      return false;
+    }
+    mHandlingNewSurfaceError = false;
+
+    gl::GLContextEGL::Cast(gl())->SetEGLSurfaceOverride(mEGLSurface);
+  } else if (kIsLinux) {
+    // Destroy EGLSurface if it exists and create a new one. We will set the
+    // swap interval after MakeCurrent() has been called.
+    DestroyEGLSurface();
+    mEGLSurface = CreateEGLSurface();
+    if (mEGLSurface != EGL_NO_SURFACE) {
+      // We have a new EGL surface, which on wayland needs to be configured for
+      // non-blocking buffer swaps. We need MakeCurrent() to set our current EGL
+      // context before we call eglSwapInterval, which is why we do it here
+      // rather than where the surface was created.
+      const auto& gle = gl::GLContextEGL::Cast(gl());
+      const auto& egl = gle->mEgl;
+      MakeCurrent();
+
+      const int interval = gfx::gfxVars::SwapIntervalEGL() ? 1 : 0;
+      egl->fSwapInterval(interval);
+    } else {
+      RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE);
+      return false;
+    }
+  }
+  return true;
+}
+
+bool RenderCompositorEGL::IsPaused() { return mEGLSurface == EGL_NO_SURFACE; }
+
+bool RenderCompositorEGL::MakeCurrent() {
+  const auto& gle = gl::GLContextEGL::Cast(gl());
+
+  gle->SetEGLSurfaceOverride(mEGLSurface);
+  bool ok = gl()->MakeCurrent();
+  if (!gl()->IsGLES() && ok && mEGLSurface != EGL_NO_SURFACE) {
+    // If we successfully made a surface current, set the draw buffer
+    // appropriately. It's not well-defined by the EGL spec whether
+    // eglMakeCurrent should do this automatically. See bug 1646135.
+    gl()->fDrawBuffer(gl()->IsDoubleBuffered() ? LOCAL_GL_BACK
+                                               : LOCAL_GL_FRONT);
+  }
+  return ok;
+}
+
+void RenderCompositorEGL::DestroyEGLSurface() {
+  const auto& gle = gl::GLContextEGL::Cast(gl());
+  const auto& egl = gle->mEgl;
+
+  // Release EGLSurface of back buffer before calling ResizeBuffers().
+  if (mEGLSurface) {
+    gle->SetEGLSurfaceOverride(EGL_NO_SURFACE);
+    gl::GLContextEGL::DestroySurface(*egl, mEGLSurface);
+    mEGLSurface = nullptr;
+  }
+}
+
+ipc::FileDescriptor RenderCompositorEGL::GetAndResetReleaseFence() {
+#ifdef MOZ_WIDGET_ANDROID
+  MOZ_ASSERT(!layers::AndroidHardwareBufferApi::Get() ||
+             mReleaseFenceFd.IsValid());
+  return std::move(mReleaseFenceFd);
+#else
+  return ipc::FileDescriptor();
+#endif
+}
+
+LayoutDeviceIntSize RenderCompositorEGL::GetBufferSize() {
+  return mWidget->GetClientSize();
+}
+
+bool RenderCompositorEGL::UsePartialPresent() {
+  return gfx::gfxVars::WebRenderMaxPartialPresentRects() > 0;
+}
+
+bool RenderCompositorEGL::RequestFullRender() { return false; }
+
+uint32_t RenderCompositorEGL::GetMaxPartialPresentRects() {
+  return gfx::gfxVars::WebRenderMaxPartialPresentRects();
+}
+
+bool RenderCompositorEGL::ShouldDrawPreviousPartialPresentRegions() {
+  return true;
+}
+
+size_t RenderCompositorEGL::GetBufferAge() const {
+  if (!StaticPrefs::
+          gfx_webrender_allow_partial_present_buffer_age_AtStartup()) {
+    return 0;
+  }
+  return gl()->GetBufferAge();
+}
+
+void RenderCompositorEGL::SetBufferDamageRegion(const wr::DeviceIntRect* aRects,
+                                                size_t aNumRects) {
+  const auto& gle = gl::GLContextEGL::Cast(gl());
+  const auto& egl = gle->mEgl;
+  if (gle->HasKhrPartialUpdate() &&
+      StaticPrefs::gfx_webrender_allow_partial_present_buffer_age_AtStartup()) {
+    std::vector<EGLint> rects;
+    rects.reserve(4 * aNumRects);
+    const auto bufferSize = GetBufferSize();
+    for (size_t i = 0; i < aNumRects; i++) {
+      const auto left =
+          std::max(0, std::min(bufferSize.width, aRects[i].min.x));
+      const auto top =
+          std::max(0, std::min(bufferSize.height, aRects[i].min.y));
+
+      const auto right =
+          std::min(bufferSize.width, std::max(0, aRects[i].max.x));
+      const auto bottom =
+          std::min(bufferSize.height, std::max(0, aRects[i].max.y));
+
+      const auto width = right - left;
+      const auto height = bottom - top;
+
+      rects.push_back(left);
+      rects.push_back(bufferSize.height - bottom);
+      rects.push_back(width);
+      rects.push_back(height);
+    }
+    const auto ret =
+        egl->fSetDamageRegion(mEGLSurface, rects.data(), rects.size() / 4);
+    if (ret == LOCAL_EGL_FALSE) {
+      const auto err = egl->mLib->fGetError();
+      gfxCriticalError() << "Error in eglSetDamageRegion: " << gfx::hexa(err);
+    }
+  }
+}
+
+}  // namespace mozilla::wr
diff --git a/gfx/webrender_bindings/RenderCompositorEGL.h b/gfx/webrender_bindings/RenderCompositorEGL.h
new file mode 100644
index 0000000000..8e851b2fc0
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorEGL.h
@@ -0,0 +1,75 @@
+/* -*- 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_RENDERCOMPOSITOR_EGL_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_EGL_H
+
+#include "GLTypes.h"
+#include "mozilla/webrender/RenderCompositor.h"
+
+namespace mozilla {
+
+namespace wr {
+
+class RenderCompositorEGL : public RenderCompositor {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  explicit RenderCompositorEGL(const RefPtr<widget::CompositorWidget>& aWidget,
+                               RefPtr<gl::GLContext>&& aGL);
+  virtual ~RenderCompositorEGL();
+
+  bool BeginFrame() override;
+  RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) final;
+  void Pause() override;
+  bool Resume() override;
+  bool IsPaused() override;
+
+  gl::GLContext* gl() const override { return mGL; }
+
+  bool MakeCurrent() override;
+
+  bool UseANGLE() const override { return false; }
+
+  LayoutDeviceIntSize GetBufferSize() override;
+
+  // Interface for partial present
+  bool UsePartialPresent() override;
+  bool RequestFullRender() override;
+  uint32_t GetMaxPartialPresentRects() override;
+  bool ShouldDrawPreviousPartialPresentRegions() override;
+  size_t GetBufferAge() const override;
+  void SetBufferDamageRegion(const wr::DeviceIntRect* aRects,
+                             size_t aNumRects) override;
+
+  ipc::FileDescriptor GetAndResetReleaseFence() override;
+
+ protected:
+  EGLSurface CreateEGLSurface();
+
+  void DestroyEGLSurface();
+
+  RefPtr<gl::GLContext> mGL;
+
+  EGLSurface mEGLSurface;
+
+  // Whether we are in the process of handling a NEW_SURFACE error. On Android
+  // this is used to allow the widget an opportunity to recover from the first
+  // instance, before raising a WebRenderError on subsequent occurences.
+  bool mHandlingNewSurfaceError = false;
+
+  // FileDescriptor of release fence.
+  // Release fence is a fence that is used for waiting until usage/composite of
+  // AHardwareBuffer is ended. The fence is delivered to client side via
+  // ImageBridge. It is used only on android.
+  ipc::FileDescriptor mReleaseFenceFd;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERCOMPOSITOR_EGL_H
diff --git a/gfx/webrender_bindings/RenderCompositorLayersSWGL.cpp b/gfx/webrender_bindings/RenderCompositorLayersSWGL.cpp
new file mode 100644
index 0000000000..cdda1b0d0d
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorLayersSWGL.cpp
@@ -0,0 +1,481 @@
+/* -*- 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 "RenderCompositorLayersSWGL.h"
+
+#include "GLContext.h"
+#include "GLContextEGL.h"
+#include "mozilla/layers/BuildConstants.h"
+#include "mozilla/layers/Effects.h"
+#include "mozilla/layers/TextureHostOGL.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "RenderCompositorRecordedFrame.h"
+
+#if defined(XP_WIN)
+#  include "mozilla/webrender/RenderCompositorD3D11SWGL.h"
+#else
+#  include "mozilla/webrender/RenderCompositorOGLSWGL.h"
+#endif
+
+namespace mozilla {
+using namespace layers;
+using namespace gfx;
+
+namespace wr {
+
+UniquePtr<RenderCompositor> RenderCompositorLayersSWGL::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+#ifdef XP_WIN
+  return RenderCompositorD3D11SWGL::Create(aWidget, aError);
+#else
+  return RenderCompositorOGLSWGL::Create(aWidget, aError);
+#endif
+}
+
+RenderCompositorLayersSWGL::RenderCompositorLayersSWGL(
+    Compositor* aCompositor, const RefPtr<widget::CompositorWidget>& aWidget,
+    void* aContext)
+    : RenderCompositor(aWidget),
+      mCompositor(aCompositor),
+      mContext(aContext),
+      mCurrentTileId(wr::NativeTileId()) {
+  MOZ_ASSERT(mCompositor);
+  MOZ_ASSERT(mContext);
+}
+
+RenderCompositorLayersSWGL::~RenderCompositorLayersSWGL() {
+  wr_swgl_destroy_context(mContext);
+}
+
+bool RenderCompositorLayersSWGL::MakeCurrent() {
+  wr_swgl_make_current(mContext);
+  return true;
+}
+
+bool RenderCompositorLayersSWGL::BeginFrame() {
+  MOZ_ASSERT(!mInFrame);
+  MakeCurrent();
+  mInFrame = true;
+  return true;
+}
+
+void RenderCompositorLayersSWGL::CancelFrame() {
+  MOZ_ASSERT(mInFrame);
+  mInFrame = false;
+  if (mCompositingStarted) {
+    mCompositor->CancelFrame();
+    mCompositingStarted = false;
+  }
+}
+
+void RenderCompositorLayersSWGL::StartCompositing(
+    wr::ColorF aClearColor, const wr::DeviceIntRect* aDirtyRects,
+    size_t aNumDirtyRects, const wr::DeviceIntRect* aOpaqueRects,
+    size_t aNumOpaqueRects) {
+  MOZ_RELEASE_ASSERT(!mCompositingStarted);
+
+  if (!mInFrame || aNumDirtyRects == 0) {
+    return;
+  }
+
+  gfx::IntRect bounds(gfx::IntPoint(0, 0), GetBufferSize().ToUnknownSize());
+  nsIntRegion dirty;
+
+  MOZ_RELEASE_ASSERT(aNumDirtyRects > 0);
+  for (size_t i = 0; i < aNumDirtyRects; i++) {
+    const auto& rect = aDirtyRects[i];
+    dirty.OrWith(
+        gfx::IntRect(rect.min.x, rect.min.y, rect.width(), rect.height()));
+  }
+  dirty.AndWith(bounds);
+
+  nsIntRegion opaque(bounds);
+  opaque.SubOut(mWidget->GetTransparentRegion().ToUnknownRegion());
+  for (size_t i = 0; i < aNumOpaqueRects; i++) {
+    const auto& rect = aOpaqueRects[i];
+    opaque.OrWith(
+        gfx::IntRect(rect.min.x, rect.min.y, rect.width(), rect.height()));
+  }
+
+  mCompositor->SetClearColor(gfx::DeviceColor(aClearColor.r, aClearColor.g,
+                                              aClearColor.b, aClearColor.a));
+
+  if (!mCompositor->BeginFrameForWindow(dirty, Nothing(), bounds, opaque)) {
+    return;
+  }
+  mCompositingStarted = true;
+}
+
+void RenderCompositorLayersSWGL::CompositorEndFrame() {
+  nsTArray<FrameSurface> frameSurfaces = std::move(mFrameSurfaces);
+
+  if (!mCompositingStarted) {
+    return;
+  }
+
+  for (auto& frameSurface : frameSurfaces) {
+    auto surfaceCursor = mSurfaces.find(frameSurface.mId);
+    MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+    Surface* surface = surfaceCursor->second.get();
+
+    for (auto it = surface->mTiles.begin(); it != surface->mTiles.end(); ++it) {
+      if (!it->second->IsValid()) {
+        continue;
+      }
+
+      gfx::Point tileOffset(it->first.mX * surface->mTileSize.width,
+                            it->first.mY * surface->mTileSize.height);
+      gfx::Rect drawRect = it->second->mValidRect + tileOffset;
+
+      RefPtr<TexturedEffect> texturedEffect =
+          new EffectRGB(it->second->GetTextureSource(),
+                        /* aPremultiplied */ true, frameSurface.mFilter);
+      if (surface->mIsOpaque) {
+        texturedEffect->mPremultipliedCopy = true;
+      }
+
+      texturedEffect->mTextureCoords =
+          gfx::Rect(it->second->mValidRect.x / surface->mTileSize.width,
+                    it->second->mValidRect.y / surface->mTileSize.height,
+                    it->second->mValidRect.width / surface->mTileSize.width,
+                    it->second->mValidRect.height / surface->mTileSize.height);
+
+      EffectChain effect;
+      effect.mPrimaryEffect = texturedEffect;
+      mCompositor->DrawQuad(drawRect, frameSurface.mClipRect, effect, 1.0,
+                            frameSurface.mTransform, drawRect);
+    }
+
+    if (surface->mExternalImage) {
+      HandleExternalImage(surface->mExternalImage, frameSurface);
+    }
+  }
+}
+
+RenderedFrameId RenderCompositorLayersSWGL::EndFrame(
+    const nsTArray<DeviceIntRect>& aDirtyRects) {
+  MOZ_ASSERT(mInFrame);
+  mInFrame = false;
+  if (mCompositingStarted) {
+    mCompositor->EndFrame();
+    mCompositingStarted = false;
+  }
+  return GetNextRenderFrameId();
+}
+
+LayoutDeviceIntSize RenderCompositorLayersSWGL::GetBufferSize() {
+  return mWidget->GetClientSize();
+}
+
+void RenderCompositorLayersSWGL::Bind(wr::NativeTileId aId,
+                                      wr::DeviceIntPoint* aOffset,
+                                      uint32_t* aFboId,
+                                      wr::DeviceIntRect aDirtyRect,
+                                      wr::DeviceIntRect aValidRect) {
+  MOZ_RELEASE_ASSERT(false);
+}
+
+void RenderCompositorLayersSWGL::Unbind() { MOZ_RELEASE_ASSERT(false); }
+
+bool RenderCompositorLayersSWGL::MapTile(wr::NativeTileId aId,
+                                         wr::DeviceIntRect aDirtyRect,
+                                         wr::DeviceIntRect aValidRect,
+                                         void** aData, int32_t* aStride) {
+  auto surfaceCursor = mSurfaces.find(aId.surface_id);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+  Surface* surface = surfaceCursor->second.get();
+
+  auto layerCursor = surface->mTiles.find(TileKey(aId.x, aId.y));
+  MOZ_RELEASE_ASSERT(layerCursor != surface->mTiles.end());
+
+  mCurrentTile = layerCursor->second.get();
+  mCurrentTileId = aId;
+  mCurrentTileDirty = gfx::IntRect(aDirtyRect.min.x, aDirtyRect.min.y,
+                                   aDirtyRect.width(), aDirtyRect.height());
+
+  if (!mCurrentTile->Map(aDirtyRect, aValidRect, aData, aStride)) {
+    gfxCriticalNote << "MapTile failed aValidRect: "
+                    << gfx::Rect(aValidRect.min.x, aValidRect.min.y,
+                                 aValidRect.width(), aValidRect.height());
+    return false;
+  }
+
+  // Store the new valid rect, so that we can composite only those pixels
+  mCurrentTile->mValidRect = gfx::Rect(aValidRect.min.x, aValidRect.min.y,
+                                       aValidRect.width(), aValidRect.height());
+  return true;
+}
+
+void RenderCompositorLayersSWGL::UnmapTile() {
+  mCurrentTile->Unmap(mCurrentTileDirty);
+  mCurrentTile = nullptr;
+}
+
+void RenderCompositorLayersSWGL::CreateSurface(
+    wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset,
+    wr::DeviceIntSize aTileSize, bool aIsOpaque) {
+  MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end());
+  auto surface = DoCreateSurface(aTileSize, aIsOpaque);
+  mSurfaces.insert({aId, std::move(surface)});
+}
+
+UniquePtr<RenderCompositorLayersSWGL::Surface>
+RenderCompositorLayersSWGL::DoCreateSurface(wr::DeviceIntSize aTileSize,
+                                            bool aIsOpaque) {
+  return MakeUnique<Surface>(aTileSize, aIsOpaque);
+}
+
+void RenderCompositorLayersSWGL::CreateExternalSurface(wr::NativeSurfaceId aId,
+                                                       bool aIsOpaque) {
+  MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end());
+  auto surface = MakeUnique<Surface>(wr::DeviceIntSize{}, aIsOpaque);
+  surface->mIsExternal = true;
+  mSurfaces.insert({aId, std::move(surface)});
+}
+
+void RenderCompositorLayersSWGL::DestroySurface(NativeSurfaceId aId) {
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+  mSurfaces.erase(surfaceCursor);
+}
+
+void RenderCompositorLayersSWGL::CreateTile(wr::NativeSurfaceId aId, int32_t aX,
+                                            int32_t aY) {
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+  Surface* surface = surfaceCursor->second.get();
+  MOZ_RELEASE_ASSERT(!surface->mIsExternal);
+
+  auto tile = DoCreateTile(surface);
+  surface->mTiles.insert({TileKey(aX, aY), std::move(tile)});
+}
+
+void RenderCompositorLayersSWGL::DestroyTile(wr::NativeSurfaceId aId,
+                                             int32_t aX, int32_t aY) {
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+  Surface* surface = surfaceCursor->second.get();
+  MOZ_RELEASE_ASSERT(!surface->mIsExternal);
+
+  auto layerCursor = surface->mTiles.find(TileKey(aX, aY));
+  MOZ_RELEASE_ASSERT(layerCursor != surface->mTiles.end());
+  surface->mTiles.erase(layerCursor);
+}
+
+void RenderCompositorLayersSWGL::AttachExternalImage(
+    wr::NativeSurfaceId aId, wr::ExternalImageId aExternalImage) {
+  RenderTextureHost* image =
+      RenderThread::Get()->GetRenderTexture(aExternalImage);
+  MOZ_ASSERT(image);
+  if (!image) {
+    gfxCriticalNoteOnce
+        << "Failed to get RenderTextureHost for D3D11SWGL extId:"
+        << AsUint64(aExternalImage);
+    return;
+  }
+#if defined(XP_WIN)
+  MOZ_RELEASE_ASSERT(image->AsRenderDXGITextureHost() ||
+                     image->AsRenderDXGIYCbCrTextureHost());
+#elif defined(ANDROID)
+  MOZ_RELEASE_ASSERT(image->AsRenderAndroidHardwareBufferTextureHost() ||
+                     image->AsRenderAndroidSurfaceTextureHost());
+#endif
+
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+
+  Surface* surface = surfaceCursor->second.get();
+  surface->mExternalImage = image;
+  MOZ_RELEASE_ASSERT(surface->mTiles.empty());
+  MOZ_RELEASE_ASSERT(surface->mIsExternal);
+}
+
+// static
+gfx::SamplingFilter RenderCompositorLayersSWGL::ToSamplingFilter(
+    wr::ImageRendering aImageRendering) {
+  if (aImageRendering == wr::ImageRendering::Auto) {
+    return gfx::SamplingFilter::LINEAR;
+  }
+  return gfx::SamplingFilter::POINT;
+}
+
+void RenderCompositorLayersSWGL::AddSurface(
+    wr::NativeSurfaceId aId, const wr::CompositorSurfaceTransform& aTransform,
+    wr::DeviceIntRect aClipRect, wr::ImageRendering aImageRendering) {
+  float sx = aTransform.scale.x;
+  float sy = aTransform.scale.y;
+  float tx = aTransform.offset.x;
+  float ty = aTransform.offset.y;
+  gfx::Matrix4x4 transform(sx, 0.0, 0.0, 0.0, 0.0, sy, 0.0, 0.0, 0.0, 0.0, 1.0,
+                           0.0, tx, ty, 0.0, 1.0);
+  gfx::IntRect clipRect(aClipRect.min.x, aClipRect.min.y, aClipRect.width(),
+                        aClipRect.height());
+
+  mFrameSurfaces.AppendElement(FrameSurface{aId, transform, clipRect,
+                                            ToSamplingFilter(aImageRendering)});
+}
+
+void RenderCompositorLayersSWGL::MaybeRequestAllowFrameRecording(
+    bool aWillRecord) {
+  mCompositor->RequestAllowFrameRecording(aWillRecord);
+}
+
+class WindowLMC : public profiler_screenshots::Window {
+ public:
+  explicit WindowLMC(Compositor* aCompositor) : mCompositor(aCompositor) {}
+
+  already_AddRefed<profiler_screenshots::RenderSource> GetWindowContents(
+      const gfx::IntSize& aWindowSize) override;
+  already_AddRefed<profiler_screenshots::DownscaleTarget> CreateDownscaleTarget(
+      const gfx::IntSize& aSize) override;
+  already_AddRefed<profiler_screenshots::AsyncReadbackBuffer>
+  CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) override;
+
+ protected:
+  Compositor* mCompositor;
+};
+
+class RenderSourceLMC : public profiler_screenshots::RenderSource {
+ public:
+  explicit RenderSourceLMC(CompositingRenderTarget* aRT)
+      : RenderSource(aRT->GetSize()), mRT(aRT) {}
+
+  const auto& RenderTarget() { return mRT; }
+
+ protected:
+  virtual ~RenderSourceLMC() {}
+
+  RefPtr<CompositingRenderTarget> mRT;
+};
+
+class DownscaleTargetLMC : public profiler_screenshots::DownscaleTarget {
+ public:
+  explicit DownscaleTargetLMC(CompositingRenderTarget* aRT,
+                              Compositor* aCompositor)
+      : profiler_screenshots::DownscaleTarget(aRT->GetSize()),
+        mRenderSource(new RenderSourceLMC(aRT)),
+        mCompositor(aCompositor) {}
+
+  already_AddRefed<profiler_screenshots::RenderSource> AsRenderSource()
+      override {
+    return do_AddRef(mRenderSource);
+  }
+
+  bool DownscaleFrom(profiler_screenshots::RenderSource* aSource,
+                     const IntRect& aSourceRect,
+                     const IntRect& aDestRect) override {
+    MOZ_RELEASE_ASSERT(aSourceRect.TopLeft() == IntPoint());
+    MOZ_RELEASE_ASSERT(aDestRect.TopLeft() == IntPoint());
+    RefPtr<CompositingRenderTarget> previousTarget =
+        mCompositor->GetCurrentRenderTarget();
+
+    mCompositor->SetRenderTarget(mRenderSource->RenderTarget());
+    bool result = mCompositor->BlitRenderTarget(
+        static_cast<RenderSourceLMC*>(aSource)->RenderTarget(),
+        aSourceRect.Size(), aDestRect.Size());
+
+    // Restore the old render target.
+    mCompositor->SetRenderTarget(previousTarget);
+
+    return result;
+  }
+
+ protected:
+  virtual ~DownscaleTargetLMC() {}
+
+  RefPtr<RenderSourceLMC> mRenderSource;
+  Compositor* mCompositor;
+};
+
+class AsyncReadbackBufferLMC
+    : public profiler_screenshots::AsyncReadbackBuffer {
+ public:
+  AsyncReadbackBufferLMC(mozilla::layers::AsyncReadbackBuffer* aARB,
+                         Compositor* aCompositor)
+      : profiler_screenshots::AsyncReadbackBuffer(aARB->GetSize()),
+        mARB(aARB),
+        mCompositor(aCompositor) {}
+  void CopyFrom(profiler_screenshots::RenderSource* aSource) override {
+    mCompositor->ReadbackRenderTarget(
+        static_cast<RenderSourceLMC*>(aSource)->RenderTarget(), mARB);
+  }
+  bool MapAndCopyInto(DataSourceSurface* aSurface,
+                      const IntSize& aReadSize) override {
+    return mARB->MapAndCopyInto(aSurface, aReadSize);
+  }
+
+ protected:
+  virtual ~AsyncReadbackBufferLMC() {}
+
+  RefPtr<mozilla::layers::AsyncReadbackBuffer> mARB;
+  Compositor* mCompositor;
+};
+
+already_AddRefed<profiler_screenshots::RenderSource>
+WindowLMC::GetWindowContents(const gfx::IntSize& aWindowSize) {
+  RefPtr<CompositingRenderTarget> rt = mCompositor->GetWindowRenderTarget();
+  if (!rt) {
+    return nullptr;
+  }
+  return MakeAndAddRef<RenderSourceLMC>(rt);
+}
+
+already_AddRefed<profiler_screenshots::DownscaleTarget>
+WindowLMC::CreateDownscaleTarget(const gfx::IntSize& aSize) {
+  RefPtr<CompositingRenderTarget> rt =
+      mCompositor->CreateRenderTarget(IntRect({}, aSize), INIT_MODE_NONE);
+  return MakeAndAddRef<DownscaleTargetLMC>(rt, mCompositor);
+}
+
+already_AddRefed<profiler_screenshots::AsyncReadbackBuffer>
+WindowLMC::CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) {
+  RefPtr<AsyncReadbackBuffer> carb =
+      mCompositor->CreateAsyncReadbackBuffer(aSize);
+  if (!carb) {
+    return nullptr;
+  }
+  return MakeAndAddRef<AsyncReadbackBufferLMC>(carb, mCompositor);
+}
+
+bool RenderCompositorLayersSWGL::MaybeRecordFrame(
+    layers::CompositionRecorder& aRecorder) {
+  WindowLMC window(mCompositor);
+  gfx::IntSize size = GetBufferSize().ToUnknownSize();
+  RefPtr<layers::profiler_screenshots::RenderSource> snapshot =
+      window.GetWindowContents(size);
+  if (!snapshot) {
+    return true;
+  }
+
+  RefPtr<layers::profiler_screenshots::AsyncReadbackBuffer> buffer =
+      window.CreateAsyncReadbackBuffer(size);
+  buffer->CopyFrom(snapshot);
+
+  RefPtr<layers::RecordedFrame> frame =
+      new RenderCompositorRecordedFrame(TimeStamp::Now(), std::move(buffer));
+  aRecorder.RecordFrame(frame);
+  return false;
+}
+
+bool RenderCompositorLayersSWGL::MaybeGrabScreenshot(
+    const gfx::IntSize& aWindowSize) {
+  if (!mCompositingStarted) {
+    return true;
+  }
+  WindowLMC window(mCompositor);
+  mProfilerScreenshotGrabber.MaybeGrabScreenshot(window, aWindowSize);
+  return true;
+}
+
+bool RenderCompositorLayersSWGL::MaybeProcessScreenshotQueue() {
+  mProfilerScreenshotGrabber.MaybeProcessQueue();
+  return true;
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderCompositorLayersSWGL.h b/gfx/webrender_bindings/RenderCompositorLayersSWGL.h
new file mode 100644
index 0000000000..3cf6bb44f5
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorLayersSWGL.h
@@ -0,0 +1,195 @@
+/* -*- 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_RENDERCOMPOSITOR_Layers_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_Layers_H
+
+#include <unordered_map>
+
+#include "mozilla/HashFunctions.h"
+#include "mozilla/layers/Compositor.h"
+#include "mozilla/layers/ScreenshotGrabber.h"
+#include "mozilla/webrender/RenderCompositor.h"
+#include "mozilla/webrender/RenderTextureHost.h"
+
+namespace mozilla {
+
+namespace wr {
+
+class SurfaceD3D11SWGL;
+
+class RenderCompositorLayersSWGL : public RenderCompositor {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositorLayersSWGL(layers::Compositor* aCompositor,
+                             const RefPtr<widget::CompositorWidget>& aWidget,
+                             void* aContext);
+  virtual ~RenderCompositorLayersSWGL();
+
+  void* swgl() const override { return mContext; }
+
+  bool MakeCurrent() override;
+
+  bool BeginFrame() override;
+  void CancelFrame() override;
+  RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) override;
+
+  bool SurfaceOriginIsTopLeft() override { return true; }
+
+  LayoutDeviceIntSize GetBufferSize() override;
+
+  // Should we support this?
+  bool SupportsExternalBufferTextures() const override { return false; }
+
+  layers::WebRenderBackend BackendType() const override {
+    return layers::WebRenderBackend::SOFTWARE;
+  }
+
+  bool ShouldUseNativeCompositor() override { return true; }
+
+  void StartCompositing(wr::ColorF aClearColor,
+                        const wr::DeviceIntRect* aDirtyRects,
+                        size_t aNumDirtyRects,
+                        const wr::DeviceIntRect* aOpaqueRects,
+                        size_t aNumOpaqueRects) override;
+
+  void CompositorBeginFrame() override {}
+  void CompositorEndFrame() override;
+  void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId,
+            wr::DeviceIntRect aDirtyRect,
+            wr::DeviceIntRect aValidRect) override;
+  void Unbind() override;
+  bool MapTile(wr::NativeTileId aId, wr::DeviceIntRect aDirtyRect,
+               wr::DeviceIntRect aValidRect, void** aData,
+               int32_t* aStride) override;
+  void UnmapTile() override;
+  void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset,
+                     wr::DeviceIntSize aTileSize, bool aIsOpaque) override;
+  void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) override;
+  void DestroySurface(NativeSurfaceId aId) override;
+  void CreateTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) override;
+  void DestroyTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) override;
+  void AttachExternalImage(wr::NativeSurfaceId aId,
+                           wr::ExternalImageId aExternalImage) override;
+  void AddSurface(wr::NativeSurfaceId aId,
+                  const wr::CompositorSurfaceTransform& aTransform,
+                  wr::DeviceIntRect aClipRect,
+                  wr::ImageRendering aImageRendering) override;
+  void EnableNativeCompositor(bool aEnable) override {}
+  void DeInit() override {}
+
+  void MaybeRequestAllowFrameRecording(bool aWillRecord) override;
+  bool MaybeRecordFrame(layers::CompositionRecorder& aRecorder) override;
+  bool MaybeGrabScreenshot(const gfx::IntSize& aWindowSize) override;
+  bool MaybeProcessScreenshotQueue() override;
+
+  // TODO: Screenshots etc
+
+  struct TileKey {
+    TileKey(int32_t aX, int32_t aY) : mX(aX), mY(aY) {}
+
+    int32_t mX;
+    int32_t mY;
+  };
+
+  // Each tile retains a texture, and a DataSourceSurface of the
+  // same size. We draw into the source surface, and then copy the
+  // changed area into the texture.
+  class Tile {
+   public:
+    Tile() = default;
+    virtual ~Tile() = default;
+
+    virtual bool Map(wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect,
+                     void** aData, int32_t* aStride) = 0;
+    virtual void Unmap(const gfx::IntRect& aDirtyRect) = 0;
+    virtual layers::DataTextureSource* GetTextureSource() = 0;
+    virtual bool IsValid() = 0;
+
+    gfx::Rect mValidRect;
+
+    struct KeyHashFn {
+      std::size_t operator()(const TileKey& aId) const {
+        return HashGeneric(aId.mX, aId.mY);
+      }
+    };
+  };
+
+  class Surface {
+   public:
+    explicit Surface(wr::DeviceIntSize aTileSize, bool aIsOpaque)
+        : mTileSize(aTileSize), mIsOpaque(aIsOpaque) {}
+    virtual ~Surface() {}
+
+    gfx::IntSize TileSize() {
+      return gfx::IntSize(mTileSize.width, mTileSize.height);
+    }
+    virtual SurfaceD3D11SWGL* AsSurfaceD3D11SWGL() { return nullptr; }
+
+    // External images can change size depending on which image
+    // is attached, so mTileSize will be 0,0 when mIsExternal
+    // is true.
+    wr::DeviceIntSize mTileSize;
+    bool mIsOpaque;
+    bool mIsExternal = false;
+    std::unordered_map<TileKey, UniquePtr<Tile>, Tile::KeyHashFn> mTiles;
+    RefPtr<RenderTextureHost> mExternalImage;
+
+    struct IdHashFn {
+      std::size_t operator()(const wr::NativeSurfaceId& aId) const {
+        return HashGeneric(wr::AsUint64(aId));
+      }
+    };
+  };
+
+  static gfx::SamplingFilter ToSamplingFilter(
+      wr::ImageRendering aImageRendering);
+
+ protected:
+  // The set of surfaces added to be composited for the current frame
+  struct FrameSurface {
+    wr::NativeSurfaceId mId;
+    gfx::Matrix4x4 mTransform;
+    gfx::IntRect mClipRect;
+    gfx::SamplingFilter mFilter;
+  };
+
+  virtual void HandleExternalImage(RenderTextureHost* aExternalImage,
+                                   FrameSurface& aFrameSurface) = 0;
+  virtual UniquePtr<RenderCompositorLayersSWGL::Surface> DoCreateSurface(
+      wr::DeviceIntSize aTileSize, bool aIsOpaque);
+  virtual UniquePtr<RenderCompositorLayersSWGL::Tile> DoCreateTile(
+      Surface* aSurface) = 0;
+
+  RefPtr<layers::Compositor> mCompositor;
+  void* mContext = nullptr;
+
+  std::unordered_map<wr::NativeSurfaceId, UniquePtr<Surface>, Surface::IdHashFn>
+      mSurfaces;
+
+  // Temporary state held between MapTile and UnmapTile
+  Tile* mCurrentTile = nullptr;
+  gfx::IntRect mCurrentTileDirty;
+  wr::NativeTileId mCurrentTileId;
+
+  nsTArray<FrameSurface> mFrameSurfaces;
+  bool mInFrame = false;
+  bool mCompositingStarted = false;
+
+  layers::ScreenshotGrabber mProfilerScreenshotGrabber;
+};
+
+static inline bool operator==(const RenderCompositorLayersSWGL::TileKey& a0,
+                              const RenderCompositorLayersSWGL::TileKey& a1) {
+  return a0.mX == a1.mX && a0.mY == a1.mY;
+}
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderCompositorNative.cpp b/gfx/webrender_bindings/RenderCompositorNative.cpp
new file mode 100644
index 0000000000..81cafd1fd6
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorNative.cpp
@@ -0,0 +1,672 @@
+/* -*- 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 "RenderCompositorNative.h"
+
+#include "GLContext.h"
+#include "GLContextProvider.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/CompositionRecorder.h"
+#include "mozilla/layers/NativeLayer.h"
+#include "mozilla/layers/SurfacePool.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "RenderCompositorRecordedFrame.h"
+
+namespace mozilla::wr {
+
+extern LazyLogModule gRenderThreadLog;
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+RenderCompositorNative::RenderCompositorNative(
+    const RefPtr<widget::CompositorWidget>& aWidget, gl::GLContext* aGL)
+    : RenderCompositor(aWidget),
+      mNativeLayerRoot(GetWidget()->GetNativeLayerRoot()) {
+  LOG("RenderCompositorNative::RenderCompositorNative()");
+
+#if defined(XP_MACOSX) || defined(MOZ_WAYLAND)
+  auto pool = RenderThread::Get()->SharedSurfacePool();
+  if (pool) {
+    mSurfacePoolHandle = pool->GetHandleForGL(aGL);
+  }
+#endif
+  MOZ_RELEASE_ASSERT(mSurfacePoolHandle);
+}
+
+RenderCompositorNative::~RenderCompositorNative() {
+  LOG("RRenderCompositorNative::~RenderCompositorNative()");
+
+  Pause();
+  mProfilerScreenshotGrabber.Destroy();
+  mNativeLayerRoot->SetLayers({});
+  mNativeLayerForEntireWindow = nullptr;
+  mNativeLayerRootSnapshotter = nullptr;
+  mNativeLayerRoot = nullptr;
+}
+
+bool RenderCompositorNative::BeginFrame() {
+  if (!MakeCurrent()) {
+    gfxCriticalNote << "Failed to make render context current, can't draw.";
+    return false;
+  }
+
+  gfx::IntSize bufferSize = GetBufferSize().ToUnknownSize();
+  if (!ShouldUseNativeCompositor()) {
+    if (bufferSize.IsEmpty()) {
+      return false;
+    }
+    if (mNativeLayerForEntireWindow &&
+        mNativeLayerForEntireWindow->GetSize() != bufferSize) {
+      mNativeLayerRoot->RemoveLayer(mNativeLayerForEntireWindow);
+      mNativeLayerForEntireWindow = nullptr;
+    }
+    if (!mNativeLayerForEntireWindow) {
+      mNativeLayerForEntireWindow =
+          mNativeLayerRoot->CreateLayer(bufferSize, false, mSurfacePoolHandle);
+      mNativeLayerRoot->AppendLayer(mNativeLayerForEntireWindow);
+    }
+  }
+
+  gfx::IntRect bounds({}, bufferSize);
+  if (!InitDefaultFramebuffer(bounds)) {
+    return false;
+  }
+
+  return true;
+}
+
+RenderedFrameId RenderCompositorNative::EndFrame(
+    const nsTArray<DeviceIntRect>& aDirtyRects) {
+  RenderedFrameId frameId = GetNextRenderFrameId();
+
+  DoSwap();
+
+  if (mNativeLayerForEntireWindow) {
+    mNativeLayerForEntireWindow->NotifySurfaceReady();
+    mNativeLayerRoot->CommitToScreen();
+  }
+
+  return frameId;
+}
+
+void RenderCompositorNative::Pause() {}
+
+bool RenderCompositorNative::Resume() { return true; }
+
+inline layers::WebRenderCompositor RenderCompositorNative::CompositorType()
+    const {
+  if (gfx::gfxVars::UseWebRenderCompositor()) {
+#if defined(XP_MACOSX)
+    return layers::WebRenderCompositor::CORE_ANIMATION;
+#elif defined(MOZ_WAYLAND)
+    return layers::WebRenderCompositor::WAYLAND;
+#endif
+  }
+  return layers::WebRenderCompositor::DRAW;
+}
+
+LayoutDeviceIntSize RenderCompositorNative::GetBufferSize() {
+  return mWidget->GetClientSize();
+}
+
+bool RenderCompositorNative::ShouldUseNativeCompositor() {
+  return gfx::gfxVars::UseWebRenderCompositor();
+}
+
+void RenderCompositorNative::GetCompositorCapabilities(
+    CompositorCapabilities* aCaps) {
+  RenderCompositor::GetCompositorCapabilities(aCaps);
+#if defined(XP_MACOSX)
+  aCaps->supports_surface_for_backdrop = !gfx::gfxVars::UseSoftwareWebRender();
+#endif
+}
+
+bool RenderCompositorNative::MaybeReadback(
+    const gfx::IntSize& aReadbackSize, const wr::ImageFormat& aReadbackFormat,
+    const Range<uint8_t>& aReadbackBuffer, bool* aNeedsYFlip) {
+  if (!ShouldUseNativeCompositor()) {
+    return false;
+  }
+
+  MOZ_RELEASE_ASSERT(aReadbackFormat == wr::ImageFormat::BGRA8);
+  if (!mNativeLayerRootSnapshotter) {
+    mNativeLayerRootSnapshotter = mNativeLayerRoot->CreateSnapshotter();
+
+    if (!mNativeLayerRootSnapshotter) {
+      return false;
+    }
+  }
+  bool success = mNativeLayerRootSnapshotter->ReadbackPixels(
+      aReadbackSize, gfx::SurfaceFormat::B8G8R8A8, aReadbackBuffer);
+
+  // ReadbackPixels might have changed the current context. Make sure GL is
+  // current again.
+  MakeCurrent();
+
+  if (aNeedsYFlip) {
+    *aNeedsYFlip = true;
+  }
+
+  return success;
+}
+
+bool RenderCompositorNative::MaybeRecordFrame(
+    layers::CompositionRecorder& aRecorder) {
+  if (!ShouldUseNativeCompositor()) {
+    return false;
+  }
+
+  if (!mNativeLayerRootSnapshotter) {
+    mNativeLayerRootSnapshotter = mNativeLayerRoot->CreateSnapshotter();
+  }
+
+  if (!mNativeLayerRootSnapshotter) {
+    return true;
+  }
+
+  gfx::IntSize size = GetBufferSize().ToUnknownSize();
+  RefPtr<layers::profiler_screenshots::RenderSource> snapshot =
+      mNativeLayerRootSnapshotter->GetWindowContents(size);
+  if (!snapshot) {
+    return true;
+  }
+
+  RefPtr<layers::profiler_screenshots::AsyncReadbackBuffer> buffer =
+      mNativeLayerRootSnapshotter->CreateAsyncReadbackBuffer(size);
+  buffer->CopyFrom(snapshot);
+
+  RefPtr<layers::RecordedFrame> frame =
+      new RenderCompositorRecordedFrame(TimeStamp::Now(), std::move(buffer));
+  aRecorder.RecordFrame(frame);
+
+  // GetWindowContents might have changed the current context. Make sure our
+  // context is current again.
+  MakeCurrent();
+  return true;
+}
+
+bool RenderCompositorNative::MaybeGrabScreenshot(
+    const gfx::IntSize& aWindowSize) {
+  if (!ShouldUseNativeCompositor()) {
+    return false;
+  }
+
+  if (!mNativeLayerRootSnapshotter) {
+    mNativeLayerRootSnapshotter = mNativeLayerRoot->CreateSnapshotter();
+  }
+
+  if (mNativeLayerRootSnapshotter) {
+    mProfilerScreenshotGrabber.MaybeGrabScreenshot(*mNativeLayerRootSnapshotter,
+                                                   aWindowSize);
+
+    // MaybeGrabScreenshot might have changed the current context. Make sure our
+    // context is current again.
+    MakeCurrent();
+  }
+
+  return true;
+}
+
+bool RenderCompositorNative::MaybeProcessScreenshotQueue() {
+  if (!ShouldUseNativeCompositor()) {
+    return false;
+  }
+
+  mProfilerScreenshotGrabber.MaybeProcessQueue();
+
+  // MaybeProcessQueue might have changed the current context. Make sure our
+  // context is current again.
+  MakeCurrent();
+
+  return true;
+}
+
+void RenderCompositorNative::CompositorBeginFrame() {
+  mAddedLayers.Clear();
+  mAddedTilePixelCount = 0;
+  mAddedClippedPixelCount = 0;
+  mBeginFrameTimeStamp = TimeStamp::Now();
+  mSurfacePoolHandle->OnBeginFrame();
+  mNativeLayerRoot->PrepareForCommit();
+}
+
+void RenderCompositorNative::CompositorEndFrame() {
+  if (profiler_thread_is_being_profiled_for_markers()) {
+    auto bufferSize = GetBufferSize();
+    [[maybe_unused]] uint64_t windowPixelCount =
+        uint64_t(bufferSize.width) * bufferSize.height;
+    int nativeLayerCount = 0;
+    for (const auto& it : mSurfaces) {
+      nativeLayerCount += int(it.second.mNativeLayers.size());
+    }
+    PROFILER_MARKER_TEXT(
+        "WR OS Compositor frame", GRAPHICS,
+        MarkerTiming::IntervalUntilNowFrom(mBeginFrameTimeStamp),
+        nsPrintfCString("%d%% painting, %d%% overdraw, %d used "
+                        "layers (%d%% memory) + %d unused layers (%d%% memory)",
+                        int(mDrawnPixelCount * 100 / windowPixelCount),
+                        int(mAddedClippedPixelCount * 100 / windowPixelCount),
+                        int(mAddedLayers.Length()),
+                        int(mAddedTilePixelCount * 100 / windowPixelCount),
+                        int(nativeLayerCount - mAddedLayers.Length()),
+                        int((mTotalTilePixelCount - mAddedTilePixelCount) *
+                            100 / windowPixelCount)));
+  }
+  mDrawnPixelCount = 0;
+
+  DoFlush();
+
+  mNativeLayerRoot->SetLayers(mAddedLayers);
+  mNativeLayerRoot->CommitToScreen();
+  mSurfacePoolHandle->OnEndFrame();
+}
+
+void RenderCompositorNative::BindNativeLayer(wr::NativeTileId aId,
+                                             const gfx::IntRect& aDirtyRect) {
+  MOZ_RELEASE_ASSERT(!mCurrentlyBoundNativeLayer);
+
+  auto surfaceCursor = mSurfaces.find(aId.surface_id);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+  Surface& surface = surfaceCursor->second;
+
+  auto layerCursor = surface.mNativeLayers.find(TileKey(aId.x, aId.y));
+  MOZ_RELEASE_ASSERT(layerCursor != surface.mNativeLayers.end());
+  RefPtr<layers::NativeLayer> layer = layerCursor->second;
+
+  mCurrentlyBoundNativeLayer = layer;
+
+  mDrawnPixelCount += aDirtyRect.Area();
+}
+
+void RenderCompositorNative::UnbindNativeLayer() {
+  MOZ_RELEASE_ASSERT(mCurrentlyBoundNativeLayer);
+
+  mCurrentlyBoundNativeLayer->NotifySurfaceReady();
+  mCurrentlyBoundNativeLayer = nullptr;
+}
+
+void RenderCompositorNative::CreateSurface(wr::NativeSurfaceId aId,
+                                           wr::DeviceIntPoint aVirtualOffset,
+                                           wr::DeviceIntSize aTileSize,
+                                           bool aIsOpaque) {
+  MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end());
+  mSurfaces.insert({aId, Surface{aTileSize, aIsOpaque}});
+}
+
+void RenderCompositorNative::CreateExternalSurface(wr::NativeSurfaceId aId,
+                                                   bool aIsOpaque) {
+  MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end());
+
+  RefPtr<layers::NativeLayer> layer =
+      mNativeLayerRoot->CreateLayerForExternalTexture(aIsOpaque);
+
+  Surface surface{DeviceIntSize{}, aIsOpaque};
+  surface.mIsExternal = true;
+  surface.mNativeLayers.insert({TileKey(0, 0), layer});
+
+  mSurfaces.insert({aId, std::move(surface)});
+}
+
+void RenderCompositorNative::CreateBackdropSurface(wr::NativeSurfaceId aId,
+                                                   wr::ColorF aColor) {
+  MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end());
+
+  gfx::DeviceColor color(aColor.r, aColor.g, aColor.b, aColor.a);
+  RefPtr<layers::NativeLayer> layer =
+      mNativeLayerRoot->CreateLayerForColor(color);
+
+  Surface surface{DeviceIntSize{}, (aColor.a >= 1.0f)};
+  surface.mNativeLayers.insert({TileKey(0, 0), layer});
+
+  mSurfaces.insert({aId, std::move(surface)});
+}
+
+void RenderCompositorNative::AttachExternalImage(
+    wr::NativeSurfaceId aId, wr::ExternalImageId aExternalImage) {
+  RenderTextureHost* image =
+      RenderThread::Get()->GetRenderTexture(aExternalImage);
+  MOZ_RELEASE_ASSERT(image);
+
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+
+  Surface& surface = surfaceCursor->second;
+  MOZ_RELEASE_ASSERT(surface.mNativeLayers.size() == 1);
+  MOZ_RELEASE_ASSERT(surface.mIsExternal);
+  surface.mNativeLayers.begin()->second->AttachExternalImage(image);
+}
+
+void RenderCompositorNative::DestroySurface(NativeSurfaceId aId) {
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+
+  Surface& surface = surfaceCursor->second;
+  if (!surface.mIsExternal) {
+    for (const auto& iter : surface.mNativeLayers) {
+      mTotalTilePixelCount -= gfx::IntRect({}, iter.second->GetSize()).Area();
+    }
+  }
+
+  mSurfaces.erase(surfaceCursor);
+}
+
+void RenderCompositorNative::CreateTile(wr::NativeSurfaceId aId, int aX,
+                                        int aY) {
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+  Surface& surface = surfaceCursor->second;
+  MOZ_RELEASE_ASSERT(!surface.mIsExternal);
+
+  RefPtr<layers::NativeLayer> layer = mNativeLayerRoot->CreateLayer(
+      surface.TileSize(), surface.mIsOpaque, mSurfacePoolHandle);
+  surface.mNativeLayers.insert({TileKey(aX, aY), layer});
+  mTotalTilePixelCount += gfx::IntRect({}, layer->GetSize()).Area();
+}
+
+void RenderCompositorNative::DestroyTile(wr::NativeSurfaceId aId, int aX,
+                                         int aY) {
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+  Surface& surface = surfaceCursor->second;
+  MOZ_RELEASE_ASSERT(!surface.mIsExternal);
+
+  auto layerCursor = surface.mNativeLayers.find(TileKey(aX, aY));
+  MOZ_RELEASE_ASSERT(layerCursor != surface.mNativeLayers.end());
+  RefPtr<layers::NativeLayer> layer = std::move(layerCursor->second);
+  surface.mNativeLayers.erase(layerCursor);
+  mTotalTilePixelCount -= gfx::IntRect({}, layer->GetSize()).Area();
+
+  // If the layer is currently present in mNativeLayerRoot, it will be destroyed
+  // once CompositorEndFrame() replaces mNativeLayerRoot's layers and drops that
+  // reference. So until that happens, the layer still needs to hold on to its
+  // front buffer. However, we can tell it to drop its back buffers now, because
+  // we know that we will never draw to it again.
+  // Dropping the back buffers now puts them back in the surface pool, so those
+  // surfaces can be immediately re-used for drawing in other layers in the
+  // current frame.
+  layer->DiscardBackbuffers();
+}
+
+gfx::SamplingFilter ToSamplingFilter(wr::ImageRendering aImageRendering) {
+  if (aImageRendering == wr::ImageRendering::Auto) {
+    return gfx::SamplingFilter::LINEAR;
+  }
+  return gfx::SamplingFilter::POINT;
+}
+
+void RenderCompositorNative::AddSurface(
+    wr::NativeSurfaceId aId, const wr::CompositorSurfaceTransform& aTransform,
+    wr::DeviceIntRect aClipRect, wr::ImageRendering aImageRendering) {
+  MOZ_RELEASE_ASSERT(!mCurrentlyBoundNativeLayer);
+
+  auto surfaceCursor = mSurfaces.find(aId);
+  MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
+  const Surface& surface = surfaceCursor->second;
+
+  float sx = aTransform.scale.x;
+  float sy = aTransform.scale.y;
+  float tx = aTransform.offset.x;
+  float ty = aTransform.offset.y;
+  gfx::Matrix4x4 transform(sx, 0.0, 0.0, 0.0, 0.0, sy, 0.0, 0.0, 0.0, 0.0, 1.0,
+                           0.0, tx, ty, 0.0, 1.0);
+
+  for (auto it = surface.mNativeLayers.begin();
+       it != surface.mNativeLayers.end(); ++it) {
+    RefPtr<layers::NativeLayer> layer = it->second;
+    gfx::IntSize layerSize = layer->GetSize();
+    gfx::IntPoint layerPosition(surface.mTileSize.width * it->first.mX,
+                                surface.mTileSize.height * it->first.mY);
+    layer->SetPosition(layerPosition);
+    gfx::IntRect clipRect(aClipRect.min.x, aClipRect.min.y, aClipRect.width(),
+                          aClipRect.height());
+    layer->SetClipRect(Some(clipRect));
+    layer->SetTransform(transform);
+    layer->SetSamplingFilter(ToSamplingFilter(aImageRendering));
+    mAddedLayers.AppendElement(layer);
+
+    if (!surface.mIsExternal) {
+      mAddedTilePixelCount += layerSize.width * layerSize.height;
+    }
+    gfx::Rect r = transform.TransformBounds(
+        gfx::Rect(layer->CurrentSurfaceDisplayRect()));
+    gfx::IntRect visibleRect =
+        clipRect.Intersect(RoundedToInt(r) + layerPosition);
+    mAddedClippedPixelCount += visibleRect.Area();
+  }
+}
+
+/* static */
+UniquePtr<RenderCompositor> RenderCompositorNativeOGL::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  RefPtr<gl::GLContext> gl = RenderThread::Get()->SingletonGL();
+  if (!gl) {
+    gl = gl::GLContextProvider::CreateForCompositorWidget(
+        aWidget, /* aHardwareWebRender */ true, /* aForceAccelerated */ true);
+    RenderThread::MaybeEnableGLDebugMessage(gl);
+  }
+  if (!gl || !gl->MakeCurrent()) {
+    gfxCriticalNote << "Failed GL context creation for WebRender: "
+                    << gfx::hexa(gl.get());
+    return nullptr;
+  }
+  return MakeUnique<RenderCompositorNativeOGL>(aWidget, std::move(gl));
+}
+
+RenderCompositorNativeOGL::RenderCompositorNativeOGL(
+    const RefPtr<widget::CompositorWidget>& aWidget,
+    RefPtr<gl::GLContext>&& aGL)
+    : RenderCompositorNative(aWidget, aGL), mGL(aGL) {
+  MOZ_ASSERT(mGL);
+}
+
+RenderCompositorNativeOGL::~RenderCompositorNativeOGL() {
+  if (!mGL->MakeCurrent()) {
+    gfxCriticalNote
+        << "Failed to make render context current during destroying.";
+    // Leak resources!
+    mPreviousFrameDoneSync = nullptr;
+    mThisFrameDoneSync = nullptr;
+    return;
+  }
+
+  if (mPreviousFrameDoneSync) {
+    mGL->fDeleteSync(mPreviousFrameDoneSync);
+  }
+  if (mThisFrameDoneSync) {
+    mGL->fDeleteSync(mThisFrameDoneSync);
+  }
+}
+
+bool RenderCompositorNativeOGL::InitDefaultFramebuffer(
+    const gfx::IntRect& aBounds) {
+  if (mNativeLayerForEntireWindow) {
+    Maybe<GLuint> fbo = mNativeLayerForEntireWindow->NextSurfaceAsFramebuffer(
+        aBounds, aBounds, true);
+    if (!fbo) {
+      return false;
+    }
+    mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, *fbo);
+  } else {
+    mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGL->GetDefaultFramebuffer());
+  }
+  return true;
+}
+
+void RenderCompositorNativeOGL::DoSwap() {
+  InsertFrameDoneSync();
+  if (mNativeLayerForEntireWindow) {
+    mGL->fFlush();
+  }
+}
+
+void RenderCompositorNativeOGL::DoFlush() { mGL->fFlush(); }
+
+void RenderCompositorNativeOGL::InsertFrameDoneSync() {
+#ifdef XP_MACOSX
+  // Only do this on macOS.
+  // On other platforms, SwapBuffers automatically applies back-pressure.
+  if (mThisFrameDoneSync) {
+    mGL->fDeleteSync(mThisFrameDoneSync);
+  }
+  mThisFrameDoneSync = mGL->fFenceSync(LOCAL_GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+#endif
+}
+
+bool RenderCompositorNativeOGL::WaitForGPU() {
+  if (mPreviousFrameDoneSync) {
+    AUTO_PROFILER_LABEL("Waiting for GPU to finish previous frame", GRAPHICS);
+    mGL->fClientWaitSync(mPreviousFrameDoneSync,
+                         LOCAL_GL_SYNC_FLUSH_COMMANDS_BIT,
+                         LOCAL_GL_TIMEOUT_IGNORED);
+    mGL->fDeleteSync(mPreviousFrameDoneSync);
+  }
+  mPreviousFrameDoneSync = mThisFrameDoneSync;
+  mThisFrameDoneSync = nullptr;
+
+  return true;
+}
+
+void RenderCompositorNativeOGL::Bind(wr::NativeTileId aId,
+                                     wr::DeviceIntPoint* aOffset,
+                                     uint32_t* aFboId,
+                                     wr::DeviceIntRect aDirtyRect,
+                                     wr::DeviceIntRect aValidRect) {
+  gfx::IntRect validRect(aValidRect.min.x, aValidRect.min.y, aValidRect.width(),
+                         aValidRect.height());
+  gfx::IntRect dirtyRect(aDirtyRect.min.x, aDirtyRect.min.y, aDirtyRect.width(),
+                         aDirtyRect.height());
+
+  BindNativeLayer(aId, dirtyRect);
+
+  Maybe<GLuint> fbo = mCurrentlyBoundNativeLayer->NextSurfaceAsFramebuffer(
+      validRect, dirtyRect, true);
+
+  *aFboId = *fbo;
+  *aOffset = wr::DeviceIntPoint{0, 0};
+}
+
+void RenderCompositorNativeOGL::Unbind() {
+  mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, 0);
+
+  UnbindNativeLayer();
+}
+
+/* static */
+UniquePtr<RenderCompositor> RenderCompositorNativeSWGL::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  void* ctx = wr_swgl_create_context();
+  if (!ctx) {
+    gfxCriticalNote << "Failed SWGL context creation for WebRender";
+    return nullptr;
+  }
+  return MakeUnique<RenderCompositorNativeSWGL>(aWidget, ctx);
+}
+
+RenderCompositorNativeSWGL::RenderCompositorNativeSWGL(
+    const RefPtr<widget::CompositorWidget>& aWidget, void* aContext)
+    : RenderCompositorNative(aWidget), mContext(aContext) {
+  MOZ_ASSERT(mContext);
+}
+
+RenderCompositorNativeSWGL::~RenderCompositorNativeSWGL() {
+  wr_swgl_destroy_context(mContext);
+}
+
+bool RenderCompositorNativeSWGL::MakeCurrent() {
+  wr_swgl_make_current(mContext);
+  return true;
+}
+
+bool RenderCompositorNativeSWGL::InitDefaultFramebuffer(
+    const gfx::IntRect& aBounds) {
+  if (mNativeLayerForEntireWindow) {
+    if (!MapNativeLayer(mNativeLayerForEntireWindow, aBounds, aBounds)) {
+      return false;
+    }
+    wr_swgl_init_default_framebuffer(mContext, aBounds.x, aBounds.y,
+                                     aBounds.width, aBounds.height,
+                                     mLayerStride, mLayerValidRectData);
+  }
+  return true;
+}
+
+void RenderCompositorNativeSWGL::CancelFrame() {
+  if (mNativeLayerForEntireWindow && mLayerTarget) {
+    wr_swgl_init_default_framebuffer(mContext, 0, 0, 0, 0, 0, nullptr);
+    UnmapNativeLayer();
+  }
+}
+
+void RenderCompositorNativeSWGL::DoSwap() {
+  if (mNativeLayerForEntireWindow && mLayerTarget) {
+    wr_swgl_init_default_framebuffer(mContext, 0, 0, 0, 0, 0, nullptr);
+    UnmapNativeLayer();
+  }
+}
+
+bool RenderCompositorNativeSWGL::MapNativeLayer(
+    layers::NativeLayer* aLayer, const gfx::IntRect& aDirtyRect,
+    const gfx::IntRect& aValidRect) {
+  uint8_t* data = nullptr;
+  gfx::IntSize size;
+  int32_t stride = 0;
+  gfx::SurfaceFormat format = gfx::SurfaceFormat::UNKNOWN;
+  RefPtr<gfx::DrawTarget> dt = aLayer->NextSurfaceAsDrawTarget(
+      aValidRect, gfx::IntRegion(aDirtyRect), gfx::BackendType::SKIA);
+  if (!dt || !dt->LockBits(&data, &size, &stride, &format)) {
+    return false;
+  }
+  MOZ_ASSERT(format == gfx::SurfaceFormat::B8G8R8A8 ||
+             format == gfx::SurfaceFormat::B8G8R8X8);
+  mLayerTarget = std::move(dt);
+  mLayerData = data;
+  mLayerValidRectData = data + aValidRect.y * stride + aValidRect.x * 4;
+  mLayerStride = stride;
+  return true;
+}
+
+void RenderCompositorNativeSWGL::UnmapNativeLayer() {
+  MOZ_ASSERT(mLayerTarget && mLayerData);
+  mLayerTarget->ReleaseBits(mLayerData);
+  mLayerTarget = nullptr;
+  mLayerData = nullptr;
+  mLayerValidRectData = nullptr;
+  mLayerStride = 0;
+}
+
+bool RenderCompositorNativeSWGL::MapTile(wr::NativeTileId aId,
+                                         wr::DeviceIntRect aDirtyRect,
+                                         wr::DeviceIntRect aValidRect,
+                                         void** aData, int32_t* aStride) {
+  if (mNativeLayerForEntireWindow) {
+    return false;
+  }
+  gfx::IntRect dirtyRect(aDirtyRect.min.x, aDirtyRect.min.y, aDirtyRect.width(),
+                         aDirtyRect.height());
+  gfx::IntRect validRect(aValidRect.min.x, aValidRect.min.y, aValidRect.width(),
+                         aValidRect.height());
+  BindNativeLayer(aId, dirtyRect);
+  if (!MapNativeLayer(mCurrentlyBoundNativeLayer, dirtyRect, validRect)) {
+    UnbindNativeLayer();
+    return false;
+  }
+  *aData = mLayerValidRectData;
+  *aStride = mLayerStride;
+  return true;
+}
+
+void RenderCompositorNativeSWGL::UnmapTile() {
+  if (!mNativeLayerForEntireWindow && mCurrentlyBoundNativeLayer) {
+    UnmapNativeLayer();
+    UnbindNativeLayer();
+  }
+}
+
+}  // namespace mozilla::wr
diff --git a/gfx/webrender_bindings/RenderCompositorNative.h b/gfx/webrender_bindings/RenderCompositorNative.h
new file mode 100644
index 0000000000..936fdd3db8
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorNative.h
@@ -0,0 +1,233 @@
+/* -*- 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_RENDERCOMPOSITOR_NATIVE_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_NATIVE_H
+
+#include <unordered_map>
+
+#include "GLTypes.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/layers/ScreenshotGrabber.h"
+#include "mozilla/webrender/RenderCompositor.h"
+#include "mozilla/TimeStamp.h"
+
+namespace mozilla {
+
+namespace layers {
+class NativeLayerRootSnapshotter;
+class NativeLayerRoot;
+class NativeLayer;
+class SurfacePoolHandle;
+}  // namespace layers
+
+namespace wr {
+
+// RenderCompositorNative is a skeleton class for implementing compositors
+// backed by NativeLayer surfaces and tiles. This is not meant to be directly
+// instantiated and is instead derived for various use-cases such as OpenGL or
+// SWGL.
+class RenderCompositorNative : public RenderCompositor {
+ public:
+  virtual ~RenderCompositorNative();
+
+  bool BeginFrame() override;
+  RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) final;
+  void Pause() override;
+  bool Resume() override;
+
+  layers::WebRenderCompositor CompositorType() const override;
+
+  LayoutDeviceIntSize GetBufferSize() override;
+
+  bool ShouldUseNativeCompositor() override;
+  void GetCompositorCapabilities(CompositorCapabilities* aCaps) override;
+
+  bool SurfaceOriginIsTopLeft() override { return true; }
+
+  // Does the readback for the ShouldUseNativeCompositor() case.
+  bool MaybeReadback(const gfx::IntSize& aReadbackSize,
+                     const wr::ImageFormat& aReadbackFormat,
+                     const Range<uint8_t>& aReadbackBuffer,
+                     bool* aNeedsYFlip) override;
+  bool MaybeRecordFrame(layers::CompositionRecorder& aRecorder) override;
+  bool MaybeGrabScreenshot(const gfx::IntSize& aWindowSize) override;
+  bool MaybeProcessScreenshotQueue() override;
+
+  // Interface for wr::Compositor
+  void CompositorBeginFrame() override;
+  void CompositorEndFrame() override;
+  void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset,
+                     wr::DeviceIntSize aTileSize, bool aIsOpaque) override;
+  void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) override;
+  void CreateBackdropSurface(wr::NativeSurfaceId aId,
+                             wr::ColorF aColor) override;
+  void DestroySurface(NativeSurfaceId aId) override;
+  void CreateTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) override;
+  void DestroyTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) override;
+  void AttachExternalImage(wr::NativeSurfaceId aId,
+                           wr::ExternalImageId aExternalImage) override;
+  void AddSurface(wr::NativeSurfaceId aId,
+                  const wr::CompositorSurfaceTransform& aTransform,
+                  wr::DeviceIntRect aClipRect,
+                  wr::ImageRendering aImageRendering) override;
+
+  struct TileKey {
+    TileKey(int32_t aX, int32_t aY) : mX(aX), mY(aY) {}
+
+    int32_t mX;
+    int32_t mY;
+  };
+
+ protected:
+  explicit RenderCompositorNative(
+      const RefPtr<widget::CompositorWidget>& aWidget,
+      gl::GLContext* aGL = nullptr);
+
+  virtual bool InitDefaultFramebuffer(const gfx::IntRect& aBounds) = 0;
+  virtual void DoSwap() = 0;
+  virtual void DoFlush() {}
+
+  void BindNativeLayer(wr::NativeTileId aId, const gfx::IntRect& aDirtyRect);
+  void UnbindNativeLayer();
+
+  // Can be null.
+  RefPtr<layers::NativeLayerRoot> mNativeLayerRoot;
+  UniquePtr<layers::NativeLayerRootSnapshotter> mNativeLayerRootSnapshotter;
+  layers::ScreenshotGrabber mProfilerScreenshotGrabber;
+  RefPtr<layers::NativeLayer> mNativeLayerForEntireWindow;
+  RefPtr<layers::SurfacePoolHandle> mSurfacePoolHandle;
+
+  struct TileKeyHashFn {
+    std::size_t operator()(const TileKey& aId) const {
+      return HashGeneric(aId.mX, aId.mY);
+    }
+  };
+
+  struct Surface {
+    explicit Surface(wr::DeviceIntSize aTileSize, bool aIsOpaque)
+        : mTileSize(aTileSize), mIsOpaque(aIsOpaque) {}
+    gfx::IntSize TileSize() {
+      return gfx::IntSize(mTileSize.width, mTileSize.height);
+    }
+
+    // External images can change size depending on which image
+    // is attached, so mTileSize will be 0,0 when mIsExternal
+    // is true.
+    wr::DeviceIntSize mTileSize;
+    bool mIsOpaque;
+    bool mIsExternal = false;
+    std::unordered_map<TileKey, RefPtr<layers::NativeLayer>, TileKeyHashFn>
+        mNativeLayers;
+  };
+
+  struct SurfaceIdHashFn {
+    std::size_t operator()(const wr::NativeSurfaceId& aId) const {
+      return HashGeneric(wr::AsUint64(aId));
+    }
+  };
+
+  // Used in native compositor mode:
+  RefPtr<layers::NativeLayer> mCurrentlyBoundNativeLayer;
+  nsTArray<RefPtr<layers::NativeLayer>> mAddedLayers;
+  uint64_t mTotalTilePixelCount = 0;
+  uint64_t mAddedTilePixelCount = 0;
+  uint64_t mAddedClippedPixelCount = 0;
+  uint64_t mDrawnPixelCount = 0;
+  gfx::IntRect mVisibleBounds;
+  std::unordered_map<wr::NativeSurfaceId, Surface, SurfaceIdHashFn> mSurfaces;
+  TimeStamp mBeginFrameTimeStamp;
+};
+
+static inline bool operator==(const RenderCompositorNative::TileKey& a0,
+                              const RenderCompositorNative::TileKey& a1) {
+  return a0.mX == a1.mX && a0.mY == a1.mY;
+}
+
+// RenderCompositorNativeOGL is a NativeLayer compositor that exposes an
+// OpenGL framebuffer for the respective NativeLayer bound to each tile.
+class RenderCompositorNativeOGL : public RenderCompositorNative {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositorNativeOGL(const RefPtr<widget::CompositorWidget>& aWidget,
+                            RefPtr<gl::GLContext>&& aGL);
+  virtual ~RenderCompositorNativeOGL();
+
+  bool WaitForGPU() override;
+
+  gl::GLContext* gl() const override { return mGL; }
+
+  void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId,
+            wr::DeviceIntRect aDirtyRect,
+            wr::DeviceIntRect aValidRect) override;
+  void Unbind() override;
+
+ protected:
+  void InsertFrameDoneSync();
+
+  bool InitDefaultFramebuffer(const gfx::IntRect& aBounds) override;
+  void DoSwap() override;
+  void DoFlush() override;
+
+  RefPtr<gl::GLContext> mGL;
+
+  // Used to apply back-pressure in WaitForGPU().
+  GLsync mPreviousFrameDoneSync = nullptr;
+  GLsync mThisFrameDoneSync = nullptr;
+};
+
+// RenderCompositorNativeSWGL is a NativeLayer compositor that only
+// deals with mapping the underlying buffer for SWGL usage of a tile.
+class RenderCompositorNativeSWGL : public RenderCompositorNative {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositorNativeSWGL(const RefPtr<widget::CompositorWidget>& aWidget,
+                             void* aContext);
+  virtual ~RenderCompositorNativeSWGL();
+
+  void* swgl() const override { return mContext; }
+
+  bool MakeCurrent() override;
+
+  void CancelFrame() override;
+
+  layers::WebRenderBackend BackendType() const override {
+    return layers::WebRenderBackend::SOFTWARE;
+  }
+
+  // Maps an underlying layer and sets aData to the top left pixel of
+  // aValidRect.  The row stride is set to aStride, note this doesn't
+  // mean there are always aStride bytes available per row (the
+  // last row will fall short if aValidRect is not at X==0).
+  bool MapTile(wr::NativeTileId aId, wr::DeviceIntRect aDirtyRect,
+               wr::DeviceIntRect aValidRect, void** aData,
+               int32_t* aStride) override;
+  void UnmapTile() override;
+
+ protected:
+  bool InitDefaultFramebuffer(const gfx::IntRect& aBounds) override;
+  void DoSwap() override;
+
+  bool MapNativeLayer(layers::NativeLayer* aLayer,
+                      const gfx::IntRect& aDirtyRect,
+                      const gfx::IntRect& aValidRect);
+  void UnmapNativeLayer();
+
+  void* mContext = nullptr;
+  RefPtr<gfx::DrawTarget> mLayerTarget;
+  uint8_t* mLayerData = nullptr;
+  uint8_t* mLayerValidRectData = nullptr;
+  int32_t mLayerStride = 0;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderCompositorOGL.cpp b/gfx/webrender_bindings/RenderCompositorOGL.cpp
new file mode 100644
index 0000000000..9653e06d43
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorOGL.cpp
@@ -0,0 +1,126 @@
+/* -*- 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 "RenderCompositorOGL.h"
+
+#include "GLContext.h"
+#include "GLContextEGL.h"
+#include "GLContextProvider.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/widget/CompositorWidget.h"
+
+namespace mozilla::wr {
+
+extern LazyLogModule gRenderThreadLog;
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+/* static */
+UniquePtr<RenderCompositor> RenderCompositorOGL::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  RefPtr<gl::GLContext> gl = RenderThread::Get()->SingletonGL();
+  if (!gl) {
+    gl = gl::GLContextProvider::CreateForCompositorWidget(
+        aWidget, /* aHardwareWebRender */ true, /* aForceAccelerated */ true);
+    RenderThread::MaybeEnableGLDebugMessage(gl);
+  }
+  if (!gl || !gl->MakeCurrent()) {
+    gfxCriticalNote << "Failed GL context creation for WebRender: "
+                    << gfx::hexa(gl.get());
+    return nullptr;
+  }
+  return MakeUnique<RenderCompositorOGL>(std::move(gl), aWidget);
+}
+
+RenderCompositorOGL::RenderCompositorOGL(
+    RefPtr<gl::GLContext>&& aGL,
+    const RefPtr<widget::CompositorWidget>& aWidget)
+    : RenderCompositor(aWidget), mGL(aGL) {
+  MOZ_ASSERT(mGL);
+  LOG("RenderCompositorOGL::RenderCompositorOGL()");
+
+  mIsEGL = aGL->GetContextType() == mozilla::gl::GLContextType::EGL;
+}
+
+RenderCompositorOGL::~RenderCompositorOGL() {
+  LOG("RenderCompositorOGL::~RenderCompositorOGL()");
+
+  if (!mGL->MakeCurrent()) {
+    gfxCriticalNote
+        << "Failed to make render context current during destroying.";
+    // Leak resources!
+    return;
+  }
+}
+
+bool RenderCompositorOGL::BeginFrame() {
+  if (!mGL->MakeCurrent()) {
+    gfxCriticalNote << "Failed to make render context current, can't draw.";
+    return false;
+  }
+
+  mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGL->GetDefaultFramebuffer());
+
+  return true;
+}
+
+RenderedFrameId RenderCompositorOGL::EndFrame(
+    const nsTArray<DeviceIntRect>& aDirtyRects) {
+  RenderedFrameId frameId = GetNextRenderFrameId();
+  if (UsePartialPresent() && aDirtyRects.Length() > 0) {
+    gfx::IntRegion bufferInvalid;
+    const auto bufferSize = GetBufferSize();
+    for (const DeviceIntRect& rect : aDirtyRects) {
+      const auto left = std::max(0, std::min(bufferSize.width, rect.min.x));
+      const auto top = std::max(0, std::min(bufferSize.height, rect.min.y));
+
+      const auto right = std::min(bufferSize.width, std::max(0, rect.max.x));
+      const auto bottom = std::min(bufferSize.height, std::max(0, rect.max.y));
+
+      const auto width = right - left;
+      const auto height = bottom - top;
+
+      bufferInvalid.OrWith(
+          gfx::IntRect(left, (GetBufferSize().height - bottom), width, height));
+    }
+    gl()->SetDamage(bufferInvalid);
+  }
+  mGL->SwapBuffers();
+  return frameId;
+}
+
+void RenderCompositorOGL::Pause() {}
+
+bool RenderCompositorOGL::Resume() { return true; }
+
+LayoutDeviceIntSize RenderCompositorOGL::GetBufferSize() {
+  return mWidget->GetClientSize();
+}
+
+uint32_t RenderCompositorOGL::GetMaxPartialPresentRects() {
+  return gfx::gfxVars::WebRenderMaxPartialPresentRects();
+}
+
+bool RenderCompositorOGL::RequestFullRender() { return false; }
+
+bool RenderCompositorOGL::UsePartialPresent() {
+  return gfx::gfxVars::WebRenderMaxPartialPresentRects() > 0;
+}
+
+bool RenderCompositorOGL::ShouldDrawPreviousPartialPresentRegions() {
+  return true;
+}
+
+size_t RenderCompositorOGL::GetBufferAge() const {
+  if (!StaticPrefs::
+          gfx_webrender_allow_partial_present_buffer_age_AtStartup()) {
+    return 0;
+  }
+  return gl()->GetBufferAge();
+}
+
+}  // namespace mozilla::wr
diff --git a/gfx/webrender_bindings/RenderCompositorOGL.h b/gfx/webrender_bindings/RenderCompositorOGL.h
new file mode 100644
index 0000000000..78429a2db4
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorOGL.h
@@ -0,0 +1,49 @@
+/* -*- 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_RENDERCOMPOSITOR_OGL_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_OGL_H
+
+#include "GLTypes.h"
+#include "mozilla/webrender/RenderCompositor.h"
+
+namespace mozilla {
+namespace wr {
+
+class RenderCompositorOGL : public RenderCompositor {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositorOGL(RefPtr<gl::GLContext>&& aGL,
+                      const RefPtr<widget::CompositorWidget>& aWidget);
+  virtual ~RenderCompositorOGL();
+
+  bool BeginFrame() override;
+  RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) final;
+  void Pause() override;
+  bool Resume() override;
+
+  gl::GLContext* gl() const override { return mGL; }
+
+  LayoutDeviceIntSize GetBufferSize() override;
+
+  // Interface for partial present
+  bool UsePartialPresent() override;
+  bool RequestFullRender() override;
+  uint32_t GetMaxPartialPresentRects() override;
+  bool ShouldDrawPreviousPartialPresentRegions() override;
+  size_t GetBufferAge() const override;
+
+ protected:
+  RefPtr<gl::GLContext> mGL;
+  bool mIsEGL;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderCompositorOGLSWGL.cpp b/gfx/webrender_bindings/RenderCompositorOGLSWGL.cpp
new file mode 100644
index 0000000000..d2d0cce016
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorOGLSWGL.cpp
@@ -0,0 +1,508 @@
+/* -*- 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 "RenderCompositorOGLSWGL.h"
+
+#include "GLContext.h"
+#include "GLContextEGL.h"
+#include "mozilla/layers/BuildConstants.h"
+#include "mozilla/layers/CompositorOGL.h"
+#include "mozilla/layers/Effects.h"
+#include "mozilla/layers/TextureHostOGL.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "OGLShaderProgram.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "mozilla/java/GeckoSurfaceTextureWrappers.h"
+#  include "mozilla/layers/AndroidHardwareBuffer.h"
+#  include "mozilla/webrender/RenderAndroidHardwareBufferTextureHost.h"
+#  include "mozilla/webrender/RenderAndroidSurfaceTextureHost.h"
+#  include "mozilla/widget/AndroidCompositorWidget.h"
+#  include <android/native_window.h>
+#  include <android/native_window_jni.h>
+#endif
+
+#ifdef MOZ_WIDGET_GTK
+#  include "mozilla/widget/GtkCompositorWidget.h"
+#  include <gdk/gdk.h>
+#  ifdef MOZ_X11
+#    include <gdk/gdkx.h>
+#  endif
+#endif
+
+namespace mozilla {
+using namespace layers;
+using namespace gfx;
+namespace wr {
+
+extern LazyLogModule gRenderThreadLog;
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+UniquePtr<RenderCompositor> RenderCompositorOGLSWGL::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  if (!aWidget->GetCompositorOptions().AllowSoftwareWebRenderOGL()) {
+    return nullptr;
+  }
+
+  RefPtr<Compositor> compositor;
+#ifdef MOZ_WIDGET_ANDROID
+  RefPtr<gl::GLContext> context =
+      RenderThread::Get()->SingletonGLForCompositorOGL();
+  if (!context) {
+    gfxCriticalNote << "SingletonGL does not exist for SWGL";
+    return nullptr;
+  }
+  auto programs = RenderThread::Get()->GetProgramsForCompositorOGL();
+  if (!programs) {
+    gfxCriticalNote << "Failed to get Programs for CompositorOGL for SWGL";
+    return nullptr;
+  }
+
+  nsCString log;
+  RefPtr<CompositorOGL> compositorOGL;
+  compositorOGL = new CompositorOGL(aWidget, /* aSurfaceWidth */ -1,
+                                    /* aSurfaceHeight */ -1,
+                                    /* aUseExternalSurfaceSize */ true);
+  if (!compositorOGL->Initialize(context, programs, &log)) {
+    gfxCriticalNote << "Failed to initialize CompositorOGL for SWGL: "
+                    << log.get();
+    return nullptr;
+  }
+  compositor = compositorOGL;
+#elif defined(MOZ_WIDGET_GTK)
+  nsCString log;
+  RefPtr<CompositorOGL> compositorOGL;
+  compositorOGL = new CompositorOGL(aWidget);
+  if (!compositorOGL->Initialize(&log)) {
+    gfxCriticalNote << "Failed to initialize CompositorOGL for SWGL: "
+                    << log.get();
+    return nullptr;
+  }
+  compositor = compositorOGL;
+#endif
+
+  if (!compositor) {
+    return nullptr;
+  }
+
+  void* ctx = wr_swgl_create_context();
+  if (!ctx) {
+    gfxCriticalNote << "Failed SWGL context creation for WebRender";
+    return nullptr;
+  }
+
+  return MakeUnique<RenderCompositorOGLSWGL>(compositor, aWidget, ctx);
+}
+
+RenderCompositorOGLSWGL::RenderCompositorOGLSWGL(
+    Compositor* aCompositor, const RefPtr<widget::CompositorWidget>& aWidget,
+    void* aContext)
+    : RenderCompositorLayersSWGL(aCompositor, aWidget, aContext) {
+  LOG("RenderCompositorOGLSWGL::RenderCompositorOGLSWGL()");
+}
+
+RenderCompositorOGLSWGL::~RenderCompositorOGLSWGL() {
+  LOG("RRenderCompositorOGLSWGL::~RenderCompositorOGLSWGL()");
+#ifdef MOZ_WIDGET_ANDROID
+  java::GeckoSurfaceTexture::DestroyUnused((int64_t)GetGLContext());
+  DestroyEGLSurface();
+#endif
+}
+
+gl::GLContext* RenderCompositorOGLSWGL::GetGLContext() {
+  return mCompositor->AsCompositorOGL()->gl();
+}
+
+bool RenderCompositorOGLSWGL::MakeCurrent() {
+  GetGLContext()->MakeCurrent();
+#ifdef MOZ_WIDGET_ANDROID
+  if (GetGLContext()->GetContextType() == gl::GLContextType::EGL) {
+    gl::GLContextEGL::Cast(GetGLContext())->SetEGLSurfaceOverride(mEGLSurface);
+  }
+#endif
+  RenderCompositorLayersSWGL::MakeCurrent();
+  return true;
+}
+
+EGLSurface RenderCompositorOGLSWGL::CreateEGLSurface() {
+  MOZ_ASSERT(GetGLContext()->GetContextType() == gl::GLContextType::EGL);
+
+  EGLSurface surface = EGL_NO_SURFACE;
+  surface = gl::GLContextEGL::CreateEGLSurfaceForCompositorWidget(
+      mWidget, gl::GLContextEGL::Cast(GetGLContext())->mSurfaceConfig);
+  if (surface == EGL_NO_SURFACE) {
+    const auto* renderThread = RenderThread::Get();
+    gfxCriticalNote << "Failed to create EGLSurface. "
+                    << renderThread->RendererCount() << " renderers, "
+                    << renderThread->ActiveRendererCount() << " active.";
+  }
+
+  // The subsequent render after creating a new surface must be a full render.
+  mFullRender = true;
+
+  return surface;
+}
+
+void RenderCompositorOGLSWGL::DestroyEGLSurface() {
+  MOZ_ASSERT(GetGLContext()->GetContextType() == gl::GLContextType::EGL);
+
+  const auto& gle = gl::GLContextEGL::Cast(GetGLContext());
+  const auto& egl = gle->mEgl;
+
+  // Release EGLSurface of back buffer before calling ResizeBuffers().
+  if (mEGLSurface) {
+    gle->SetEGLSurfaceOverride(EGL_NO_SURFACE);
+    gl::GLContextEGL::DestroySurface(*egl, mEGLSurface);
+    mEGLSurface = EGL_NO_SURFACE;
+  }
+}
+
+bool RenderCompositorOGLSWGL::BeginFrame() {
+  MOZ_ASSERT(!mInFrame);
+  RenderCompositorLayersSWGL::BeginFrame();
+
+#ifdef MOZ_WIDGET_ANDROID
+  java::GeckoSurfaceTexture::DestroyUnused((int64_t)GetGLContext());
+  GetGLContext()
+      ->MakeCurrent();  // DestroyUnused can change the current context!
+#endif
+
+  return true;
+}
+
+RenderedFrameId RenderCompositorOGLSWGL::EndFrame(
+    const nsTArray<DeviceIntRect>& aDirtyRects) {
+  mFullRender = false;
+
+  return RenderCompositorLayersSWGL::EndFrame(aDirtyRects);
+}
+
+void RenderCompositorOGLSWGL::HandleExternalImage(
+    RenderTextureHost* aExternalImage, FrameSurface& aFrameSurface) {
+  MOZ_ASSERT(aExternalImage);
+
+#ifdef MOZ_WIDGET_ANDROID
+  GLenum target =
+      LOCAL_GL_TEXTURE_EXTERNAL;  // This is required by SurfaceTexture
+  GLenum wrapMode = LOCAL_GL_CLAMP_TO_EDGE;
+
+  if (auto* host = aExternalImage->AsRenderAndroidSurfaceTextureHost()) {
+    host->UpdateTexImageIfNecessary();
+
+    // We need to hold the texture source separately from the effect,
+    // since the effect doesn't hold a strong reference.
+    RefPtr<SurfaceTextureSource> layer = new SurfaceTextureSource(
+        (TextureSourceProvider*)mCompositor, host->mSurfTex, host->mFormat,
+        target, wrapMode, host->mSize, host->mTransformOverride);
+    RefPtr<TexturedEffect> texturedEffect =
+        CreateTexturedEffect(host->mFormat, layer, aFrameSurface.mFilter,
+                             /* isAlphaPremultiplied */ true);
+
+    gfx::Rect drawRect(0, 0, host->mSize.width, host->mSize.height);
+
+    EffectChain effect;
+    effect.mPrimaryEffect = texturedEffect;
+    mCompositor->DrawQuad(drawRect, aFrameSurface.mClipRect, effect, 1.0,
+                          aFrameSurface.mTransform, drawRect);
+  } else if (auto* host =
+                 aExternalImage->AsRenderAndroidHardwareBufferTextureHost()) {
+    // We need to hold the texture source separately from the effect,
+    // since the effect doesn't hold a strong reference.
+    RefPtr<AndroidHardwareBufferTextureSource> layer =
+        new AndroidHardwareBufferTextureSource(
+            (TextureSourceProvider*)mCompositor,
+            host->GetAndroidHardwareBuffer(),
+            host->GetAndroidHardwareBuffer()->mFormat, target, wrapMode,
+            host->GetSize());
+    RefPtr<TexturedEffect> texturedEffect = CreateTexturedEffect(
+        host->GetAndroidHardwareBuffer()->mFormat, layer, aFrameSurface.mFilter,
+        /* isAlphaPremultiplied */ true);
+
+    gfx::Rect drawRect(0, 0, host->GetSize().width, host->GetSize().height);
+
+    EffectChain effect;
+    effect.mPrimaryEffect = texturedEffect;
+    mCompositor->DrawQuad(drawRect, aFrameSurface.mClipRect, effect, 1.0,
+                          aFrameSurface.mTransform, drawRect);
+  }
+#endif
+}
+
+void RenderCompositorOGLSWGL::GetCompositorCapabilities(
+    CompositorCapabilities* aCaps) {
+  RenderCompositor::GetCompositorCapabilities(aCaps);
+
+  // max_update_rects are not yet handled properly
+  aCaps->max_update_rects = 0;
+}
+
+bool RenderCompositorOGLSWGL::RequestFullRender() { return mFullRender; }
+
+void RenderCompositorOGLSWGL::Pause() {
+#ifdef MOZ_WIDGET_ANDROID
+  DestroyEGLSurface();
+#elif defined(MOZ_WIDGET_GTK)
+  mCompositor->Pause();
+#endif
+}
+
+bool RenderCompositorOGLSWGL::Resume() {
+#ifdef MOZ_WIDGET_ANDROID
+  // Destroy EGLSurface if it exists.
+  DestroyEGLSurface();
+
+  auto size = GetBufferSize();
+  GLint maxTextureSize = 0;
+  GetGLContext()->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE,
+                               (GLint*)&maxTextureSize);
+
+  // When window size is too big, hardware buffer allocation could fail.
+  if (maxTextureSize < size.width || maxTextureSize < size.height) {
+    gfxCriticalNote << "Too big ANativeWindow size(" << size.width << ", "
+                    << size.height << ") MaxTextureSize " << maxTextureSize;
+    return false;
+  }
+
+  mEGLSurface = CreateEGLSurface();
+  if (mEGLSurface == EGL_NO_SURFACE) {
+    // Often when we fail to create an EGL surface it is because the
+    // Java Surface we have been provided is invalid. Therefore the on
+    // the first occurence we don't raise a WebRenderError and instead
+    // just return failure. This allows the widget a chance to request
+    // a new Java Surface. On subsequent failures, raising the
+    // WebRenderError will result in the compositor being recreated,
+    // falling back through webrender configurations, and eventually
+    // crashing if we still do not succeed.
+    if (!mHandlingNewSurfaceError) {
+      mHandlingNewSurfaceError = true;
+    } else {
+      RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE);
+    }
+    return false;
+  }
+  mHandlingNewSurfaceError = false;
+
+  gl::GLContextEGL::Cast(GetGLContext())->SetEGLSurfaceOverride(mEGLSurface);
+  mCompositor->SetDestinationSurfaceSize(size.ToUnknownSize());
+#elif defined(MOZ_WIDGET_GTK)
+  bool resumed = mCompositor->Resume();
+  if (!resumed) {
+    RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE);
+    return false;
+  }
+#endif
+  return true;
+}
+
+bool RenderCompositorOGLSWGL::IsPaused() {
+#ifdef MOZ_WIDGET_ANDROID
+  return mEGLSurface == EGL_NO_SURFACE;
+#endif
+  return false;
+}
+
+LayoutDeviceIntSize RenderCompositorOGLSWGL::GetBufferSize() {
+  return mWidget->GetClientSize();
+}
+
+UniquePtr<RenderCompositorLayersSWGL::Tile>
+RenderCompositorOGLSWGL::DoCreateTile(Surface* aSurface) {
+  auto source = MakeRefPtr<TextureImageTextureSourceOGL>(
+      mCompositor->AsCompositorOGL(), layers::TextureFlags::NO_FLAGS);
+
+  return MakeUnique<TileOGL>(std::move(source), aSurface->TileSize());
+}
+
+bool RenderCompositorOGLSWGL::MaybeReadback(
+    const gfx::IntSize& aReadbackSize, const wr::ImageFormat& aReadbackFormat,
+    const Range<uint8_t>& aReadbackBuffer, bool* aNeedsYFlip) {
+#ifdef MOZ_WIDGET_ANDROID
+  MOZ_ASSERT(aReadbackFormat == wr::ImageFormat::RGBA8);
+  const GLenum format = LOCAL_GL_RGBA;
+#else
+  MOZ_ASSERT(aReadbackFormat == wr::ImageFormat::BGRA8);
+  const GLenum format = LOCAL_GL_BGRA;
+#endif
+
+  GetGLContext()->fReadPixels(0, 0, aReadbackSize.width, aReadbackSize.height,
+                              format, LOCAL_GL_UNSIGNED_BYTE,
+                              &aReadbackBuffer[0]);
+
+  if (aNeedsYFlip) {
+    *aNeedsYFlip = true;
+  }
+
+  return true;
+}
+
+// This is a DataSourceSurface that represents a 0-based PBO for GLTextureImage.
+class PBOUnpackSurface : public gfx::DataSourceSurface {
+ public:
+  MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PBOUnpackSurface, override)
+
+  explicit PBOUnpackSurface(const gfx::IntSize& aSize) : mSize(aSize) {}
+
+  uint8_t* GetData() override { return nullptr; }
+  int32_t Stride() override { return mSize.width * sizeof(uint32_t); }
+  gfx::SurfaceType GetType() const override {
+    return gfx::SurfaceType::DATA_ALIGNED;
+  }
+  gfx::IntSize GetSize() const override { return mSize; }
+  gfx::SurfaceFormat GetFormat() const override {
+    return gfx::SurfaceFormat::B8G8R8A8;
+  }
+
+  // PBO offsets need to start from a 0 address, but DataSourceSurface::Map
+  // checks for failure by comparing the address against nullptr. Override Map
+  // to work around this.
+  bool Map(MapType, MappedSurface* aMappedSurface) override {
+    aMappedSurface->mData = GetData();
+    aMappedSurface->mStride = Stride();
+    return true;
+  }
+
+  void Unmap() override {}
+
+ private:
+  gfx::IntSize mSize;
+};
+
+RenderCompositorOGLSWGL::TileOGL::TileOGL(
+    RefPtr<layers::TextureImageTextureSourceOGL>&& aTexture,
+    const gfx::IntSize& aSize)
+    : mTexture(aTexture) {
+  auto* gl = mTexture->gl();
+  if (gl && gl->HasPBOState() && gl->MakeCurrent()) {
+    mSurface = new PBOUnpackSurface(aSize);
+    // Create a PBO large enough to encompass any valid rects within the tile.
+    gl->fGenBuffers(1, &mPBO);
+    gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, mPBO);
+    gl->fBufferData(LOCAL_GL_PIXEL_UNPACK_BUFFER,
+                    mSurface->Stride() * aSize.height, nullptr,
+                    LOCAL_GL_DYNAMIC_DRAW);
+    gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, 0);
+  } else {
+    // Couldn't allocate a PBO, so just use a memory surface instead.
+    mSurface = gfx::Factory::CreateDataSourceSurface(
+        aSize, gfx::SurfaceFormat::B8G8R8A8);
+  }
+}
+
+RenderCompositorOGLSWGL::TileOGL::~TileOGL() {
+  if (mPBO) {
+    auto* gl = mTexture->gl();
+    if (gl && gl->MakeCurrent()) {
+      gl->fDeleteBuffers(1, &mPBO);
+      mPBO = 0;
+    }
+  }
+}
+
+layers::DataTextureSource*
+RenderCompositorOGLSWGL::TileOGL::GetTextureSource() {
+  return mTexture.get();
+}
+
+bool RenderCompositorOGLSWGL::TileOGL::Map(wr::DeviceIntRect aDirtyRect,
+                                           wr::DeviceIntRect aValidRect,
+                                           void** aData, int32_t* aStride) {
+  if (mPBO) {
+    auto* gl = mTexture->gl();
+    if (!gl) {
+      return false;
+    }
+    // Map the PBO, but only within the range of the buffer that spans from the
+    // linear start offset to the linear end offset. Since we don't care about
+    // the previous contents of the buffer, we can just tell OpenGL to
+    // invalidate the entire buffer, even though we're only mapping a sub-range.
+    gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, mPBO);
+    size_t stride = mSurface->Stride();
+    size_t offset =
+        stride * aValidRect.min.y + aValidRect.min.x * sizeof(uint32_t);
+    size_t length = stride * (aValidRect.height() - 1) +
+                    (aValidRect.width()) * sizeof(uint32_t);
+    void* data = gl->fMapBufferRange(
+        LOCAL_GL_PIXEL_UNPACK_BUFFER, offset, length,
+        LOCAL_GL_MAP_WRITE_BIT | LOCAL_GL_MAP_INVALIDATE_BUFFER_BIT);
+    gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, 0);
+    if (!data) {
+      return false;
+    }
+    *aData = data;
+    *aStride = stride;
+  } else {
+    // No PBO is available, so just directly write to the memory surface.
+    gfx::DataSourceSurface::MappedSurface map;
+    if (!mSurface->Map(gfx::DataSourceSurface::READ_WRITE, &map)) {
+      return false;
+    }
+    // Verify that we're not somehow using a PBOUnpackSurface.
+    MOZ_ASSERT(map.mData != nullptr);
+    // glTex(Sub)Image on ES doesn't support arbitrary strides without
+    // the EXT_unpack_subimage extension. To avoid needing to make a
+    // copy of the data we'll always draw it with stride = bpp*width
+    // unless we're uploading the entire texture.
+    if (!mTexture->IsValid()) {
+      // If we don't have a texture we need to position our
+      // data in the correct spot because we're going to upload
+      // the entire surface
+      *aData = map.mData + aValidRect.min.y * map.mStride +
+               aValidRect.min.x * sizeof(uint32_t);
+
+      *aStride = map.mStride;
+      mSubSurface = nullptr;
+    } else {
+      // Otherwise, we can just use the top left as a scratch space
+      *aData = map.mData;
+      *aStride = aDirtyRect.width() * BytesPerPixel(mSurface->GetFormat());
+      mSubSurface = Factory::CreateWrappingDataSourceSurface(
+          (uint8_t*)*aData, *aStride,
+          IntSize(aDirtyRect.width(), aDirtyRect.height()),
+          mSurface->GetFormat());
+    }
+  }
+  return true;
+}
+
+void RenderCompositorOGLSWGL::TileOGL::Unmap(const gfx::IntRect& aDirtyRect) {
+  nsIntRegion dirty(aDirtyRect);
+  if (mPBO) {
+    // If there is a PBO, it must be unmapped before it can be sourced from.
+    // Leave the PBO bound before the call to Update so that the texture uploads
+    // will source from it.
+    auto* gl = mTexture->gl();
+    if (!gl) {
+      return;
+    }
+    gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, mPBO);
+    gl->fUnmapBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER);
+    mTexture->Update(mSurface, &dirty);
+    gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, 0);
+  } else {
+    if (mSubSurface) {
+      mSurface->Unmap();
+      // Our subsurface has a stride = aDirtyRect.width
+      // We use a negative offset to move it to match
+      // the dirty rect's top-left. These two offsets
+      // will cancel each other out by the time we reach
+      // TexSubImage.
+      IntPoint srcOffset = {0, 0};
+      IntPoint dstOffset = aDirtyRect.TopLeft();
+      // adjust the dirty region to be relative to the dstOffset
+      dirty.MoveBy(-dstOffset);
+      mTexture->Update(mSubSurface, &dirty, &srcOffset, &dstOffset);
+      mSubSurface = nullptr;
+    } else {
+      mSurface->Unmap();
+      mTexture->Update(mSurface, &dirty);
+    }
+  }
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderCompositorOGLSWGL.h b/gfx/webrender_bindings/RenderCompositorOGLSWGL.h
new file mode 100644
index 0000000000..7752574311
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorOGLSWGL.h
@@ -0,0 +1,104 @@
+/* -*- 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_RENDERCOMPOSITOR_OGL_SWGL_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_OGL_SWGL_H
+
+#include "mozilla/layers/Compositor.h"
+#include "mozilla/webrender/RenderCompositorLayersSWGL.h"
+
+namespace mozilla {
+
+namespace layers {
+class TextureImageTextureSourceOGL;
+}
+
+namespace wr {
+
+class RenderCompositorOGLSWGL : public RenderCompositorLayersSWGL {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositorOGLSWGL(layers::Compositor* aCompositor,
+                          const RefPtr<widget::CompositorWidget>& aWidget,
+                          void* aContext);
+  virtual ~RenderCompositorOGLSWGL();
+
+  gl::GLContext* GetGLContext();
+
+  bool MakeCurrent() override;
+
+  bool BeginFrame() override;
+  RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) override;
+
+  void GetCompositorCapabilities(CompositorCapabilities* aCaps) override;
+
+  // Returns true for requesting rendering during readback.
+  // RenderCompositorOGLSWGL::MaybeReadback() requests rendering.
+  // This value is not used by WebRender, since native compositor API is used
+  // for sw-wr.
+  bool UsePartialPresent() override { return true; }
+  bool RequestFullRender() override;
+
+  void Pause() override;
+  bool Resume() override;
+  bool IsPaused() override;
+
+  LayoutDeviceIntSize GetBufferSize() override;
+
+  layers::WebRenderCompositor CompositorType() const override {
+    return layers::WebRenderCompositor::OPENGL;
+  }
+
+  bool MaybeReadback(const gfx::IntSize& aReadbackSize,
+                     const wr::ImageFormat& aReadbackFormat,
+                     const Range<uint8_t>& aReadbackBuffer,
+                     bool* aNeedsYFlip) override;
+
+ private:
+  void HandleExternalImage(RenderTextureHost* aExternalImage,
+                           FrameSurface& aFrameSurface) override;
+  UniquePtr<RenderCompositorLayersSWGL::Tile> DoCreateTile(
+      Surface* aSurface) override;
+
+  EGLSurface CreateEGLSurface();
+  void DestroyEGLSurface();
+
+  EGLSurface mEGLSurface = EGL_NO_SURFACE;
+  bool mFullRender = false;
+
+#ifdef MOZ_WIDGET_ANDROID
+  // Whether we are in the process of handling a NEW_SURFACE error. On Android
+  // this is used to allow the widget an opportunity to recover from the first
+  // instance, before raising a WebRenderError on subsequent occurences.
+  bool mHandlingNewSurfaceError = false;
+#endif
+
+  class TileOGL : public RenderCompositorLayersSWGL::Tile {
+   public:
+    TileOGL(RefPtr<layers::TextureImageTextureSourceOGL>&& aTexture,
+            const gfx::IntSize& aSize);
+    virtual ~TileOGL();
+
+    bool Map(wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect,
+             void** aData, int32_t* aStride) override;
+    void Unmap(const gfx::IntRect& aDirtyRect) override;
+    layers::DataTextureSource* GetTextureSource() override;
+    bool IsValid() override { return true; }
+
+   private:
+    RefPtr<layers::TextureImageTextureSourceOGL> mTexture;
+    RefPtr<gfx::DataSourceSurface> mSurface;
+    RefPtr<gfx::DataSourceSurface> mSubSurface;
+    GLuint mPBO = 0;
+  };
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderCompositorRecordedFrame.h b/gfx/webrender_bindings/RenderCompositorRecordedFrame.h
new file mode 100644
index 0000000000..f7a516107b
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorRecordedFrame.h
@@ -0,0 +1,49 @@
+/* -*- 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_RENDERCOMPOSITOR_RECORDEDFRAME_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_RECORDEDFRAME_H
+
+#include "mozilla/layers/CompositionRecorder.h"
+
+namespace mozilla {
+
+namespace wr {
+
+class RenderCompositorRecordedFrame final : public layers::RecordedFrame {
+ public:
+  RenderCompositorRecordedFrame(
+      const TimeStamp& aTimeStamp,
+      RefPtr<layers::profiler_screenshots::AsyncReadbackBuffer>&& aBuffer)
+      : RecordedFrame(aTimeStamp), mBuffer(aBuffer) {}
+
+  virtual already_AddRefed<gfx::DataSourceSurface> GetSourceSurface() override {
+    if (mSurface) {
+      return do_AddRef(mSurface);
+    }
+
+    gfx::IntSize size = mBuffer->Size();
+    mSurface = gfx::Factory::CreateDataSourceSurface(
+        size, gfx::SurfaceFormat::B8G8R8A8,
+        /* aZero = */ false);
+
+    if (!mBuffer->MapAndCopyInto(mSurface, size)) {
+      mSurface = nullptr;
+      return nullptr;
+    }
+
+    return do_AddRef(mSurface);
+  }
+
+ private:
+  RefPtr<layers::profiler_screenshots::AsyncReadbackBuffer> mBuffer;
+  RefPtr<gfx::DataSourceSurface> mSurface;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderCompositorSWGL.cpp b/gfx/webrender_bindings/RenderCompositorSWGL.cpp
new file mode 100644
index 0000000000..d767ff83f7
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorSWGL.cpp
@@ -0,0 +1,315 @@
+/* -*- 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 "RenderCompositorSWGL.h"
+
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/widget/CompositorWidget.h"
+
+#ifdef MOZ_WIDGET_GTK
+#  include "mozilla/WidgetUtilsGtk.h"
+#endif
+
+namespace mozilla {
+using namespace gfx;
+
+namespace wr {
+
+extern LazyLogModule gRenderThreadLog;
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+/* static */
+UniquePtr<RenderCompositor> RenderCompositorSWGL::Create(
+    const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
+  void* ctx = wr_swgl_create_context();
+  if (!ctx) {
+    gfxCriticalNote << "Failed SWGL context creation for WebRender";
+    return nullptr;
+  }
+  return MakeUnique<RenderCompositorSWGL>(aWidget, ctx);
+}
+
+RenderCompositorSWGL::RenderCompositorSWGL(
+    const RefPtr<widget::CompositorWidget>& aWidget, void* aContext)
+    : RenderCompositor(aWidget), mContext(aContext) {
+  MOZ_ASSERT(mContext);
+  LOG("RenderCompositorSWGL::RenderCompositorSWGL()");
+}
+
+RenderCompositorSWGL::~RenderCompositorSWGL() {
+  LOG("RenderCompositorSWGL::~RenderCompositorSWGL()");
+
+  wr_swgl_destroy_context(mContext);
+}
+
+void RenderCompositorSWGL::ClearMappedBuffer() {
+  mMappedData = nullptr;
+  mMappedStride = 0;
+  mDT = nullptr;
+}
+
+bool RenderCompositorSWGL::MakeCurrent() {
+  wr_swgl_make_current(mContext);
+  return true;
+}
+
+bool RenderCompositorSWGL::BeginFrame() {
+  mRenderWidgetSize = Some(mWidget->GetClientSize());
+#ifdef MOZ_WIDGET_GTK
+  if (mLastRenderWidgetSize != mRenderWidgetSize.value()) {
+    mLastRenderWidgetSize = mRenderWidgetSize.value();
+    mRequestFullRender = true;
+  }
+#endif
+  // Set up a temporary region representing the entire window surface in case a
+  // dirty region is not supplied.
+  ClearMappedBuffer();
+  mDirtyRegion = LayoutDeviceIntRect(LayoutDeviceIntPoint(), GetBufferSize());
+  wr_swgl_make_current(mContext);
+  return true;
+}
+
+bool RenderCompositorSWGL::AllocateMappedBuffer(
+    const wr::DeviceIntRect* aOpaqueRects, size_t aNumOpaqueRects) {
+  // Request a new draw target to use from the widget...
+  MOZ_ASSERT(!mDT);
+  layers::BufferMode bufferMode = layers::BufferMode::BUFFERED;
+  mDT = mWidget->StartRemoteDrawingInRegion(mDirtyRegion, &bufferMode);
+  if (!mDT) {
+    gfxCriticalNoteOnce
+        << "RenderCompositorSWGL failed mapping default framebuffer, no dt";
+    return false;
+  }
+  // Attempt to lock the underlying buffer directly from the draw target.
+  // Verify that the size at least matches what the widget claims and that
+  // the format is BGRA8 as SWGL requires.
+  uint8_t* data = nullptr;
+  gfx::IntSize size;
+  int32_t stride = 0;
+  gfx::SurfaceFormat format = gfx::SurfaceFormat::UNKNOWN;
+  if (bufferMode != layers::BufferMode::BUFFERED && !mSurface &&
+      mDT->LockBits(&data, &size, &stride, &format) &&
+      (format != gfx::SurfaceFormat::B8G8R8A8 &&
+       format != gfx::SurfaceFormat::B8G8R8X8)) {
+    // We tried to lock the DT and it succeeded, but the size or format
+    // of the data is not compatible, so just release it and fall back below...
+    mDT->ReleaseBits(data);
+    data = nullptr;
+  }
+  LayoutDeviceIntRect bounds = mDirtyRegion.GetBounds();
+  // If locking succeeded above, just use that.
+  if (data) {
+    mMappedData = data;
+    mMappedStride = stride;
+    // Disambiguate whether the widget's draw target has its origin at zero or
+    // if it is offset to the dirty region origin. The DT might either enclose
+    // only the region itself, the region including the origin, or the entire
+    // widget. Thus, if the DT doesn't only enclose the region, we assume it
+    // contains the origin.
+    if (size != bounds.Size().ToUnknownSize()) {
+      // Update the bounds to include zero if the origin is at zero.
+      bounds.ExpandToEnclose(LayoutDeviceIntPoint(0, 0));
+    }
+    // Sometimes we end up racing on the widget size, and it can shrink between
+    // BeginFrame and StartCompositing. We calculated our dirty region based on
+    // the previous widget size, so we need to clamp the bounds here to ensure
+    // we remain within the buffer.
+    bounds.IntersectRect(
+        bounds,
+        LayoutDeviceIntRect(bounds.TopLeft(),
+                            LayoutDeviceIntSize(size.width, size.height)));
+  } else {
+    // If we couldn't lock the DT above, then allocate a data surface and map
+    // that for usage with SWGL.
+    size = bounds.Size().ToUnknownSize();
+    if (!mSurface || mSurface->GetSize() != size) {
+      mSurface = gfx::Factory::CreateDataSourceSurface(
+          size, gfx::SurfaceFormat::B8G8R8A8);
+    }
+    gfx::DataSourceSurface::MappedSurface map = {nullptr, 0};
+    if (!mSurface || !mSurface->Map(gfx::DataSourceSurface::READ_WRITE, &map)) {
+      // We failed mapping the data surface, so need to cancel the frame.
+      mWidget->EndRemoteDrawingInRegion(mDT, mDirtyRegion);
+      ClearMappedBuffer();
+      gfxCriticalNoteOnce
+          << "RenderCompositorSWGL failed mapping default framebuffer, no surf";
+      return false;
+    }
+    mMappedData = map.mData;
+    mMappedStride = map.mStride;
+  }
+  MOZ_ASSERT(mMappedData != nullptr && mMappedStride > 0);
+  wr_swgl_init_default_framebuffer(mContext, bounds.x, bounds.y, bounds.width,
+                                   bounds.height, mMappedStride, mMappedData);
+
+  LayoutDeviceIntRegion opaque;
+  for (size_t i = 0; i < aNumOpaqueRects; i++) {
+    const auto& rect = aOpaqueRects[i];
+    opaque.OrWith(LayoutDeviceIntRect(rect.min.x, rect.min.y, rect.width(),
+                                      rect.height()));
+  }
+
+  LayoutDeviceIntRegion clear = mWidget->GetTransparentRegion();
+  clear.AndWith(mDirtyRegion);
+  clear.SubOut(opaque);
+  for (auto iter = clear.RectIter(); !iter.Done(); iter.Next()) {
+    const auto& rect = iter.Get();
+    wr_swgl_clear_color_rect(mContext, 0, rect.x, rect.y, rect.width,
+                             rect.height, 0, 0, 0, 0);
+  }
+
+  return true;
+}
+
+void RenderCompositorSWGL::StartCompositing(
+    wr::ColorF aClearColor, const wr::DeviceIntRect* aDirtyRects,
+    size_t aNumDirtyRects, const wr::DeviceIntRect* aOpaqueRects,
+    size_t aNumOpaqueRects) {
+  if (mDT) {
+    // Cancel any existing buffers that might accidentally be left from updates
+    CommitMappedBuffer(false);
+    // Reset the region to the widget bounds
+    mDirtyRegion = LayoutDeviceIntRect(LayoutDeviceIntPoint(), GetBufferSize());
+  }
+  if (aNumDirtyRects) {
+    // Install the dirty rects into the bounds of the existing region
+    auto bounds = mDirtyRegion.GetBounds();
+    mDirtyRegion.SetEmpty();
+    for (size_t i = 0; i < aNumDirtyRects; i++) {
+      const auto& rect = aDirtyRects[i];
+      mDirtyRegion.OrWith(LayoutDeviceIntRect(rect.min.x, rect.min.y,
+                                              rect.width(), rect.height()));
+    }
+    // Ensure the region lies within the widget bounds
+    mDirtyRegion.AndWith(bounds);
+  }
+  // Now that the dirty rects have been supplied and the composition region
+  // is known, allocate and install a framebuffer encompassing the composition
+  // region.
+  if (mDirtyRegion.IsEmpty() ||
+      !AllocateMappedBuffer(aOpaqueRects, aNumOpaqueRects)) {
+    // If allocation of the mapped default framebuffer failed, then just install
+    // a temporary framebuffer (with a minimum size of 2x2) so compositing can
+    // still proceed.
+    auto bounds = mDirtyRegion.GetBounds();
+    bounds.width = std::max(bounds.width, 2);
+    bounds.height = std::max(bounds.height, 2);
+    wr_swgl_init_default_framebuffer(mContext, bounds.x, bounds.y, bounds.width,
+                                     bounds.height, 0, nullptr);
+  }
+}
+
+void RenderCompositorSWGL::CommitMappedBuffer(bool aDirty) {
+  if (!mDT) {
+    mDirtyRegion.SetEmpty();
+    return;
+  }
+  // Force any delayed clears to resolve.
+  if (aDirty) {
+    wr_swgl_resolve_framebuffer(mContext, 0);
+  }
+  // Clear out the old framebuffer in case something tries to access it after
+  // the frame.
+  wr_swgl_init_default_framebuffer(mContext, 0, 0, 0, 0, 0, nullptr);
+  // If we have a draw target at this point, mapping must have succeeded.
+  MOZ_ASSERT(mMappedData != nullptr);
+  if (mSurface) {
+    // If we're using a data surface, unmap it and draw it to the DT if there
+    // are any supplied dirty rects.
+    mSurface->Unmap();
+    if (aDirty) {
+      // The temporary source surface is always a partial region of the widget
+      // that is offset from the origin to the actual bounds of the dirty
+      // region. The destination DT may also be an offset partial region, but we
+      // must check to see if its size matches the region bounds to verify this.
+      LayoutDeviceIntRect bounds = mDirtyRegion.GetBounds();
+      gfx::IntPoint srcOffset = bounds.TopLeft().ToUnknownPoint();
+      gfx::IntPoint dstOffset = mDT->GetSize() == bounds.Size().ToUnknownSize()
+                                    ? srcOffset
+                                    : gfx::IntPoint(0, 0);
+      for (auto iter = mDirtyRegion.RectIter(); !iter.Done(); iter.Next()) {
+        gfx::IntRect dirtyRect = iter.Get().ToUnknownRect();
+        mDT->CopySurface(mSurface, dirtyRect - srcOffset,
+                         dirtyRect.TopLeft() - dstOffset);
+      }
+    }
+  } else {
+    // Otherwise, we had locked the DT directly. Just release the data.
+    mDT->ReleaseBits(mMappedData);
+  }
+  mDT->Flush();
+
+  // Done with the DT. Hand it back to the widget and clear out any trace of it.
+  mWidget->EndRemoteDrawingInRegion(mDT, mDirtyRegion);
+  mDirtyRegion.SetEmpty();
+  ClearMappedBuffer();
+}
+
+void RenderCompositorSWGL::CancelFrame() {
+  CommitMappedBuffer(false);
+  mRenderWidgetSize = Nothing();
+}
+
+RenderedFrameId RenderCompositorSWGL::EndFrame(
+    const nsTArray<DeviceIntRect>& aDirtyRects) {
+  // Dirty rects have already been set inside StartCompositing. We need to keep
+  // those dirty rects exactly the same here so we supply the same exact region
+  // to EndRemoteDrawingInRegion as for StartRemoteDrawingInRegion.
+  RenderedFrameId frameId = GetNextRenderFrameId();
+  CommitMappedBuffer();
+  mRenderWidgetSize = Nothing();
+  return frameId;
+}
+
+bool RenderCompositorSWGL::RequestFullRender() {
+#ifdef MOZ_WIDGET_ANDROID
+  // XXX Add partial present support.
+  return true;
+#endif
+#ifdef MOZ_WIDGET_GTK
+  // We're requested to do full render after Resume() on Wayland.
+  if (mRequestFullRender) {
+    mRequestFullRender = false;
+    return true;
+  }
+#endif
+  return false;
+}
+
+void RenderCompositorSWGL::Pause() {}
+
+bool RenderCompositorSWGL::Resume() {
+#ifdef MOZ_WIDGET_GTK
+  mRequestFullRender = true;
+#endif
+  return true;
+}
+
+LayoutDeviceIntSize RenderCompositorSWGL::GetBufferSize() {
+  // If we're between BeginFrame() and EndFrame()/CancelFrame() calls
+  // return recent rendering size instead of actual underlying widget
+  // size. It prevents possible rendering artifacts if widget size was changed.
+  return mRenderWidgetSize ? mRenderWidgetSize.value()
+                           : mWidget->GetClientSize();
+}
+
+void RenderCompositorSWGL::GetCompositorCapabilities(
+    CompositorCapabilities* aCaps) {
+  // Always support a single update rect for SwCompositor
+  aCaps->max_update_rects = 1;
+
+  // On uncomposited desktops such as X11 without compositor or Window 7 with
+  // Aero disabled we need to force a full redraw when the window contents may
+  // be damaged.
+#ifdef MOZ_WIDGET_GTK
+  aCaps->redraw_on_invalidation = widget::GdkIsX11Display();
+#else
+  aCaps->redraw_on_invalidation = true;
+#endif
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderCompositorSWGL.h b/gfx/webrender_bindings/RenderCompositorSWGL.h
new file mode 100644
index 0000000000..ad1db8faaf
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorSWGL.h
@@ -0,0 +1,90 @@
+/* -*- 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_RENDERCOMPOSITOR_SWGL_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_SWGL_H
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/webrender/RenderCompositor.h"
+
+namespace mozilla {
+
+namespace wr {
+
+class RenderCompositorSWGL : public RenderCompositor {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositorSWGL(const RefPtr<widget::CompositorWidget>& aWidget,
+                       void* aContext);
+  virtual ~RenderCompositorSWGL();
+
+  void* swgl() const override { return mContext; }
+
+  bool MakeCurrent() override;
+
+  bool BeginFrame() override;
+  void CancelFrame() override;
+  RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) final;
+
+  void StartCompositing(wr::ColorF aClearColor,
+                        const wr::DeviceIntRect* aDirtyRects,
+                        size_t aNumDirtyRects,
+                        const wr::DeviceIntRect* aOpaqueRects,
+                        size_t aNumOpaqueRects) override;
+
+  bool UsePartialPresent() override { return true; }
+  bool RequestFullRender() override;
+
+  void Pause() override;
+  bool Resume() override;
+
+  layers::WebRenderBackend BackendType() const override {
+    return layers::WebRenderBackend::SOFTWARE;
+  }
+  layers::WebRenderCompositor CompositorType() const override {
+    return layers::WebRenderCompositor::SOFTWARE;
+  }
+
+  bool SurfaceOriginIsTopLeft() override { return true; }
+
+  LayoutDeviceIntSize GetBufferSize() override;
+
+  bool SupportsExternalBufferTextures() const override { return true; }
+
+  // Interface for wr::Compositor
+  void GetCompositorCapabilities(CompositorCapabilities* aCaps) override;
+
+ private:
+  void* mContext = nullptr;
+  RefPtr<gfx::DrawTarget> mDT;
+  LayoutDeviceIntRegion mDirtyRegion;
+  // Keep consistent buffer size between BeginFrame and EndFrame/CancelFrame
+  // calls to make sure we don't change buffer size during rendering.
+  Maybe<LayoutDeviceIntSize> mRenderWidgetSize;
+  RefPtr<gfx::DataSourceSurface> mSurface;
+  uint8_t* mMappedData = nullptr;
+  int32_t mMappedStride = 0;
+#ifdef MOZ_WIDGET_GTK
+  // On Wayland we need to request full render if widget size is changed
+  // because SW rendering backend reallocates and clears target surface.
+  LayoutDeviceIntSize mLastRenderWidgetSize;
+  bool mRequestFullRender = false;
+#endif
+
+  void ClearMappedBuffer();
+
+  bool AllocateMappedBuffer(const wr::DeviceIntRect* aOpaqueRects,
+                            size_t aNumOpaqueRects);
+
+  void CommitMappedBuffer(bool aDirty = true);
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RenderD3D11TextureHost.cpp b/gfx/webrender_bindings/RenderD3D11TextureHost.cpp
new file mode 100644
index 0000000000..451d0d9072
--- /dev/null
+++ b/gfx/webrender_bindings/RenderD3D11TextureHost.cpp
@@ -0,0 +1,775 @@
+/* -*- 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 "RenderD3D11TextureHost.h"
+
+#include "GLContextEGL.h"
+#include "GLLibraryEGL.h"
+#include "RenderThread.h"
+#include "RenderCompositor.h"
+#include "RenderCompositorD3D11SWGL.h"
+#include "ScopedGLHelpers.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/gfx/CanvasManagerParent.h"
+#include "mozilla/gfx/DeviceManagerDx.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/FenceD3D11.h"
+#include "mozilla/layers/GpuProcessD3D11QueryMap.h"
+#include "mozilla/layers/GpuProcessD3D11TextureMap.h"
+#include "mozilla/layers/TextureD3D11.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderDXGITextureHost::RenderDXGITextureHost(
+    RefPtr<gfx::FileHandleWrapper> aHandle,
+    Maybe<layers::GpuProcessTextureId>& aGpuProcessTextureId,
+    uint32_t aArrayIndex, gfx::SurfaceFormat aFormat,
+    gfx::ColorSpace2 aColorSpace, gfx::ColorRange aColorRange,
+    gfx::IntSize aSize, bool aHasKeyedMutex, gfx::FenceInfo& aAcquireFenceInfo,
+    Maybe<layers::GpuProcessQueryId>& aGpuProcessQueryId)
+    : mHandle(aHandle),
+      mGpuProcessTextureId(aGpuProcessTextureId),
+      mGpuProcessQueryId(aGpuProcessQueryId),
+      mArrayIndex(aArrayIndex),
+      mSurface(0),
+      mStream(0),
+      mTextureHandle{0},
+      mFormat(aFormat),
+      mColorSpace(aColorSpace),
+      mColorRange(aColorRange),
+      mSize(aSize),
+      mHasKeyedMutex(aHasKeyedMutex),
+      mAcquireFenceInfo(aAcquireFenceInfo),
+      mLocked(false) {
+  MOZ_COUNT_CTOR_INHERITED(RenderDXGITextureHost, RenderTextureHost);
+  MOZ_ASSERT((mFormat != gfx::SurfaceFormat::NV12 &&
+              mFormat != gfx::SurfaceFormat::P010 &&
+              mFormat != gfx::SurfaceFormat::P016) ||
+             (mSize.width % 2 == 0 && mSize.height % 2 == 0));
+  MOZ_ASSERT((aHandle && aGpuProcessTextureId.isNothing()) ||
+             (!aHandle && aGpuProcessTextureId.isSome()));
+}
+
+RenderDXGITextureHost::~RenderDXGITextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderDXGITextureHost, RenderTextureHost);
+  DeleteTextureHandle();
+}
+
+RefPtr<ID3D11Query> RenderDXGITextureHost::GetQuery() {
+  if (mGpuProcessQueryId.isNothing()) {
+    return nullptr;
+  }
+
+  auto* queryMap = layers::GpuProcessD3D11QueryMap::Get();
+  if (!queryMap) {
+    return nullptr;
+  }
+
+  auto query = queryMap->GetQuery(mGpuProcessQueryId.ref());
+  if (!query) {
+    gfxCriticalNoteOnce << "Failed to get ID3D11Query";
+  }
+
+  return query;
+}
+
+ID3D11Texture2D* RenderDXGITextureHost::GetD3D11Texture2DWithGL() {
+  if (mTexture) {
+    return mTexture;
+  }
+
+  if (!mGL) {
+    // SingletonGL is always used on Windows with ANGLE.
+    mGL = RenderThread::Get()->SingletonGL();
+  }
+
+  if (!EnsureD3D11Texture2DWithGL()) {
+    return nullptr;
+  }
+
+  return mTexture;
+}
+
+size_t RenderDXGITextureHost::GetPlaneCount() const {
+  if (mFormat == gfx::SurfaceFormat::NV12 ||
+      mFormat == gfx::SurfaceFormat::P010 ||
+      mFormat == gfx::SurfaceFormat::P016) {
+    return 2;
+  }
+  return 1;
+}
+
+template <typename T>
+static bool MapTexture(T* aHost, RenderCompositor* aCompositor,
+                       RefPtr<ID3D11Texture2D>& aTexture,
+                       RefPtr<ID3D11DeviceContext>& aDeviceContext,
+                       RefPtr<ID3D11Texture2D>& aCpuTexture,
+                       D3D11_MAPPED_SUBRESOURCE& aMappedSubresource) {
+  if (!aCompositor) {
+    return false;
+  }
+
+  RenderCompositorD3D11SWGL* compositor =
+      aCompositor->AsRenderCompositorD3D11SWGL();
+  if (!compositor) {
+    return false;
+  }
+
+  if (!aHost->EnsureD3D11Texture2D(compositor->GetDevice())) {
+    return false;
+  }
+
+  if (!aHost->LockInternal()) {
+    return false;
+  }
+
+  D3D11_TEXTURE2D_DESC textureDesc = {0};
+  aTexture->GetDesc(&textureDesc);
+
+  compositor->GetDevice()->GetImmediateContext(getter_AddRefs(aDeviceContext));
+
+  textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+  textureDesc.Usage = D3D11_USAGE_STAGING;
+  textureDesc.BindFlags = 0;
+  textureDesc.MiscFlags = 0;
+  textureDesc.MipLevels = 1;
+  HRESULT hr = compositor->GetDevice()->CreateTexture2D(
+      &textureDesc, nullptr, getter_AddRefs(aCpuTexture));
+  if (FAILED(hr)) {
+    return false;
+  }
+
+  aDeviceContext->CopyResource(aCpuTexture, aTexture);
+  aHost->Unlock();
+
+  hr = aDeviceContext->Map(aCpuTexture, 0, D3D11_MAP_READ, 0,
+                           &aMappedSubresource);
+  return SUCCEEDED(hr);
+}
+
+bool RenderDXGITextureHost::MapPlane(RenderCompositor* aCompositor,
+                                     uint8_t aChannelIndex,
+                                     PlaneInfo& aPlaneInfo) {
+  // TODO: We currently readback from the GPU texture into a new
+  // staging texture every time this is mapped. We might be better
+  // off retaining the mapped memory to trade performance for memory
+  // usage.
+  if (!mCpuTexture && !MapTexture(this, aCompositor, mTexture, mDeviceContext,
+                                  mCpuTexture, mMappedSubresource)) {
+    return false;
+  }
+
+  aPlaneInfo.mSize = GetSize(aChannelIndex);
+  aPlaneInfo.mStride = mMappedSubresource.RowPitch;
+  aPlaneInfo.mData = mMappedSubresource.pData;
+
+  // If this is the second plane, then offset the data pointer by the
+  // size of the first plane.
+  if (aChannelIndex == 1) {
+    aPlaneInfo.mData =
+        (uint8_t*)aPlaneInfo.mData + aPlaneInfo.mStride * GetSize(0).height;
+  }
+  return true;
+}
+
+void RenderDXGITextureHost::UnmapPlanes() {
+  mMappedSubresource.pData = nullptr;
+  if (mCpuTexture) {
+    mDeviceContext->Unmap(mCpuTexture, 0);
+    mCpuTexture = nullptr;
+  }
+  mDeviceContext = nullptr;
+}
+
+bool RenderDXGITextureHost::EnsureD3D11Texture2DWithGL() {
+  if (mTexture) {
+    return true;
+  }
+
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+
+  // Fetch the D3D11 device.
+  EGLDeviceEXT eglDevice = nullptr;
+  egl->fQueryDisplayAttribEXT(LOCAL_EGL_DEVICE_EXT, (EGLAttrib*)&eglDevice);
+  MOZ_ASSERT(eglDevice);
+  ID3D11Device* device = nullptr;
+  egl->mLib->fQueryDeviceAttribEXT(eglDevice, LOCAL_EGL_D3D11_DEVICE_ANGLE,
+                                   (EGLAttrib*)&device);
+  // There's a chance this might fail if we end up on d3d9 angle for some
+  // reason.
+  if (!device) {
+    gfxCriticalNote << "RenderDXGITextureHost device is not available";
+    return false;
+  }
+
+  return EnsureD3D11Texture2D(device);
+}
+
+bool RenderDXGITextureHost::EnsureD3D11Texture2D(ID3D11Device* aDevice) {
+  if (mTexture) {
+    RefPtr<ID3D11Device> device;
+    mTexture->GetDevice(getter_AddRefs(device));
+    if (aDevice != device) {
+      gfxCriticalNote << "RenderDXGITextureHost uses obsoleted device";
+      return false;
+    }
+    return true;
+  }
+
+  if (mGpuProcessTextureId.isSome()) {
+    auto* textureMap = layers::GpuProcessD3D11TextureMap::Get();
+    if (textureMap) {
+      RefPtr<ID3D11Texture2D> texture;
+      textureMap->WaitTextureReady(mGpuProcessTextureId.ref());
+      mTexture = textureMap->GetTexture(mGpuProcessTextureId.ref());
+      if (mTexture) {
+        return true;
+      } else {
+        gfxCriticalNote << "GpuProcessTextureId is not valid";
+      }
+    }
+    return false;
+  }
+
+  RefPtr<ID3D11Device1> device1;
+  aDevice->QueryInterface((ID3D11Device1**)getter_AddRefs(device1));
+  if (!device1) {
+    gfxCriticalNoteOnce << "Failed to get ID3D11Device1";
+    return 0;
+  }
+
+  // Get the D3D11 texture from shared handle.
+  HRESULT hr = device1->OpenSharedResource1(
+      (HANDLE)mHandle->GetHandle(), __uuidof(ID3D11Texture2D),
+      (void**)(ID3D11Texture2D**)getter_AddRefs(mTexture));
+  if (FAILED(hr)) {
+    MOZ_ASSERT(false,
+               "RenderDXGITextureHost::EnsureLockable(): Failed to open shared "
+               "texture");
+    gfxCriticalNote
+        << "RenderDXGITextureHost Failed to open shared texture, hr="
+        << gfx::hexa(hr);
+    return false;
+  }
+  MOZ_ASSERT(mTexture.get());
+  mTexture->QueryInterface((IDXGIKeyedMutex**)getter_AddRefs(mKeyedMutex));
+
+  MOZ_ASSERT(mHasKeyedMutex == !!mKeyedMutex);
+  if (mHasKeyedMutex != !!mKeyedMutex) {
+    gfxCriticalNoteOnce << "KeyedMutex mismatch";
+  }
+  return true;
+}
+
+bool RenderDXGITextureHost::EnsureLockable() {
+  if (mTextureHandle[0]) {
+    return true;
+  }
+
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+
+  // We use EGLStream to get the converted gl handle from d3d texture. The
+  // NV_stream_consumer_gltexture_yuv and ANGLE_stream_producer_d3d_texture
+  // could support nv12 and rgb d3d texture format.
+  if (!egl->IsExtensionSupported(
+          gl::EGLExtension::NV_stream_consumer_gltexture_yuv) ||
+      !egl->IsExtensionSupported(
+          gl::EGLExtension::ANGLE_stream_producer_d3d_texture)) {
+    gfxCriticalNote << "RenderDXGITextureHost egl extensions are not suppored";
+    return false;
+  }
+
+  // Get the D3D11 texture from shared handle.
+  if (!EnsureD3D11Texture2DWithGL()) {
+    return false;
+  }
+
+  // Create the EGLStream.
+  mStream = egl->fCreateStreamKHR(nullptr);
+  MOZ_ASSERT(mStream);
+
+  bool ok = true;
+  if (mFormat != gfx::SurfaceFormat::NV12 &&
+      mFormat != gfx::SurfaceFormat::P010 &&
+      mFormat != gfx::SurfaceFormat::P016) {
+    // The non-nv12 format.
+
+    mGL->fGenTextures(1, mTextureHandle);
+    ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0,
+                                 LOCAL_GL_TEXTURE_EXTERNAL_OES,
+                                 mTextureHandle[0]);
+    ok &=
+        bool(egl->fStreamConsumerGLTextureExternalAttribsNV(mStream, nullptr));
+    ok &= bool(egl->fCreateStreamProducerD3DTextureANGLE(mStream, nullptr));
+  } else {
+    // The nv12/p016 format.
+
+    // Setup the NV12 stream consumer/producer.
+    EGLAttrib consumerAttributes[] = {
+        LOCAL_EGL_COLOR_BUFFER_TYPE,
+        LOCAL_EGL_YUV_BUFFER_EXT,
+        LOCAL_EGL_YUV_NUMBER_OF_PLANES_EXT,
+        2,
+        LOCAL_EGL_YUV_PLANE0_TEXTURE_UNIT_NV,
+        0,
+        LOCAL_EGL_YUV_PLANE1_TEXTURE_UNIT_NV,
+        1,
+        LOCAL_EGL_NONE,
+    };
+    mGL->fGenTextures(2, mTextureHandle);
+    ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0,
+                                 LOCAL_GL_TEXTURE_EXTERNAL_OES,
+                                 mTextureHandle[0]);
+    ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE1,
+                                 LOCAL_GL_TEXTURE_EXTERNAL_OES,
+                                 mTextureHandle[1]);
+    ok &= bool(egl->fStreamConsumerGLTextureExternalAttribsNV(
+        mStream, consumerAttributes));
+    ok &= bool(egl->fCreateStreamProducerD3DTextureANGLE(mStream, nullptr));
+  }
+
+  const EGLAttrib frameAttributes[] = {
+      LOCAL_EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE,
+      static_cast<EGLAttrib>(mArrayIndex),
+      LOCAL_EGL_NONE,
+  };
+
+  // Insert the d3d texture.
+  ok &= bool(egl->fStreamPostD3DTextureANGLE(mStream, (void*)mTexture.get(),
+                                             frameAttributes));
+
+  if (!ok) {
+    gfxCriticalNote << "RenderDXGITextureHost init stream failed";
+    DeleteTextureHandle();
+    return false;
+  }
+
+  // Now, we could get the gl handle from the stream.
+  MOZ_ALWAYS_TRUE(egl->fStreamConsumerAcquireKHR(mStream));
+
+  return true;
+}
+
+wr::WrExternalImage RenderDXGITextureHost::Lock(uint8_t aChannelIndex,
+                                                gl::GLContext* aGL) {
+  if (mGL.get() != aGL) {
+    // Release the texture handle in the previous gl context.
+    DeleteTextureHandle();
+    mGL = aGL;
+  }
+
+  if (!mGL) {
+    // XXX Software WebRender is not handled yet.
+    // Software WebRender does not provide GLContext
+    gfxCriticalNoteOnce
+        << "Software WebRender is not suppored by RenderDXGITextureHost.";
+    return InvalidToWrExternalImage();
+  }
+
+  if (!EnsureLockable()) {
+    return InvalidToWrExternalImage();
+  }
+
+  if (!LockInternal()) {
+    return InvalidToWrExternalImage();
+  }
+
+  const auto uvs = GetUvCoords(GetSize(aChannelIndex));
+  return NativeTextureToWrExternalImage(GetGLHandle(aChannelIndex), uvs.first.x,
+                                        uvs.first.y, uvs.second.x,
+                                        uvs.second.y);
+}
+
+bool RenderDXGITextureHost::LockInternal() {
+  if (!mLocked) {
+    if (mAcquireFenceInfo.mFenceHandle) {
+      if (!mAcquireFence) {
+        mAcquireFence = layers::FenceD3D11::CreateFromHandle(
+            mAcquireFenceInfo.mFenceHandle);
+      }
+      if (mAcquireFence) {
+        MOZ_ASSERT(mAcquireFenceInfo.mFenceHandle == mAcquireFence->mHandle);
+
+        mAcquireFence->Update(mAcquireFenceInfo.mFenceValue);
+        RefPtr<ID3D11Device> d3d11Device =
+            gfx::DeviceManagerDx::Get()->GetCompositorDevice();
+        mAcquireFence->Wait(d3d11Device);
+      }
+    }
+    if (mKeyedMutex) {
+      HRESULT hr = mKeyedMutex->AcquireSync(0, 10000);
+      if (hr != S_OK) {
+        gfxCriticalError() << "RenderDXGITextureHost AcquireSync timeout, hr="
+                           << gfx::hexa(hr);
+        return false;
+      }
+    }
+    mLocked = true;
+  }
+  return true;
+}
+
+void RenderDXGITextureHost::Unlock() {
+  if (mLocked) {
+    if (mKeyedMutex) {
+      mKeyedMutex->ReleaseSync(0);
+    }
+    mLocked = false;
+  }
+}
+
+void RenderDXGITextureHost::ClearCachedResources() {
+  DeleteTextureHandle();
+  mGL = nullptr;
+}
+
+void RenderDXGITextureHost::DeleteTextureHandle() {
+  if (mTextureHandle[0] == 0) {
+    return;
+  }
+
+  MOZ_ASSERT(mGL.get());
+  if (!mGL) {
+    return;
+  }
+
+  if (mGL->MakeCurrent()) {
+    mGL->fDeleteTextures(2, mTextureHandle);
+
+    const auto& gle = gl::GLContextEGL::Cast(mGL);
+    const auto& egl = gle->mEgl;
+    if (mSurface) {
+      egl->fDestroySurface(mSurface);
+    }
+    if (mStream) {
+      egl->fDestroyStreamKHR(mStream);
+    }
+  }
+
+  for (int i = 0; i < 2; ++i) {
+    mTextureHandle[i] = 0;
+  }
+
+  mTexture = nullptr;
+  mKeyedMutex = nullptr;
+  mSurface = 0;
+  mStream = 0;
+}
+
+GLuint RenderDXGITextureHost::GetGLHandle(uint8_t aChannelIndex) const {
+  MOZ_ASSERT(((mFormat == gfx::SurfaceFormat::NV12 ||
+               mFormat == gfx::SurfaceFormat::P010 ||
+               mFormat == gfx::SurfaceFormat::P016) &&
+              aChannelIndex < 2) ||
+             aChannelIndex < 1);
+  return mTextureHandle[aChannelIndex];
+}
+
+gfx::IntSize RenderDXGITextureHost::GetSize(uint8_t aChannelIndex) const {
+  MOZ_ASSERT(((mFormat == gfx::SurfaceFormat::NV12 ||
+               mFormat == gfx::SurfaceFormat::P010 ||
+               mFormat == gfx::SurfaceFormat::P016) &&
+              aChannelIndex < 2) ||
+             aChannelIndex < 1);
+
+  if (aChannelIndex == 0) {
+    return mSize;
+  } else {
+    // The CbCr channel size is a half of Y channel size in NV12 format.
+    return mSize / 2;
+  }
+}
+
+bool RenderDXGITextureHost::SyncObjectNeeded() {
+  return mGpuProcessTextureId.isNothing() && !mHasKeyedMutex &&
+         !mAcquireFenceInfo.mFenceHandle;
+}
+
+RenderDXGIYCbCrTextureHost::RenderDXGIYCbCrTextureHost(
+    RefPtr<gfx::FileHandleWrapper> (&aHandles)[3],
+    gfx::YUVColorSpace aYUVColorSpace, gfx::ColorDepth aColorDepth,
+    gfx::ColorRange aColorRange, gfx::IntSize aSizeY, gfx::IntSize aSizeCbCr)
+    : mHandles{aHandles[0], aHandles[1], aHandles[2]},
+      mSurfaces{0},
+      mStreams{0},
+      mTextureHandles{0},
+      mYUVColorSpace(aYUVColorSpace),
+      mColorDepth(aColorDepth),
+      mColorRange(aColorRange),
+      mSizeY(aSizeY),
+      mSizeCbCr(aSizeCbCr),
+      mLocked(false) {
+  MOZ_COUNT_CTOR_INHERITED(RenderDXGIYCbCrTextureHost, RenderTextureHost);
+  // Assume the chroma planes are rounded up if the luma plane is odd sized.
+  MOZ_ASSERT((mSizeCbCr.width == mSizeY.width ||
+              mSizeCbCr.width == (mSizeY.width + 1) >> 1) &&
+             (mSizeCbCr.height == mSizeY.height ||
+              mSizeCbCr.height == (mSizeY.height + 1) >> 1));
+  MOZ_ASSERT(aHandles[0] && aHandles[1] && aHandles[2]);
+}
+
+bool RenderDXGIYCbCrTextureHost::MapPlane(RenderCompositor* aCompositor,
+                                          uint8_t aChannelIndex,
+                                          PlaneInfo& aPlaneInfo) {
+  D3D11_MAPPED_SUBRESOURCE mappedSubresource;
+  if (!MapTexture(this, aCompositor, mTextures[aChannelIndex], mDeviceContext,
+                  mCpuTexture[aChannelIndex], mappedSubresource)) {
+    return false;
+  }
+
+  aPlaneInfo.mSize = GetSize(aChannelIndex);
+  aPlaneInfo.mStride = mappedSubresource.RowPitch;
+  aPlaneInfo.mData = mappedSubresource.pData;
+  return true;
+}
+
+void RenderDXGIYCbCrTextureHost::UnmapPlanes() {
+  for (uint32_t i = 0; i < 3; i++) {
+    if (mCpuTexture[i]) {
+      mDeviceContext->Unmap(mCpuTexture[i], 0);
+      mCpuTexture[i] = nullptr;
+    }
+  }
+  mDeviceContext = nullptr;
+}
+
+RenderDXGIYCbCrTextureHost::~RenderDXGIYCbCrTextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderDXGIYCbCrTextureHost, RenderTextureHost);
+  DeleteTextureHandle();
+}
+
+bool RenderDXGIYCbCrTextureHost::EnsureLockable() {
+  if (mTextureHandles[0]) {
+    return true;
+  }
+
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+
+  // The eglCreatePbufferFromClientBuffer doesn't support R8 format, so we
+  // use EGLStream to get the converted gl handle from d3d R8 texture.
+
+  if (!egl->IsExtensionSupported(
+          gl::EGLExtension::NV_stream_consumer_gltexture_yuv) ||
+      !egl->IsExtensionSupported(
+          gl::EGLExtension::ANGLE_stream_producer_d3d_texture)) {
+    gfxCriticalNote
+        << "RenderDXGIYCbCrTextureHost egl extensions are not suppored";
+    return false;
+  }
+
+  // Fetch the D3D11 device.
+  EGLDeviceEXT eglDevice = nullptr;
+  egl->fQueryDisplayAttribEXT(LOCAL_EGL_DEVICE_EXT, (EGLAttrib*)&eglDevice);
+  MOZ_ASSERT(eglDevice);
+  ID3D11Device* device = nullptr;
+  egl->mLib->fQueryDeviceAttribEXT(eglDevice, LOCAL_EGL_D3D11_DEVICE_ANGLE,
+                                   (EGLAttrib*)&device);
+  // There's a chance this might fail if we end up on d3d9 angle for some
+  // reason.
+  if (!device) {
+    gfxCriticalNote << "RenderDXGIYCbCrTextureHost device is not available";
+    return false;
+  }
+
+  if (!EnsureD3D11Texture2D(device)) {
+    return false;
+  }
+
+  mGL->fGenTextures(3, mTextureHandles);
+  bool ok = true;
+  for (int i = 0; i < 3; ++i) {
+    ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0 + i,
+                                 LOCAL_GL_TEXTURE_EXTERNAL_OES,
+                                 mTextureHandles[i]);
+
+    // Create the EGLStream.
+    mStreams[i] = egl->fCreateStreamKHR(nullptr);
+    MOZ_ASSERT(mStreams[i]);
+
+    ok &= bool(
+        egl->fStreamConsumerGLTextureExternalAttribsNV(mStreams[i], nullptr));
+    ok &= bool(egl->fCreateStreamProducerD3DTextureANGLE(mStreams[i], nullptr));
+
+    // Insert the R8 texture.
+    ok &= bool(egl->fStreamPostD3DTextureANGLE(
+        mStreams[i], (void*)mTextures[i].get(), nullptr));
+
+    // Now, we could get the R8 gl handle from the stream.
+    MOZ_ALWAYS_TRUE(egl->fStreamConsumerAcquireKHR(mStreams[i]));
+  }
+
+  if (!ok) {
+    gfxCriticalNote << "RenderDXGIYCbCrTextureHost init stream failed";
+    DeleteTextureHandle();
+    return false;
+  }
+
+  return true;
+}
+
+bool RenderDXGIYCbCrTextureHost::EnsureD3D11Texture2D(ID3D11Device* aDevice) {
+  RefPtr<ID3D11Device1> device1;
+  aDevice->QueryInterface((ID3D11Device1**)getter_AddRefs(device1));
+  if (!device1) {
+    gfxCriticalNoteOnce << "Failed to get ID3D11Device1";
+    return false;
+  }
+
+  if (mTextures[0]) {
+    RefPtr<ID3D11Device> device;
+    mTextures[0]->GetDevice(getter_AddRefs(device));
+    if (aDevice != device) {
+      gfxCriticalNote << "RenderDXGIYCbCrTextureHost uses obsoleted device";
+      return false;
+    }
+  }
+
+  if (mTextureHandles[0]) {
+    return true;
+  }
+
+  for (int i = 0; i < 3; ++i) {
+    // Get the R8 D3D11 texture from shared handle.
+    HRESULT hr = device1->OpenSharedResource1(
+        (HANDLE)mHandles[i]->GetHandle(), __uuidof(ID3D11Texture2D),
+        (void**)(ID3D11Texture2D**)getter_AddRefs(mTextures[i]));
+    if (FAILED(hr)) {
+      NS_WARNING(
+          "RenderDXGIYCbCrTextureHost::EnsureLockable(): Failed to open "
+          "shared "
+          "texture");
+      gfxCriticalNote
+          << "RenderDXGIYCbCrTextureHost Failed to open shared texture, hr="
+          << gfx::hexa(hr);
+      return false;
+    }
+  }
+
+  for (int i = 0; i < 3; ++i) {
+    mTextures[i]->QueryInterface(
+        (IDXGIKeyedMutex**)getter_AddRefs(mKeyedMutexs[i]));
+  }
+  return true;
+}
+
+bool RenderDXGIYCbCrTextureHost::LockInternal() {
+  if (!mLocked) {
+    if (mKeyedMutexs[0]) {
+      for (const auto& mutex : mKeyedMutexs) {
+        HRESULT hr = mutex->AcquireSync(0, 10000);
+        if (hr != S_OK) {
+          gfxCriticalError()
+              << "RenderDXGIYCbCrTextureHost AcquireSync timeout, hr="
+              << gfx::hexa(hr);
+          return false;
+        }
+      }
+    }
+    mLocked = true;
+  }
+  return true;
+}
+
+wr::WrExternalImage RenderDXGIYCbCrTextureHost::Lock(uint8_t aChannelIndex,
+                                                     gl::GLContext* aGL) {
+  if (mGL.get() != aGL) {
+    // Release the texture handle in the previous gl context.
+    DeleteTextureHandle();
+    mGL = aGL;
+  }
+
+  if (!mGL) {
+    // XXX Software WebRender is not handled yet.
+    // Software WebRender does not provide GLContext
+    gfxCriticalNoteOnce << "Software WebRender is not suppored by "
+                           "RenderDXGIYCbCrTextureHost.";
+    return InvalidToWrExternalImage();
+  }
+
+  if (!EnsureLockable()) {
+    return InvalidToWrExternalImage();
+  }
+
+  if (!LockInternal()) {
+    return InvalidToWrExternalImage();
+  }
+
+  const auto uvs = GetUvCoords(GetSize(aChannelIndex));
+  return NativeTextureToWrExternalImage(GetGLHandle(aChannelIndex), uvs.first.x,
+                                        uvs.first.y, uvs.second.x,
+                                        uvs.second.y);
+}
+
+void RenderDXGIYCbCrTextureHost::Unlock() {
+  if (mLocked) {
+    if (mKeyedMutexs[0]) {
+      for (const auto& mutex : mKeyedMutexs) {
+        mutex->ReleaseSync(0);
+      }
+    }
+    mLocked = false;
+  }
+}
+
+void RenderDXGIYCbCrTextureHost::ClearCachedResources() {
+  DeleteTextureHandle();
+  mGL = nullptr;
+}
+
+GLuint RenderDXGIYCbCrTextureHost::GetGLHandle(uint8_t aChannelIndex) const {
+  MOZ_ASSERT(aChannelIndex < 3);
+
+  return mTextureHandles[aChannelIndex];
+}
+
+gfx::IntSize RenderDXGIYCbCrTextureHost::GetSize(uint8_t aChannelIndex) const {
+  MOZ_ASSERT(aChannelIndex < 3);
+
+  if (aChannelIndex == 0) {
+    return mSizeY;
+  } else {
+    return mSizeCbCr;
+  }
+}
+
+void RenderDXGIYCbCrTextureHost::DeleteTextureHandle() {
+  if (mTextureHandles[0] == 0) {
+    return;
+  }
+
+  MOZ_ASSERT(mGL.get());
+  if (!mGL) {
+    return;
+  }
+
+  if (mGL->MakeCurrent()) {
+    mGL->fDeleteTextures(3, mTextureHandles);
+
+    const auto& gle = gl::GLContextEGL::Cast(mGL);
+    const auto& egl = gle->mEgl;
+    for (int i = 0; i < 3; ++i) {
+      mTextureHandles[i] = 0;
+      mTextures[i] = nullptr;
+      mKeyedMutexs[i] = nullptr;
+
+      if (mSurfaces[i]) {
+        egl->fDestroySurface(mSurfaces[i]);
+        mSurfaces[i] = 0;
+      }
+      if (mStreams[i]) {
+        egl->fDestroyStreamKHR(mStreams[i]);
+        mStreams[i] = 0;
+      }
+    }
+  }
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderD3D11TextureHost.h b/gfx/webrender_bindings/RenderD3D11TextureHost.h
new file mode 100644
index 0000000000..a46b5f3fb5
--- /dev/null
+++ b/gfx/webrender_bindings/RenderD3D11TextureHost.h
@@ -0,0 +1,230 @@
+/* -*- 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_RENDERD3D11TEXTUREHOST_H
+#define MOZILLA_GFX_RENDERD3D11TEXTUREHOST_H
+
+#include <d3d11.h>
+
+#include "GLTypes.h"
+#include "mozilla/gfx/FileHandleWrapper.h"
+#include "RenderTextureHostSWGL.h"
+
+struct ID3D11Texture2D;
+struct IDXGIKeyedMutex;
+
+namespace mozilla {
+
+namespace layers {
+class FenceD3D11;
+}  // namespace layers
+
+namespace wr {
+
+class RenderDXGITextureHost final : public RenderTextureHostSWGL {
+ public:
+  RenderDXGITextureHost(
+      RefPtr<gfx::FileHandleWrapper> aHandle,
+      Maybe<layers::GpuProcessTextureId>& aGpuProcessTextureId,
+      uint32_t aArrayIndex, gfx::SurfaceFormat aFormat, gfx::ColorSpace2,
+      gfx::ColorRange aColorRange, gfx::IntSize aSize, bool aHasKeyedMutex,
+      gfx::FenceInfo& aAcquireFenceInfo,
+      Maybe<layers::GpuProcessQueryId>& aGpuProcessQueryId);
+
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+  void ClearCachedResources() override;
+
+  gfx::IntSize GetSize(uint8_t aChannelIndex) const;
+  GLuint GetGLHandle(uint8_t aChannelIndex) const;
+
+  bool SyncObjectNeeded() override;
+
+  RenderDXGITextureHost* AsRenderDXGITextureHost() override { return this; }
+
+  gfx::ColorRange GetColorRange() const { return mColorRange; }
+
+  ID3D11Texture2D* GetD3D11Texture2DWithGL();
+  ID3D11Texture2D* GetD3D11Texture2D() { return mTexture; }
+
+  // RenderTextureHostSWGL
+  gfx::SurfaceFormat GetFormat() const override { return mFormat; }
+  gfx::ColorDepth GetColorDepth() const override {
+    if (mFormat == gfx::SurfaceFormat::P010) {
+      return gfx::ColorDepth::COLOR_10;
+    }
+    if (mFormat == gfx::SurfaceFormat::P016) {
+      return gfx::ColorDepth::COLOR_16;
+    }
+    return gfx::ColorDepth::COLOR_8;
+  }
+  size_t GetPlaneCount() const override;
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+  void UnmapPlanes() override;
+  gfx::YUVRangedColorSpace GetYUVColorSpace() const override {
+    return ToYUVRangedColorSpace(ToYUVColorSpace(mColorSpace), mColorRange);
+  }
+
+  bool EnsureD3D11Texture2D(ID3D11Device* aDevice);
+  bool LockInternal();
+
+  size_t Bytes() override {
+    size_t bytes = 0;
+
+    size_t bpp = GetPlaneCount() > 1
+                     ? (GetColorDepth() == gfx::ColorDepth::COLOR_8 ? 1 : 2)
+                     : 4;
+
+    for (size_t i = 0; i < GetPlaneCount(); i++) {
+      gfx::IntSize size = GetSize(i);
+      bytes += size.width * size.height * bpp;
+    }
+    return bytes;
+  }
+
+  uint32_t ArrayIndex() const { return mArrayIndex; }
+
+  void SetIsSoftwareDecodedVideo() override { mIsSoftwareDecodedVideo = true; }
+  bool IsSoftwareDecodedVideo() override { return mIsSoftwareDecodedVideo; }
+
+  RefPtr<ID3D11Query> GetQuery();
+
+ private:
+  virtual ~RenderDXGITextureHost();
+
+  bool EnsureD3D11Texture2DWithGL();
+  bool EnsureLockable();
+
+  void DeleteTextureHandle();
+
+  RefPtr<gl::GLContext> mGL;
+
+  RefPtr<gfx::FileHandleWrapper> mHandle;
+  Maybe<layers::GpuProcessTextureId> mGpuProcessTextureId;
+  Maybe<layers::GpuProcessQueryId> mGpuProcessQueryId;
+  RefPtr<ID3D11Texture2D> mTexture;
+  uint32_t mArrayIndex = 0;
+  RefPtr<IDXGIKeyedMutex> mKeyedMutex;
+
+  // Temporary state between MapPlane and UnmapPlanes.
+  RefPtr<ID3D11DeviceContext> mDeviceContext;
+  RefPtr<ID3D11Texture2D> mCpuTexture;
+  D3D11_MAPPED_SUBRESOURCE mMappedSubresource;
+
+  EGLSurface mSurface;
+  EGLStreamKHR mStream;
+
+  // We could use NV12 format for this texture. So, we might have 2 gl texture
+  // handles for Y and CbCr data.
+  GLuint mTextureHandle[2];
+
+  bool mIsSoftwareDecodedVideo = false;
+
+  RefPtr<layers::FenceD3D11> mAcquireFence;
+
+ public:
+  const gfx::SurfaceFormat mFormat;
+  const gfx::ColorSpace2 mColorSpace;
+  const gfx::ColorRange mColorRange;
+  const gfx::IntSize mSize;
+  const bool mHasKeyedMutex;
+  const gfx::FenceInfo mAcquireFenceInfo;
+
+ private:
+  bool mLocked;
+};
+
+class RenderDXGIYCbCrTextureHost final : public RenderTextureHostSWGL {
+ public:
+  explicit RenderDXGIYCbCrTextureHost(
+      RefPtr<gfx::FileHandleWrapper> (&aHandles)[3],
+      gfx::YUVColorSpace aYUVColorSpace, gfx::ColorDepth aColorDepth,
+      gfx::ColorRange aColorRange, gfx::IntSize aSizeY, gfx::IntSize aSizeCbCr);
+
+  RenderDXGIYCbCrTextureHost* AsRenderDXGIYCbCrTextureHost() override {
+    return this;
+  }
+
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+  void ClearCachedResources() override;
+
+  gfx::IntSize GetSize(uint8_t aChannelIndex) const;
+  GLuint GetGLHandle(uint8_t aChannelIndex) const;
+
+  bool SyncObjectNeeded() override { return true; }
+
+  gfx::ColorRange GetColorRange() const { return mColorRange; }
+
+  // RenderTextureHostSWGL
+  gfx::SurfaceFormat GetFormat() const override {
+    return gfx::SurfaceFormat::YUV;
+  }
+  gfx::ColorDepth GetColorDepth() const override { return mColorDepth; }
+  size_t GetPlaneCount() const override { return 3; }
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+  void UnmapPlanes() override;
+  gfx::YUVRangedColorSpace GetYUVColorSpace() const override {
+    return ToYUVRangedColorSpace(mYUVColorSpace, GetColorRange());
+  }
+
+  bool EnsureD3D11Texture2D(ID3D11Device* aDevice);
+  bool LockInternal();
+
+  ID3D11Texture2D* GetD3D11Texture2D(uint8_t aChannelIndex) {
+    return mTextures[aChannelIndex];
+  }
+
+  size_t Bytes() override {
+    size_t bytes = 0;
+
+    size_t bpp = mColorDepth == gfx::ColorDepth::COLOR_8 ? 1 : 2;
+
+    for (size_t i = 0; i < GetPlaneCount(); i++) {
+      gfx::IntSize size = GetSize(i);
+      bytes += size.width * size.height * bpp;
+    }
+    return bytes;
+  }
+
+ private:
+  virtual ~RenderDXGIYCbCrTextureHost();
+
+  bool EnsureLockable();
+
+  void DeleteTextureHandle();
+
+  RefPtr<gl::GLContext> mGL;
+
+  RefPtr<gfx::FileHandleWrapper> mHandles[3];
+  RefPtr<ID3D11Texture2D> mTextures[3];
+  RefPtr<IDXGIKeyedMutex> mKeyedMutexs[3];
+
+  EGLSurface mSurfaces[3];
+  EGLStreamKHR mStreams[3];
+
+  // The gl handles for Y, Cb and Cr data.
+  GLuint mTextureHandles[3];
+
+  // Temporary state between MapPlane and UnmapPlanes.
+  RefPtr<ID3D11DeviceContext> mDeviceContext;
+  RefPtr<ID3D11Texture2D> mCpuTexture[3];
+
+  gfx::YUVColorSpace mYUVColorSpace;
+  gfx::ColorDepth mColorDepth;
+  gfx::ColorRange mColorRange;
+  gfx::IntSize mSizeY;
+  gfx::IntSize mSizeCbCr;
+
+  bool mLocked;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERD3D11TEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderDMABUFTextureHost.cpp b/gfx/webrender_bindings/RenderDMABUFTextureHost.cpp
new file mode 100644
index 0000000000..f52535b95a
--- /dev/null
+++ b/gfx/webrender_bindings/RenderDMABUFTextureHost.cpp
@@ -0,0 +1,67 @@
+/* -*- 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 "RenderDMABUFTextureHost.h"
+
+#include "GLContextEGL.h"
+#include "mozilla/gfx/Logging.h"
+#include "ScopedGLHelpers.h"
+
+namespace mozilla::wr {
+
+RenderDMABUFTextureHost::RenderDMABUFTextureHost(DMABufSurface* aSurface)
+    : mSurface(aSurface) {
+  MOZ_COUNT_CTOR_INHERITED(RenderDMABUFTextureHost, RenderTextureHost);
+}
+
+RenderDMABUFTextureHost::~RenderDMABUFTextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderDMABUFTextureHost, RenderTextureHost);
+  DeleteTextureHandle();
+}
+
+wr::WrExternalImage RenderDMABUFTextureHost::Lock(uint8_t aChannelIndex,
+                                                  gl::GLContext* aGL) {
+  if (mGL.get() != aGL) {
+    if (mGL) {
+      // This should not happen. EGLImage is created only in
+      // parent process.
+      MOZ_ASSERT_UNREACHABLE("Unexpected GL context");
+      return InvalidToWrExternalImage();
+    }
+    mGL = aGL;
+  }
+
+  if (!mGL || !mGL->MakeCurrent()) {
+    return InvalidToWrExternalImage();
+  }
+
+  if (!mSurface->GetTexture(aChannelIndex)) {
+    if (!mSurface->CreateTexture(mGL, aChannelIndex)) {
+      return InvalidToWrExternalImage();
+    }
+    ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0, LOCAL_GL_TEXTURE_2D,
+                                 mSurface->GetTexture(aChannelIndex));
+  }
+
+  const auto uvs = GetUvCoords(gfx::IntSize(
+      mSurface->GetWidth(aChannelIndex), mSurface->GetHeight(aChannelIndex)));
+  return NativeTextureToWrExternalImage(mSurface->GetTexture(aChannelIndex),
+                                        uvs.first.x, uvs.first.y, uvs.second.x,
+                                        uvs.second.y);
+}
+
+void RenderDMABUFTextureHost::Unlock() {}
+
+void RenderDMABUFTextureHost::DeleteTextureHandle() {
+  mSurface->ReleaseTextures();
+}
+
+void RenderDMABUFTextureHost::ClearCachedResources() {
+  DeleteTextureHandle();
+  mGL = nullptr;
+}
+
+}  // namespace mozilla::wr
diff --git a/gfx/webrender_bindings/RenderDMABUFTextureHost.h b/gfx/webrender_bindings/RenderDMABUFTextureHost.h
new file mode 100644
index 0000000000..a38eeaf596
--- /dev/null
+++ b/gfx/webrender_bindings/RenderDMABUFTextureHost.h
@@ -0,0 +1,46 @@
+/* -*- 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_RENDERDMABUFTEXTUREHOST_H
+#define MOZILLA_GFX_RENDERDMABUFTEXTUREHOST_H
+
+#include "mozilla/layers/TextureHostOGL.h"
+#include "RenderTextureHost.h"
+#include "mozilla/widget/DMABufSurface.h"
+
+namespace mozilla {
+
+namespace layers {
+class SurfaceDescriptorDMABuf;
+}
+
+namespace wr {
+
+class RenderDMABUFTextureHost final : public RenderTextureHost {
+ public:
+  explicit RenderDMABUFTextureHost(DMABufSurface* aSurface);
+
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+  void ClearCachedResources() override;
+
+  size_t Bytes() override {
+    return mSurface->GetWidth() * mSurface->GetHeight() *
+           BytesPerPixel(mSurface->GetFormat());
+  }
+
+ private:
+  virtual ~RenderDMABUFTextureHost();
+  void DeleteTextureHandle();
+
+  RefPtr<DMABufSurface> mSurface;
+  RefPtr<gl::GLContext> mGL;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERDMABUFTEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.cpp
new file mode 100644
index 0000000000..51e12d6ace
--- /dev/null
+++ b/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.cpp
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "RenderDcompSurfaceTextureHost.h"
+
+#include <dcomp.h>
+
+#define LOG(msg, ...)                                                        \
+  MOZ_LOG(gDcompSurface, LogLevel::Debug,                                    \
+          ("RenderDcompSurfaceTextureHost=%p, handle=%p, size=[%u,%u] " msg, \
+           this, this->mHandle, this->mSize.Width(), this->mSize.Height(),   \
+           ##__VA_ARGS__))
+
+namespace mozilla::wr {
+
+RenderDcompSurfaceTextureHost::RenderDcompSurfaceTextureHost(
+    HANDLE aHandle, gfx::IntSize aSize, gfx::SurfaceFormat aFormat)
+    : mHandle(aHandle), mSize(aSize), mFormat(aFormat) {
+  MOZ_ASSERT(aHandle && aHandle != INVALID_HANDLE_VALUE);
+}
+
+IDCompositionSurface* RenderDcompSurfaceTextureHost::CreateSurfaceFromDevice(
+    IDCompositionDevice* aDevice) {
+  // Already created surface, no need to recreate it again.
+  if (mDcompSurface) {
+    return mDcompSurface;
+  }
+
+  auto* surface =
+      static_cast<IDCompositionSurface**>(getter_AddRefs(mDcompSurface));
+  auto hr = aDevice->CreateSurfaceFromHandle(
+      mHandle, reinterpret_cast<IUnknown**>(surface));
+  if (FAILED(hr)) {
+    LOG("Failed to create surface from Dcomp handle %p, hr=%lx", mHandle, hr);
+    return nullptr;
+  }
+  LOG("Created surface %p correctly", surface);
+  return mDcompSurface;
+}
+
+}  // namespace mozilla::wr
+
+#undef LOG
diff --git a/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.h b/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.h
new file mode 100644
index 0000000000..7533e7c75f
--- /dev/null
+++ b/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.h
@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: ; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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_RENDERDCOMPSURFACETEXTUREHOST_H
+#define MOZILLA_GFX_RENDERDCOMPSURFACETEXTUREHOST_H
+
+#include "GLTypes.h"
+#include "RenderTextureHostSWGL.h"
+#include "mozilla/webrender/RenderThread.h"
+
+struct IDCompositionDevice;
+struct IDCompositionSurface;
+
+inline mozilla::LazyLogModule gDcompSurface("DcompSurface");
+
+namespace mozilla::wr {
+
+/**
+ * A render texture host is responsible to create a dcomp surface from an
+ * existing dcomp handle. Currently usage is that MF media engine will create
+ * a surface handle from another remote process, and we reconstruct the surface
+ * and use it in the DCLayerTree in the GPU process.
+ */
+class RenderDcompSurfaceTextureHost final : public RenderTextureHostSWGL {
+ public:
+  RenderDcompSurfaceTextureHost(HANDLE aHandle, gfx::IntSize aSize,
+                                gfx::SurfaceFormat aFormat);
+
+  // RenderTextureHost
+  RenderDcompSurfaceTextureHost* AsRenderDcompSurfaceTextureHost() override {
+    return this;
+  }
+
+  // RenderTextureHostSWGL
+  gfx::SurfaceFormat GetFormat() const override { return mFormat; }
+  gfx::ColorDepth GetColorDepth() const override {
+    return gfx::ColorDepth::COLOR_8;
+  }
+  size_t GetPlaneCount() const override { return 1; }
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override {
+    return false;
+  }
+  void UnmapPlanes() override {}
+  gfx::YUVRangedColorSpace GetYUVColorSpace() const override {
+    return gfx::YUVRangedColorSpace::GbrIdentity;
+  }
+  size_t Bytes() override { return 0; }
+
+  gfx::IntSize GetSize() const { return mSize; };
+
+  HANDLE GetDcompSurfaceHandle() const { return mHandle; }
+
+  // Not thread-safe. They should only be called on the renderer thread on the
+  // GPU process.
+  IDCompositionSurface* CreateSurfaceFromDevice(IDCompositionDevice* aDevice);
+  IDCompositionSurface* GetSurface() const { return mDcompSurface; };
+
+ private:
+  const HANDLE mHandle;
+  const gfx::IntSize mSize;
+  const gfx::SurfaceFormat mFormat;
+  RefPtr<IDCompositionSurface> mDcompSurface;
+};
+
+}  // namespace mozilla::wr
+
+#endif  // MOZILLA_GFX_RENDERDCOMPSURFACETEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderEGLImageTextureHost.cpp b/gfx/webrender_bindings/RenderEGLImageTextureHost.cpp
new file mode 100644
index 0000000000..6ca9e74072
--- /dev/null
+++ b/gfx/webrender_bindings/RenderEGLImageTextureHost.cpp
@@ -0,0 +1,96 @@
+/* -*- 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 "RenderEGLImageTextureHost.h"
+
+#include "mozilla/gfx/Logging.h"
+#include "GLContextEGL.h"
+#include "GLLibraryEGL.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderEGLImageTextureHost::RenderEGLImageTextureHost(EGLImage aImage,
+                                                     EGLSync aSync,
+                                                     gfx::IntSize aSize)
+    : mImage(aImage),
+      mSync(aSync),
+      mSize(aSize),
+      mTextureTarget(LOCAL_GL_TEXTURE_2D),
+      mTextureHandle(0) {
+  MOZ_COUNT_CTOR_INHERITED(RenderEGLImageTextureHost, RenderTextureHost);
+}
+
+RenderEGLImageTextureHost::~RenderEGLImageTextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderEGLImageTextureHost, RenderTextureHost);
+  DeleteTextureHandle();
+}
+
+wr::WrExternalImage RenderEGLImageTextureHost::Lock(uint8_t aChannelIndex,
+                                                    gl::GLContext* aGL) {
+  MOZ_ASSERT(aChannelIndex == 0);
+
+  if (mGL.get() != aGL) {
+    if (mGL) {
+      // This should not happen. SharedSurface_EGLImage is created only in
+      // parent process.
+      MOZ_ASSERT_UNREACHABLE("Unexpected GL context");
+      return InvalidToWrExternalImage();
+    }
+    mGL = aGL;
+  }
+
+  if (!mImage || !mGL || !mGL->MakeCurrent()) {
+    return InvalidToWrExternalImage();
+  }
+
+  EGLint status = LOCAL_EGL_CONDITION_SATISFIED;
+  if (mSync) {
+    const auto& gle = gl::GLContextEGL::Cast(mGL);
+    const auto& egl = gle->mEgl;
+    MOZ_ASSERT(egl->IsExtensionSupported(gl::EGLExtension::KHR_fence_sync));
+    status = egl->fClientWaitSync(mSync, 0, LOCAL_EGL_FOREVER);
+    // We do not need to delete sync here. It is deleted by
+    // SharedSurface_EGLImage.
+    mSync = 0;
+  }
+
+  if (status != LOCAL_EGL_CONDITION_SATISFIED) {
+    MOZ_ASSERT(
+        status != 0,
+        "ClientWaitSync generated an error. Has mSync already been destroyed?");
+    return InvalidToWrExternalImage();
+  }
+
+  if (!mTextureHandle) {
+    mTextureTarget = mGL->GetPreferredEGLImageTextureTarget();
+    MOZ_ASSERT(mTextureTarget == LOCAL_GL_TEXTURE_2D ||
+               mTextureTarget == LOCAL_GL_TEXTURE_EXTERNAL);
+
+    mGL->fGenTextures(1, &mTextureHandle);
+    ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0, mTextureTarget,
+                                 mTextureHandle);
+    mGL->fEGLImageTargetTexture2D(mTextureTarget, mImage);
+  }
+
+  const auto uvs = GetUvCoords(mSize);
+  return NativeTextureToWrExternalImage(
+      mTextureHandle, uvs.first.x, uvs.first.y, uvs.second.x, uvs.second.y);
+}
+
+void RenderEGLImageTextureHost::Unlock() {}
+
+void RenderEGLImageTextureHost::DeleteTextureHandle() {
+  if (mTextureHandle) {
+    // XXX recycle gl texture, since SharedSurface_EGLImage and
+    // RenderEGLImageTextureHost is not recycled.
+    mGL->fDeleteTextures(1, &mTextureHandle);
+    mTextureHandle = 0;
+  }
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderEGLImageTextureHost.h b/gfx/webrender_bindings/RenderEGLImageTextureHost.h
new file mode 100644
index 0000000000..c2d1b512d2
--- /dev/null
+++ b/gfx/webrender_bindings/RenderEGLImageTextureHost.h
@@ -0,0 +1,46 @@
+/* -*- 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_RENDEREGLIMAGETEXTUREHOST_H
+#define MOZILLA_GFX_RENDEREGLIMAGETEXTUREHOST_H
+
+#include "mozilla/layers/TextureHostOGL.h"
+#include "RenderTextureHost.h"
+
+namespace mozilla {
+
+namespace wr {
+
+// RenderEGLImageTextureHost is created only for SharedSurface_EGLImage that is
+// created in parent process.
+class RenderEGLImageTextureHost final : public RenderTextureHost {
+ public:
+  RenderEGLImageTextureHost(EGLImage aImage, EGLSync aSync, gfx::IntSize aSize);
+
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+  size_t Bytes() override {
+    // XXX: we don't have a format so we can't get bpp.
+    return mSize.width * mSize.height;
+  }
+
+ private:
+  virtual ~RenderEGLImageTextureHost();
+  void DeleteTextureHandle();
+
+  const EGLImage mImage;
+  EGLSync mSync;
+  const gfx::IntSize mSize;
+
+  RefPtr<gl::GLContext> mGL;
+  GLenum mTextureTarget;
+  GLuint mTextureHandle;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDEREGLIMAGETEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderExternalTextureHost.cpp b/gfx/webrender_bindings/RenderExternalTextureHost.cpp
new file mode 100644
index 0000000000..db8107ff0a
--- /dev/null
+++ b/gfx/webrender_bindings/RenderExternalTextureHost.cpp
@@ -0,0 +1,265 @@
+/* -*- 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 "RenderExternalTextureHost.h"
+
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/ImageDataSerializer.h"
+
+#include "GLContext.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderExternalTextureHost::RenderExternalTextureHost(
+    uint8_t* aBuffer, const layers::BufferDescriptor& aDescriptor)
+    : mBuffer(aBuffer),
+      mDescriptor(aDescriptor),
+      mInitialized(false),
+      mTextureUpdateNeeded(true) {
+  MOZ_COUNT_CTOR_INHERITED(RenderExternalTextureHost, RenderTextureHost);
+
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor: {
+      const layers::YCbCrDescriptor& ycbcr = mDescriptor.get_YCbCrDescriptor();
+      mSize = ycbcr.display().Size();
+      mFormat = gfx::SurfaceFormat::YUV;
+      break;
+    }
+    case layers::BufferDescriptor::TRGBDescriptor: {
+      const layers::RGBDescriptor& rgb = mDescriptor.get_RGBDescriptor();
+      mSize = rgb.size();
+      mFormat = rgb.format();
+      break;
+    }
+    default:
+      gfxCriticalError() << "Bad buffer host descriptor "
+                         << (int)mDescriptor.type();
+      MOZ_CRASH("GFX: Bad descriptor");
+  }
+}
+
+RenderExternalTextureHost::~RenderExternalTextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderExternalTextureHost, RenderTextureHost);
+
+  if (NS_WARN_IF(!IsReadyForDeletion())) {
+    gfxCriticalNote << "RenderExternalTextureHost sync failed";
+  }
+
+  DeleteTextures();
+}
+
+bool RenderExternalTextureHost::CreateSurfaces() {
+  if (!IsYUV()) {
+    mSurfaces[0] = gfx::Factory::CreateWrappingDataSourceSurface(
+        GetBuffer(),
+        layers::ImageDataSerializer::GetRGBStride(
+            mDescriptor.get_RGBDescriptor()),
+        mSize, mFormat);
+  } else {
+    const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
+    const gfx::SurfaceFormat surfaceFormat =
+        SurfaceFormatForColorDepth(desc.colorDepth());
+    auto cbcrSize = layers::ImageDataSerializer::GetCroppedCbCrSize(desc);
+
+    mSurfaces[0] = gfx::Factory::CreateWrappingDataSourceSurface(
+        layers::ImageDataSerializer::GetYChannel(GetBuffer(), desc),
+        desc.yStride(), desc.display().Size(), surfaceFormat);
+    mSurfaces[1] = gfx::Factory::CreateWrappingDataSourceSurface(
+        layers::ImageDataSerializer::GetCbChannel(GetBuffer(), desc),
+        desc.cbCrStride(), cbcrSize, surfaceFormat);
+    mSurfaces[2] = gfx::Factory::CreateWrappingDataSourceSurface(
+        layers::ImageDataSerializer::GetCrChannel(GetBuffer(), desc),
+        desc.cbCrStride(), cbcrSize, surfaceFormat);
+  }
+
+  for (size_t i = 0; i < PlaneCount(); ++i) {
+    if (NS_WARN_IF(!mSurfaces[i])) {
+      gfxCriticalNote << "Surface is null";
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void RenderExternalTextureHost::DeleteSurfaces() {
+  for (size_t i = 0; i < PlaneCount(); ++i) {
+    mSurfaces[i] = nullptr;
+  }
+}
+
+void RenderExternalTextureHost::DeleteTextures() {
+  for (size_t i = 0; i < PlaneCount(); ++i) {
+    mTextureSources[i] = nullptr;
+    mImages[i] = InvalidToWrExternalImage();
+  }
+}
+
+bool RenderExternalTextureHost::InitializeIfNeeded() {
+  if (mInitialized) {
+    return true;
+  }
+
+  if (!GetBuffer()) {
+    // We hit some problems to get the shmem.
+    gfxCriticalNote << "GetBuffer Failed";
+    return false;
+  }
+
+  if (!CreateSurfaces()) {
+    DeleteSurfaces();
+    return false;
+  }
+
+  mInitialized = true;
+  return mInitialized;
+}
+
+bool RenderExternalTextureHost::IsReadyForDeletion() {
+  if (!mInitialized) {
+    return true;
+  }
+
+  auto& textureSource = mTextureSources[0];
+  if (textureSource) {
+    return textureSource->Sync(false);
+  }
+
+  return true;
+}
+
+wr::WrExternalImage RenderExternalTextureHost::Lock(uint8_t aChannelIndex,
+                                                    gl::GLContext* aGL) {
+  if (mGL.get() != aGL) {
+    mGL = aGL;
+    mGL->MakeCurrent();
+  }
+
+  if (!mGL || !mGL->MakeCurrent()) {
+    return InvalidToWrExternalImage();
+  }
+
+  if (!InitializeIfNeeded()) {
+    return InvalidToWrExternalImage();
+  }
+
+  UpdateTextures();
+  return mImages[aChannelIndex];
+}
+
+void RenderExternalTextureHost::PrepareForUse() { mTextureUpdateNeeded = true; }
+
+void RenderExternalTextureHost::Unlock() {}
+
+void RenderExternalTextureHost::UpdateTexture(size_t aIndex) {
+  MOZ_ASSERT(mSurfaces[aIndex]);
+
+  auto& texture = mTextureSources[aIndex];
+
+  if (texture) {
+    texture->Update(mSurfaces[aIndex]);
+  } else {
+    texture = new layers::DirectMapTextureSource(mGL, mSurfaces[aIndex]);
+
+    const GLuint handle = texture->GetTextureHandle();
+    const auto uvs = GetUvCoords(texture->GetSize());
+    mImages[aIndex] = NativeTextureToWrExternalImage(
+        handle, uvs.first.x, uvs.first.y, uvs.second.x, uvs.second.y);
+  }
+
+  MOZ_ASSERT(mGL->GetError() == LOCAL_GL_NO_ERROR);
+}
+
+void RenderExternalTextureHost::UpdateTextures() {
+  if (!mTextureUpdateNeeded) {
+    // Nothing to do here.
+    return;
+  }
+
+  for (size_t i = 0; i < PlaneCount(); ++i) {
+    UpdateTexture(i);
+  }
+
+  mTextureSources[0]->MaybeFenceTexture();
+  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::YUVRangedColorSpace RenderExternalTextureHost::GetYUVColorSpace() const {
+  switch (mDescriptor.type()) {
+    case layers::BufferDescriptor::TYCbCrDescriptor:
+      return gfx::GetYUVRangedColorSpace(mDescriptor.get_YCbCrDescriptor());
+    default:
+      return gfx::YUVRangedColorSpace::Default;
+  }
+}
+
+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.display().Size();
+          break;
+        case 1:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetCbChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.cbCrStride();
+          aPlaneInfo.mSize =
+              layers::ImageDataSerializer::GetCroppedCbCrSize(desc);
+          break;
+        case 2:
+          aPlaneInfo.mData =
+              layers::ImageDataSerializer::GetCrChannel(mBuffer, desc);
+          aPlaneInfo.mStride = desc.cbCrStride();
+          aPlaneInfo.mSize =
+              layers::ImageDataSerializer::GetCroppedCbCrSize(desc);
+          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
diff --git a/gfx/webrender_bindings/RenderExternalTextureHost.h b/gfx/webrender_bindings/RenderExternalTextureHost.h
new file mode 100644
index 0000000000..c3b13250c1
--- /dev/null
+++ b/gfx/webrender_bindings/RenderExternalTextureHost.h
@@ -0,0 +1,81 @@
+/* -*- 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_RENDEREXTERNALTEXTUREHOST_H
+#define MOZILLA_GFX_RENDEREXTERNALTEXTUREHOST_H
+
+#include "mozilla/layers/TextureHostOGL.h"
+#include "RenderTextureHostSWGL.h"
+
+namespace mozilla {
+namespace wr {
+
+/**
+ * RenderExternalTextureHost manages external textures used by WebRender on Mac.
+ * The motivation for this is to be able to use Apple Client Storage OpenGL
+ * extension, which makes it possible to avoid some copies during texture
+ * upload. This is especially helpful for high resolution video.
+ */
+class RenderExternalTextureHost final : public RenderTextureHostSWGL {
+ public:
+  RenderExternalTextureHost(uint8_t* aBuffer,
+                            const layers::BufferDescriptor& aDescriptor);
+
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+  void PrepareForUse() override;
+  size_t Bytes() override {
+    return mSize.width * mSize.height * BytesPerPixel(mFormat);
+  }
+
+  // RenderTextureHostSWGL
+  size_t GetPlaneCount() const override;
+
+  gfx::SurfaceFormat GetFormat() const override;
+
+  gfx::ColorDepth GetColorDepth() const override;
+
+  gfx::YUVRangedColorSpace GetYUVColorSpace() const override;
+
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+
+  void UnmapPlanes() override;
+
+ private:
+  ~RenderExternalTextureHost();
+
+  bool CreateSurfaces();
+  void DeleteSurfaces();
+  void DeleteTextures();
+
+  uint8_t* GetBuffer() const { return mBuffer; }
+  bool InitializeIfNeeded();
+  bool IsReadyForDeletion();
+  bool IsYUV() const { return mFormat == gfx::SurfaceFormat::YUV; }
+  size_t PlaneCount() const { return IsYUV() ? 3 : 1; }
+  void UpdateTexture(size_t aIndex);
+  void UpdateTextures();
+
+  uint8_t* mBuffer;
+  layers::BufferDescriptor mDescriptor;
+
+  bool mInitialized;
+  bool mTextureUpdateNeeded;
+
+  gfx::IntSize mSize;
+  gfx::SurfaceFormat mFormat;
+
+  RefPtr<gl::GLContext> mGL;
+  RefPtr<gfx::DataSourceSurface> mSurfaces[3];
+  RefPtr<layers::DirectMapTextureSource> mTextureSources[3];
+  wr::WrExternalImage mImages[3];
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDEREXTERNALTEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.cpp
new file mode 100644
index 0000000000..bb0575949b
--- /dev/null
+++ b/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.cpp
@@ -0,0 +1,157 @@
+/* -*- 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 "RenderMacIOSurfaceTextureHost.h"
+
+#include "GLContextCGL.h"
+#include "mozilla/gfx/Logging.h"
+#include "ScopedGLHelpers.h"
+
+namespace mozilla {
+namespace wr {
+
+static CGLError CreateTextureForPlane(uint8_t aPlaneID, gl::GLContext* aGL,
+                                      MacIOSurface* aSurface,
+                                      GLuint* aTexture) {
+  MOZ_ASSERT(aGL && aSurface && aTexture);
+
+  aGL->fGenTextures(1, aTexture);
+  ActivateBindAndTexParameteri(aGL, LOCAL_GL_TEXTURE0,
+                               LOCAL_GL_TEXTURE_RECTANGLE_ARB, *aTexture);
+  aGL->fTexParameteri(LOCAL_GL_TEXTURE_RECTANGLE_ARB, LOCAL_GL_TEXTURE_WRAP_T,
+                      LOCAL_GL_CLAMP_TO_EDGE);
+  aGL->fTexParameteri(LOCAL_GL_TEXTURE_RECTANGLE_ARB, LOCAL_GL_TEXTURE_WRAP_S,
+                      LOCAL_GL_CLAMP_TO_EDGE);
+
+  CGLError result = kCGLNoError;
+  gfx::SurfaceFormat readFormat = gfx::SurfaceFormat::UNKNOWN;
+  result = aSurface->CGLTexImageIOSurface2D(
+      aGL, gl::GLContextCGL::Cast(aGL)->GetCGLContext(), aPlaneID, &readFormat);
+  // If this is a yuv format, the Webrender only supports YUV422 interleaving
+  // format.
+  MOZ_ASSERT(aSurface->GetFormat() != gfx::SurfaceFormat::YUV422 ||
+             readFormat == gfx::SurfaceFormat::YUV422);
+
+  return result;
+}
+
+RenderMacIOSurfaceTextureHost::RenderMacIOSurfaceTextureHost(
+    MacIOSurface* aSurface)
+    : mSurface(aSurface), mTextureHandles{0, 0, 0} {
+  MOZ_COUNT_CTOR_INHERITED(RenderMacIOSurfaceTextureHost, RenderTextureHost);
+}
+
+RenderMacIOSurfaceTextureHost::~RenderMacIOSurfaceTextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderMacIOSurfaceTextureHost, RenderTextureHost);
+  DeleteTextureHandle();
+}
+
+GLuint RenderMacIOSurfaceTextureHost::GetGLHandle(uint8_t aChannelIndex) const {
+  MOZ_ASSERT(mSurface);
+  MOZ_ASSERT((mSurface->GetPlaneCount() == 0)
+                 ? (aChannelIndex == mSurface->GetPlaneCount())
+                 : (aChannelIndex < mSurface->GetPlaneCount()));
+  return mTextureHandles[aChannelIndex];
+}
+
+gfx::IntSize RenderMacIOSurfaceTextureHost::GetSize(
+    uint8_t aChannelIndex) const {
+  MOZ_ASSERT(mSurface);
+  MOZ_ASSERT((mSurface->GetPlaneCount() == 0)
+                 ? (aChannelIndex == mSurface->GetPlaneCount())
+                 : (aChannelIndex < mSurface->GetPlaneCount()));
+
+  if (!mSurface) {
+    return gfx::IntSize();
+  }
+  return gfx::IntSize(mSurface->GetDevicePixelWidth(aChannelIndex),
+                      mSurface->GetDevicePixelHeight(aChannelIndex));
+}
+
+size_t RenderMacIOSurfaceTextureHost::Bytes() {
+  return mSurface->GetAllocSize();
+}
+
+wr::WrExternalImage RenderMacIOSurfaceTextureHost::Lock(uint8_t aChannelIndex,
+                                                        gl::GLContext* aGL) {
+  if (mGL.get() != aGL) {
+    // release the texture handle in the previous gl context
+    DeleteTextureHandle();
+    mGL = aGL;
+    mGL->MakeCurrent();
+  }
+
+  if (!mSurface || !mGL || !mGL->MakeCurrent()) {
+    return InvalidToWrExternalImage();
+  }
+
+  if (!mTextureHandles[0]) {
+    MOZ_ASSERT(gl::GLContextCGL::Cast(mGL.get())->GetCGLContext());
+
+    // The result of GetPlaneCount() is 0 for single plane format, but it will
+    // be 2 if the format has 2 planar data.
+    CreateTextureForPlane(0, mGL, mSurface, &(mTextureHandles[0]));
+    for (size_t i = 1; i < mSurface->GetPlaneCount(); ++i) {
+      CreateTextureForPlane(i, mGL, mSurface, &(mTextureHandles[i]));
+    }
+  }
+
+  const auto uvs = GetUvCoords(GetSize(aChannelIndex));
+  return NativeTextureToWrExternalImage(GetGLHandle(aChannelIndex), uvs.first.x,
+                                        uvs.first.y, uvs.second.x,
+                                        uvs.second.y);
+}
+
+void RenderMacIOSurfaceTextureHost::Unlock() {}
+
+void RenderMacIOSurfaceTextureHost::DeleteTextureHandle() {
+  if (mTextureHandles[0] != 0 && mGL && mGL->MakeCurrent()) {
+    // Calling glDeleteTextures on 0 isn't an error. So, just make them a single
+    // call.
+    mGL->fDeleteTextures(3, mTextureHandles);
+    for (size_t i = 0; i < 3; ++i) {
+      mTextureHandles[i] = 0;
+    }
+  }
+}
+
+size_t RenderMacIOSurfaceTextureHost::GetPlaneCount() const {
+  size_t planeCount = mSurface->GetPlaneCount();
+  return planeCount > 0 ? planeCount : 1;
+}
+
+gfx::SurfaceFormat RenderMacIOSurfaceTextureHost::GetFormat() const {
+  return mSurface->GetFormat();
+}
+
+gfx::ColorDepth RenderMacIOSurfaceTextureHost::GetColorDepth() const {
+  return mSurface->GetColorDepth();
+}
+
+gfx::YUVRangedColorSpace RenderMacIOSurfaceTextureHost::GetYUVColorSpace()
+    const {
+  return ToYUVRangedColorSpace(mSurface->GetYUVColorSpace(),
+                               mSurface->GetColorRange());
+}
+
+bool RenderMacIOSurfaceTextureHost::MapPlane(RenderCompositor* aCompositor,
+                                             uint8_t aChannelIndex,
+                                             PlaneInfo& aPlaneInfo) {
+  if (!aChannelIndex) {
+    mSurface->Lock();
+  }
+  aPlaneInfo.mData = mSurface->GetBaseAddressOfPlane(aChannelIndex);
+  aPlaneInfo.mStride = mSurface->GetBytesPerRow(aChannelIndex);
+  aPlaneInfo.mSize =
+      gfx::IntSize(mSurface->GetDevicePixelWidth(aChannelIndex),
+                   mSurface->GetDevicePixelHeight(aChannelIndex));
+  return true;
+}
+
+void RenderMacIOSurfaceTextureHost::UnmapPlanes() { mSurface->Unlock(); }
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.h b/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.h
new file mode 100644
index 0000000000..173cd3c223
--- /dev/null
+++ b/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.h
@@ -0,0 +1,61 @@
+/* -*- 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_RENDERMACIOSURFACETEXTUREHOST_H
+#define MOZILLA_GFX_RENDERMACIOSURFACETEXTUREHOST_H
+
+#include "mozilla/gfx/MacIOSurface.h"
+#include "mozilla/layers/TextureHostOGL.h"
+#include "RenderTextureHostSWGL.h"
+
+namespace mozilla {
+
+namespace layers {
+class SurfaceDescriptorMacIOSurface;
+}
+
+namespace wr {
+
+class RenderMacIOSurfaceTextureHost final : public RenderTextureHostSWGL {
+ public:
+  explicit RenderMacIOSurfaceTextureHost(MacIOSurface* aSurface);
+
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+
+  gfx::IntSize GetSize(uint8_t aChannelIndex) const;
+  GLuint GetGLHandle(uint8_t aChannelIndex) const;
+
+  RenderMacIOSurfaceTextureHost* AsRenderMacIOSurfaceTextureHost() override {
+    return this;
+  }
+
+  size_t Bytes() override;
+
+  MacIOSurface* GetSurface() { return mSurface; }
+
+  // RenderTextureHostSWGL
+  size_t GetPlaneCount() const override;
+  gfx::SurfaceFormat GetFormat() const override;
+  gfx::ColorDepth GetColorDepth() const override;
+  gfx::YUVRangedColorSpace GetYUVColorSpace() const override;
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+  void UnmapPlanes() override;
+
+ private:
+  virtual ~RenderMacIOSurfaceTextureHost();
+  void DeleteTextureHandle();
+
+  RefPtr<MacIOSurface> mSurface;
+  RefPtr<gl::GLContext> mGL;
+  GLuint mTextureHandles[3];
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERMACIOSURFACETEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp
new file mode 100644
index 0000000000..db085f8f2f
--- /dev/null
+++ b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp
@@ -0,0 +1,78 @@
+/* -*- 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 "RenderSharedSurfaceTextureHost.h"
+
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/ImageDataSerializer.h"
+#include "mozilla/layers/SourceSurfaceSharedData.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderSharedSurfaceTextureHost::RenderSharedSurfaceTextureHost(
+    gfx::SourceSurfaceSharedDataWrapper* aSurface)
+    : mSurface(aSurface), mMap(), mLocked(false) {
+  MOZ_COUNT_CTOR_INHERITED(RenderSharedSurfaceTextureHost, RenderTextureHost);
+  MOZ_ASSERT(aSurface);
+}
+
+RenderSharedSurfaceTextureHost::~RenderSharedSurfaceTextureHost() {
+  MOZ_COUNT_DTOR_INHERITED(RenderSharedSurfaceTextureHost, RenderTextureHost);
+}
+
+wr::WrExternalImage RenderSharedSurfaceTextureHost::Lock(uint8_t aChannelIndex,
+                                                         gl::GLContext* aGL) {
+  if (!mLocked) {
+    if (NS_WARN_IF(
+            !mSurface->Map(gfx::DataSourceSurface::MapType::READ, &mMap))) {
+      return InvalidToWrExternalImage();
+    }
+    mLocked = true;
+  }
+
+  return RawDataToWrExternalImage(mMap.mData,
+                                  mMap.mStride * mSurface->GetSize().height);
+}
+
+void RenderSharedSurfaceTextureHost::Unlock() {
+  if (mLocked) {
+    mSurface->Unmap();
+    mLocked = false;
+  }
+}
+
+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
diff --git a/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.h b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.h
new file mode 100644
index 0000000000..2575abdac3
--- /dev/null
+++ b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.h
@@ -0,0 +1,57 @@
+/* -*- 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_RENDERSHAREDSURFACETEXTUREHOST_H
+#define MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOST_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 RenderSharedSurfaceTextureHost final : public RenderTextureHostSWGL {
+ public:
+  explicit RenderSharedSurfaceTextureHost(
+      gfx::SourceSurfaceSharedDataWrapper* aSurface);
+
+  // RenderTextureHost
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) 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();
+
+  RefPtr<gfx::SourceSurfaceSharedDataWrapper> mSurface;
+  gfx::DataSourceSurface::MappedSurface mMap;
+  bool mLocked;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderTextureHost.cpp b/gfx/webrender_bindings/RenderTextureHost.cpp
new file mode 100644
index 0000000000..71391bd1f7
--- /dev/null
+++ b/gfx/webrender_bindings/RenderTextureHost.cpp
@@ -0,0 +1,58 @@
+/* -*- 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 "RenderTextureHost.h"
+
+#include "GLContext.h"
+#include "RenderThread.h"
+
+namespace mozilla {
+namespace wr {
+
+void ActivateBindAndTexParameteri(gl::GLContext* aGL, GLenum aActiveTexture,
+                                  GLenum aBindTarget, GLuint aBindTexture) {
+  aGL->fActiveTexture(aActiveTexture);
+  aGL->fBindTexture(aBindTarget, aBindTexture);
+  // Initialize the mip filters to linear by default.
+  aGL->fTexParameteri(aBindTarget, LOCAL_GL_TEXTURE_MIN_FILTER,
+                      LOCAL_GL_LINEAR);
+  aGL->fTexParameteri(aBindTarget, LOCAL_GL_TEXTURE_MAG_FILTER,
+                      LOCAL_GL_LINEAR);
+}
+
+RenderTextureHost::RenderTextureHost() : mIsFromDRMSource(false) {
+  MOZ_COUNT_CTOR(RenderTextureHost);
+}
+
+RenderTextureHost::~RenderTextureHost() {
+  MOZ_ASSERT(RenderThread::IsInRenderThread());
+  MOZ_COUNT_DTOR(RenderTextureHost);
+}
+
+wr::WrExternalImage RenderTextureHost::Lock(uint8_t aChannelIndex,
+                                            gl::GLContext* aGL) {
+  return InvalidToWrExternalImage();
+}
+
+wr::WrExternalImage RenderTextureHost::LockSWGL(uint8_t aChannelIndex,
+                                                void* aContext,
+                                                RenderCompositor* aCompositor) {
+  return InvalidToWrExternalImage();
+}
+
+std::pair<gfx::Point, gfx::Point> RenderTextureHost::GetUvCoords(
+    gfx::IntSize aTextureSize) const {
+  return std::make_pair(gfx::Point(0.0, 0.0),
+                        gfx::Point(static_cast<float>(aTextureSize.width),
+                                   static_cast<float>(aTextureSize.height)));
+}
+
+void RenderTextureHost::Destroy() {
+  MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderTextureHost.h b/gfx/webrender_bindings/RenderTextureHost.h
new file mode 100644
index 0000000000..5798cf94f5
--- /dev/null
+++ b/gfx/webrender_bindings/RenderTextureHost.h
@@ -0,0 +1,141 @@
+/* -*- 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_RENDERTEXTUREHOST_H
+#define MOZILLA_GFX_RENDERTEXTUREHOST_H
+
+#include "GLConsts.h"
+#include "GLTypes.h"
+#include "nsISupportsImpl.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/layers/LayersSurfaces.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/webrender/webrender_ffi.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+
+namespace mozilla {
+
+namespace gl {
+class GLContext;
+}
+
+namespace wr {
+
+class RenderAndroidHardwareBufferTextureHost;
+class RenderAndroidSurfaceTextureHost;
+class RenderCompositor;
+class RenderDXGITextureHost;
+class RenderDXGIYCbCrTextureHost;
+class RenderDcompSurfaceTextureHost;
+class RenderMacIOSurfaceTextureHost;
+class RenderBufferTextureHost;
+class RenderTextureHostSWGL;
+class RenderTextureHostWrapper;
+
+void ActivateBindAndTexParameteri(gl::GLContext* aGL, GLenum aActiveTexture,
+                                  GLenum aBindTarget, GLuint aBindTexture);
+
+class RenderTextureHost {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RenderTextureHost)
+
+ public:
+  RenderTextureHost();
+
+  virtual gfx::SurfaceFormat GetFormat() const {
+    return gfx::SurfaceFormat::UNKNOWN;
+  }
+
+  virtual gfx::YUVRangedColorSpace GetYUVColorSpace() const {
+    return gfx::YUVRangedColorSpace::Default;
+  }
+
+  virtual wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL);
+
+  virtual void Unlock() {}
+
+  virtual wr::WrExternalImage LockSWGL(uint8_t aChannelIndex, void* aContext,
+                                       RenderCompositor* aCompositor);
+
+  virtual void UnlockSWGL() {}
+
+  virtual void ClearCachedResources() {}
+
+  // Called asynchronouly when corresponding TextureHost's mCompositableCount
+  // becomes from 0 to 1. For now, it is used only for
+  // SurfaceTextureHost/RenderAndroidSurfaceTextureHost.
+  virtual void PrepareForUse() {}
+  // Called asynchronouly when corresponding TextureHost's is actually going to
+  // be used by WebRender. For now, it is used only for
+  // SurfaceTextureHost/RenderAndroidSurfaceTextureHost.
+  virtual void NotifyForUse() {}
+  // Called asynchronouly when corresponding TextureHost's mCompositableCount
+  // becomes 0. For now, it is used only for
+  // SurfaceTextureHost/RenderAndroidSurfaceTextureHost.
+  virtual void NotifyNotUsed() {}
+  // Returns true when RenderTextureHost needs SyncObjectHost::Synchronize()
+  // call, before its usage.
+  virtual bool SyncObjectNeeded() { return false; }
+  // Returns true when this texture was generated from a DRM-protected source.
+  bool IsFromDRMSource() { return mIsFromDRMSource; }
+  void SetIsFromDRMSource(bool aIsFromDRMSource) {
+    mIsFromDRMSource = aIsFromDRMSource;
+  }
+
+  virtual size_t Bytes() = 0;
+
+  virtual RenderDXGITextureHost* AsRenderDXGITextureHost() { return nullptr; }
+  virtual RenderDXGIYCbCrTextureHost* AsRenderDXGIYCbCrTextureHost() {
+    return nullptr;
+  }
+
+  virtual RenderMacIOSurfaceTextureHost* AsRenderMacIOSurfaceTextureHost() {
+    return nullptr;
+  }
+
+  virtual RenderAndroidHardwareBufferTextureHost*
+  AsRenderAndroidHardwareBufferTextureHost() {
+    return nullptr;
+  }
+
+  virtual RenderAndroidSurfaceTextureHost* AsRenderAndroidSurfaceTextureHost() {
+    return nullptr;
+  }
+
+  virtual RenderTextureHostSWGL* AsRenderTextureHostSWGL() { return nullptr; }
+
+  virtual RenderDcompSurfaceTextureHost* AsRenderDcompSurfaceTextureHost() {
+    return nullptr;
+  }
+
+  virtual void Destroy();
+
+  virtual void SetIsSoftwareDecodedVideo() {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+  }
+  virtual bool IsSoftwareDecodedVideo() {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return false;
+  }
+
+ protected:
+  virtual ~RenderTextureHost();
+
+  // Returns the UV coordinates to be used when sampling the texture, in pixels.
+  // For most implementations these will be (0, 0) and (size.x, size.y), but
+  // some texture types (such as RenderAndroidSurfaceTextureHost) require an
+  // additional transform to be applied to the coordinates.
+  virtual std::pair<gfx::Point, gfx::Point> GetUvCoords(
+      gfx::IntSize aTextureSize) const;
+
+  bool mIsFromDRMSource;
+
+  friend class RenderTextureHostWrapper;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERTEXTUREHOST_H
diff --git a/gfx/webrender_bindings/RenderTextureHostSWGL.cpp b/gfx/webrender_bindings/RenderTextureHostSWGL.cpp
new file mode 100644
index 0000000000..ad2d960837
--- /dev/null
+++ b/gfx/webrender_bindings/RenderTextureHostSWGL.cpp
@@ -0,0 +1,231 @@
+/* -*- 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 "RenderTextureHostSWGL.h"
+
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/TextureHost.h"
+#include "RenderThread.h"
+
+namespace mozilla {
+namespace wr {
+
+bool RenderTextureHostSWGL::UpdatePlanes(RenderCompositor* aCompositor) {
+  wr_swgl_make_current(mContext);
+  size_t planeCount = GetPlaneCount();
+  bool texInit = false;
+  if (mPlanes.size() < planeCount) {
+    mPlanes.reserve(planeCount);
+    while (mPlanes.size() < planeCount) {
+      mPlanes.push_back(PlaneInfo(wr_swgl_gen_texture(mContext)));
+    }
+    texInit = true;
+  }
+  gfx::SurfaceFormat format = GetFormat();
+  gfx::ColorDepth colorDepth = GetColorDepth();
+  for (size_t i = 0; i < planeCount; i++) {
+    PlaneInfo& plane = mPlanes[i];
+    if (!MapPlane(aCompositor, i, plane)) {
+      if (i > 0) {
+        UnmapPlanes();
+      }
+      return false;
+    }
+    GLenum internalFormat = 0;
+    switch (format) {
+      case gfx::SurfaceFormat::B8G8R8A8:
+      case gfx::SurfaceFormat::B8G8R8X8:
+        MOZ_ASSERT(colorDepth == gfx::ColorDepth::COLOR_8);
+        internalFormat = LOCAL_GL_RGBA8;
+        break;
+      case gfx::SurfaceFormat::YUV:
+        switch (colorDepth) {
+          case gfx::ColorDepth::COLOR_8:
+            internalFormat = LOCAL_GL_R8;
+            break;
+          case gfx::ColorDepth::COLOR_10:
+          case gfx::ColorDepth::COLOR_12:
+          case gfx::ColorDepth::COLOR_16:
+            internalFormat = LOCAL_GL_R16;
+            break;
+        }
+        break;
+      case gfx::SurfaceFormat::NV12:
+        switch (colorDepth) {
+          case gfx::ColorDepth::COLOR_8:
+            internalFormat = i > 0 ? LOCAL_GL_RG8 : LOCAL_GL_R8;
+            break;
+          case gfx::ColorDepth::COLOR_10:
+          case gfx::ColorDepth::COLOR_12:
+          case gfx::ColorDepth::COLOR_16:
+            internalFormat = i > 0 ? LOCAL_GL_RG16 : LOCAL_GL_R16;
+            break;
+        }
+        break;
+      case gfx::SurfaceFormat::P010:
+        MOZ_ASSERT(colorDepth == gfx::ColorDepth::COLOR_10);
+        internalFormat = i > 0 ? LOCAL_GL_RG16 : LOCAL_GL_R16;
+        break;
+      case gfx::SurfaceFormat::YUV422:
+        MOZ_ASSERT(colorDepth == gfx::ColorDepth::COLOR_8);
+        internalFormat = LOCAL_GL_RGB_RAW_422_APPLE;
+        break;
+      default:
+        MOZ_RELEASE_ASSERT(false, "Unhandled external image format");
+        break;
+    }
+    wr_swgl_set_texture_buffer(mContext, plane.mTexture, internalFormat,
+                               plane.mSize.width, plane.mSize.height,
+                               plane.mStride, plane.mData, 0, 0);
+  }
+  if (texInit) {
+    // Initialize the mip filters to linear by default.
+    for (const auto& plane : mPlanes) {
+      wr_swgl_set_texture_parameter(mContext, plane.mTexture,
+                                    LOCAL_GL_TEXTURE_MIN_FILTER,
+                                    LOCAL_GL_LINEAR);
+      wr_swgl_set_texture_parameter(mContext, plane.mTexture,
+                                    LOCAL_GL_TEXTURE_MAG_FILTER,
+                                    LOCAL_GL_LINEAR);
+    }
+  }
+  return true;
+}
+
+bool RenderTextureHostSWGL::SetContext(void* aContext) {
+  if (mContext != aContext) {
+    CleanupPlanes();
+    mContext = aContext;
+    wr_swgl_reference_context(mContext);
+  }
+  return mContext != nullptr;
+}
+
+wr::WrExternalImage RenderTextureHostSWGL::LockSWGL(
+    uint8_t aChannelIndex, void* aContext, RenderCompositor* aCompositor) {
+  if (!SetContext(aContext)) {
+    return InvalidToWrExternalImage();
+  }
+  if (!mLocked) {
+    if (!UpdatePlanes(aCompositor)) {
+      return InvalidToWrExternalImage();
+    }
+    mLocked = true;
+  }
+  if (aChannelIndex >= mPlanes.size()) {
+    return InvalidToWrExternalImage();
+  }
+  const PlaneInfo& plane = mPlanes[aChannelIndex];
+
+  const auto uvs = GetUvCoords(plane.mSize);
+
+  // Prefer native textures, unless our backend forbids it.
+  // If the GetUvCoords call above returned anything other than the default,
+  // for example if this is a RenderAndroidSurfaceTextureHost, then this won't
+  // be handled correctly in the RawDataToWrExternalImage path. But we shouldn't
+  // hit this path in practice with a RenderAndroidSurfaceTextureHost.
+  layers::TextureHost::NativeTexturePolicy policy =
+      layers::TextureHost::BackendNativeTexturePolicy(
+          layers::WebRenderBackend::SOFTWARE, plane.mSize);
+  return policy == layers::TextureHost::NativeTexturePolicy::FORBID
+             ? RawDataToWrExternalImage((uint8_t*)plane.mData,
+                                        plane.mStride * plane.mSize.height)
+             : NativeTextureToWrExternalImage(plane.mTexture, uvs.first.x,
+                                              uvs.first.y, uvs.second.x,
+                                              uvs.second.y);
+}
+
+void RenderTextureHostSWGL::UnlockSWGL() {
+  if (mLocked) {
+    mLocked = false;
+    UnmapPlanes();
+  }
+}
+
+void RenderTextureHostSWGL::CleanupPlanes() {
+  if (!mContext) {
+    return;
+  }
+  if (!mPlanes.empty()) {
+    wr_swgl_make_current(mContext);
+    for (const auto& plane : mPlanes) {
+      wr_swgl_delete_texture(mContext, plane.mTexture);
+    }
+    mPlanes.clear();
+  }
+  wr_swgl_destroy_context(mContext);
+  mContext = nullptr;
+}
+
+RenderTextureHostSWGL::~RenderTextureHostSWGL() { CleanupPlanes(); }
+
+bool RenderTextureHostSWGL::LockSWGLCompositeSurface(
+    void* aContext, wr::SWGLCompositeSurfaceInfo* aInfo) {
+  if (!SetContext(aContext)) {
+    return false;
+  }
+  if (!mLocked) {
+    if (!UpdatePlanes(nullptr)) {
+      return false;
+    }
+    mLocked = true;
+  }
+  MOZ_ASSERT(mPlanes.size() <= 3);
+  for (size_t i = 0; i < mPlanes.size(); i++) {
+    aInfo->textures[i] = mPlanes[i].mTexture;
+  }
+  switch (GetFormat()) {
+    case gfx::SurfaceFormat::YUV:
+    case gfx::SurfaceFormat::NV12:
+    case gfx::SurfaceFormat::P010:
+    case gfx::SurfaceFormat::YUV422: {
+      aInfo->yuv_planes = mPlanes.size();
+      auto colorSpace = GetYUVColorSpace();
+      aInfo->color_space = ToWrYuvRangedColorSpace(colorSpace);
+      auto colorDepth = GetColorDepth();
+      aInfo->color_depth = ToWrColorDepth(colorDepth);
+      break;
+    }
+    case gfx::SurfaceFormat::B8G8R8A8:
+    case gfx::SurfaceFormat::B8G8R8X8:
+      break;
+    default:
+      gfxCriticalNote << "Unhandled external image format: " << GetFormat();
+      MOZ_RELEASE_ASSERT(false, "Unhandled external image format");
+      break;
+  }
+  aInfo->size.width = mPlanes[0].mSize.width;
+  aInfo->size.height = mPlanes[0].mSize.height;
+  return true;
+}
+
+bool wr_swgl_lock_composite_surface(void* aContext, wr::ExternalImageId aId,
+                                    wr::SWGLCompositeSurfaceInfo* aInfo) {
+  RenderTextureHost* texture = RenderThread::Get()->GetRenderTexture(aId);
+  if (!texture) {
+    return false;
+  }
+  RenderTextureHostSWGL* swglTex = texture->AsRenderTextureHostSWGL();
+  if (!swglTex) {
+    return false;
+  }
+  return swglTex->LockSWGLCompositeSurface(aContext, aInfo);
+}
+
+void wr_swgl_unlock_composite_surface(void* aContext, wr::ExternalImageId aId) {
+  RenderTextureHost* texture = RenderThread::Get()->GetRenderTexture(aId);
+  if (!texture) {
+    return;
+  }
+  RenderTextureHostSWGL* swglTex = texture->AsRenderTextureHostSWGL();
+  if (!swglTex) {
+    return;
+  }
+  swglTex->UnlockSWGL();
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderTextureHostSWGL.h b/gfx/webrender_bindings/RenderTextureHostSWGL.h
new file mode 100644
index 0000000000..b5d1e92056
--- /dev/null
+++ b/gfx/webrender_bindings/RenderTextureHostSWGL.h
@@ -0,0 +1,80 @@
+/* -*- 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_RENDERTEXTUREHOSTSWGL_H
+#define MOZILLA_GFX_RENDERTEXTUREHOSTSWGL_H
+
+#include "GLTypes.h"
+#include "RenderTextureHost.h"
+
+namespace mozilla {
+namespace wr {
+
+class RenderTextureHostSWGL : public RenderTextureHost {
+ public:
+  RenderTextureHostSWGL() {}
+
+  wr::WrExternalImage LockSWGL(uint8_t aChannelIndex, void* aContext,
+                               RenderCompositor* aCompositor) override;
+
+  void UnlockSWGL() override;
+
+  RenderTextureHostSWGL* AsRenderTextureHostSWGL() override { return this; }
+
+  virtual size_t GetPlaneCount() const = 0;
+
+  virtual gfx::ColorDepth GetColorDepth() const {
+    return gfx::ColorDepth::COLOR_8;
+  }
+
+  struct PlaneInfo {
+    explicit PlaneInfo(GLuint aTexture) : mTexture(aTexture) {}
+
+    GLuint mTexture = 0;
+    void* mData = nullptr;
+    int32_t mStride = 0;
+    gfx::IntSize mSize;
+  };
+
+  virtual bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                        PlaneInfo& aPlaneInfo) = 0;
+
+  virtual void UnmapPlanes() = 0;
+
+  // Lock this texture host as an attached external image for a SWGL compositor
+  // surface. See swgl_bindings.rs for a description of the resulting
+  // WrSWGLCompositeSurfaceInfo. This is paired with a call to UnlockSWGL when
+  // composition is done.
+  bool LockSWGLCompositeSurface(void* aContext,
+                                wr::SWGLCompositeSurfaceInfo* aInfo);
+
+  size_t BytesFromPlanes() {
+    NS_ASSERTION(mPlanes.size(), "Can't compute bytes without any planes");
+    size_t bytes = 0;
+    for (auto& plane : mPlanes) {
+      bytes += plane.mStride * plane.mSize.height;
+    }
+    return bytes;
+  }
+
+ protected:
+  bool mLocked = false;
+  void* mContext = nullptr;
+  std::vector<PlaneInfo> mPlanes;
+
+  bool SetContext(void* aContext);
+
+  bool UpdatePlanes(RenderCompositor* aCompositor);
+
+  void CleanupPlanes();
+
+  virtual ~RenderTextureHostSWGL();
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERTEXTUREHOSTSWGL_H
diff --git a/gfx/webrender_bindings/RenderTextureHostWrapper.cpp b/gfx/webrender_bindings/RenderTextureHostWrapper.cpp
new file mode 100644
index 0000000000..b700eafcfb
--- /dev/null
+++ b/gfx/webrender_bindings/RenderTextureHostWrapper.cpp
@@ -0,0 +1,212 @@
+/* -*- 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 "RenderTextureHostWrapper.h"
+
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/RemoteTextureMap.h"
+#include "mozilla/webrender/RenderThread.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderTextureHostWrapper::RenderTextureHostWrapper(
+    ExternalImageId aExternalImageId)
+    : mExternalImageId(aExternalImageId) {
+  MOZ_COUNT_CTOR_INHERITED(RenderTextureHostWrapper, RenderTextureHost);
+  EnsureTextureHost();
+}
+
+RenderTextureHostWrapper::~RenderTextureHostWrapper() {
+  MOZ_COUNT_DTOR_INHERITED(RenderTextureHostWrapper, RenderTextureHost);
+}
+
+void RenderTextureHostWrapper::EnsureTextureHost() const {
+  if (mTextureHost) {
+    return;
+  }
+
+  mTextureHost = RenderThread::Get()->GetRenderTexture(mExternalImageId);
+  MOZ_ASSERT(mTextureHost);
+  if (!mTextureHost) {
+    gfxCriticalNoteOnce << "Failed to get RenderTextureHost for extId:"
+                        << AsUint64(mExternalImageId);
+  }
+}
+
+wr::WrExternalImage RenderTextureHostWrapper::Lock(uint8_t aChannelIndex,
+                                                   gl::GLContext* aGL) {
+  if (!mTextureHost) {
+    return InvalidToWrExternalImage();
+  }
+
+  return mTextureHost->Lock(aChannelIndex, aGL);
+}
+
+void RenderTextureHostWrapper::Unlock() {
+  if (mTextureHost) {
+    mTextureHost->Unlock();
+  }
+}
+
+std::pair<gfx::Point, gfx::Point> RenderTextureHostWrapper::GetUvCoords(
+    gfx::IntSize aTextureSize) const {
+  if (mTextureHost) {
+    return mTextureHost->GetUvCoords(aTextureSize);
+  }
+  return RenderTextureHost::GetUvCoords(aTextureSize);
+}
+
+void RenderTextureHostWrapper::ClearCachedResources() {
+  if (mTextureHost) {
+    mTextureHost->ClearCachedResources();
+  }
+}
+
+void RenderTextureHostWrapper::PrepareForUse() {
+  if (!mTextureHost) {
+    return;
+  }
+  mTextureHost->PrepareForUse();
+}
+
+void RenderTextureHostWrapper::NotifyForUse() {
+  if (!mTextureHost) {
+    return;
+  }
+  mTextureHost->NotifyForUse();
+}
+
+void RenderTextureHostWrapper::NotifyNotUsed() {
+  if (!mTextureHost) {
+    return;
+  }
+  mTextureHost->NotifyNotUsed();
+}
+
+bool RenderTextureHostWrapper::SyncObjectNeeded() { return false; }
+
+RenderMacIOSurfaceTextureHost*
+RenderTextureHostWrapper::AsRenderMacIOSurfaceTextureHost() {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  return mTextureHost->AsRenderMacIOSurfaceTextureHost();
+}
+
+RenderDXGITextureHost* RenderTextureHostWrapper::AsRenderDXGITextureHost() {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  return mTextureHost->AsRenderDXGITextureHost();
+}
+
+RenderDXGIYCbCrTextureHost*
+RenderTextureHostWrapper::AsRenderDXGIYCbCrTextureHost() {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  return mTextureHost->AsRenderDXGIYCbCrTextureHost();
+}
+
+RenderDcompSurfaceTextureHost*
+RenderTextureHostWrapper::AsRenderDcompSurfaceTextureHost() {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  return mTextureHost->AsRenderDcompSurfaceTextureHost();
+}
+
+RenderTextureHostSWGL* RenderTextureHostWrapper::AsRenderTextureHostSWGL() {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  return mTextureHost->AsRenderTextureHostSWGL();
+}
+
+RenderAndroidHardwareBufferTextureHost*
+RenderTextureHostWrapper::AsRenderAndroidHardwareBufferTextureHost() {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  return mTextureHost->AsRenderAndroidHardwareBufferTextureHost();
+}
+
+RenderAndroidSurfaceTextureHost*
+RenderTextureHostWrapper::AsRenderAndroidSurfaceTextureHost() {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  return mTextureHost->AsRenderAndroidSurfaceTextureHost();
+}
+
+RenderTextureHostSWGL* RenderTextureHostWrapper::EnsureRenderTextureHostSWGL()
+    const {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  return mTextureHost->AsRenderTextureHostSWGL();
+}
+
+void RenderTextureHostWrapper::SetIsSoftwareDecodedVideo() {
+  if (!mTextureHost) {
+    return;
+  }
+  return mTextureHost->SetIsSoftwareDecodedVideo();
+}
+
+bool RenderTextureHostWrapper::IsSoftwareDecodedVideo() {
+  if (!mTextureHost) {
+    return false;
+  }
+  return mTextureHost->IsSoftwareDecodedVideo();
+}
+
+size_t RenderTextureHostWrapper::GetPlaneCount() const {
+  if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) {
+    return swglHost->GetPlaneCount();
+  }
+  return 0;
+}
+
+gfx::SurfaceFormat RenderTextureHostWrapper::GetFormat() const {
+  if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) {
+    return swglHost->GetFormat();
+  }
+  return gfx::SurfaceFormat::UNKNOWN;
+}
+
+gfx::ColorDepth RenderTextureHostWrapper::GetColorDepth() const {
+  if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) {
+    return swglHost->GetColorDepth();
+  }
+  return gfx::ColorDepth::COLOR_8;
+}
+
+gfx::YUVRangedColorSpace RenderTextureHostWrapper::GetYUVColorSpace() const {
+  if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) {
+    return swglHost->GetYUVColorSpace();
+  }
+  return gfx::YUVRangedColorSpace::Default;
+}
+
+bool RenderTextureHostWrapper::MapPlane(RenderCompositor* aCompositor,
+                                        uint8_t aChannelIndex,
+                                        PlaneInfo& aPlaneInfo) {
+  if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) {
+    return swglHost->MapPlane(aCompositor, aChannelIndex, aPlaneInfo);
+  }
+  return false;
+}
+
+void RenderTextureHostWrapper::UnmapPlanes() {
+  if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) {
+    swglHost->UnmapPlanes();
+  }
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RenderTextureHostWrapper.h b/gfx/webrender_bindings/RenderTextureHostWrapper.h
new file mode 100644
index 0000000000..67f26b2a65
--- /dev/null
+++ b/gfx/webrender_bindings/RenderTextureHostWrapper.h
@@ -0,0 +1,81 @@
+/* -*- 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_RENDERTEXTUREHOSTWRAPPER_H
+#define MOZILLA_GFX_RENDERTEXTUREHOSTWRAPPER_H
+
+#include "RenderTextureHostSWGL.h"
+
+namespace mozilla {
+
+namespace wr {
+
+/**
+ * RenderTextureHost of GPUVideoTextureHost.
+ *
+ * GPUVideoTextureHost wraps TextureHost. This class wraps RenderTextureHost of
+ * the wrapped TextureHost. Lifetime of the wrapped TextureHost is usually
+ * longer than GPUVideoTextureHost and the wrapped TextureHost is used by
+ * multiple GPUVideoTextureHosts. This class is used to reduce recreations of
+ * the wrappded RenderTextureHost. Initializations of some
+ * RenderTextureHosts(RenderDXGITextureHost and
+ * RenderDXGIYCbCrTextureHost) have overhead.
+ */
+class RenderTextureHostWrapper final : public RenderTextureHostSWGL {
+ public:
+  explicit RenderTextureHostWrapper(ExternalImageId aExternalImageId);
+
+  // RenderTextureHost
+  wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
+  void Unlock() override;
+  void ClearCachedResources() override;
+  void PrepareForUse() override;
+  void NotifyForUse() override;
+  void NotifyNotUsed() override;
+  bool SyncObjectNeeded() override;
+  RenderMacIOSurfaceTextureHost* AsRenderMacIOSurfaceTextureHost() override;
+  RenderDXGITextureHost* AsRenderDXGITextureHost() override;
+  RenderDXGIYCbCrTextureHost* AsRenderDXGIYCbCrTextureHost() override;
+  RenderDcompSurfaceTextureHost* AsRenderDcompSurfaceTextureHost() override;
+  RenderAndroidHardwareBufferTextureHost*
+  AsRenderAndroidHardwareBufferTextureHost() override;
+  RenderAndroidSurfaceTextureHost* AsRenderAndroidSurfaceTextureHost() override;
+  RenderTextureHostSWGL* AsRenderTextureHostSWGL() override;
+  void SetIsSoftwareDecodedVideo() override;
+  bool IsSoftwareDecodedVideo() override;
+
+  // RenderTextureHostSWGL
+  size_t GetPlaneCount() const override;
+  gfx::SurfaceFormat GetFormat() const override;
+  gfx::ColorDepth GetColorDepth() const override;
+  gfx::YUVRangedColorSpace GetYUVColorSpace() const override;
+  bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
+                PlaneInfo& aPlaneInfo) override;
+  void UnmapPlanes() override;
+
+  // This is just a wrapper, so doesn't need to report the
+  // size of the wrapped object (which reports itself).
+  size_t Bytes() override { return 0; }
+
+ protected:
+  // RenderTextureHost
+  std::pair<gfx::Point, gfx::Point> GetUvCoords(
+      gfx::IntSize aTextureSize) const override;
+
+ private:
+  ~RenderTextureHostWrapper() override;
+
+  void EnsureTextureHost() const;
+  RenderTextureHostSWGL* EnsureRenderTextureHostSWGL() const;
+
+  ExternalImageId mExternalImageId;
+  mutable RefPtr<RenderTextureHost> mTextureHost;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_RENDERTEXTUREHOSTWRAPPER_H
diff --git a/gfx/webrender_bindings/RenderThread.cpp b/gfx/webrender_bindings/RenderThread.cpp
new file mode 100644
index 0000000000..89fc339c03
--- /dev/null
+++ b/gfx/webrender_bindings/RenderThread.cpp
@@ -0,0 +1,1649 @@
+/* -*- 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 "base/task.h"
+#include "GeckoProfiler.h"
+#include "gfxPlatform.h"
+#include "GLContext.h"
+#include "RenderThread.h"
+#include "nsThread.h"
+#include "nsThreadUtils.h"
+#include "transport/runnable_utils.h"
+#include "mozilla/BackgroundHangMonitor.h"
+#include "mozilla/layers/AsyncImagePipelineManager.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/GPUParent.h"
+#include "mozilla/gfx/GPUProcessManager.h"
+#include "mozilla/glean/GleanMetrics.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/CompositorManagerParent.h"
+#include "mozilla/layers/WebRenderBridgeParent.h"
+#include "mozilla/layers/SharedSurfacesParent.h"
+#include "mozilla/layers/SurfacePool.h"
+#include "mozilla/layers/SynchronousTask.h"
+#include "mozilla/PerfStats.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/webrender/RendererOGL.h"
+#include "mozilla/webrender/RenderTextureHost.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "OGLShaderProgram.h"
+
+#ifdef XP_WIN
+#  include "GLContextEGL.h"
+#  include "GLLibraryEGL.h"
+#  include "mozilla/widget/WinCompositorWindowThread.h"
+#  include "mozilla/gfx/DeviceManagerDx.h"
+#  include "mozilla/webrender/DCLayerTree.h"
+// #  include "nsWindowsHelpers.h"
+// #  include <d3d11.h>
+#endif
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "GLLibraryEGL.h"
+#  include "mozilla/webrender/RenderAndroidSurfaceTextureHost.h"
+#endif
+
+#ifdef MOZ_WIDGET_GTK
+#  include "mozilla/WidgetUtilsGtk.h"
+#  include "GLLibraryEGL.h"
+#endif
+
+using namespace mozilla;
+
+static already_AddRefed<gl::GLContext> CreateGLContext(nsACString& aError);
+
+MOZ_DEFINE_MALLOC_SIZE_OF(WebRenderRendererMallocSizeOf)
+
+namespace mozilla::wr {
+
+LazyLogModule gRenderThreadLog("RenderThread");
+// Should be called only on RenderThread, since LazyLogModule is not thread safe
+#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
+
+static StaticRefPtr<RenderThread> sRenderThread;
+static mozilla::BackgroundHangMonitor* sBackgroundHangMonitor;
+#ifdef DEBUG
+static bool sRenderThreadEverStarted = false;
+#endif
+
+RenderThread::RenderThread(RefPtr<nsIThread> aThread)
+    : mThread(std::move(aThread)),
+      mThreadPool(false),
+      mThreadPoolLP(true),
+      mSingletonGLIsForHardwareWebRender(true),
+      mWindowInfos("RenderThread.mWindowInfos"),
+      mRenderTextureMapLock("RenderThread.mRenderTextureMapLock"),
+      mHasShutdown(false),
+      mHandlingDeviceReset(false),
+      mHandlingWebRenderError(false) {}
+
+RenderThread::~RenderThread() { MOZ_ASSERT(mRenderTexturesDeferred.empty()); }
+
+// static
+RenderThread* RenderThread::Get() { return sRenderThread; }
+
+// static
+void RenderThread::Start(uint32_t aNamespace) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!sRenderThread);
+
+#ifdef DEBUG
+  // Check to ensure nobody will try to ever start us more than once during
+  // the process' lifetime (in particular after ShutDown).
+  MOZ_ASSERT(!sRenderThreadEverStarted);
+  sRenderThreadEverStarted = true;
+#endif
+
+  // When the CanvasRenderer thread is disabled, WebGL may be handled on this
+  // thread, requiring a bigger stack size. See: CanvasManagerParent::Init
+  //
+  // This is 4M, which is higher than the default 256K.
+  // Increased with bug 1753349 to accommodate the `chromium/5359` branch of
+  // ANGLE, which has large peak stack usage for some pathological shader
+  // compilations.
+  //
+  // Previously increased to 512K to accommodate Mesa in bug 1753340.
+  //
+  // Previously increased to 320K to avoid a stack overflow in the
+  // Intel Vulkan driver initialization in bug 1716120.
+  //
+  // Note: we only override it if it's limited already.
+  uint32_t stackSize = nsIThreadManager::DEFAULT_STACK_SIZE;
+  if (stackSize && !gfx::gfxVars::SupportsThreadsafeGL()) {
+    stackSize = std::max(stackSize, 4096U << 10);
+  }
+
+  RefPtr<nsIThread> thread;
+  nsresult rv = NS_NewNamedThread(
+      "Renderer", getter_AddRefs(thread),
+      NS_NewRunnableFunction(
+          "Renderer::BackgroundHanSetup",
+          []() {
+            sBackgroundHangMonitor = new mozilla::BackgroundHangMonitor(
+                "Render",
+                /* Timeout values are powers-of-two to enable us get better
+                   data. 128ms is chosen for transient hangs because 8Hz should
+                   be the minimally acceptable goal for Render
+                   responsiveness (normal goal is 60Hz). */
+                128,
+                /* 2048ms is chosen for permanent hangs because it's longer than
+                 * most Render hangs seen in the wild, but is short enough
+                 * to not miss getting native hang stacks. */
+                2048);
+            nsCOMPtr<nsIThread> thread = NS_GetCurrentThread();
+            nsThread* nsthread = static_cast<nsThread*>(thread.get());
+            nsthread->SetUseHangMonitor(true);
+            nsthread->SetPriority(nsISupportsPriority::PRIORITY_HIGH);
+          }),
+      {.stackSize = stackSize});
+
+  if (NS_FAILED(rv)) {
+    gfxCriticalNote << "Failed to create Renderer thread: "
+                    << gfx::hexa((uint32_t)rv);
+    return;
+  }
+
+  sRenderThread = new RenderThread(thread);
+#ifdef XP_WIN
+  widget::WinCompositorWindowThread::Start();
+#endif
+  layers::SharedSurfacesParent::Initialize();
+
+  RefPtr<Runnable> runnable = WrapRunnable(
+      RefPtr<RenderThread>(sRenderThread.get()), &RenderThread::InitDeviceTask);
+  sRenderThread->PostRunnable(runnable.forget());
+}
+
+// static
+void RenderThread::ShutDown() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(sRenderThread);
+
+  {
+    MutexAutoLock lock(sRenderThread->mRenderTextureMapLock);
+    sRenderThread->mHasShutdown = true;
+  }
+
+  RefPtr<Runnable> runnable = WrapRunnable(
+      RefPtr<RenderThread>(sRenderThread.get()), &RenderThread::ShutDownTask);
+  sRenderThread->PostRunnable(runnable.forget());
+
+  // This will empty the thread queue and thus run the above runnable while
+  // spinning the MT event loop.
+  nsCOMPtr<nsIThread> oldThread = sRenderThread->GetRenderThread();
+  oldThread->Shutdown();
+
+  layers::SharedSurfacesParent::Shutdown();
+
+#ifdef XP_WIN
+  if (widget::WinCompositorWindowThread::Get()) {
+    widget::WinCompositorWindowThread::ShutDown();
+  }
+#endif
+
+  // We null this out only after we finished shutdown to give everbody the
+  // chance to check for sRenderThread->mHasShutdown. Hopefully everybody
+  // checks this before using us!
+  sRenderThread = nullptr;
+}
+
+extern void ClearAllBlobImageResources();
+
+void RenderThread::ShutDownTask() {
+  MOZ_ASSERT(IsInRenderThread());
+  LOG("RenderThread::ShutDownTask()");
+
+  {
+    // Clear RenderTextureHosts
+    MutexAutoLock lock(mRenderTextureMapLock);
+    mRenderTexturesDeferred.clear();
+    mRenderTextures.clear();
+    mSyncObjectNeededRenderTextures.clear();
+    mRenderTextureOps.clear();
+  }
+
+  // Let go of our handle to the (internally ref-counted) thread pool.
+  mThreadPool.Release();
+  mThreadPoolLP.Release();
+
+  // Releasing on the render thread will allow us to avoid dispatching to remove
+  // remaining textures from the texture map.
+  layers::SharedSurfacesParent::ShutdownRenderThread();
+
+#ifdef XP_WIN
+  DCLayerTree::Shutdown();
+#endif
+
+  ClearAllBlobImageResources();
+  ClearSingletonGL();
+  ClearSharedSurfacePool();
+}
+
+// static
+bool RenderThread::IsInRenderThread() {
+  return sRenderThread && sRenderThread->mThread == NS_GetCurrentThread();
+}
+
+// static
+already_AddRefed<nsIThread> RenderThread::GetRenderThread() {
+  nsCOMPtr<nsIThread> thread;
+  if (sRenderThread) {
+    thread = sRenderThread->mThread;
+  }
+  return thread.forget();
+}
+
+void RenderThread::DoAccumulateMemoryReport(
+    MemoryReport aReport,
+    const RefPtr<MemoryReportPromise::Private>& aPromise) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  for (auto& r : mRenderers) {
+    r.second->AccumulateMemoryReport(&aReport);
+  }
+
+  // Note memory used by the shader cache, which is shared across all WR
+  // instances.
+  MOZ_ASSERT(aReport.shader_cache == 0);
+  if (mProgramCache) {
+    aReport.shader_cache = wr_program_cache_report_memory(
+        mProgramCache->Raw(), &WebRenderRendererMallocSizeOf);
+  }
+
+  size_t renderTextureMemory = 0;
+  {
+    MutexAutoLock lock(mRenderTextureMapLock);
+    for (const auto& entry : mRenderTextures) {
+      renderTextureMemory += entry.second->Bytes();
+    }
+  }
+  aReport.render_texture_hosts = renderTextureMemory;
+
+  aPromise->Resolve(aReport, __func__);
+}
+
+// static
+RefPtr<MemoryReportPromise> RenderThread::AccumulateMemoryReport(
+    MemoryReport aInitial) {
+  RefPtr<MemoryReportPromise::Private> p =
+      new MemoryReportPromise::Private(__func__);
+  MOZ_ASSERT(!IsInRenderThread());
+  if (!Get()) {
+    // This happens when the GPU process fails to start and we fall back to the
+    // basic compositor in the parent process. We could assert against this if
+    // we made the webrender detection code in gfxPlatform.cpp smarter. See bug
+    // 1494430 comment 12.
+    NS_WARNING("No render thread, returning empty memory report");
+    p->Resolve(aInitial, __func__);
+    return p;
+  }
+
+  Get()->PostRunnable(
+      NewRunnableMethod<MemoryReport, RefPtr<MemoryReportPromise::Private>>(
+          "wr::RenderThread::DoAccumulateMemoryReport", Get(),
+          &RenderThread::DoAccumulateMemoryReport, aInitial, p));
+
+  return p;
+}
+
+void RenderThread::AddRenderer(wr::WindowId aWindowId,
+                               UniquePtr<RendererOGL> aRenderer) {
+  MOZ_ASSERT(IsInRenderThread());
+  LOG("RenderThread::AddRenderer() aWindowId %" PRIx64 "", AsUint64(aWindowId));
+
+  if (mHasShutdown) {
+    return;
+  }
+
+  mRenderers[aWindowId] = std::move(aRenderer);
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::GraphicsNumRenderers,
+      (unsigned int)mRenderers.size());
+
+  auto windows = mWindowInfos.Lock();
+  windows->emplace(AsUint64(aWindowId), new WindowInfo());
+  mWrNotifierEventsQueues.emplace(AsUint64(aWindowId),
+                                  new std::queue<WrNotifierEvent>);
+}
+
+void RenderThread::RemoveRenderer(wr::WindowId aWindowId) {
+  MOZ_ASSERT(IsInRenderThread());
+  LOG("RenderThread::RemoveRenderer() aWindowId %" PRIx64 "",
+      AsUint64(aWindowId));
+
+  if (mHasShutdown) {
+    return;
+  }
+
+  mRenderers.erase(aWindowId);
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::GraphicsNumRenderers,
+      (unsigned int)mRenderers.size());
+
+  if (mRenderers.empty()) {
+    if (mHandlingDeviceReset) {
+      ClearSingletonGL();
+    }
+    mHandlingDeviceReset = false;
+    mHandlingWebRenderError = false;
+  }
+
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  MOZ_ASSERT(it != windows->end());
+  windows->erase(it);
+
+  // Defer std::deque<WrNotifierEvent> remove, RemoveRenderer() is called in
+  // HandleWrNotifierEvents().
+  RefPtr<Runnable> runnable =
+      NS_NewRunnableFunction("RenderThread::RemoveRenderer", [aWindowId]() {
+        auto* self = RenderThread::Get();
+        auto it = self->mWrNotifierEventsQueues.find(AsUint64(aWindowId));
+        if (it == self->mWrNotifierEventsQueues.end()) {
+          return;
+        }
+        self->mWrNotifierEventsQueues.erase(it);
+      });
+  RenderThread::Get()->PostRunnable(runnable.forget());
+}
+
+RendererOGL* RenderThread::GetRenderer(wr::WindowId aWindowId) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  auto it = mRenderers.find(aWindowId);
+  MOZ_ASSERT(it != mRenderers.end());
+
+  if (it == mRenderers.end()) {
+    return nullptr;
+  }
+
+  return it->second.get();
+}
+
+size_t RenderThread::RendererCount() const {
+  MOZ_ASSERT(IsInRenderThread());
+  return mRenderers.size();
+}
+
+size_t RenderThread::ActiveRendererCount() const {
+  MOZ_ASSERT(IsInRenderThread());
+  size_t num_active = 0;
+  for (const auto& it : mRenderers) {
+    if (!it.second->IsPaused()) {
+      num_active++;
+    }
+  }
+  return num_active;
+}
+
+void RenderThread::WrNotifierEvent_WakeUp(WrWindowId aWindowId,
+                                          bool aCompositeNeeded) {
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  if (it == windows->end()) {
+    MOZ_ASSERT(false);
+    return;
+  }
+
+  WindowInfo* info = it->second.get();
+
+  info->mPendingWrNotifierEvents.emplace(
+      WrNotifierEvent::WakeUp(aCompositeNeeded));
+  PostWrNotifierEvents(aWindowId, info);
+}
+
+void RenderThread::WrNotifierEvent_NewFrameReady(WrWindowId aWindowId,
+                                                 bool aCompositeNeeded,
+                                                 FramePublishId aPublishId) {
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  if (it == windows->end()) {
+    MOZ_ASSERT(false);
+    return;
+  }
+  WindowInfo* info = it->second.get();
+
+  info->mPendingWrNotifierEvents.emplace(
+      WrNotifierEvent::NewFrameReady(aCompositeNeeded, aPublishId));
+  PostWrNotifierEvents(aWindowId, info);
+}
+
+void RenderThread::WrNotifierEvent_ExternalEvent(WrWindowId aWindowId,
+                                                 size_t aRawEvent) {
+  UniquePtr<RendererEvent> evt(reinterpret_cast<RendererEvent*>(aRawEvent));
+  {
+    auto windows = mWindowInfos.Lock();
+    auto it = windows->find(AsUint64(aWindowId));
+    if (it == windows->end()) {
+      MOZ_ASSERT(false);
+      return;
+    }
+    WindowInfo* info = it->second.get();
+
+    info->mPendingWrNotifierEvents.emplace(
+        WrNotifierEvent::ExternalEvent(std::move(evt)));
+    PostWrNotifierEvents(aWindowId, info);
+  }
+}
+
+void RenderThread::PostWrNotifierEvents(WrWindowId aWindowId) {
+  {
+    auto windows = mWindowInfos.Lock();
+    auto it = windows->find(AsUint64(aWindowId));
+    if (it == windows->end()) {
+      MOZ_ASSERT(false);
+      return;
+    }
+    WindowInfo* info = it->second.get();
+    PostWrNotifierEvents(aWindowId, info);
+  }
+}
+
+void RenderThread::PostWrNotifierEvents(WrWindowId aWindowId,
+                                        WindowInfo* aInfo) {
+  // Runnable has already been triggered.
+  if (aInfo->mWrNotifierEventsRunnable) {
+    return;
+  }
+
+  // Runnable has not been triggered yet.
+  RefPtr<nsIRunnable> runnable = NewRunnableMethod<WrWindowId>(
+      "RenderThread::HandleWrNotifierEvents", this,
+      &RenderThread::HandleWrNotifierEvents, aWindowId);
+  aInfo->mWrNotifierEventsRunnable = runnable;
+  PostRunnable(runnable.forget());
+}
+
+void RenderThread::HandleWrNotifierEvents(WrWindowId aWindowId) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  auto eventsIt = mWrNotifierEventsQueues.find(AsUint64(aWindowId));
+  if (eventsIt == mWrNotifierEventsQueues.end()) {
+    return;
+  }
+  auto* events = eventsIt->second.get();
+
+  {
+    auto windows = mWindowInfos.Lock();
+    auto infoIt = windows->find(AsUint64(aWindowId));
+    if (infoIt == windows->end()) {
+      MOZ_ASSERT(false);
+      return;
+    }
+    WindowInfo* info = infoIt->second.get();
+    info->mWrNotifierEventsRunnable = nullptr;
+
+    if (events->empty() && !info->mPendingWrNotifierEvents.empty()) {
+      events->swap(info->mPendingWrNotifierEvents);
+    }
+  }
+
+  bool handleNext = true;
+
+  while (!events->empty() && handleNext) {
+    auto& front = events->front();
+    switch (front.mTag) {
+      case WrNotifierEvent::Tag::WakeUp:
+        WrNotifierEvent_HandleWakeUp(aWindowId, front.CompositeNeeded());
+        handleNext = false;
+        break;
+      case WrNotifierEvent::Tag::NewFrameReady:
+        WrNotifierEvent_HandleNewFrameReady(aWindowId, front.CompositeNeeded(),
+                                            front.PublishId());
+        handleNext = false;
+        break;
+      case WrNotifierEvent::Tag::ExternalEvent:
+        WrNotifierEvent_HandleExternalEvent(aWindowId, front.ExternalEvent());
+        break;
+    }
+    events->pop();
+  }
+
+  {
+    auto windows = mWindowInfos.Lock();
+    auto it = windows->find(AsUint64(aWindowId));
+    if (it == windows->end()) {
+      return;
+    }
+    WindowInfo* info = it->second.get();
+
+    if (!events->empty() || !info->mPendingWrNotifierEvents.empty()) {
+      PostWrNotifierEvents(aWindowId, info);
+    }
+  }
+}
+
+void RenderThread::WrNotifierEvent_HandleWakeUp(wr::WindowId aWindowId,
+                                                bool aCompositeNeeded) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  bool isTrackedFrame = false;
+  HandleFrameOneDoc(aWindowId, aCompositeNeeded, isTrackedFrame, Nothing());
+}
+
+void RenderThread::WrNotifierEvent_HandleNewFrameReady(
+    wr::WindowId aWindowId, bool aCompositeNeeded, FramePublishId aPublishId) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  bool isTrackedFrame = true;
+  HandleFrameOneDoc(aWindowId, aCompositeNeeded, isTrackedFrame,
+                    Some(aPublishId));
+}
+
+void RenderThread::WrNotifierEvent_HandleExternalEvent(
+    wr::WindowId aWindowId, UniquePtr<RendererEvent> aRendererEvent) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  RunEvent(aWindowId, std::move(aRendererEvent));
+}
+
+void RenderThread::BeginRecordingForWindow(wr::WindowId aWindowId,
+                                           const TimeStamp& aRecordingStart,
+                                           wr::PipelineId aRootPipelineId) {
+  MOZ_ASSERT(IsInRenderThread());
+  RendererOGL* renderer = GetRenderer(aWindowId);
+  MOZ_ASSERT(renderer);
+
+  renderer->BeginRecording(aRecordingStart, aRootPipelineId);
+}
+
+Maybe<layers::FrameRecording> RenderThread::EndRecordingForWindow(
+    wr::WindowId aWindowId) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  RendererOGL* renderer = GetRenderer(aWindowId);
+  MOZ_ASSERT(renderer);
+  return renderer->EndRecording();
+}
+
+void RenderThread::HandleFrameOneDoc(wr::WindowId aWindowId, bool aRender,
+                                     bool aTrackedFrame,
+                                     Maybe<FramePublishId> aPublishId) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  if (mHasShutdown) {
+    return;
+  }
+
+  HandleFrameOneDocInner(aWindowId, aRender, aTrackedFrame, aPublishId);
+
+  if (aTrackedFrame) {
+    DecPendingFrameCount(aWindowId);
+  }
+}
+
+void RenderThread::HandleFrameOneDocInner(wr::WindowId aWindowId, bool aRender,
+                                          bool aTrackedFrame,
+                                          Maybe<FramePublishId> aPublishId) {
+  if (IsDestroyed(aWindowId)) {
+    return;
+  }
+
+  if (mHandlingDeviceReset) {
+    return;
+  }
+
+  bool render = aRender;
+  PendingFrameInfo frame;
+  if (aTrackedFrame) {
+    // scope lock
+    auto windows = mWindowInfos.Lock();
+    auto it = windows->find(AsUint64(aWindowId));
+    if (it == windows->end()) {
+      MOZ_ASSERT(false);
+      return;
+    }
+
+    WindowInfo* info = it->second.get();
+    PendingFrameInfo& frameInfo = info->mPendingFrames.front();
+
+    frame = frameInfo;
+  } else {
+    // Just give the frame info default values.
+    frame = {TimeStamp::Now(), VsyncId()};
+  }
+
+  // Sadly this doesn't include the lock, since we don't have the frame there
+  // yet.
+  glean::wr::time_to_render_start.AccumulateRawDuration(TimeStamp::Now() -
+                                                        frame.mStartTime);
+
+  // It is for ensuring that PrepareForUse() is called before
+  // RenderTextureHost::Lock().
+  HandleRenderTextureOps();
+
+  if (aPublishId.isSome()) {
+    SetFramePublishId(aWindowId, aPublishId.ref());
+  }
+
+  UpdateAndRender(aWindowId, frame.mStartId, frame.mStartTime, render,
+                  /* aReadbackSize */ Nothing(),
+                  /* aReadbackFormat */ Nothing(),
+                  /* aReadbackBuffer */ Nothing());
+
+  // The start time is from WebRenderBridgeParent::CompositeToTarget. From that
+  // point until now (when the frame is finally pushed to the screen) is
+  // equivalent to the COMPOSITE_TIME metric in the non-WR codepath.
+  TimeDuration compositeDuration = TimeStamp::Now() - frame.mStartTime;
+  mozilla::glean::gfx::composite_time.AccumulateRawDuration(compositeDuration);
+  PerfStats::RecordMeasurement(PerfStats::Metric::Compositing,
+                               compositeDuration);
+}
+
+void RenderThread::SetClearColor(wr::WindowId aWindowId, wr::ColorF aColor) {
+  if (mHasShutdown) {
+    return;
+  }
+
+  if (!IsInRenderThread()) {
+    PostRunnable(NewRunnableMethod<wr::WindowId, wr::ColorF>(
+        "wr::RenderThread::SetClearColor", this, &RenderThread::SetClearColor,
+        aWindowId, aColor));
+    return;
+  }
+
+  if (IsDestroyed(aWindowId)) {
+    return;
+  }
+
+  auto it = mRenderers.find(aWindowId);
+  MOZ_ASSERT(it != mRenderers.end());
+  if (it != mRenderers.end()) {
+    wr_renderer_set_clear_color(it->second->GetRenderer(), aColor);
+  }
+}
+
+void RenderThread::SetProfilerUI(wr::WindowId aWindowId,
+                                 const nsACString& aUI) {
+  if (mHasShutdown) {
+    return;
+  }
+
+  if (!IsInRenderThread()) {
+    PostRunnable(NewRunnableMethod<wr::WindowId, nsCString>(
+        "wr::RenderThread::SetProfilerUI", this, &RenderThread::SetProfilerUI,
+        aWindowId, nsCString(aUI)));
+    return;
+  }
+
+  auto it = mRenderers.find(aWindowId);
+  if (it != mRenderers.end()) {
+    it->second->SetProfilerUI(aUI);
+  }
+}
+
+void RenderThread::PostEvent(wr::WindowId aWindowId,
+                             UniquePtr<RendererEvent> aEvent) {
+  PostRunnable(NewRunnableMethod<wr::WindowId, UniquePtr<RendererEvent>&&>(
+      "wr::RenderThread::PostEvent", this, &RenderThread::RunEvent, aWindowId,
+      std::move(aEvent)));
+}
+
+void RenderThread::RunEvent(wr::WindowId aWindowId,
+                            UniquePtr<RendererEvent> aEvent) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  aEvent->Run(*this, aWindowId);
+  aEvent = nullptr;
+}
+
+static void NotifyDidRender(layers::CompositorBridgeParent* aBridge,
+                            const RefPtr<const WebRenderPipelineInfo>& aInfo,
+                            VsyncId aCompositeStartId,
+                            TimeStamp aCompositeStart, TimeStamp aRenderStart,
+                            TimeStamp aEnd, bool aRender,
+                            RendererStats aStats) {
+  if (aRender && aBridge->GetWrBridge()) {
+    // We call this here to mimic the behavior in LayerManagerComposite, as to
+    // not change what Talos measures. That is, we do not record an empty frame
+    // as a frame.
+    aBridge->GetWrBridge()->RecordFrame();
+  }
+
+  aBridge->NotifyDidRender(aCompositeStartId, aCompositeStart, aRenderStart,
+                           aEnd, &aStats);
+
+  for (const auto& epoch : aInfo->Raw().epochs) {
+    aBridge->NotifyPipelineRendered(epoch.pipeline_id, epoch.epoch,
+                                    aCompositeStartId, aCompositeStart,
+                                    aRenderStart, aEnd, &aStats);
+  }
+
+  if (aBridge->GetWrBridge()) {
+    aBridge->GetWrBridge()->RetrySkippedComposite();
+  }
+}
+
+static void NotifyDidStartRender(layers::CompositorBridgeParent* aBridge) {
+  if (aBridge->GetWrBridge()) {
+    aBridge->GetWrBridge()->RetrySkippedComposite();
+  }
+}
+
+void RenderThread::SetFramePublishId(wr::WindowId aWindowId,
+                                     FramePublishId aPublishId) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  auto it = mRenderers.find(aWindowId);
+  MOZ_ASSERT(it != mRenderers.end());
+  if (it == mRenderers.end()) {
+    return;
+  }
+  auto& renderer = it->second;
+
+  renderer->SetFramePublishId(aPublishId);
+}
+
+void RenderThread::UpdateAndRender(
+    wr::WindowId aWindowId, const VsyncId& aStartId,
+    const TimeStamp& aStartTime, bool aRender,
+    const Maybe<gfx::IntSize>& aReadbackSize,
+    const Maybe<wr::ImageFormat>& aReadbackFormat,
+    const Maybe<Range<uint8_t>>& aReadbackBuffer, bool* aNeedsYFlip) {
+  AUTO_PROFILER_LABEL("RenderThread::UpdateAndRender", GRAPHICS);
+  MOZ_ASSERT(IsInRenderThread());
+  MOZ_ASSERT(aRender || aReadbackBuffer.isNothing());
+
+  auto it = mRenderers.find(aWindowId);
+  MOZ_ASSERT(it != mRenderers.end());
+  if (it == mRenderers.end()) {
+    return;
+  }
+
+  TimeStamp start = TimeStamp::Now();
+
+  auto& renderer = it->second;
+
+  std::string markerName = "Composite #" + std::to_string(AsUint64(aWindowId));
+  AutoProfilerTracing tracingCompositeMarker(
+      "Paint", markerName.c_str(), geckoprofiler::category::GRAPHICS,
+      Some(renderer->GetCompositorBridge()->GetInnerWindowId()));
+
+  if (renderer->IsPaused()) {
+    aRender = false;
+  }
+  LOG("RenderThread::UpdateAndRender() aWindowId %" PRIx64 " aRender %d",
+      AsUint64(aWindowId), aRender);
+
+  layers::CompositorThread()->Dispatch(
+      NewRunnableFunction("NotifyDidStartRenderRunnable", &NotifyDidStartRender,
+                          renderer->GetCompositorBridge()));
+
+  wr::RenderedFrameId latestFrameId;
+  RendererStats stats = {0};
+  if (aRender) {
+    latestFrameId = renderer->UpdateAndRender(
+        aReadbackSize, aReadbackFormat, aReadbackBuffer, aNeedsYFlip, &stats);
+  } else {
+    renderer->Update();
+  }
+  // Check graphics reset status even when rendering is skipped.
+  renderer->CheckGraphicsResetStatus("PostUpdate", /* aForce */ false);
+
+  TimeStamp end = TimeStamp::Now();
+  RefPtr<const WebRenderPipelineInfo> info = renderer->GetLastPipelineInfo();
+
+  layers::CompositorThread()->Dispatch(
+      NewRunnableFunction("NotifyDidRenderRunnable", &NotifyDidRender,
+                          renderer->GetCompositorBridge(), info, aStartId,
+                          aStartTime, start, end, aRender, stats));
+
+  ipc::FileDescriptor fenceFd;
+
+  if (latestFrameId.IsValid()) {
+    fenceFd = renderer->GetAndResetReleaseFence();
+
+    // Wait for GPU after posting NotifyDidRender, since the wait is not
+    // necessary for the NotifyDidRender.
+    // The wait is necessary for Textures recycling of AsyncImagePipelineManager
+    // and for avoiding GPU queue is filled with too much tasks.
+    // WaitForGPU's implementation is different for each platform.
+    auto timerId = glean::wr::gpu_wait_time.Start();
+    renderer->WaitForGPU();
+    glean::wr::gpu_wait_time.StopAndAccumulate(std::move(timerId));
+  } else {
+    // Update frame id for NotifyPipelinesUpdated() when rendering does not
+    // happen, either because rendering was not requested or the frame was
+    // canceled. Rendering can sometimes be canceled if UpdateAndRender is
+    // called when the window is not yet ready (not mapped or 0 size).
+    latestFrameId = renderer->UpdateFrameId();
+  }
+
+  RenderedFrameId lastCompletedFrameId = renderer->GetLastCompletedFrameId();
+
+  RefPtr<layers::AsyncImagePipelineManager> pipelineMgr =
+      renderer->GetCompositorBridge()->GetAsyncImagePipelineManager();
+  // pipelineMgr should always be non-null here because it is only nulled out
+  // after the WebRenderAPI instance for the CompositorBridgeParent is
+  // destroyed, and that destruction blocks until the renderer thread has
+  // removed the relevant renderer. And after that happens we should never reach
+  // this code at all; it would bail out at the mRenderers.find check above.
+  MOZ_ASSERT(pipelineMgr);
+  pipelineMgr->NotifyPipelinesUpdated(info, latestFrameId, lastCompletedFrameId,
+                                      std::move(fenceFd));
+}
+
+void RenderThread::Pause(wr::WindowId aWindowId) {
+  MOZ_ASSERT(IsInRenderThread());
+  LOG("RenderThread::Pause() aWindowId %" PRIx64 "", AsUint64(aWindowId));
+
+  auto it = mRenderers.find(aWindowId);
+  MOZ_ASSERT(it != mRenderers.end());
+  if (it == mRenderers.end()) {
+    gfxCriticalNote << "RenderThread cannot find renderer for window "
+                    << gfx::hexa(aWindowId) << " to pause.";
+    return;
+  }
+  auto& renderer = it->second;
+  renderer->Pause();
+
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::GraphicsNumActiveRenderers,
+      (unsigned int)ActiveRendererCount());
+}
+
+bool RenderThread::Resume(wr::WindowId aWindowId) {
+  MOZ_ASSERT(IsInRenderThread());
+  LOG("enderThread::Resume() aWindowId %" PRIx64 "", AsUint64(aWindowId));
+
+  auto it = mRenderers.find(aWindowId);
+  MOZ_ASSERT(it != mRenderers.end());
+  if (it == mRenderers.end()) {
+    gfxCriticalNote << "RenderThread cannot find renderer for window "
+                    << gfx::hexa(aWindowId) << " to resume.";
+    return false;
+  }
+  auto& renderer = it->second;
+  bool resumed = renderer->Resume();
+
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::GraphicsNumActiveRenderers,
+      (unsigned int)ActiveRendererCount());
+
+  return resumed;
+}
+
+bool RenderThread::TooManyPendingFrames(wr::WindowId aWindowId) {
+  const int64_t maxFrameCount = 1;
+
+  // Too many pending frames if pending frames exit more than maxFrameCount
+  // or if RenderBackend is still processing a frame.
+
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  if (it == windows->end()) {
+    MOZ_ASSERT(false);
+    return true;
+  }
+  WindowInfo* info = it->second.get();
+
+  if (info->PendingCount() > maxFrameCount) {
+    return true;
+  }
+  // If there is no ongoing frame build, we accept a new frame.
+  return info->mPendingFrameBuild > 0;
+}
+
+bool RenderThread::IsDestroyed(wr::WindowId aWindowId) {
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  if (it == windows->end()) {
+    return true;
+  }
+
+  return it->second->mIsDestroyed;
+}
+
+void RenderThread::SetDestroyed(wr::WindowId aWindowId) {
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  if (it == windows->end()) {
+    MOZ_ASSERT(false);
+    return;
+  }
+  it->second->mIsDestroyed = true;
+}
+
+void RenderThread::IncPendingFrameCount(wr::WindowId aWindowId,
+                                        const VsyncId& aStartId,
+                                        const TimeStamp& aStartTime) {
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  if (it == windows->end()) {
+    MOZ_ASSERT(false);
+    return;
+  }
+  it->second->mPendingFrameBuild++;
+  it->second->mPendingFrames.push(PendingFrameInfo{aStartTime, aStartId});
+}
+
+void RenderThread::DecPendingFrameBuildCount(wr::WindowId aWindowId) {
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  if (it == windows->end()) {
+    MOZ_ASSERT(false);
+    return;
+  }
+  WindowInfo* info = it->second.get();
+  MOZ_RELEASE_ASSERT(info->mPendingFrameBuild >= 1);
+  info->mPendingFrameBuild--;
+}
+
+void RenderThread::DecPendingFrameCount(wr::WindowId aWindowId) {
+  auto windows = mWindowInfos.Lock();
+  auto it = windows->find(AsUint64(aWindowId));
+  if (it == windows->end()) {
+    MOZ_ASSERT(false);
+    return;
+  }
+  WindowInfo* info = it->second.get();
+  info->mPendingFrames.pop();
+}
+
+void RenderThread::RegisterExternalImage(
+    const wr::ExternalImageId& aExternalImageId,
+    already_AddRefed<RenderTextureHost> aTexture) {
+  MutexAutoLock lock(mRenderTextureMapLock);
+
+  if (mHasShutdown) {
+    return;
+  }
+  MOZ_ASSERT(mRenderTextures.find(aExternalImageId) == mRenderTextures.end());
+  RefPtr<RenderTextureHost> texture = aTexture;
+  if (texture->SyncObjectNeeded()) {
+    mSyncObjectNeededRenderTextures.emplace(aExternalImageId, texture);
+  }
+  mRenderTextures.emplace(aExternalImageId, texture);
+}
+
+void RenderThread::UnregisterExternalImage(
+    const wr::ExternalImageId& aExternalImageId) {
+  MutexAutoLock lock(mRenderTextureMapLock);
+  if (mHasShutdown) {
+    return;
+  }
+  auto it = mRenderTextures.find(aExternalImageId);
+  if (it == mRenderTextures.end()) {
+    return;
+  }
+
+  auto& texture = it->second;
+  if (texture->SyncObjectNeeded()) {
+    MOZ_RELEASE_ASSERT(
+        mSyncObjectNeededRenderTextures.erase(aExternalImageId) == 1);
+  }
+
+  if (!IsInRenderThread()) {
+    // The RenderTextureHost should be released in render thread. So, post the
+    // deletion task here.
+    // The shmem and raw buffer are owned by compositor ipc channel. It's
+    // possible that RenderTextureHost is still exist after the shmem/raw buffer
+    // deletion. Then the buffer in RenderTextureHost becomes invalid. It's fine
+    // for this situation. Gecko will only release the buffer if WR doesn't need
+    // it. So, no one will access the invalid buffer in RenderTextureHost.
+    RefPtr<RenderTextureHost> texture = it->second;
+    mRenderTextures.erase(it);
+    mRenderTexturesDeferred.emplace_back(std::move(texture));
+    PostRunnable(NewRunnableMethod(
+        "RenderThread::DeferredRenderTextureHostDestroy", this,
+        &RenderThread::DeferredRenderTextureHostDestroy));
+  } else {
+    mRenderTextures.erase(it);
+  }
+}
+
+void RenderThread::DestroyExternalImagesSyncWait(
+    const std::vector<wr::ExternalImageId>&& aIds) {
+  if (!IsInRenderThread()) {
+    layers::SynchronousTask task("Destroy external images");
+
+    RefPtr<Runnable> runnable = NS_NewRunnableFunction(
+        "RenderThread::DestroyExternalImagesSyncWait::Runnable",
+        [&task, ids = std::move(aIds)]() {
+          layers::AutoCompleteTask complete(&task);
+          RenderThread::Get()->DestroyExternalImages(std::move(ids));
+        });
+
+    PostRunnable(runnable.forget());
+    task.Wait();
+    return;
+  }
+  DestroyExternalImages(std::move(aIds));
+}
+
+void RenderThread::DestroyExternalImages(
+    const std::vector<wr::ExternalImageId>&& aIds) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  std::vector<RefPtr<RenderTextureHost>> hosts;
+  {
+    MutexAutoLock lock(mRenderTextureMapLock);
+    if (mHasShutdown) {
+      return;
+    }
+
+    for (auto& id : aIds) {
+      auto it = mRenderTextures.find(id);
+      if (it == mRenderTextures.end()) {
+        continue;
+      }
+      hosts.emplace_back(it->second);
+    }
+  }
+
+  for (auto& host : hosts) {
+    host->Destroy();
+  }
+}
+
+void RenderThread::PrepareForUse(const wr::ExternalImageId& aExternalImageId) {
+  AddRenderTextureOp(RenderTextureOp::PrepareForUse, aExternalImageId);
+}
+
+void RenderThread::NotifyNotUsed(const wr::ExternalImageId& aExternalImageId) {
+  AddRenderTextureOp(RenderTextureOp::NotifyNotUsed, aExternalImageId);
+}
+
+void RenderThread::NotifyForUse(const wr::ExternalImageId& aExternalImageId) {
+  AddRenderTextureOp(RenderTextureOp::NotifyForUse, aExternalImageId);
+}
+
+void RenderThread::AddRenderTextureOp(
+    RenderTextureOp aOp, const wr::ExternalImageId& aExternalImageId) {
+  MOZ_ASSERT(!IsInRenderThread());
+
+  MutexAutoLock lock(mRenderTextureMapLock);
+
+  auto it = mRenderTextures.find(aExternalImageId);
+  MOZ_ASSERT(it != mRenderTextures.end());
+  if (it == mRenderTextures.end()) {
+    return;
+  }
+
+  RefPtr<RenderTextureHost> texture = it->second;
+  mRenderTextureOps.emplace_back(aOp, std::move(texture));
+
+  if (mRenderTextureOpsRunnable) {
+    // Runnable was already triggered
+    return;
+  }
+
+  RefPtr<nsIRunnable> runnable =
+      NewRunnableMethod("RenderThread::HandleRenderTextureOps", this,
+                        &RenderThread::HandleRenderTextureOps);
+  mRenderTextureOpsRunnable = runnable;
+  PostRunnable(runnable.forget());
+}
+
+void RenderThread::HandleRenderTextureOps() {
+  MOZ_ASSERT(IsInRenderThread());
+
+  std::list<std::pair<RenderTextureOp, RefPtr<RenderTextureHost>>>
+      renderTextureOps;
+  {
+    MutexAutoLock lock(mRenderTextureMapLock);
+    mRenderTextureOps.swap(renderTextureOps);
+    mRenderTextureOpsRunnable = nullptr;
+  }
+
+  for (auto& it : renderTextureOps) {
+    switch (it.first) {
+      case RenderTextureOp::PrepareForUse:
+        it.second->PrepareForUse();
+        break;
+      case RenderTextureOp::NotifyForUse:
+        it.second->NotifyForUse();
+        break;
+      case RenderTextureOp::NotifyNotUsed:
+        it.second->NotifyNotUsed();
+        break;
+    }
+  }
+}
+
+void RenderThread::UnregisterExternalImageDuringShutdown(
+    const wr::ExternalImageId& aExternalImageId) {
+  MOZ_ASSERT(IsInRenderThread());
+  MutexAutoLock lock(mRenderTextureMapLock);
+  MOZ_ASSERT(mHasShutdown);
+  mRenderTextures.erase(aExternalImageId);
+}
+
+bool RenderThread::SyncObjectNeeded() {
+  MOZ_ASSERT(IsInRenderThread());
+  MutexAutoLock lock(mRenderTextureMapLock);
+  return !mSyncObjectNeededRenderTextures.empty();
+}
+
+void RenderThread::DeferredRenderTextureHostDestroy() {
+  MutexAutoLock lock(mRenderTextureMapLock);
+  mRenderTexturesDeferred.clear();
+}
+
+RenderTextureHost* RenderThread::GetRenderTexture(
+    const wr::ExternalImageId& aExternalImageId) {
+  MutexAutoLock lock(mRenderTextureMapLock);
+  auto it = mRenderTextures.find(aExternalImageId);
+  MOZ_ASSERT(it != mRenderTextures.end());
+  if (it == mRenderTextures.end()) {
+    return nullptr;
+  }
+  return it->second;
+}
+
+void RenderThread::InitDeviceTask() {
+  MOZ_ASSERT(IsInRenderThread());
+  MOZ_ASSERT(!mSingletonGL);
+  LOG("RenderThread::InitDeviceTask()");
+
+  if (gfx::gfxVars::UseSoftwareWebRender()) {
+    // Ensure we don't instantiate any shared GL context when SW-WR is used.
+    return;
+  }
+
+  nsAutoCString err;
+  CreateSingletonGL(err);
+  if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) {
+    mProgramCache = MakeUnique<WebRenderProgramCache>(ThreadPool().Raw());
+  }
+  // Query the shared GL context to force the
+  // lazy initialization to happen now.
+  SingletonGL();
+}
+
+void RenderThread::PostRunnable(already_AddRefed<nsIRunnable> aRunnable) {
+  nsCOMPtr<nsIRunnable> runnable = aRunnable;
+  mThread->Dispatch(runnable.forget());
+}
+
+#ifndef XP_WIN
+static DeviceResetReason GLenumToResetReason(GLenum aReason) {
+  switch (aReason) {
+    case LOCAL_GL_NO_ERROR:
+      return DeviceResetReason::FORCED_RESET;
+    case LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB:
+      return DeviceResetReason::DRIVER_ERROR;
+    case LOCAL_GL_PURGED_CONTEXT_RESET_NV:
+      return DeviceResetReason::NVIDIA_VIDEO;
+    case LOCAL_GL_GUILTY_CONTEXT_RESET_ARB:
+      return DeviceResetReason::RESET;
+    case LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB:
+      return DeviceResetReason::UNKNOWN;
+    case LOCAL_GL_OUT_OF_MEMORY:
+      return DeviceResetReason::OUT_OF_MEMORY;
+    default:
+      return DeviceResetReason::OTHER;
+  }
+}
+#endif
+
+void RenderThread::HandleDeviceReset(const char* aWhere, GLenum aReason) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  // This happens only on simulate device reset.
+  if (aReason == LOCAL_GL_NO_ERROR) {
+    if (!mHandlingDeviceReset) {
+      mHandlingDeviceReset = true;
+
+      MutexAutoLock lock(mRenderTextureMapLock);
+      mRenderTexturesDeferred.clear();
+      for (const auto& entry : mRenderTextures) {
+        entry.second->ClearCachedResources();
+      }
+
+      // All RenderCompositors will be destroyed by the GPUProcessManager in
+      // either OnRemoteProcessDeviceReset via the GPUChild, or
+      // OnInProcessDeviceReset here directly.
+      if (XRE_IsGPUProcess()) {
+        gfx::GPUParent::GetSingleton()->NotifyDeviceReset();
+      } else {
+        NS_DispatchToMainThread(NS_NewRunnableFunction(
+            "gfx::GPUProcessManager::OnInProcessDeviceReset", []() -> void {
+              gfx::GPUProcessManager::Get()->OnInProcessDeviceReset(
+                  /* aTrackThreshold */ false);
+            }));
+      }
+    }
+    return;
+  }
+
+  if (mHandlingDeviceReset) {
+    return;
+  }
+
+  mHandlingDeviceReset = true;
+
+#ifndef XP_WIN
+  // On Windows, see DeviceManagerDx::MaybeResetAndReacquireDevices.
+  gfx::GPUProcessManager::RecordDeviceReset(GLenumToResetReason(aReason));
+#endif
+
+  {
+    MutexAutoLock lock(mRenderTextureMapLock);
+    mRenderTexturesDeferred.clear();
+    for (const auto& entry : mRenderTextures) {
+      entry.second->ClearCachedResources();
+    }
+  }
+
+  // All RenderCompositors will be destroyed by the GPUProcessManager in
+  // either OnRemoteProcessDeviceReset via the GPUChild, or
+  // OnInProcessDeviceReset here directly.
+  // On Windows, device will be re-created before sessions re-creation.
+  gfxCriticalNote << "GFX: RenderThread detected a device reset in " << aWhere;
+  if (XRE_IsGPUProcess()) {
+    gfx::GPUParent::GetSingleton()->NotifyDeviceReset();
+  } else {
+#ifndef XP_WIN
+    // FIXME(aosmond): Do we need to do this on Windows? nsWindow::OnPaint
+    // seems to do its own detection for the parent process.
+    bool guilty = aReason == LOCAL_GL_GUILTY_CONTEXT_RESET_ARB;
+    NS_DispatchToMainThread(NS_NewRunnableFunction(
+        "gfx::GPUProcessManager::OnInProcessDeviceReset", [guilty]() -> void {
+          gfx::GPUProcessManager::Get()->OnInProcessDeviceReset(guilty);
+        }));
+#endif
+  }
+}
+
+bool RenderThread::IsHandlingDeviceReset() {
+  MOZ_ASSERT(IsInRenderThread());
+  return mHandlingDeviceReset;
+}
+
+void RenderThread::SimulateDeviceReset() {
+  if (!IsInRenderThread()) {
+    PostRunnable(NewRunnableMethod("RenderThread::SimulateDeviceReset", this,
+                                   &RenderThread::SimulateDeviceReset));
+  } else {
+    // When this function is called GPUProcessManager::SimulateDeviceReset()
+    // already triggers destroying all CompositorSessions before re-creating
+    // them.
+    HandleDeviceReset("SimulateDeviceReset", LOCAL_GL_NO_ERROR);
+  }
+}
+
+static void DoNotifyWebRenderError(WebRenderError aError) {
+  layers::CompositorManagerParent::NotifyWebRenderError(aError);
+}
+
+void RenderThread::NotifyWebRenderError(WebRenderError aError) {
+  MOZ_ASSERT(IsInRenderThread());
+
+  layers::CompositorThread()->Dispatch(NewRunnableFunction(
+      "DoNotifyWebRenderErrorRunnable", &DoNotifyWebRenderError, aError));
+}
+
+void RenderThread::HandleWebRenderError(WebRenderError aError) {
+  MOZ_ASSERT(IsInRenderThread());
+  if (mHandlingWebRenderError) {
+    return;
+  }
+
+  NotifyWebRenderError(aError);
+
+  {
+    MutexAutoLock lock(mRenderTextureMapLock);
+    mRenderTexturesDeferred.clear();
+    for (const auto& entry : mRenderTextures) {
+      entry.second->ClearCachedResources();
+    }
+  }
+  mHandlingWebRenderError = true;
+  // WebRender is going to be disabled by
+  // GPUProcessManager::NotifyWebRenderError()
+}
+
+bool RenderThread::IsHandlingWebRenderError() {
+  MOZ_ASSERT(IsInRenderThread());
+  return mHandlingWebRenderError;
+}
+
+gl::GLContext* RenderThread::SingletonGL() {
+  nsAutoCString err;
+  auto* gl = SingletonGL(err);
+  if (!err.IsEmpty()) {
+    gfxCriticalNote << err.get();
+  }
+  return gl;
+}
+
+void RenderThread::CreateSingletonGL(nsACString& aError) {
+  MOZ_ASSERT(IsInRenderThread());
+  LOG("RenderThread::CreateSingletonGL()");
+
+  mSingletonGL = CreateGLContext(aError);
+  mSingletonGLIsForHardwareWebRender = !gfx::gfxVars::UseSoftwareWebRender();
+}
+
+gl::GLContext* RenderThread::SingletonGL(nsACString& aError) {
+  MOZ_ASSERT(IsInRenderThread());
+  if (!mSingletonGL) {
+    CreateSingletonGL(aError);
+    mShaders = nullptr;
+  }
+  if (mSingletonGL && mSingletonGLIsForHardwareWebRender && !mShaders) {
+    mShaders = MakeUnique<WebRenderShaders>(mSingletonGL, mProgramCache.get());
+  }
+
+  return mSingletonGL.get();
+}
+
+gl::GLContext* RenderThread::SingletonGLForCompositorOGL() {
+  MOZ_RELEASE_ASSERT(gfx::gfxVars::UseSoftwareWebRender());
+
+  if (mSingletonGLIsForHardwareWebRender) {
+    // Clear singleton GL, since GLContext is for hardware WebRender.
+    ClearSingletonGL();
+  }
+  return SingletonGL();
+}
+
+void RenderThread::ClearSingletonGL() {
+  MOZ_ASSERT(IsInRenderThread());
+  LOG("RenderThread::ClearSingletonGL()");
+
+  if (mSurfacePool) {
+    mSurfacePool->DestroyGLResourcesForContext(mSingletonGL);
+  }
+  if (mProgramsForCompositorOGL) {
+    mProgramsForCompositorOGL->Clear();
+    mProgramsForCompositorOGL = nullptr;
+  }
+  if (mShaders) {
+    if (mSingletonGL) {
+      mSingletonGL->MakeCurrent();
+    }
+    mShaders = nullptr;
+  }
+  mSingletonGL = nullptr;
+}
+
+RefPtr<layers::ShaderProgramOGLsHolder>
+RenderThread::GetProgramsForCompositorOGL() {
+  if (!mSingletonGL) {
+    return nullptr;
+  }
+
+  if (!mProgramsForCompositorOGL) {
+    mProgramsForCompositorOGL =
+        MakeAndAddRef<layers::ShaderProgramOGLsHolder>(mSingletonGL);
+  }
+  return mProgramsForCompositorOGL;
+}
+
+RefPtr<layers::SurfacePool> RenderThread::SharedSurfacePool() {
+#if defined(XP_MACOSX) || defined(MOZ_WAYLAND)
+  if (!mSurfacePool) {
+    size_t poolSizeLimit =
+        StaticPrefs::gfx_webrender_compositor_surface_pool_size_AtStartup();
+    mSurfacePool = layers::SurfacePool::Create(poolSizeLimit);
+  }
+#endif
+  return mSurfacePool;
+}
+
+void RenderThread::ClearSharedSurfacePool() { mSurfacePool = nullptr; }
+
+static void GLAPIENTRY DebugMessageCallback(GLenum aSource, GLenum aType,
+                                            GLuint aId, GLenum aSeverity,
+                                            GLsizei aLength,
+                                            const GLchar* aMessage,
+                                            const GLvoid* aUserParam) {
+  constexpr const char* kContextLost = "Context has been lost.";
+
+  if (StaticPrefs::gfx_webrender_gl_debug_message_critical_note_AtStartup() &&
+      aSeverity == LOCAL_GL_DEBUG_SEVERITY_HIGH) {
+    auto message = std::string(aMessage, aLength);
+    // When content lost happned, error messages are flooded by its message.
+    if (message != kContextLost) {
+      gfxCriticalNote << message;
+    } else {
+      gfxCriticalNoteOnce << message;
+    }
+  }
+
+  if (StaticPrefs::gfx_webrender_gl_debug_message_print_AtStartup()) {
+    gl::GLContext* gl = (gl::GLContext*)aUserParam;
+    gl->DebugCallback(aSource, aType, aId, aSeverity, aLength, aMessage);
+  }
+}
+
+// static
+void RenderThread::MaybeEnableGLDebugMessage(gl::GLContext* aGLContext) {
+  if (!aGLContext) {
+    return;
+  }
+
+  bool enableDebugMessage =
+      StaticPrefs::gfx_webrender_gl_debug_message_critical_note_AtStartup() ||
+      StaticPrefs::gfx_webrender_gl_debug_message_print_AtStartup();
+
+  if (enableDebugMessage &&
+      aGLContext->IsExtensionSupported(gl::GLContext::KHR_debug)) {
+    aGLContext->fEnable(LOCAL_GL_DEBUG_OUTPUT);
+    aGLContext->fDisable(LOCAL_GL_DEBUG_OUTPUT_SYNCHRONOUS);
+    aGLContext->fDebugMessageCallback(&DebugMessageCallback, (void*)aGLContext);
+    aGLContext->fDebugMessageControl(LOCAL_GL_DONT_CARE, LOCAL_GL_DONT_CARE,
+                                     LOCAL_GL_DONT_CARE, 0, nullptr, true);
+  }
+}
+
+WebRenderShaders::WebRenderShaders(gl::GLContext* gl,
+                                   WebRenderProgramCache* programCache) {
+  mGL = gl;
+  mShaders =
+      wr_shaders_new(gl, programCache ? programCache->Raw() : nullptr,
+                     StaticPrefs::gfx_webrender_precache_shaders_AtStartup());
+}
+
+WebRenderShaders::~WebRenderShaders() {
+  wr_shaders_delete(mShaders, mGL.get());
+}
+
+WebRenderThreadPool::WebRenderThreadPool(bool low_priority) {
+  mThreadPool = wr_thread_pool_new(low_priority);
+}
+
+WebRenderThreadPool::~WebRenderThreadPool() { Release(); }
+
+void WebRenderThreadPool::Release() {
+  if (mThreadPool) {
+    wr_thread_pool_delete(mThreadPool);
+    mThreadPool = nullptr;
+  }
+}
+
+WebRenderProgramCache::WebRenderProgramCache(wr::WrThreadPool* aThreadPool) {
+  MOZ_ASSERT(aThreadPool);
+
+  nsAutoString path;
+  if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) {
+    path.Append(gfx::gfxVars::ProfDirectory());
+  }
+  mProgramCache = wr_program_cache_new(&path, aThreadPool);
+  if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) {
+    wr_try_load_startup_shaders_from_disk(mProgramCache);
+  }
+}
+
+WebRenderProgramCache::~WebRenderProgramCache() {
+  wr_program_cache_delete(mProgramCache);
+}
+
+}  // namespace mozilla::wr
+
+#ifdef XP_WIN
+static already_AddRefed<gl::GLContext> CreateGLContextANGLE(
+    nsACString& aError) {
+  const RefPtr<ID3D11Device> d3d11Device =
+      gfx::DeviceManagerDx::Get()->GetCompositorDevice();
+  if (!d3d11Device) {
+    aError.Assign("RcANGLE(no compositor device for EGLDisplay)"_ns);
+    return nullptr;
+  }
+
+  nsCString failureId;
+  const auto lib = gl::GLLibraryEGL::Get(&failureId);
+  if (!lib) {
+    aError.Assign(
+        nsPrintfCString("RcANGLE(load EGL lib failed: %s)", failureId.get()));
+    return nullptr;
+  }
+
+  const auto egl = lib->CreateDisplay(d3d11Device.get());
+  if (!egl) {
+    aError.Assign(nsPrintfCString("RcANGLE(create EGLDisplay failed: %s)",
+                                  failureId.get()));
+    return nullptr;
+  }
+
+  gl::CreateContextFlags flags = gl::CreateContextFlags::PREFER_ES3;
+
+  if (StaticPrefs::gfx_webrender_prefer_robustness_AtStartup()) {
+    flags |= gl::CreateContextFlags::PREFER_ROBUSTNESS;
+  }
+
+  if (egl->IsExtensionSupported(
+          gl::EGLExtension::MOZ_create_context_provoking_vertex_dont_care)) {
+    flags |= gl::CreateContextFlags::PROVOKING_VERTEX_DONT_CARE;
+  }
+
+  // Create GLContext with dummy EGLSurface, the EGLSurface is not used.
+  // Instread we override it with EGLSurface of SwapChain's back buffer.
+
+  auto gl = gl::GLContextEGL::CreateWithoutSurface(egl, {flags}, &failureId);
+  if (!gl || !gl->IsANGLE()) {
+    aError.Assign(nsPrintfCString("RcANGLE(create GL context failed: %p, %s)",
+                                  gl.get(), failureId.get()));
+    return nullptr;
+  }
+
+  if (!gl->MakeCurrent()) {
+    aError.Assign(
+        nsPrintfCString("RcANGLE(make current GL context failed: %p, %x)",
+                        gl.get(), gl->mEgl->mLib->fGetError()));
+    return nullptr;
+  }
+
+  return gl.forget();
+}
+#endif
+
+#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK)
+static already_AddRefed<gl::GLContext> CreateGLContextEGL() {
+  // Create GLContext with dummy EGLSurface.
+  bool forHardwareWebRender = true;
+  // SW-WR uses CompositorOGL in native compositor.
+  if (gfx::gfxVars::UseSoftwareWebRender()) {
+    forHardwareWebRender = false;
+  }
+  RefPtr<gl::GLContext> gl =
+      gl::GLContextProviderEGL::CreateForCompositorWidget(
+          nullptr, forHardwareWebRender, /* aForceAccelerated */ true);
+  if (!gl || !gl->MakeCurrent()) {
+    gfxCriticalNote << "Failed GL context creation for hardware WebRender: "
+                    << forHardwareWebRender;
+    return nullptr;
+  }
+  return gl.forget();
+}
+#endif
+
+#ifdef XP_MACOSX
+static already_AddRefed<gl::GLContext> CreateGLContextCGL() {
+  nsCString failureUnused;
+  return gl::GLContextProvider::CreateHeadless(
+      {gl::CreateContextFlags::ALLOW_OFFLINE_RENDERER |
+       gl::CreateContextFlags::FORBID_SOFTWARE},
+      &failureUnused);
+}
+#endif
+
+static already_AddRefed<gl::GLContext> CreateGLContext(nsACString& aError) {
+  RefPtr<gl::GLContext> gl;
+
+#ifdef XP_WIN
+  if (gfx::gfxVars::UseWebRenderANGLE()) {
+    gl = CreateGLContextANGLE(aError);
+  }
+#elif defined(MOZ_WIDGET_ANDROID)
+  gl = CreateGLContextEGL();
+#elif defined(MOZ_WIDGET_GTK)
+  if (gfx::gfxVars::UseEGL()) {
+    gl = CreateGLContextEGL();
+  }
+#elif XP_MACOSX
+  gl = CreateGLContextCGL();
+#endif
+
+  wr::RenderThread::MaybeEnableGLDebugMessage(gl);
+
+  return gl.forget();
+}
+
+extern "C" {
+
+void wr_notifier_wake_up(mozilla::wr::WrWindowId aWindowId,
+                         bool aCompositeNeeded) {
+  // wake_up is used for things like propagating debug options or memory
+  // pressure events, so we are not tracking pending frame counts.
+  mozilla::wr::RenderThread::Get()->WrNotifierEvent_WakeUp(aWindowId,
+                                                           aCompositeNeeded);
+}
+
+void wr_notifier_new_frame_ready(mozilla::wr::WrWindowId aWindowId,
+                                 bool aCompositeNeeded,
+                                 mozilla::wr::FramePublishId aPublishId) {
+  auto* renderThread = mozilla::wr::RenderThread::Get();
+  renderThread->DecPendingFrameBuildCount(aWindowId);
+
+  renderThread->WrNotifierEvent_NewFrameReady(aWindowId, aCompositeNeeded,
+                                              aPublishId);
+}
+
+void wr_notifier_external_event(mozilla::wr::WrWindowId aWindowId,
+                                size_t aRawEvent) {
+  mozilla::wr::RenderThread::Get()->WrNotifierEvent_ExternalEvent(
+      mozilla::wr::WindowId(aWindowId), aRawEvent);
+}
+
+static void NotifyScheduleRender(mozilla::wr::WrWindowId aWindowId,
+                                 wr::RenderReasons aReasons) {
+  RefPtr<mozilla::layers::CompositorBridgeParent> cbp = mozilla::layers::
+      CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId);
+  if (cbp) {
+    cbp->ScheduleComposition(aReasons);
+  }
+}
+
+void wr_schedule_render(mozilla::wr::WrWindowId aWindowId,
+                        wr::RenderReasons aReasons) {
+  layers::CompositorThread()->Dispatch(NewRunnableFunction(
+      "NotifyScheduleRender", &NotifyScheduleRender, aWindowId, aReasons));
+}
+
+static void NotifyDidSceneBuild(
+    mozilla::wr::WrWindowId aWindowId,
+    const RefPtr<const wr::WebRenderPipelineInfo>& aInfo) {
+  RefPtr<mozilla::layers::CompositorBridgeParent> cbp = mozilla::layers::
+      CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId);
+  if (cbp) {
+    cbp->NotifyDidSceneBuild(aInfo);
+  }
+}
+
+void wr_finished_scene_build(mozilla::wr::WrWindowId aWindowId,
+                             mozilla::wr::WrPipelineInfo* aPipelineInfo) {
+  RefPtr<wr::WebRenderPipelineInfo> info = new wr::WebRenderPipelineInfo();
+  info->Raw() = std::move(*aPipelineInfo);
+  layers::CompositorThread()->Dispatch(NewRunnableFunction(
+      "NotifyDidSceneBuild", &NotifyDidSceneBuild, aWindowId, info));
+}
+
+}  // extern C
diff --git a/gfx/webrender_bindings/RenderThread.h b/gfx/webrender_bindings/RenderThread.h
new file mode 100644
index 0000000000..aa508e5581
--- /dev/null
+++ b/gfx/webrender_bindings/RenderThread.h
@@ -0,0 +1,493 @@
+/* -*- 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_LAYERS_RENDERTHREAD_H
+#define MOZILLA_LAYERS_RENDERTHREAD_H
+
+#include "base/basictypes.h"       // for DISALLOW_EVIL_CONSTRUCTORS
+#include "base/platform_thread.h"  // for PlatformThreadId
+#include "base/thread.h"           // for Thread
+#include "base/message_loop.h"
+#include "GLTypes.h"  // for GLenum
+#include "nsISupportsImpl.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/DataMutex.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/webrender/webrender_ffi.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "mozilla/layers/CompositionRecorder.h"
+#include "mozilla/layers/SynchronousTask.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/VsyncDispatcher.h"
+
+#include <list>
+#include <queue>
+#include <unordered_map>
+
+namespace mozilla {
+namespace gl {
+class GLContext;
+}  // namespace gl
+namespace layers {
+class CompositorBridgeParent;
+class ShaderProgramOGLsHolder;
+class SurfacePool;
+}  // namespace layers
+namespace wr {
+
+typedef MozPromise<MemoryReport, bool, true> MemoryReportPromise;
+
+class RendererOGL;
+class RenderTextureHost;
+class RenderThread;
+
+/// A rayon thread pool that is shared by all WebRender instances within a
+/// process.
+class WebRenderThreadPool {
+ public:
+  explicit WebRenderThreadPool(bool low_priority);
+
+  ~WebRenderThreadPool();
+
+  wr::WrThreadPool* Raw() {
+    // If this pointer is null we are likely at some late shutdown stage,
+    // when threads are no longer safe to interact with.
+    MOZ_RELEASE_ASSERT(mThreadPool);
+    return mThreadPool;
+  }
+
+  /// Prematurely destroys this handle to the thread pool.
+  /// After calling this the object is useless.
+  void Release();
+
+ protected:
+  wr::WrThreadPool* mThreadPool;
+};
+
+class WebRenderProgramCache final {
+ public:
+  explicit WebRenderProgramCache(wr::WrThreadPool* aThreadPool);
+
+  ~WebRenderProgramCache();
+
+  wr::WrProgramCache* Raw() { return mProgramCache; }
+
+ protected:
+  wr::WrProgramCache* mProgramCache;
+};
+
+class WebRenderShaders final {
+ public:
+  WebRenderShaders(gl::GLContext* gl, WebRenderProgramCache* programCache);
+  ~WebRenderShaders();
+
+  wr::WrShaders* RawShaders() { return mShaders; }
+
+ protected:
+  RefPtr<gl::GLContext> mGL;
+  wr::WrShaders* mShaders;
+};
+
+class WebRenderPipelineInfo final {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderPipelineInfo);
+
+  const wr::WrPipelineInfo& Raw() const { return mPipelineInfo; }
+  wr::WrPipelineInfo& Raw() { return mPipelineInfo; }
+
+ protected:
+  ~WebRenderPipelineInfo() = default;
+  wr::WrPipelineInfo mPipelineInfo;
+};
+
+/// Base class for an event that can be scheduled to run on the render thread.
+///
+/// The event can be passed through the same channels as regular WebRender
+/// messages to preserve ordering.
+class RendererEvent {
+ public:
+  virtual ~RendererEvent() = default;
+  virtual void Run(RenderThread& aRenderThread, wr::WindowId aWindow) = 0;
+};
+
+/// The render thread is where WebRender issues all of its GPU work, and as much
+/// as possible this thread should only serve this purpose.
+///
+/// The render thread owns the different RendererOGLs (one per window) and
+/// implements the RenderNotifier api exposed by the WebRender bindings.
+///
+/// Callers are not allowed to post tasks to the render thread's event loop
+/// directly and must instead use the RendererEvent mechanism which avoids races
+/// between the events and WebRender's own messages.
+///
+/// The GL context(s) should be created and used on this thread only.
+/// XXX - I've tried to organize code so that we can potentially avoid making
+/// this a singleton since this bad habit has a tendency to bite us later, but
+/// I haven't gotten all the way there either, in order to focus on the more
+/// important pieces first. So we are a bit in-between (this is totally a
+/// singleton but in some places we pretend it's not). Hopefully we can evolve
+/// this in a way that keeps the door open to removing the singleton bits.
+class RenderThread final {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DELETE_ON_MAIN_THREAD(RenderThread)
+
+ public:
+  /// Can be called from any thread.
+  static RenderThread* Get();
+
+  /// Can only be called from the main thread.
+  static void Start(uint32_t aNamespace);
+
+  /// Can only be called from the main thread.
+  static void ShutDown();
+
+  /// Can be called from any thread.
+  static bool IsInRenderThread();
+
+  /// Can be called from any thread.
+  static already_AddRefed<nsIThread> GetRenderThread();
+
+  // Can be called from any thread. Dispatches an event to the Renderer thread
+  // to iterate over all Renderers, accumulates memory statistics, and resolves
+  // the return promise.
+  static RefPtr<MemoryReportPromise> AccumulateMemoryReport(
+      MemoryReport aInitial);
+
+  /// Can only be called from the render thread.
+  void AddRenderer(wr::WindowId aWindowId, UniquePtr<RendererOGL> aRenderer);
+
+  /// Can only be called from the render thread.
+  void RemoveRenderer(wr::WindowId aWindowId);
+
+  /// Can only be called from the render thread.
+  RendererOGL* GetRenderer(wr::WindowId aWindowId);
+
+  /// Automatically forwarded to the render thread.
+  void SetClearColor(wr::WindowId aWindowId, wr::ColorF aColor);
+
+  /// Automatically forwarded to the render thread.
+  void SetProfilerUI(wr::WindowId aWindowId, const nsACString& aUI);
+
+  /// Automatically forwarded to the render thread.
+  void PipelineSizeChanged(wr::WindowId aWindowId, uint64_t aPipelineId,
+                           float aWidth, float aHeight);
+
+  /// Post RendererEvent to the render thread.
+  void PostEvent(wr::WindowId aWindowId, UniquePtr<RendererEvent> aEvent);
+
+  /// Can only be called from the render thread.
+  void SetFramePublishId(wr::WindowId aWindowId, FramePublishId aPublishId);
+
+  /// Can only be called from the render thread.
+  void UpdateAndRender(wr::WindowId aWindowId, const VsyncId& aStartId,
+                       const TimeStamp& aStartTime, bool aRender,
+                       const Maybe<gfx::IntSize>& aReadbackSize,
+                       const Maybe<wr::ImageFormat>& aReadbackFormat,
+                       const Maybe<Range<uint8_t>>& aReadbackBuffer,
+                       bool* aNeedsYFlip = nullptr);
+
+  void Pause(wr::WindowId aWindowId);
+  bool Resume(wr::WindowId aWindowId);
+
+  /// Can be called from any thread.
+  void RegisterExternalImage(const wr::ExternalImageId& aExternalImageId,
+                             already_AddRefed<RenderTextureHost> aTexture);
+
+  /// Can be called from any thread.
+  void UnregisterExternalImage(const wr::ExternalImageId& aExternalImageId);
+
+  /// Can be called from any thread.
+  void DestroyExternalImagesSyncWait(
+      const std::vector<wr::ExternalImageId>&& aIds);
+
+  /// Can be called from any thread.
+  void PrepareForUse(const wr::ExternalImageId& aExternalImageId);
+
+  /// Can be called from any thread.
+  void NotifyNotUsed(const wr::ExternalImageId& aExternalImageId);
+
+  /// Can be called from any thread.
+  void NotifyForUse(const wr::ExternalImageId& aExternalImageId);
+
+  void HandleRenderTextureOps();
+
+  /// Can only be called from the render thread.
+  void UnregisterExternalImageDuringShutdown(
+      const wr::ExternalImageId& aExternalImageId);
+
+  /// Can only be called from the render thread.
+  RenderTextureHost* GetRenderTexture(
+      const wr::ExternalImageId& aExternalImageId);
+
+  /// Can be called from any thread.
+  bool IsDestroyed(wr::WindowId aWindowId);
+  /// Can be called from any thread.
+  void SetDestroyed(wr::WindowId aWindowId);
+  /// Can be called from any thread.
+  bool TooManyPendingFrames(wr::WindowId aWindowId);
+  /// Can be called from any thread.
+  void IncPendingFrameCount(wr::WindowId aWindowId, const VsyncId& aStartId,
+                            const TimeStamp& aStartTime);
+  /// Can be called from any thread.
+  void DecPendingFrameBuildCount(wr::WindowId aWindowId);
+  void DecPendingFrameCount(wr::WindowId aWindowId);
+
+  // RenderNotifier implementation
+  void WrNotifierEvent_WakeUp(WrWindowId aWindowId, bool aCompositeNeeded);
+  void WrNotifierEvent_NewFrameReady(WrWindowId aWindowId,
+                                     bool aCompositeNeeded,
+                                     FramePublishId aPublishId);
+  void WrNotifierEvent_ExternalEvent(WrWindowId aWindowId, size_t aRawEvent);
+
+  /// Can be called from any thread.
+  WebRenderThreadPool& ThreadPool() { return mThreadPool; }
+
+  /// Thread pool for low priority scene building
+  /// Can be called from any thread.
+  WebRenderThreadPool& ThreadPoolLP() { return mThreadPoolLP; }
+
+  /// Returns the cache used to serialize shader programs to disk, if enabled.
+  ///
+  /// Can only be called from the render thread.
+  WebRenderProgramCache* GetProgramCache() {
+    MOZ_ASSERT(IsInRenderThread());
+    return mProgramCache.get();
+  }
+
+  /// Can only be called from the render thread.
+  WebRenderShaders* GetShaders() {
+    MOZ_ASSERT(IsInRenderThread());
+    return mShaders.get();
+  }
+
+  /// Can only be called from the render thread.
+  gl::GLContext* SingletonGL(nsACString& aError);
+  gl::GLContext* SingletonGL();
+  gl::GLContext* SingletonGLForCompositorOGL();
+  void ClearSingletonGL();
+  RefPtr<layers::SurfacePool> SharedSurfacePool();
+  void ClearSharedSurfacePool();
+
+  RefPtr<layers::ShaderProgramOGLsHolder> GetProgramsForCompositorOGL();
+
+  /// Can only be called from the render thread.
+  void HandleDeviceReset(const char* aWhere, GLenum aReason);
+  /// Can only be called from the render thread.
+  bool IsHandlingDeviceReset();
+  /// Can be called from any thread.
+  void SimulateDeviceReset();
+
+  /// Can only be called from the render thread.
+  void NotifyWebRenderError(WebRenderError aError);
+
+  /// Can only be called from the render thread.
+  void HandleWebRenderError(WebRenderError aError);
+  /// Can only be called from the render thread.
+  bool IsHandlingWebRenderError();
+
+  /// Can only be called from the render thread.
+  bool SyncObjectNeeded();
+
+  size_t RendererCount() const;
+  size_t ActiveRendererCount() const;
+
+  void BeginRecordingForWindow(wr::WindowId aWindowId,
+                               const TimeStamp& aRecordingStart,
+                               wr::PipelineId aRootPipelineId);
+
+  Maybe<layers::FrameRecording> EndRecordingForWindow(wr::WindowId aWindowId);
+
+  static void MaybeEnableGLDebugMessage(gl::GLContext* aGLContext);
+
+ private:
+  enum class RenderTextureOp {
+    PrepareForUse,
+    NotifyForUse,
+    NotifyNotUsed,
+  };
+  class WrNotifierEvent {
+   public:
+    enum class Tag {
+      WakeUp,
+      NewFrameReady,
+      ExternalEvent,
+    };
+    const Tag mTag;
+
+   private:
+    WrNotifierEvent(const Tag aTag, const bool aCompositeNeeded)
+        : mTag(aTag), mCompositeNeeded(aCompositeNeeded) {
+      MOZ_ASSERT(mTag == Tag::WakeUp);
+    }
+    WrNotifierEvent(const Tag aTag, bool aCompositeNeeded,
+                    FramePublishId aPublishId)
+        : mTag(aTag),
+          mCompositeNeeded(aCompositeNeeded),
+          mPublishId(aPublishId) {
+      MOZ_ASSERT(mTag == Tag::NewFrameReady);
+    }
+    WrNotifierEvent(const Tag aTag, UniquePtr<RendererEvent>&& aRendererEvent)
+        : mTag(aTag), mRendererEvent(std::move(aRendererEvent)) {
+      MOZ_ASSERT(mTag == Tag::ExternalEvent);
+    }
+
+    const bool mCompositeNeeded = false;
+    const FramePublishId mPublishId = FramePublishId::INVALID;
+    UniquePtr<RendererEvent> mRendererEvent;
+
+   public:
+    static WrNotifierEvent WakeUp(const bool aCompositeNeeded) {
+      return WrNotifierEvent(Tag::WakeUp, aCompositeNeeded);
+    }
+
+    static WrNotifierEvent NewFrameReady(const bool aCompositeNeeded,
+                                         const FramePublishId aPublishId) {
+      return WrNotifierEvent(Tag::NewFrameReady, aCompositeNeeded, aPublishId);
+    }
+
+    static WrNotifierEvent ExternalEvent(
+        UniquePtr<RendererEvent>&& aRendererEvent) {
+      return WrNotifierEvent(Tag::ExternalEvent, std::move(aRendererEvent));
+    }
+
+    bool CompositeNeeded() {
+      if (mTag == Tag::WakeUp || mTag == Tag::NewFrameReady) {
+        return mCompositeNeeded;
+      }
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+      return false;
+    }
+    FramePublishId PublishId() {
+      if (mTag == Tag::NewFrameReady) {
+        return mPublishId;
+      }
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+      return FramePublishId::INVALID;
+    }
+    UniquePtr<RendererEvent> ExternalEvent() {
+      if (mTag == Tag::ExternalEvent) {
+        MOZ_ASSERT(mRendererEvent);
+        return std::move(mRendererEvent);
+      }
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+      return nullptr;
+    }
+  };
+
+  explicit RenderThread(RefPtr<nsIThread> aThread);
+
+  void HandleFrameOneDocInner(wr::WindowId aWindowId, bool aRender,
+                              bool aTrackedFrame,
+                              Maybe<FramePublishId> aPublishId);
+
+  void DeferredRenderTextureHostDestroy();
+  void ShutDownTask();
+  void InitDeviceTask();
+  void HandleFrameOneDoc(wr::WindowId aWindowId, bool aRender,
+                         bool aTrackedFrame, Maybe<FramePublishId> aPublishId);
+  void RunEvent(wr::WindowId aWindowId, UniquePtr<RendererEvent> aEvent);
+  void PostRunnable(already_AddRefed<nsIRunnable> aRunnable);
+
+  void DoAccumulateMemoryReport(MemoryReport,
+                                const RefPtr<MemoryReportPromise::Private>&);
+
+  void AddRenderTextureOp(RenderTextureOp aOp,
+                          const wr::ExternalImageId& aExternalImageId);
+
+  void CreateSingletonGL(nsACString& aError);
+
+  void DestroyExternalImages(const std::vector<wr::ExternalImageId>&& aIds);
+
+  struct WindowInfo;
+
+  void PostWrNotifierEvents(WrWindowId aWindowId);
+  void PostWrNotifierEvents(WrWindowId aWindowId, WindowInfo* aInfo);
+  void HandleWrNotifierEvents(WrWindowId aWindowId);
+  void WrNotifierEvent_HandleWakeUp(wr::WindowId aWindowId,
+                                    bool aCompositeNeeded);
+  void WrNotifierEvent_HandleNewFrameReady(wr::WindowId aWindowId,
+                                           bool aCompositeNeeded,
+                                           FramePublishId aPublishId);
+  void WrNotifierEvent_HandleExternalEvent(
+      wr::WindowId aWindowId, UniquePtr<RendererEvent> aRendererEvent);
+
+  ~RenderThread();
+
+  RefPtr<nsIThread> const mThread;
+
+  WebRenderThreadPool mThreadPool;
+  WebRenderThreadPool mThreadPoolLP;
+
+  UniquePtr<WebRenderProgramCache> mProgramCache;
+  UniquePtr<WebRenderShaders> mShaders;
+  RefPtr<layers::ShaderProgramOGLsHolder> mProgramsForCompositorOGL;
+
+  // An optional shared GLContext to be used for all
+  // windows.
+  RefPtr<gl::GLContext> mSingletonGL;
+  bool mSingletonGLIsForHardwareWebRender;
+
+  RefPtr<layers::SurfacePool> mSurfacePool;
+
+  std::map<wr::WindowId, UniquePtr<RendererOGL>> mRenderers;
+
+  struct PendingFrameInfo {
+    TimeStamp mStartTime;
+    VsyncId mStartId;
+  };
+
+  struct WindowInfo {
+    int64_t PendingCount() { return mPendingFrames.size(); }
+    std::queue<PendingFrameInfo> mPendingFrames;
+    uint8_t mPendingFrameBuild = 0;
+    bool mIsDestroyed = false;
+    RefPtr<nsIRunnable> mWrNotifierEventsRunnable;
+    std::queue<WrNotifierEvent> mPendingWrNotifierEvents;
+  };
+
+  DataMutex<std::unordered_map<uint64_t, UniquePtr<WindowInfo>>> mWindowInfos;
+
+  std::unordered_map<uint64_t, UniquePtr<std::queue<WrNotifierEvent>>>
+      mWrNotifierEventsQueues;
+
+  struct ExternalImageIdHashFn {
+    std::size_t operator()(const wr::ExternalImageId& aId) const {
+      return HashGeneric(wr::AsUint64(aId));
+    }
+  };
+
+  Mutex mRenderTextureMapLock;
+  std::unordered_map<wr::ExternalImageId, RefPtr<RenderTextureHost>,
+                     ExternalImageIdHashFn>
+      mRenderTextures MOZ_GUARDED_BY(mRenderTextureMapLock);
+  std::unordered_map<wr::ExternalImageId, RefPtr<RenderTextureHost>,
+                     ExternalImageIdHashFn>
+      mSyncObjectNeededRenderTextures MOZ_GUARDED_BY(mRenderTextureMapLock);
+  std::list<std::pair<RenderTextureOp, RefPtr<RenderTextureHost>>>
+      mRenderTextureOps MOZ_GUARDED_BY(mRenderTextureMapLock);
+
+  // Used to remove all RenderTextureHost that are going to be removed by
+  // a deferred callback and remove them right away without waiting for the
+  // callback. On device reset we have to remove all GL related resources right
+  // away.
+  std::list<RefPtr<RenderTextureHost>> mRenderTexturesDeferred
+      MOZ_GUARDED_BY(mRenderTextureMapLock);
+
+  RefPtr<nsIRunnable> mRenderTextureOpsRunnable
+      MOZ_GUARDED_BY(mRenderTextureMapLock);
+
+  // Set from MainThread, read from either MainThread or RenderThread
+  bool mHasShutdown;
+
+  // Only accessed from the RenderThread
+  bool mHandlingDeviceReset;
+  bool mHandlingWebRenderError;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RendererOGL.cpp b/gfx/webrender_bindings/RendererOGL.cpp
new file mode 100644
index 0000000000..3c4d13e376
--- /dev/null
+++ b/gfx/webrender_bindings/RendererOGL.cpp
@@ -0,0 +1,430 @@
+/* -*- 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 "RendererOGL.h"
+
+#include "base/task.h"
+#include "GLContext.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/layers/ProfilerScreenshots.h"
+#include "mozilla/webrender/RenderCompositor.h"
+#include "mozilla/webrender/RenderTextureHost.h"
+#include "mozilla/widget/CompositorWidget.h"
+
+namespace mozilla {
+namespace wr {
+
+class RendererRecordedFrame final : public layers::RecordedFrame {
+ public:
+  RendererRecordedFrame(const TimeStamp& aTimeStamp, wr::Renderer* aRenderer,
+                        const wr::RecordedFrameHandle aHandle,
+                        const gfx::IntSize& aSize)
+      : RecordedFrame(aTimeStamp),
+        mRenderer(aRenderer),
+        mSize(aSize),
+        mHandle(aHandle) {}
+
+  already_AddRefed<gfx::DataSourceSurface> GetSourceSurface() override {
+    if (!mSurface) {
+      mSurface = gfx::Factory::CreateDataSourceSurface(
+          mSize, gfx::SurfaceFormat::B8G8R8A8, /* aZero = */ false);
+
+      gfx::DataSourceSurface::ScopedMap map(mSurface,
+                                            gfx::DataSourceSurface::WRITE);
+
+      if (!wr_renderer_map_recorded_frame(mRenderer, mHandle, map.GetData(),
+                                          map.GetStride() * mSize.height,
+                                          map.GetStride())) {
+        return nullptr;
+      }
+    }
+
+    return do_AddRef(mSurface);
+  }
+
+ private:
+  wr::Renderer* mRenderer;
+  RefPtr<gfx::DataSourceSurface> mSurface;
+  gfx::IntSize mSize;
+  wr::RecordedFrameHandle mHandle;
+};
+
+wr::WrExternalImage wr_renderer_lock_external_image(void* aObj,
+                                                    wr::ExternalImageId aId,
+                                                    uint8_t aChannelIndex) {
+  RendererOGL* renderer = reinterpret_cast<RendererOGL*>(aObj);
+  RenderTextureHost* texture = renderer->GetRenderTexture(aId);
+  MOZ_ASSERT(texture);
+  if (!texture) {
+    gfxCriticalNoteOnce << "Failed to lock ExternalImage for extId:"
+                        << AsUint64(aId);
+    return InvalidToWrExternalImage();
+  }
+  if (auto* gl = renderer->gl()) {
+    return texture->Lock(aChannelIndex, gl);
+  } else if (auto* swgl = renderer->swgl()) {
+    return texture->LockSWGL(aChannelIndex, swgl, renderer->GetCompositor());
+  } else {
+    gfxCriticalNoteOnce
+        << "No GL or SWGL context available to lock ExternalImage for extId:"
+        << AsUint64(aId);
+    return InvalidToWrExternalImage();
+  }
+}
+
+void wr_renderer_unlock_external_image(void* aObj, wr::ExternalImageId aId,
+                                       uint8_t aChannelIndex) {
+  RendererOGL* renderer = reinterpret_cast<RendererOGL*>(aObj);
+  RenderTextureHost* texture = renderer->GetRenderTexture(aId);
+  MOZ_ASSERT(texture);
+  if (!texture) {
+    return;
+  }
+  if (renderer->gl()) {
+    texture->Unlock();
+  } else if (renderer->swgl()) {
+    texture->UnlockSWGL();
+  }
+}
+
+RendererOGL::RendererOGL(RefPtr<RenderThread>&& aThread,
+                         UniquePtr<RenderCompositor> aCompositor,
+                         wr::WindowId aWindowId, wr::Renderer* aRenderer,
+                         layers::CompositorBridgeParent* aBridge)
+    : mThread(aThread),
+      mCompositor(std::move(aCompositor)),
+      mRenderer(aRenderer),
+      mBridge(aBridge),
+      mWindowId(aWindowId),
+      mDisableNativeCompositor(false),
+      mLastPipelineInfo(new WebRenderPipelineInfo) {
+  MOZ_ASSERT(mThread);
+  MOZ_ASSERT(mCompositor);
+  MOZ_ASSERT(mRenderer);
+  MOZ_ASSERT(mBridge);
+  MOZ_COUNT_CTOR(RendererOGL);
+}
+
+RendererOGL::~RendererOGL() {
+  MOZ_COUNT_DTOR(RendererOGL);
+  if (!mCompositor->MakeCurrent()) {
+    gfxCriticalNote
+        << "Failed to make render context current during destroying.";
+    // Leak resources!
+  } else {
+    wr_renderer_delete(mRenderer);
+  }
+}
+
+wr::WrExternalImageHandler RendererOGL::GetExternalImageHandler() {
+  return wr::WrExternalImageHandler{
+      this,
+  };
+}
+
+void RendererOGL::SetFramePublishId(FramePublishId aPublishId) {
+  wr_renderer_set_target_frame_publish_id(mRenderer, aPublishId);
+}
+
+void RendererOGL::Update() {
+  mCompositor->Update();
+  if (mCompositor->MakeCurrent()) {
+    wr_renderer_update(mRenderer);
+    FlushPipelineInfo();
+  }
+}
+
+static void DoWebRenderDisableNativeCompositor(
+    layers::CompositorBridgeParent* aBridge) {
+  aBridge->NotifyWebRenderDisableNativeCompositor();
+}
+
+RenderedFrameId RendererOGL::UpdateAndRender(
+    const Maybe<gfx::IntSize>& aReadbackSize,
+    const Maybe<wr::ImageFormat>& aReadbackFormat,
+    const Maybe<Range<uint8_t>>& aReadbackBuffer, bool* aNeedsYFlip,
+    RendererStats* aOutStats) {
+  mozilla::widget::WidgetRenderingContext widgetContext;
+
+#if defined(XP_MACOSX)
+  widgetContext.mGL = mCompositor->gl();
+#endif
+
+  if (!mCompositor->GetWidget()->PreRender(&widgetContext)) {
+    // XXX This could cause oom in webrender since pending_texture_updates is
+    // not handled. It needs to be addressed.
+    return RenderedFrameId();
+  }
+  // XXX set clear color if MOZ_WIDGET_ANDROID is defined.
+
+  if (mThread->IsHandlingDeviceReset() || !mCompositor->BeginFrame()) {
+    CheckGraphicsResetStatus("BeginFrame", /* aForce */ true);
+    mCompositor->GetWidget()->PostRender(&widgetContext);
+    return RenderedFrameId();
+  }
+
+  auto size = mCompositor->GetBufferSize();
+  auto bufferAge = mCompositor->GetBufferAge();
+
+  wr_renderer_update(mRenderer);
+
+  bool fullRender = mCompositor->RequestFullRender();
+  // When we're rendering to an external target, we want to render everything.
+  if (mCompositor->UsePartialPresent() &&
+      (aReadbackBuffer.isSome() || layers::ProfilerScreenshots::IsEnabled())) {
+    fullRender = true;
+  }
+  if (fullRender) {
+    wr_renderer_force_redraw(mRenderer);
+  }
+
+  nsTArray<DeviceIntRect> dirtyRects;
+  bool rendered = wr_renderer_render(mRenderer, size.width, size.height,
+                                     bufferAge, aOutStats, &dirtyRects);
+  FlushPipelineInfo();
+  if (!rendered) {
+    mCompositor->CancelFrame();
+    RenderThread::Get()->HandleWebRenderError(WebRenderError::RENDER);
+    mCompositor->GetWidget()->PostRender(&widgetContext);
+    return RenderedFrameId();
+  }
+
+  if (aReadbackBuffer.isSome()) {
+    MOZ_ASSERT(aReadbackSize.isSome());
+    MOZ_ASSERT(aReadbackFormat.isSome());
+    if (!mCompositor->MaybeReadback(aReadbackSize.ref(), aReadbackFormat.ref(),
+                                    aReadbackBuffer.ref(), aNeedsYFlip)) {
+      wr_renderer_readback(mRenderer, aReadbackSize.ref().width,
+                           aReadbackSize.ref().height, aReadbackFormat.ref(),
+                           &aReadbackBuffer.ref()[0],
+                           aReadbackBuffer.ref().length());
+      if (aNeedsYFlip) {
+        *aNeedsYFlip = !mCompositor->SurfaceOriginIsTopLeft();
+      }
+    }
+  }
+
+  if (size.Width() != 0 && size.Height() != 0) {
+    if (!mCompositor->MaybeGrabScreenshot(size.ToUnknownSize())) {
+      mScreenshotGrabber.MaybeGrabScreenshot(this, size.ToUnknownSize());
+    }
+  }
+
+  // Frame recording must happen before EndFrame, as we must ensure we read the
+  // contents of the back buffer before any calls to SwapBuffers which might
+  // invalidate it.
+  MaybeRecordFrame(mLastPipelineInfo);
+
+  RenderedFrameId frameId = mCompositor->EndFrame(dirtyRects);
+
+  mCompositor->GetWidget()->PostRender(&widgetContext);
+
+#if defined(ENABLE_FRAME_LATENCY_LOG)
+  if (mFrameStartTime) {
+    uint32_t latencyMs =
+        round((TimeStamp::Now() - mFrameStartTime).ToMilliseconds());
+    printf_stderr("generate frame latencyMs latencyMs %d\n", latencyMs);
+  }
+  // Clear frame start time
+  mFrameStartTime = TimeStamp();
+#endif
+
+  if (!mCompositor->MaybeProcessScreenshotQueue()) {
+    mScreenshotGrabber.MaybeProcessQueue(this);
+  }
+
+  // TODO: Flush pending actions such as texture deletions/unlocks and
+  //       textureHosts recycling.
+
+  return frameId;
+}
+
+bool RendererOGL::EnsureAsyncScreenshot() {
+  if (mCompositor->SupportAsyncScreenshot()) {
+    return true;
+  }
+  if (!mDisableNativeCompositor) {
+    layers::CompositorThread()->Dispatch(
+        NewRunnableFunction("DoWebRenderDisableNativeCompositorRunnable",
+                            &DoWebRenderDisableNativeCompositor, mBridge));
+
+    mDisableNativeCompositor = true;
+    gfxCriticalNote << "Disable native compositor for async screenshot";
+  }
+  return false;
+}
+
+void RendererOGL::CheckGraphicsResetStatus(const char* aCaller, bool aForce) {
+  if (mCompositor) {
+    auto reason = mCompositor->IsContextLost(aForce);
+    if (reason != LOCAL_GL_NO_ERROR) {
+      RenderThread::Get()->HandleDeviceReset(aCaller, reason);
+    }
+  }
+}
+
+void RendererOGL::WaitForGPU() {
+  if (!mCompositor->WaitForGPU()) {
+    CheckGraphicsResetStatus("WaitForGPU", /* aForce */ true);
+  }
+}
+
+ipc::FileDescriptor RendererOGL::GetAndResetReleaseFence() {
+  return mCompositor->GetAndResetReleaseFence();
+}
+
+RenderedFrameId RendererOGL::GetLastCompletedFrameId() {
+  return mCompositor->GetLastCompletedFrameId();
+}
+
+RenderedFrameId RendererOGL::UpdateFrameId() {
+  return mCompositor->UpdateFrameId();
+}
+
+void RendererOGL::Pause() { mCompositor->Pause(); }
+
+bool RendererOGL::Resume() { return mCompositor->Resume(); }
+
+bool RendererOGL::IsPaused() { return mCompositor->IsPaused(); }
+
+layers::SyncObjectHost* RendererOGL::GetSyncObject() const {
+  return mCompositor->GetSyncObject();
+}
+
+gl::GLContext* RendererOGL::gl() const { return mCompositor->gl(); }
+
+void* RendererOGL::swgl() const { return mCompositor->swgl(); }
+
+void RendererOGL::SetFrameStartTime(const TimeStamp& aTime) {
+  if (mFrameStartTime) {
+    // frame start time is already set. This could happen when multiple
+    // generate frame requests are merged by webrender.
+    return;
+  }
+  mFrameStartTime = aTime;
+}
+
+void RendererOGL::BeginRecording(const TimeStamp& aRecordingStart,
+                                 wr::PipelineId aRootPipelineId) {
+  MOZ_ASSERT(!mCompositionRecorder);
+
+  mRootPipelineId = aRootPipelineId;
+  mCompositionRecorder =
+      MakeUnique<layers::CompositionRecorder>(aRecordingStart);
+  mCompositor->MaybeRequestAllowFrameRecording(true);
+}
+
+void RendererOGL::MaybeRecordFrame(const WebRenderPipelineInfo* aPipelineInfo) {
+  if (!mCompositionRecorder || !EnsureAsyncScreenshot()) {
+    return;
+  }
+
+  if (!mRenderer || !aPipelineInfo || !DidPaintContent(aPipelineInfo)) {
+    return;
+  }
+
+  if (mCompositor->MaybeRecordFrame(*mCompositionRecorder)) {
+    return;
+  }
+
+  wr::RecordedFrameHandle handle{0};
+  gfx::IntSize size(0, 0);
+
+  if (wr_renderer_record_frame(mRenderer, wr::ImageFormat::BGRA8, &handle,
+                               &size.width, &size.height)) {
+    RefPtr<layers::RecordedFrame> frame =
+        new RendererRecordedFrame(TimeStamp::Now(), mRenderer, handle, size);
+
+    mCompositionRecorder->RecordFrame(frame);
+  }
+}
+
+bool RendererOGL::DidPaintContent(const WebRenderPipelineInfo* aFrameEpochs) {
+  const wr::WrPipelineInfo& info = aFrameEpochs->Raw();
+  bool didPaintContent = false;
+
+  // Check if a non-root pipeline has updated to a new epoch.
+  // We treat all non-root pipelines as "content" pipelines, even if they're
+  // not fed by content paints, such as videos (see bug 1665512).
+  for (const auto& epoch : info.epochs) {
+    const wr::PipelineId pipelineId = epoch.pipeline_id;
+
+    if (pipelineId == mRootPipelineId) {
+      continue;
+    }
+
+    const auto it = mContentPipelineEpochs.find(AsUint64(pipelineId));
+    if (it == mContentPipelineEpochs.end() || it->second != epoch.epoch) {
+      // This pipeline has updated since last render or has newly rendered.
+      didPaintContent = true;
+      mContentPipelineEpochs[AsUint64(pipelineId)] = epoch.epoch;
+    }
+  }
+
+  for (const auto& removedPipeline : info.removed_pipelines) {
+    const wr::PipelineId pipelineId = removedPipeline.pipeline_id;
+    if (pipelineId == mRootPipelineId) {
+      continue;
+    }
+    mContentPipelineEpochs.erase(AsUint64(pipelineId));
+  }
+
+  return didPaintContent;
+}
+
+Maybe<layers::FrameRecording> RendererOGL::EndRecording() {
+  if (!mCompositionRecorder) {
+    MOZ_DIAGNOSTIC_ASSERT(
+        false, "Attempted to get frames from a window that was not recording.");
+    return Nothing();
+  }
+
+  auto maybeRecording = mCompositionRecorder->GetRecording();
+
+  wr_renderer_release_composition_recorder_structures(mRenderer);
+
+  mCompositor->MaybeRequestAllowFrameRecording(false);
+  mCompositionRecorder = nullptr;
+
+  return maybeRecording;
+}
+
+void RendererOGL::FlushPipelineInfo() {
+  RefPtr<WebRenderPipelineInfo> info = new WebRenderPipelineInfo;
+  wr_renderer_flush_pipeline_info(mRenderer, &info->Raw());
+  mLastPipelineInfo = info;
+}
+
+RenderTextureHost* RendererOGL::GetRenderTexture(
+    wr::ExternalImageId aExternalImageId) {
+  return mThread->GetRenderTexture(aExternalImageId);
+}
+
+void RendererOGL::AccumulateMemoryReport(MemoryReport* aReport) {
+  wr_renderer_accumulate_memory_report(GetRenderer(), aReport, swgl());
+
+  LayoutDeviceIntSize size = mCompositor->GetBufferSize();
+
+  // Assume BGRA8 for the format since it's not exposed anywhere,
+  // and all compositor backends should be using that.
+  uintptr_t swapChainSize = size.width * size.height *
+                            BytesPerPixel(gfx::SurfaceFormat::B8G8R8A8) *
+                            (mCompositor->UseTripleBuffering() ? 3 : 2);
+  aReport->swap_chain += swapChainSize;
+}
+
+void RendererOGL::SetProfilerUI(const nsACString& aUI) {
+  wr_renderer_set_profiler_ui(GetRenderer(), (const uint8_t*)aUI.BeginReading(),
+                              aUI.Length());
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RendererOGL.h b/gfx/webrender_bindings/RendererOGL.h
new file mode 100644
index 0000000000..bf79f70d16
--- /dev/null
+++ b/gfx/webrender_bindings/RendererOGL.h
@@ -0,0 +1,176 @@
+/* -*- 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_LAYERS_RENDEREROGL_H
+#define MOZILLA_LAYERS_RENDEREROGL_H
+
+#include "mozilla/ipc/FileDescriptor.h"
+#include "mozilla/layers/CompositorTypes.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "mozilla/webrender/webrender_ffi.h"
+#include "mozilla/webrender/RendererScreenshotGrabber.h"
+
+namespace mozilla {
+
+namespace gfx {
+class DrawTarget;
+}
+
+namespace gl {
+class GLContext;
+}
+
+namespace layers {
+class CompositorBridgeParent;
+class SyncObjectHost;
+}  // namespace layers
+
+namespace widget {
+class CompositorWidget;
+}
+
+namespace wr {
+
+class RenderCompositor;
+class RenderTextureHost;
+
+/// Owns the WebRender renderer and GL context.
+///
+/// There is one renderer per window, all owned by the render thread.
+/// This class is a similar abstraction to CompositorOGL except that it is used
+/// on the render thread instead of the compositor thread.
+class RendererOGL {
+  friend wr::WrExternalImage LockExternalImage(void* aObj,
+                                               wr::ExternalImageId aId,
+                                               uint8_t aChannelIndex,
+                                               wr::ImageRendering);
+  friend void UnlockExternalImage(void* aObj, wr::ExternalImageId aId,
+                                  uint8_t aChannelIndex);
+
+ public:
+  wr::WrExternalImageHandler GetExternalImageHandler();
+
+  void SetFramePublishId(FramePublishId aPublishId);
+
+  /// This can be called on the render thread only.
+  void Update();
+
+  /// This can be called on the render thread only.
+  RenderedFrameId UpdateAndRender(const Maybe<gfx::IntSize>& aReadbackSize,
+                                  const Maybe<wr::ImageFormat>& aReadbackFormat,
+                                  const Maybe<Range<uint8_t>>& aReadbackBuffer,
+                                  bool* aNeedsYFlip, RendererStats* aOutStats);
+
+  /// This can be called on the render thread only.
+  void WaitForGPU();
+
+  /// This can be called on the render thread only.
+  ipc::FileDescriptor GetAndResetReleaseFence();
+
+  /// This can be called on the render thread only.
+  RenderedFrameId GetLastCompletedFrameId();
+
+  /// This can be called on the render thread only.
+  RenderedFrameId UpdateFrameId();
+
+  /// This can be called on the render thread only.
+  void SetProfilerEnabled(bool aEnabled);
+
+  /// This can be called on the render thread only.
+  void SetFrameStartTime(const TimeStamp& aTime);
+
+  /// These can be called on the render thread only.
+  void BeginRecording(const TimeStamp& aRecordingStart,
+                      wr::PipelineId aPipelineId);
+  void MaybeRecordFrame(const WebRenderPipelineInfo* aPipelineInfo);
+
+  Maybe<layers::FrameRecording> EndRecording();
+
+  /// This can be called on the render thread only.
+  ~RendererOGL();
+
+  /// This can be called on the render thread only.
+  RendererOGL(RefPtr<RenderThread>&& aThread,
+              UniquePtr<RenderCompositor> aCompositor, wr::WindowId aWindowId,
+              wr::Renderer* aRenderer, layers::CompositorBridgeParent* aBridge);
+
+  /// This can be called on the render thread only.
+  void Pause();
+
+  /// This can be called on the render thread only.
+  bool Resume();
+
+  /// This can be called on the render thread only.
+  bool IsPaused();
+
+  /// This can be called on the render thread only.
+  void CheckGraphicsResetStatus(const char* aCaller, bool aForce);
+
+  layers::SyncObjectHost* GetSyncObject() const;
+
+  layers::CompositorBridgeParent* GetCompositorBridge() { return mBridge; }
+
+  void FlushPipelineInfo();
+
+  RefPtr<const WebRenderPipelineInfo> GetLastPipelineInfo() const {
+    return mLastPipelineInfo;
+  }
+
+  RenderTextureHost* GetRenderTexture(wr::ExternalImageId aExternalImageId);
+
+  RenderCompositor* GetCompositor() { return mCompositor.get(); }
+
+  void AccumulateMemoryReport(MemoryReport* aReport);
+
+  void SetProfilerUI(const nsACString& aUI);
+
+  wr::Renderer* GetRenderer() { return mRenderer; }
+
+  gl::GLContext* gl() const;
+
+  void* swgl() const;
+
+  bool EnsureAsyncScreenshot();
+
+ protected:
+  /**
+   * Determine if any content pipelines updated, and update
+   * mContentPipelineEpochs.
+   */
+  bool DidPaintContent(const wr::WebRenderPipelineInfo* aFrameEpochs);
+
+  RefPtr<RenderThread> mThread;
+  UniquePtr<RenderCompositor> mCompositor;
+  UniquePtr<layers::CompositionRecorder> mCompositionRecorder;  // can be null
+  wr::Renderer* mRenderer;
+  layers::CompositorBridgeParent* mBridge;
+  wr::WindowId mWindowId;
+  TimeStamp mFrameStartTime;
+
+  bool mDisableNativeCompositor;
+
+  RendererScreenshotGrabber mScreenshotGrabber;
+
+  // The id of the root WebRender pipeline.
+  //
+  // All other pipelines are considered content.
+  wr::PipelineId mRootPipelineId;
+
+  // A mapping of wr::PipelineId to the epochs when last they updated.
+  //
+  // We need to use uint64_t here since wr::PipelineId is not default
+  // constructable.
+  std::unordered_map<uint64_t, wr::Epoch> mContentPipelineEpochs;
+
+  RefPtr<WebRenderPipelineInfo> mLastPipelineInfo;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/RendererScreenshotGrabber.cpp b/gfx/webrender_bindings/RendererScreenshotGrabber.cpp
new file mode 100644
index 0000000000..1d001d4727
--- /dev/null
+++ b/gfx/webrender_bindings/RendererScreenshotGrabber.cpp
@@ -0,0 +1,104 @@
+/* -*- 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 "RendererScreenshotGrabber.h"
+
+#include "RendererOGL.h"
+
+#include "mozilla/gfx/2D.h"
+
+using mozilla::layers::ProfilerScreenshots;
+
+namespace mozilla {
+namespace wr {
+
+RendererScreenshotGrabber::RendererScreenshotGrabber() {
+  mMaxScreenshotSize = ProfilerScreenshots::ScreenshotSize();
+}
+
+void RendererScreenshotGrabber::MaybeGrabScreenshot(
+    RendererOGL* aRendererOGL, const gfx::IntSize& aWindowSize) {
+  bool isEnabled =
+      ProfilerScreenshots::IsEnabled() && aRendererOGL->EnsureAsyncScreenshot();
+
+  if (isEnabled) {
+    if (!mProfilerScreenshots) {
+      mProfilerScreenshots = new ProfilerScreenshots();
+    }
+
+    GrabScreenshot(aRendererOGL->GetRenderer(), aWindowSize);
+  } else if (mProfilerScreenshots) {
+    Destroy(aRendererOGL->GetRenderer());
+  }
+}
+
+void RendererScreenshotGrabber::MaybeProcessQueue(RendererOGL* aRendererOGL) {
+  bool isEnabled =
+      ProfilerScreenshots::IsEnabled() && aRendererOGL->EnsureAsyncScreenshot();
+
+  if (isEnabled) {
+    if (!mProfilerScreenshots) {
+      mProfilerScreenshots = new ProfilerScreenshots();
+    }
+
+    ProcessQueue(aRendererOGL->GetRenderer());
+  } else if (mProfilerScreenshots) {
+    Destroy(aRendererOGL->GetRenderer());
+  }
+}
+
+void RendererScreenshotGrabber::Destroy(Renderer* aRenderer) {
+  mQueue.Clear();
+  mCurrentFrameQueueItem = Nothing();
+  mProfilerScreenshots = nullptr;
+
+  wr_renderer_release_profiler_structures(aRenderer);
+}
+
+void RendererScreenshotGrabber::GrabScreenshot(
+    Renderer* aRenderer, const gfx::IntSize& aWindowSize) {
+  gfx::IntSize screenshotSize;
+
+  AsyncScreenshotHandle handle = wr_renderer_get_screenshot_async(
+      aRenderer, 0, 0, aWindowSize.width, aWindowSize.height,
+      mMaxScreenshotSize.width, mMaxScreenshotSize.height, ImageFormat::BGRA8,
+      &screenshotSize.width, &screenshotSize.height);
+
+  mCurrentFrameQueueItem = Some(QueueItem{
+      TimeStamp::Now(),
+      handle,
+      screenshotSize,
+      aWindowSize,
+  });
+}
+
+void RendererScreenshotGrabber::ProcessQueue(Renderer* aRenderer) {
+  for (const auto& item : mQueue) {
+    mProfilerScreenshots->SubmitScreenshot(
+        item.mWindowSize, item.mScreenshotSize, item.mTimeStamp,
+        [&item, aRenderer](gfx::DataSourceSurface* aTargetSurface) {
+          gfx::DataSourceSurface::ScopedMap map(aTargetSurface,
+                                                gfx::DataSourceSurface::WRITE);
+          int32_t destStride = map.GetStride();
+
+          bool success = wr_renderer_map_and_recycle_screenshot(
+              aRenderer, item.mHandle, map.GetData(),
+              destStride * aTargetSurface->GetSize().height, destStride);
+
+          return success;
+        });
+  }
+
+  mQueue.Clear();
+
+  if (mCurrentFrameQueueItem) {
+    mQueue.AppendElement(*mCurrentFrameQueueItem);
+    mCurrentFrameQueueItem = Nothing();
+  }
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/RendererScreenshotGrabber.h b/gfx/webrender_bindings/RendererScreenshotGrabber.h
new file mode 100644
index 0000000000..81f11a392d
--- /dev/null
+++ b/gfx/webrender_bindings/RendererScreenshotGrabber.h
@@ -0,0 +1,101 @@
+/* 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_layers_RendererScreenshotGrabber_h
+#define mozilla_layers_RendererScreenshotGrabber_h
+
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/layers/ProfilerScreenshots.h"
+#include "mozilla/webrender/webrender_ffi.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+namespace wr {
+
+struct Renderer;
+class RendererOGL;
+
+/**
+ * Used by |RendererOGL| to grab screenshots from WebRender and submit them to
+ * the Gecko profiler.
+ *
+ * If the profiler is not running or the screenshots feature is disabled, no
+ * work will be done.
+ */
+class RendererScreenshotGrabber final {
+ public:
+  RendererScreenshotGrabber();
+
+  /**
+   * Grab a screenshot from WebRender if we are profiling and screenshots are
+   * enabled.
+   *
+   * The captured screenshot will not be mapped until the second call to
+   * |MaybeProcessQueue| after this call to |MaybeGrabScreenshot|.
+   */
+  void MaybeGrabScreenshot(RendererOGL* aRendererOGL,
+                           const gfx::IntSize& aWindowSize);
+
+  /**
+   * Process the screenshots pending in the queue if we are profiling and
+   * screenshots are enabled.
+   */
+  void MaybeProcessQueue(RendererOGL* aRenderer);
+
+ private:
+  /**
+   * Drop all our allocated memory when we are no longer profiling.
+   *
+   * This will also instruct WebRender to drop all its Gecko profiler
+   * associated memory.
+   */
+  void Destroy(Renderer* aRenderer);
+
+  /**
+   * Actually grab a screenshot from WebRender.
+   */
+  void GrabScreenshot(Renderer* aRenderer, const gfx::IntSize& aWindowSize);
+
+  /**
+   * Process the screenshots pending in the queue.
+   */
+  void ProcessQueue(Renderer* aRenderer);
+
+  struct QueueItem {
+    mozilla::TimeStamp mTimeStamp;
+    AsyncScreenshotHandle mHandle;
+    gfx::IntSize mScreenshotSize;
+    gfx::IntSize mWindowSize;
+  };
+
+  /**
+   * The maximum size for screenshots, as dictated by
+   * |ProfilerScrenshots::ScreenshotSize|.
+   */
+  gfx::IntSize mMaxScreenshotSize;
+
+  /**
+   * The queue of screenshots waiting to be processed and submitted.
+   */
+  nsTArray<QueueItem> mQueue;
+
+  /**
+   * The queue item for the current frame. This will be inserted into the queue
+   * after a call to |MaybeProcessQueue| so it will be not be processed until
+   * the next frame.
+   */
+  Maybe<QueueItem> mCurrentFrameQueueItem;
+
+  /**
+   * Our handle to the profiler screenshots object.
+   */
+  RefPtr<mozilla::layers::ProfilerScreenshots> mProfilerScreenshots;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // mozilla_layers_RendererScreenshotGrabber_h
diff --git a/gfx/webrender_bindings/WebRenderAPI.cpp b/gfx/webrender_bindings/WebRenderAPI.cpp
new file mode 100644
index 0000000000..09a024a897
--- /dev/null
+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
@@ -0,0 +1,1867 @@
+/* -*- 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 "WebRenderAPI.h"
+
+#include "mozilla/Logging.h"
+#include "mozilla/ipc/ByteBuf.h"
+#include "mozilla/webrender/RendererOGL.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/StaticPrefs_webgl.h"
+#include "mozilla/ToString.h"
+#include "mozilla/webrender/RenderCompositor.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "mozilla/layers/SynchronousTask.h"
+#include "nsThreadUtils.h"
+#include "TextDrawTarget.h"
+#include "malloc_decls.h"
+#include "GLContext.h"
+
+static mozilla::LazyLogModule sWrDLLog("wr.dl");
+#define WRDL_LOG(...) \
+  MOZ_LOG(sWrDLLog, LogLevel::Debug, ("WRDL(%p): " __VA_ARGS__))
+
+namespace mozilla {
+using namespace layers;
+
+namespace wr {
+
+MOZ_DEFINE_MALLOC_SIZE_OF(WebRenderMallocSizeOf)
+MOZ_DEFINE_MALLOC_ENCLOSING_SIZE_OF(WebRenderMallocEnclosingSizeOf)
+
+class NewRenderer : public RendererEvent {
+ public:
+  NewRenderer(wr::DocumentHandle** aDocHandle,
+              layers::CompositorBridgeParent* aBridge,
+              WebRenderBackend* aBackend, WebRenderCompositor* aCompositor,
+              int32_t* aMaxTextureSize, bool* aUseANGLE, bool* aUseDComp,
+              bool* aUseTripleBuffering, bool* aSupportsExternalBufferTextures,
+              RefPtr<widget::CompositorWidget>&& aWidget,
+              layers::SynchronousTask* aTask, LayoutDeviceIntSize aSize,
+              layers::WindowKind aWindowKind, layers::SyncHandle* aHandle,
+              nsACString* aError)
+      : mDocHandle(aDocHandle),
+        mBackend(aBackend),
+        mCompositor(aCompositor),
+        mMaxTextureSize(aMaxTextureSize),
+        mUseANGLE(aUseANGLE),
+        mUseDComp(aUseDComp),
+        mUseTripleBuffering(aUseTripleBuffering),
+        mSupportsExternalBufferTextures(aSupportsExternalBufferTextures),
+        mBridge(aBridge),
+        mCompositorWidget(std::move(aWidget)),
+        mTask(aTask),
+        mSize(aSize),
+        mWindowKind(aWindowKind),
+        mSyncHandle(aHandle),
+        mError(aError) {
+    MOZ_COUNT_CTOR(NewRenderer);
+  }
+
+  MOZ_COUNTED_DTOR(NewRenderer)
+
+  void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+    layers::AutoCompleteTask complete(mTask);
+
+    UniquePtr<RenderCompositor> compositor =
+        RenderCompositor::Create(std::move(mCompositorWidget), *mError);
+    if (!compositor) {
+      if (!mError->IsEmpty()) {
+        gfxCriticalNote << mError->BeginReading();
+      }
+      return;
+    }
+
+    compositor->MakeCurrent();
+
+    *mBackend = compositor->BackendType();
+    *mCompositor = compositor->CompositorType();
+    *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
+    // returns an error code.
+    bool panic_on_gl_error = false;
+#ifdef NIGHTLY_BUILD
+    panic_on_gl_error =
+        StaticPrefs::gfx_webrender_panic_on_gl_error_AtStartup();
+#endif
+
+    bool isMainWindow = true;  // TODO!
+    bool supportLowPriorityTransactions = isMainWindow;
+    bool supportLowPriorityThreadpool =
+        supportLowPriorityTransactions &&
+        StaticPrefs::gfx_webrender_enable_low_priority_pool();
+    wr::Renderer* wrRenderer = nullptr;
+    char* errorMessage = nullptr;
+    int picTileWidth = StaticPrefs::gfx_webrender_picture_tile_width();
+    int picTileHeight = StaticPrefs::gfx_webrender_picture_tile_height();
+    auto* swgl = compositor->swgl();
+    auto* gl = (compositor->gl() && !swgl) ? compositor->gl() : nullptr;
+    auto* progCache = (aRenderThread.GetProgramCache() && !swgl)
+                          ? aRenderThread.GetProgramCache()->Raw()
+                          : nullptr;
+    auto* shaders = (aRenderThread.GetShaders() && !swgl)
+                        ? aRenderThread.GetShaders()->RawShaders()
+                        : nullptr;
+
+    // Check That if we are not using SWGL, we have at least a GL or GLES 3.0
+    // context.
+    if (gl && !swgl) {
+      bool versionCheck =
+          gl->IsAtLeast(gl::ContextProfile::OpenGLCore, 300) ||
+          gl->IsAtLeast(gl::ContextProfile::OpenGLCompatibility, 300) ||
+          gl->IsAtLeast(gl::ContextProfile::OpenGLES, 300);
+
+      if (!versionCheck) {
+        gfxCriticalNote << "GL context version (" << gl->Version()
+                        << ") insufficent for hardware WebRender";
+
+        mError->AssignASCII("GL context version insufficient");
+        return;
+      }
+    }
+
+    if (!wr_window_new(
+            aWindowId, mSize.width, mSize.height,
+            mWindowKind == WindowKind::MAIN, supportLowPriorityTransactions,
+            supportLowPriorityThreadpool, gfx::gfxVars::UseGLSwizzle(),
+            gfx::gfxVars::UseWebRenderScissoredCacheClears(), swgl, gl,
+            compositor->SurfaceOriginIsTopLeft(), progCache, shaders,
+            aRenderThread.ThreadPool().Raw(),
+            aRenderThread.ThreadPoolLP().Raw(), &WebRenderMallocSizeOf,
+            &WebRenderMallocEnclosingSizeOf, 0, compositor.get(),
+            compositor->ShouldUseNativeCompositor(),
+            compositor->UsePartialPresent(),
+            compositor->GetMaxPartialPresentRects(),
+            compositor->ShouldDrawPreviousPartialPresentRegions(), mDocHandle,
+            &wrRenderer, mMaxTextureSize, &errorMessage,
+            StaticPrefs::gfx_webrender_enable_gpu_markers_AtStartup(),
+            panic_on_gl_error, picTileWidth, picTileHeight,
+            gfx::gfxVars::WebRenderRequiresHardwareDriver(),
+            StaticPrefs::gfx_webrender_low_quality_pinch_zoom_AtStartup(),
+            StaticPrefs::gfx_webrender_max_shared_surface_size_AtStartup(),
+            StaticPrefs::gfx_webrender_enable_subpixel_aa_AtStartup())) {
+      // wr_window_new puts a message into gfxCriticalNote if it returns false
+      MOZ_ASSERT(errorMessage);
+      mError->AssignASCII(errorMessage);
+      wr_api_free_error_msg(errorMessage);
+      return;
+    }
+    MOZ_ASSERT(wrRenderer);
+
+    RefPtr<RenderThread> thread = &aRenderThread;
+    auto renderer =
+        MakeUnique<RendererOGL>(std::move(thread), std::move(compositor),
+                                aWindowId, wrRenderer, mBridge);
+    if (wrRenderer && renderer) {
+      wr::WrExternalImageHandler handler = renderer->GetExternalImageHandler();
+      wr_renderer_set_external_image_handler(wrRenderer, &handler);
+    }
+
+    if (renderer) {
+      layers::SyncObjectHost* syncObj = renderer->GetSyncObject();
+      if (syncObj) {
+        *mSyncHandle = syncObj->GetSyncHandle();
+      }
+    }
+
+    aRenderThread.AddRenderer(aWindowId, std::move(renderer));
+  }
+
+ private:
+  wr::DocumentHandle** mDocHandle;
+  WebRenderBackend* mBackend;
+  WebRenderCompositor* mCompositor;
+  int32_t* mMaxTextureSize;
+  bool* mUseANGLE;
+  bool* mUseDComp;
+  bool* mUseTripleBuffering;
+  bool* mSupportsExternalBufferTextures;
+  layers::CompositorBridgeParent* mBridge;
+  RefPtr<widget::CompositorWidget> mCompositorWidget;
+  layers::SynchronousTask* mTask;
+  LayoutDeviceIntSize mSize;
+  layers::WindowKind mWindowKind;
+  layers::SyncHandle* mSyncHandle;
+  nsACString* mError;
+};
+
+class RemoveRenderer : public RendererEvent {
+ public:
+  explicit RemoveRenderer(layers::SynchronousTask* aTask) : mTask(aTask) {
+    MOZ_COUNT_CTOR(RemoveRenderer);
+  }
+
+  MOZ_COUNTED_DTOR_OVERRIDE(RemoveRenderer)
+
+  void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+    aRenderThread.RemoveRenderer(aWindowId);
+    layers::AutoCompleteTask complete(mTask);
+  }
+
+ private:
+  layers::SynchronousTask* mTask;
+};
+
+TransactionBuilder::TransactionBuilder(WebRenderAPI* aApi,
+                                       bool aUseSceneBuilderThread)
+    : mUseSceneBuilderThread(aUseSceneBuilderThread),
+      mApiBackend(aApi->GetBackendType()),
+      mOwnsData(true) {
+  mTxn = wr_transaction_new(mUseSceneBuilderThread);
+}
+
+TransactionBuilder::TransactionBuilder(WebRenderAPI* aApi, Transaction* aTxn,
+                                       bool aUseSceneBuilderThread,
+                                       bool aOwnsData)
+    : mTxn(aTxn),
+      mUseSceneBuilderThread(aUseSceneBuilderThread),
+      mApiBackend(aApi->GetBackendType()),
+      mOwnsData(aOwnsData) {}
+
+TransactionBuilder::~TransactionBuilder() {
+  if (mOwnsData) {
+    wr_transaction_delete(mTxn);
+  }
+}
+
+void TransactionBuilder::SetLowPriority(bool aIsLowPriority) {
+  wr_transaction_set_low_priority(mTxn, aIsLowPriority);
+}
+
+void TransactionBuilder::UpdateEpoch(PipelineId aPipelineId, Epoch aEpoch) {
+  wr_transaction_update_epoch(mTxn, aPipelineId, aEpoch);
+}
+
+void TransactionBuilder::SetRootPipeline(PipelineId aPipelineId) {
+  wr_transaction_set_root_pipeline(mTxn, aPipelineId);
+}
+
+void TransactionBuilder::RemovePipeline(PipelineId aPipelineId) {
+  wr_transaction_remove_pipeline(mTxn, aPipelineId);
+}
+
+void TransactionBuilder::SetDisplayList(
+    Epoch aEpoch, wr::WrPipelineId pipeline_id,
+    wr::BuiltDisplayListDescriptor dl_descriptor,
+    wr::Vec<uint8_t>& dl_items_data, wr::Vec<uint8_t>& dl_cache_data,
+    wr::Vec<uint8_t>& dl_spatial_tree) {
+  wr_transaction_set_display_list(mTxn, aEpoch, pipeline_id, dl_descriptor,
+                                  &dl_items_data.inner, &dl_cache_data.inner,
+                                  &dl_spatial_tree.inner);
+}
+
+void TransactionBuilder::ClearDisplayList(Epoch aEpoch,
+                                          wr::WrPipelineId aPipelineId) {
+  wr_transaction_clear_display_list(mTxn, aEpoch, aPipelineId);
+}
+
+void TransactionBuilder::GenerateFrame(const VsyncId& aVsyncId,
+                                       wr::RenderReasons aReasons) {
+  wr_transaction_generate_frame(mTxn, aVsyncId.mId, aReasons);
+}
+
+void TransactionBuilder::InvalidateRenderedFrame(wr::RenderReasons aReasons) {
+  wr_transaction_invalidate_rendered_frame(mTxn, aReasons);
+}
+
+bool TransactionBuilder::IsEmpty() const {
+  return wr_transaction_is_empty(mTxn);
+}
+
+bool TransactionBuilder::IsResourceUpdatesEmpty() const {
+  return wr_transaction_resource_updates_is_empty(mTxn);
+}
+
+bool TransactionBuilder::IsRenderedFrameInvalidated() const {
+  return wr_transaction_is_rendered_frame_invalidated(mTxn);
+}
+
+void TransactionBuilder::SetDocumentView(
+    const LayoutDeviceIntRect& aDocumentRect) {
+  wr::DeviceIntRect wrDocRect;
+  wrDocRect.min.x = aDocumentRect.x;
+  wrDocRect.min.y = aDocumentRect.y;
+  wrDocRect.max.x = aDocumentRect.x + aDocumentRect.width;
+  wrDocRect.max.y = aDocumentRect.y + aDocumentRect.height;
+  wr_transaction_set_document_view(mTxn, &wrDocRect);
+}
+
+TransactionWrapper::TransactionWrapper(Transaction* aTxn) : mTxn(aTxn) {}
+
+void TransactionWrapper::AppendDynamicProperties(
+    const nsTArray<wr::WrOpacityProperty>& aOpacityArray,
+    const nsTArray<wr::WrTransformProperty>& aTransformArray,
+    const nsTArray<wr::WrColorProperty>& aColorArray) {
+  wr_transaction_append_dynamic_properties(
+      mTxn, aOpacityArray.IsEmpty() ? nullptr : aOpacityArray.Elements(),
+      aOpacityArray.Length(),
+      aTransformArray.IsEmpty() ? nullptr : aTransformArray.Elements(),
+      aTransformArray.Length(),
+      aColorArray.IsEmpty() ? nullptr : aColorArray.Elements(),
+      aColorArray.Length());
+}
+
+void TransactionWrapper::AppendTransformProperties(
+    const nsTArray<wr::WrTransformProperty>& aTransformArray) {
+  wr_transaction_append_transform_properties(
+      mTxn, aTransformArray.IsEmpty() ? nullptr : aTransformArray.Elements(),
+      aTransformArray.Length());
+}
+
+void TransactionWrapper::UpdateScrollPosition(
+    const wr::ExternalScrollId& aScrollId,
+    const nsTArray<wr::SampledScrollOffset>& aSampledOffsets) {
+  wr_transaction_scroll_layer(mTxn, aScrollId, &aSampledOffsets);
+}
+
+void TransactionWrapper::UpdateIsTransformAsyncZooming(uint64_t aAnimationId,
+                                                       bool aIsZooming) {
+  wr_transaction_set_is_transform_async_zooming(mTxn, aAnimationId, aIsZooming);
+}
+
+void TransactionWrapper::AddMinimapData(const wr::ExternalScrollId& aScrollId,
+                                        const MinimapData& aMinimapData) {
+  wr_transaction_add_minimap_data(mTxn, aScrollId, aMinimapData);
+}
+
+/*static*/
+already_AddRefed<WebRenderAPI> WebRenderAPI::Create(
+    layers::CompositorBridgeParent* aBridge,
+    RefPtr<widget::CompositorWidget>&& aWidget, const wr::WrWindowId& aWindowId,
+    LayoutDeviceIntSize aSize, layers::WindowKind aWindowKind,
+    nsACString& aError) {
+  MOZ_ASSERT(aBridge);
+  MOZ_ASSERT(aWidget);
+  static_assert(
+      sizeof(size_t) == sizeof(uintptr_t),
+      "The FFI bindings assume size_t is the same size as uintptr_t!");
+
+  wr::DocumentHandle* docHandle = nullptr;
+  WebRenderBackend backend = WebRenderBackend::HARDWARE;
+  WebRenderCompositor compositor = WebRenderCompositor::DRAW;
+  int32_t maxTextureSize = 0;
+  bool useANGLE = false;
+  bool useDComp = false;
+  bool useTripleBuffering = false;
+  bool supportsExternalBufferTextures = false;
+  layers::SyncHandle syncHandle = {};
+
+  // 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, &backend, &compositor, &maxTextureSize, &useANGLE,
+      &useDComp, &useTripleBuffering, &supportsExternalBufferTextures,
+      std::move(aWidget), &task, aSize, aWindowKind, &syncHandle, &aError);
+  RenderThread::Get()->PostEvent(aWindowId, std::move(event));
+
+  task.Wait();
+
+  if (!docHandle) {
+    return nullptr;
+  }
+
+  return RefPtr<WebRenderAPI>(
+             new WebRenderAPI(docHandle, aWindowId, backend, compositor,
+                              maxTextureSize, useANGLE, useDComp,
+                              useTripleBuffering,
+                              supportsExternalBufferTextures, syncHandle))
+      .forget();
+}
+
+already_AddRefed<WebRenderAPI> WebRenderAPI::Clone() {
+  wr::DocumentHandle* docHandle = nullptr;
+  wr_api_clone(mDocHandle, &docHandle);
+
+  RefPtr<WebRenderAPI> renderApi = new WebRenderAPI(
+      docHandle, mId, mBackend, mCompositor, mMaxTextureSize, mUseANGLE,
+      mUseDComp, mUseTripleBuffering, mSupportsExternalBufferTextures,
+      mSyncHandle, this, this);
+
+  return renderApi.forget();
+}
+
+wr::WrIdNamespace WebRenderAPI::GetNamespace() {
+  return wr_api_get_namespace(mDocHandle);
+}
+
+WebRenderAPI::WebRenderAPI(
+    wr::DocumentHandle* aHandle, wr::WindowId aId, WebRenderBackend aBackend,
+    WebRenderCompositor aCompositor, uint32_t aMaxTextureSize, bool aUseANGLE,
+    bool aUseDComp, bool aUseTripleBuffering,
+    bool aSupportsExternalBufferTextures, layers::SyncHandle aSyncHandle,
+    wr::WebRenderAPI* aRootApi, wr::WebRenderAPI* aRootDocumentApi)
+    : mDocHandle(aHandle),
+      mId(aId),
+      mBackend(aBackend),
+      mCompositor(aCompositor),
+      mMaxTextureSize(aMaxTextureSize),
+      mUseANGLE(aUseANGLE),
+      mUseDComp(aUseDComp),
+      mUseTripleBuffering(aUseTripleBuffering),
+      mSupportsExternalBufferTextures(aSupportsExternalBufferTextures),
+      mCaptureSequence(false),
+      mSyncHandle(aSyncHandle),
+      mRendererDestroyed(false),
+      mRootApi(aRootApi),
+      mRootDocumentApi(aRootDocumentApi) {}
+
+WebRenderAPI::~WebRenderAPI() {
+  if (!mRootDocumentApi) {
+    wr_api_delete_document(mDocHandle);
+  }
+
+  if (!mRootApi) {
+    MOZ_RELEASE_ASSERT(mRendererDestroyed);
+    wr_api_shut_down(mDocHandle);
+  }
+
+  wr_api_delete(mDocHandle);
+}
+
+void WebRenderAPI::DestroyRenderer() {
+  MOZ_RELEASE_ASSERT(!mRootApi);
+
+  RenderThread::Get()->SetDestroyed(GetId());
+  // Call wr_api_stop_render_backend() before RemoveRenderer.
+  wr_api_stop_render_backend(mDocHandle);
+
+  layers::SynchronousTask task("Destroy WebRenderAPI");
+  auto event = MakeUnique<RemoveRenderer>(&task);
+  RunOnRenderThread(std::move(event));
+  task.Wait();
+
+  mRendererDestroyed = true;
+}
+
+wr::WebRenderAPI* WebRenderAPI::GetRootAPI() {
+  if (mRootApi) {
+    return mRootApi;
+  }
+  return this;
+}
+
+void WebRenderAPI::UpdateDebugFlags(uint32_t aFlags) {
+  wr_api_set_debug_flags(mDocHandle, wr::DebugFlags{aFlags});
+}
+
+void WebRenderAPI::SendTransaction(TransactionBuilder& aTxn) {
+  if (mRootApi && mRootApi->mRendererDestroyed) {
+    return;
+  }
+
+  if (mPendingRemoteTextureInfoList &&
+      !mPendingRemoteTextureInfoList->mList.empty()) {
+    mPendingWrTransactionEvents.emplace(
+        WrTransactionEvent::PendingRemoteTextures(
+            std::move(mPendingRemoteTextureInfoList)));
+  }
+
+  if (mPendingAsyncImagePipelineOps &&
+      !mPendingAsyncImagePipelineOps->mList.empty()) {
+    mPendingWrTransactionEvents.emplace(
+        WrTransactionEvent::PendingAsyncImagePipelineOps(
+            std::move(mPendingAsyncImagePipelineOps), this, aTxn.Raw(),
+            aTxn.UseSceneBuilderThread()));
+  }
+
+  if (!mPendingWrTransactionEvents.empty()) {
+    mPendingWrTransactionEvents.emplace(WrTransactionEvent::Transaction(
+        this, aTxn.Take(), aTxn.UseSceneBuilderThread()));
+    HandleWrTransactionEvents(RemoteTextureWaitType::AsyncWait);
+  } else {
+    wr_api_send_transaction(mDocHandle, aTxn.Raw(),
+                            aTxn.UseSceneBuilderThread());
+  }
+}
+
+layers::RemoteTextureInfoList* WebRenderAPI::GetPendingRemoteTextureInfoList() {
+  if (!mRootApi) {
+    // root api does not support async wait RemoteTexture.
+    return nullptr;
+  }
+
+  if (!mPendingRemoteTextureInfoList) {
+    mPendingRemoteTextureInfoList = MakeUnique<layers::RemoteTextureInfoList>();
+  }
+  return mPendingRemoteTextureInfoList.get();
+}
+
+layers::AsyncImagePipelineOps* WebRenderAPI::GetPendingAsyncImagePipelineOps(
+    TransactionBuilder& aTxn) {
+  if (!mRootApi) {
+    // root api does not support async wait RemoteTexture.
+    return nullptr;
+  }
+
+  if (!mPendingAsyncImagePipelineOps ||
+      mPendingAsyncImagePipelineOps->mTransaction != aTxn.Raw()) {
+    if (mPendingAsyncImagePipelineOps &&
+        !mPendingAsyncImagePipelineOps->mList.empty()) {
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+      gfxCriticalNoteOnce << "Invalid AsyncImagePipelineOps";
+    }
+    mPendingAsyncImagePipelineOps =
+        MakeUnique<layers::AsyncImagePipelineOps>(aTxn.Raw());
+  } else {
+    MOZ_RELEASE_ASSERT(mPendingAsyncImagePipelineOps->mTransaction ==
+                       aTxn.Raw());
+  }
+
+  return mPendingAsyncImagePipelineOps.get();
+}
+
+bool WebRenderAPI::CheckIsRemoteTextureReady(
+    layers::RemoteTextureInfoList* aList, const TimeStamp& aTimeStamp) {
+  MOZ_ASSERT(layers::CompositorThreadHolder::IsInCompositorThread());
+  MOZ_ASSERT(aList);
+
+  RefPtr<WebRenderAPI> self = this;
+  auto callback = [self](const layers::RemoteTextureInfo&) {
+    RefPtr<nsIRunnable> runnable = NewRunnableMethod<RemoteTextureWaitType>(
+        "WebRenderAPI::HandleWrTransactionEvents", self,
+        &WebRenderAPI::HandleWrTransactionEvents,
+        RemoteTextureWaitType::AsyncWait);
+    layers::CompositorThread()->Dispatch(runnable.forget());
+  };
+
+  const auto maxWaitDurationMs = 10000;
+  const auto now = TimeStamp::Now();
+  const auto waitDurationMs =
+      static_cast<uint32_t>((now - aTimeStamp).ToMilliseconds());
+
+  const auto isTimeout = waitDurationMs > maxWaitDurationMs;
+  if (isTimeout) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    gfxCriticalNote << "RemoteTexture ready timeout";
+  }
+
+  bool isReady = true;
+  while (!aList->mList.empty() && isReady) {
+    auto& front = aList->mList.front();
+    isReady &= layers::RemoteTextureMap::Get()->CheckRemoteTextureReady(
+        front, callback);
+    if (isTimeout) {
+      isReady = true;
+    }
+    if (isReady) {
+      aList->mList.pop();
+    }
+  }
+
+  return isReady;
+}
+
+void WebRenderAPI::WaitRemoteTextureReady(
+    layers::RemoteTextureInfoList* aList) {
+  MOZ_ASSERT(layers::CompositorThreadHolder::IsInCompositorThread());
+  MOZ_ASSERT(aList);
+
+  while (!aList->mList.empty()) {
+    auto& front = aList->mList.front();
+    layers::RemoteTextureMap::Get()->WaitRemoteTextureReady(front);
+    aList->mList.pop();
+  }
+}
+
+void WebRenderAPI::FlushPendingWrTransactionEventsWithoutWait() {
+  HandleWrTransactionEvents(RemoteTextureWaitType::FlushWithoutWait);
+}
+
+void WebRenderAPI::FlushPendingWrTransactionEventsWithWait() {
+  HandleWrTransactionEvents(RemoteTextureWaitType::FlushWithWait);
+}
+
+void WebRenderAPI::HandleWrTransactionEvents(RemoteTextureWaitType aType) {
+  auto& events = mPendingWrTransactionEvents;
+
+  while (!events.empty()) {
+    auto& front = events.front();
+    switch (front.mTag) {
+      case WrTransactionEvent::Tag::Transaction:
+        wr_api_send_transaction(mDocHandle, front.RawTransaction(),
+                                front.UseSceneBuilderThread());
+        break;
+      case WrTransactionEvent::Tag::PendingRemoteTextures: {
+        bool isReady = true;
+        if (aType == RemoteTextureWaitType::AsyncWait) {
+          isReady = CheckIsRemoteTextureReady(front.RemoteTextureInfoList(),
+                                              front.mTimeStamp);
+        } else if (aType == RemoteTextureWaitType::FlushWithWait) {
+          WaitRemoteTextureReady(front.RemoteTextureInfoList());
+        } else {
+          MOZ_ASSERT(aType == RemoteTextureWaitType::FlushWithoutWait);
+          auto* list = front.RemoteTextureInfoList();
+          while (!list->mList.empty()) {
+            auto& front = list->mList.front();
+            layers::RemoteTextureMap::Get()->SuppressRemoteTextureReadyCheck(
+                front.mTextureId, front.mForPid);
+            list->mList.pop();
+          }
+        }
+        if (!isReady && (aType != RemoteTextureWaitType::FlushWithoutWait)) {
+          return;
+        }
+        break;
+      }
+      case WrTransactionEvent::Tag::PendingAsyncImagePipelineOps: {
+        auto* list = front.AsyncImagePipelineOps();
+        TransactionBuilder& txn = *front.GetTransactionBuilder();
+
+        list->HandleOps(txn);
+        break;
+      }
+    }
+    events.pop();
+  }
+}
+
+std::vector<WrHitResult> WebRenderAPI::HitTest(const wr::WorldPoint& aPoint) {
+  static_assert(gfx::DoesCompositorHitTestInfoFitIntoBits<12>(),
+                "CompositorHitTestFlags MAX value has to be less than number "
+                "of bits in uint16_t minus 4 for SideBitsPacked");
+
+  nsTArray<wr::HitResult> wrResults;
+  wr_api_hit_test(mDocHandle, aPoint, &wrResults);
+
+  std::vector<WrHitResult> geckoResults;
+  for (wr::HitResult wrResult : wrResults) {
+    WrHitResult geckoResult;
+    geckoResult.mLayersId = wr::AsLayersId(wrResult.pipeline_id);
+    geckoResult.mScrollId =
+        static_cast<layers::ScrollableLayerGuid::ViewID>(wrResult.scroll_id);
+    geckoResult.mHitInfo.deserialize(wrResult.hit_info & 0x0fff);
+    geckoResult.mSideBits = static_cast<SideBits>(wrResult.hit_info >> 12);
+
+    if (wrResult.animation_id != 0) {
+      geckoResult.mAnimationId = Some(wrResult.animation_id);
+    } else {
+      geckoResult.mAnimationId = Nothing();
+    }
+    geckoResults.push_back(geckoResult);
+  }
+  return geckoResults;
+}
+
+void WebRenderAPI::Readback(const TimeStamp& aStartTime, gfx::IntSize size,
+                            const gfx::SurfaceFormat& aFormat,
+                            const Range<uint8_t>& buffer, bool* aNeedsYFlip) {
+  class Readback : public RendererEvent {
+   public:
+    explicit Readback(layers::SynchronousTask* aTask, TimeStamp aStartTime,
+                      gfx::IntSize aSize, const gfx::SurfaceFormat& aFormat,
+                      const Range<uint8_t>& aBuffer, bool* aNeedsYFlip)
+        : mTask(aTask),
+          mStartTime(aStartTime),
+          mSize(aSize),
+          mFormat(aFormat),
+          mBuffer(aBuffer),
+          mNeedsYFlip(aNeedsYFlip) {
+      MOZ_COUNT_CTOR(Readback);
+    }
+
+    MOZ_COUNTED_DTOR_OVERRIDE(Readback)
+
+    void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+      aRenderThread.UpdateAndRender(aWindowId, VsyncId(), mStartTime,
+                                    /* aRender */ true, Some(mSize),
+                                    wr::SurfaceFormatToImageFormat(mFormat),
+                                    Some(mBuffer), mNeedsYFlip);
+      layers::AutoCompleteTask complete(mTask);
+    }
+
+    layers::SynchronousTask* mTask;
+    TimeStamp mStartTime;
+    gfx::IntSize mSize;
+    gfx::SurfaceFormat mFormat;
+    const Range<uint8_t>& mBuffer;
+    bool* mNeedsYFlip;
+  };
+
+  // Disable debug flags during readback. See bug 1436020.
+  UpdateDebugFlags(0);
+
+  layers::SynchronousTask task("Readback");
+  auto event = MakeUnique<Readback>(&task, aStartTime, size, aFormat, buffer,
+                                    aNeedsYFlip);
+  // This event will be passed from wr_backend thread to renderer thread. That
+  // implies that all frame data have been processed when the renderer runs this
+  // read-back event. Then, we could make sure this read-back event gets the
+  // latest result.
+  RunOnRenderThread(std::move(event));
+
+  task.Wait();
+
+  UpdateDebugFlags(gfx::gfxVars::WebRenderDebugFlags());
+}
+
+void WebRenderAPI::ClearAllCaches() { wr_api_clear_all_caches(mDocHandle); }
+
+void WebRenderAPI::EnableNativeCompositor(bool aEnable) {
+  wr_api_enable_native_compositor(mDocHandle, aEnable);
+}
+
+void WebRenderAPI::SetBatchingLookback(uint32_t aCount) {
+  wr_api_set_batching_lookback(mDocHandle, aCount);
+}
+
+void WebRenderAPI::SetBool(wr::BoolParameter aKey, bool aValue) {
+  wr_api_set_bool(mDocHandle, aKey, aValue);
+}
+
+void WebRenderAPI::SetInt(wr::IntParameter aKey, int32_t aValue) {
+  wr_api_set_int(mDocHandle, aKey, aValue);
+}
+
+void WebRenderAPI::SetClearColor(const gfx::DeviceColor& aColor) {
+  RenderThread::Get()->SetClearColor(mId, ToColorF(aColor));
+}
+
+void WebRenderAPI::SetProfilerUI(const nsACString& aUIString) {
+  RenderThread::Get()->SetProfilerUI(mId, aUIString);
+}
+
+void WebRenderAPI::Pause() {
+  class PauseEvent : public RendererEvent {
+   public:
+    explicit PauseEvent(layers::SynchronousTask* aTask) : mTask(aTask) {
+      MOZ_COUNT_CTOR(PauseEvent);
+    }
+
+    MOZ_COUNTED_DTOR_OVERRIDE(PauseEvent)
+
+    void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+      aRenderThread.Pause(aWindowId);
+      layers::AutoCompleteTask complete(mTask);
+    }
+
+    layers::SynchronousTask* mTask;
+  };
+
+  layers::SynchronousTask task("Pause");
+  auto event = MakeUnique<PauseEvent>(&task);
+  // This event will be passed from wr_backend thread to renderer thread. That
+  // implies that all frame data have been processed when the renderer runs this
+  // event.
+  RunOnRenderThread(std::move(event));
+
+  task.Wait();
+}
+
+bool WebRenderAPI::Resume() {
+  class ResumeEvent : public RendererEvent {
+   public:
+    explicit ResumeEvent(layers::SynchronousTask* aTask, bool* aResult)
+        : mTask(aTask), mResult(aResult) {
+      MOZ_COUNT_CTOR(ResumeEvent);
+    }
+
+    MOZ_COUNTED_DTOR_OVERRIDE(ResumeEvent)
+
+    void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+      *mResult = aRenderThread.Resume(aWindowId);
+      layers::AutoCompleteTask complete(mTask);
+    }
+
+    layers::SynchronousTask* mTask;
+    bool* mResult;
+  };
+
+  bool result = false;
+  layers::SynchronousTask task("Resume");
+  auto event = MakeUnique<ResumeEvent>(&task, &result);
+  // This event will be passed from wr_backend thread to renderer thread. That
+  // implies that all frame data have been processed when the renderer runs this
+  // event.
+  RunOnRenderThread(std::move(event));
+
+  task.Wait();
+  return result;
+}
+
+void WebRenderAPI::NotifyMemoryPressure() {
+  wr_api_notify_memory_pressure(mDocHandle);
+}
+
+void WebRenderAPI::AccumulateMemoryReport(MemoryReport* aReport) {
+  wr_api_accumulate_memory_report(mDocHandle, aReport, &WebRenderMallocSizeOf,
+                                  &WebRenderMallocEnclosingSizeOf);
+}
+
+void WebRenderAPI::WakeSceneBuilder() { wr_api_wake_scene_builder(mDocHandle); }
+
+void WebRenderAPI::FlushSceneBuilder() {
+  wr_api_flush_scene_builder(mDocHandle);
+}
+
+void WebRenderAPI::WaitFlushed() {
+  class WaitFlushedEvent : public RendererEvent {
+   public:
+    explicit WaitFlushedEvent(layers::SynchronousTask* aTask) : mTask(aTask) {
+      MOZ_COUNT_CTOR(WaitFlushedEvent);
+    }
+
+    MOZ_COUNTED_DTOR_OVERRIDE(WaitFlushedEvent)
+
+    void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+      layers::AutoCompleteTask complete(mTask);
+    }
+
+    layers::SynchronousTask* mTask;
+  };
+
+  layers::SynchronousTask task("WaitFlushed");
+  auto event = MakeUnique<WaitFlushedEvent>(&task);
+  // This event will be passed from wr_backend thread to renderer thread. That
+  // implies that all frame data have been processed when the renderer runs this
+  // event.
+  RunOnRenderThread(std::move(event));
+
+  task.Wait();
+}
+
+void WebRenderAPI::Capture() {
+  // see CaptureBits
+  // SCENE | FRAME | TILE_CACHE
+  uint8_t bits = 15;                // TODO: get from JavaScript
+  const char* path = "wr-capture";  // TODO: get from JavaScript
+  wr_api_capture(mDocHandle, path, bits);
+}
+
+void WebRenderAPI::StartCaptureSequence(const nsACString& aPath,
+                                        uint32_t aFlags) {
+  if (mCaptureSequence) {
+    wr_api_stop_capture_sequence(mDocHandle);
+  }
+
+  wr_api_start_capture_sequence(mDocHandle, PromiseFlatCString(aPath).get(),
+                                aFlags);
+
+  mCaptureSequence = true;
+}
+
+void WebRenderAPI::StopCaptureSequence() {
+  if (mCaptureSequence) {
+    wr_api_stop_capture_sequence(mDocHandle);
+  }
+
+  mCaptureSequence = false;
+}
+
+void WebRenderAPI::BeginRecording(const TimeStamp& aRecordingStart,
+                                  wr::PipelineId aRootPipelineId) {
+  class BeginRecordingEvent final : public RendererEvent {
+   public:
+    explicit BeginRecordingEvent(const TimeStamp& aRecordingStart,
+                                 wr::PipelineId aRootPipelineId)
+        : mRecordingStart(aRecordingStart), mRootPipelineId(aRootPipelineId) {
+      MOZ_COUNT_CTOR(BeginRecordingEvent);
+    }
+
+    ~BeginRecordingEvent() { MOZ_COUNT_DTOR(BeginRecordingEvent); }
+
+    void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+      aRenderThread.BeginRecordingForWindow(aWindowId, mRecordingStart,
+                                            mRootPipelineId);
+    }
+
+   private:
+    TimeStamp mRecordingStart;
+    wr::PipelineId mRootPipelineId;
+  };
+
+  auto event =
+      MakeUnique<BeginRecordingEvent>(aRecordingStart, aRootPipelineId);
+  RunOnRenderThread(std::move(event));
+}
+
+RefPtr<WebRenderAPI::EndRecordingPromise> WebRenderAPI::EndRecording() {
+  class EndRecordingEvent final : public RendererEvent {
+   public:
+    explicit EndRecordingEvent() { MOZ_COUNT_CTOR(EndRecordingEvent); }
+
+    MOZ_COUNTED_DTOR(EndRecordingEvent);
+
+    void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+      Maybe<layers::FrameRecording> recording =
+          aRenderThread.EndRecordingForWindow(aWindowId);
+
+      if (recording) {
+        mPromise.Resolve(recording.extract(), __func__);
+      } else {
+        mPromise.Reject(NS_ERROR_UNEXPECTED, __func__);
+      }
+    }
+
+    RefPtr<WebRenderAPI::EndRecordingPromise> GetPromise() {
+      return mPromise.Ensure(__func__);
+    }
+
+   private:
+    MozPromiseHolder<WebRenderAPI::EndRecordingPromise> mPromise;
+  };
+
+  auto event = MakeUnique<EndRecordingEvent>();
+  auto promise = event->GetPromise();
+
+  RunOnRenderThread(std::move(event));
+  return promise;
+}
+
+void TransactionBuilder::Clear() { wr_resource_updates_clear(mTxn); }
+
+Transaction* TransactionBuilder::Take() {
+  if (!mOwnsData) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return nullptr;
+  }
+  Transaction* txn = mTxn;
+  mTxn = wr_transaction_new(mUseSceneBuilderThread);
+  return txn;
+}
+
+void TransactionBuilder::Notify(wr::Checkpoint aWhen,
+                                UniquePtr<NotificationHandler> aEvent) {
+  wr_transaction_notify(mTxn, aWhen,
+                        reinterpret_cast<uintptr_t>(aEvent.release()));
+}
+
+void TransactionBuilder::AddImage(ImageKey key,
+                                  const ImageDescriptor& aDescriptor,
+                                  wr::Vec<uint8_t>& aBytes) {
+  wr_resource_updates_add_image(mTxn, key, &aDescriptor, &aBytes.inner);
+}
+
+void TransactionBuilder::AddBlobImage(BlobImageKey key,
+                                      const ImageDescriptor& aDescriptor,
+                                      uint16_t aTileSize,
+                                      wr::Vec<uint8_t>& aBytes,
+                                      const wr::DeviceIntRect& aVisibleRect) {
+  wr_resource_updates_add_blob_image(mTxn, key, &aDescriptor, aTileSize,
+                                     &aBytes.inner, aVisibleRect);
+}
+
+void TransactionBuilder::AddExternalImage(ImageKey key,
+                                          const ImageDescriptor& aDescriptor,
+                                          ExternalImageId aExtID,
+                                          wr::ExternalImageType aImageType,
+                                          uint8_t aChannelIndex) {
+  wr_resource_updates_add_external_image(mTxn, key, &aDescriptor, aExtID,
+                                         &aImageType, aChannelIndex);
+}
+
+void TransactionBuilder::AddExternalImageBuffer(
+    ImageKey aKey, const ImageDescriptor& aDescriptor,
+    ExternalImageId aHandle) {
+  auto channelIndex = 0;
+  AddExternalImage(aKey, aDescriptor, aHandle, wr::ExternalImageType::Buffer(),
+                   channelIndex);
+}
+
+void TransactionBuilder::UpdateImageBuffer(ImageKey aKey,
+                                           const ImageDescriptor& aDescriptor,
+                                           wr::Vec<uint8_t>& aBytes) {
+  wr_resource_updates_update_image(mTxn, aKey, &aDescriptor, &aBytes.inner);
+}
+
+void TransactionBuilder::UpdateBlobImage(BlobImageKey aKey,
+                                         const ImageDescriptor& aDescriptor,
+                                         wr::Vec<uint8_t>& aBytes,
+                                         const wr::DeviceIntRect& aVisibleRect,
+                                         const wr::LayoutIntRect& aDirtyRect) {
+  wr_resource_updates_update_blob_image(mTxn, aKey, &aDescriptor, &aBytes.inner,
+                                        aVisibleRect, aDirtyRect);
+}
+
+void TransactionBuilder::UpdateExternalImage(ImageKey aKey,
+                                             const ImageDescriptor& aDescriptor,
+                                             ExternalImageId aExtID,
+                                             wr::ExternalImageType aImageType,
+                                             uint8_t aChannelIndex) {
+  wr_resource_updates_update_external_image(mTxn, aKey, &aDescriptor, aExtID,
+                                            &aImageType, aChannelIndex);
+}
+
+void TransactionBuilder::UpdateExternalImageWithDirtyRect(
+    ImageKey aKey, const ImageDescriptor& aDescriptor, ExternalImageId aExtID,
+    wr::ExternalImageType aImageType, const wr::DeviceIntRect& aDirtyRect,
+    uint8_t aChannelIndex) {
+  wr_resource_updates_update_external_image_with_dirty_rect(
+      mTxn, aKey, &aDescriptor, aExtID, &aImageType, aChannelIndex, aDirtyRect);
+}
+
+void TransactionBuilder::SetBlobImageVisibleArea(
+    BlobImageKey aKey, const wr::DeviceIntRect& aArea) {
+  wr_resource_updates_set_blob_image_visible_area(mTxn, aKey, &aArea);
+}
+
+void TransactionBuilder::DeleteImage(ImageKey aKey) {
+  wr_resource_updates_delete_image(mTxn, aKey);
+}
+
+void TransactionBuilder::DeleteBlobImage(BlobImageKey aKey) {
+  wr_resource_updates_delete_blob_image(mTxn, aKey);
+}
+
+void TransactionBuilder::AddRawFont(wr::FontKey aKey, wr::Vec<uint8_t>& aBytes,
+                                    uint32_t aIndex) {
+  wr_resource_updates_add_raw_font(mTxn, aKey, &aBytes.inner, aIndex);
+}
+
+void TransactionBuilder::AddFontDescriptor(wr::FontKey aKey,
+                                           wr::Vec<uint8_t>& aBytes,
+                                           uint32_t aIndex) {
+  wr_resource_updates_add_font_descriptor(mTxn, aKey, &aBytes.inner, aIndex);
+}
+
+void TransactionBuilder::DeleteFont(wr::FontKey aKey) {
+  wr_resource_updates_delete_font(mTxn, aKey);
+}
+
+void TransactionBuilder::AddFontInstance(
+    wr::FontInstanceKey aKey, wr::FontKey aFontKey, float aGlyphSize,
+    const wr::FontInstanceOptions* aOptions,
+    const wr::FontInstancePlatformOptions* aPlatformOptions,
+    wr::Vec<uint8_t>& aVariations) {
+  wr_resource_updates_add_font_instance(mTxn, aKey, aFontKey, aGlyphSize,
+                                        aOptions, aPlatformOptions,
+                                        &aVariations.inner);
+}
+
+void TransactionBuilder::DeleteFontInstance(wr::FontInstanceKey aKey) {
+  wr_resource_updates_delete_font_instance(mTxn, aKey);
+}
+
+void TransactionBuilder::UpdateQualitySettings(
+    bool aForceSubpixelAAWherePossible) {
+  wr_transaction_set_quality_settings(mTxn, aForceSubpixelAAWherePossible);
+}
+
+class FrameStartTime : public RendererEvent {
+ public:
+  explicit FrameStartTime(const TimeStamp& aTime) : mTime(aTime) {
+    MOZ_COUNT_CTOR(FrameStartTime);
+  }
+
+  MOZ_COUNTED_DTOR_OVERRIDE(FrameStartTime)
+
+  void Run(RenderThread& aRenderThread, WindowId aWindowId) override {
+    auto renderer = aRenderThread.GetRenderer(aWindowId);
+    if (renderer) {
+      renderer->SetFrameStartTime(mTime);
+    }
+  }
+
+ private:
+  TimeStamp mTime;
+};
+
+void WebRenderAPI::SetFrameStartTime(const TimeStamp& aTime) {
+  auto event = MakeUnique<FrameStartTime>(aTime);
+  RunOnRenderThread(std::move(event));
+}
+
+void WebRenderAPI::RunOnRenderThread(UniquePtr<RendererEvent> aEvent) {
+  auto event = reinterpret_cast<uintptr_t>(aEvent.release());
+  wr_api_send_external_event(mDocHandle, event);
+}
+
+DisplayListBuilder::DisplayListBuilder(PipelineId aId,
+                                       WebRenderBackend aBackend)
+    : mCurrentSpaceAndClipChain(wr::RootScrollNodeWithChain()),
+      mActiveFixedPosTracker(nullptr),
+      mPipelineId(aId),
+      mBackend(aBackend),
+      mDisplayItemCache(nullptr) {
+  MOZ_COUNT_CTOR(DisplayListBuilder);
+  mWrState = wr_state_new(aId);
+
+  if (mDisplayItemCache && mDisplayItemCache->IsEnabled()) {
+    mDisplayItemCache->SetPipelineId(aId);
+  }
+}
+
+DisplayListBuilder::~DisplayListBuilder() {
+  MOZ_COUNT_DTOR(DisplayListBuilder);
+  wr_state_delete(mWrState);
+}
+
+void DisplayListBuilder::Save() { wr_dp_save(mWrState); }
+void DisplayListBuilder::Restore() { wr_dp_restore(mWrState); }
+void DisplayListBuilder::ClearSave() { wr_dp_clear_save(mWrState); }
+
+usize DisplayListBuilder::Dump(usize aIndent, const Maybe<usize>& aStart,
+                               const Maybe<usize>& aEnd) {
+  return wr_dump_display_list(mWrState, aIndent, aStart.ptrOr(nullptr),
+                              aEnd.ptrOr(nullptr));
+}
+
+void DisplayListBuilder::DumpSerializedDisplayList() {
+  wr_dump_serialized_display_list(mWrState);
+}
+
+void DisplayListBuilder::Begin(layers::DisplayItemCache* aCache) {
+  wr_api_begin_builder(mWrState);
+
+  mScrollIds.clear();
+  mCurrentSpaceAndClipChain = wr::RootScrollNodeWithChain();
+  mClipChainLeaf = Nothing();
+  mSuspendedSpaceAndClipChain = Nothing();
+  mSuspendedClipChainLeaf = Nothing();
+  mCachedTextDT = nullptr;
+  mCachedContext = nullptr;
+  mActiveFixedPosTracker = nullptr;
+  mDisplayItemCache = aCache;
+  mCurrentCacheSlot = Nothing();
+}
+
+void DisplayListBuilder::End(BuiltDisplayList& aOutDisplayList) {
+  wr_api_end_builder(
+      mWrState, &aOutDisplayList.dl_desc, &aOutDisplayList.dl_items.inner,
+      &aOutDisplayList.dl_cache.inner, &aOutDisplayList.dl_spatial_tree.inner);
+
+  mDisplayItemCache = nullptr;
+}
+
+void DisplayListBuilder::End(layers::DisplayListData& aOutTransaction) {
+  if (mDisplayItemCache && mDisplayItemCache->IsEnabled()) {
+    wr_dp_set_cache_size(mWrState, mDisplayItemCache->CurrentSize());
+  }
+
+  wr::VecU8 dlItems, dlCache, dlSpatialTree;
+  wr_api_end_builder(mWrState, &aOutTransaction.mDLDesc, &dlItems.inner,
+                     &dlCache.inner, &dlSpatialTree.inner);
+  aOutTransaction.mDLItems.emplace(dlItems.inner.data, dlItems.inner.length,
+                                   dlItems.inner.capacity);
+  aOutTransaction.mDLCache.emplace(dlCache.inner.data, dlCache.inner.length,
+                                   dlCache.inner.capacity);
+  aOutTransaction.mDLSpatialTree.emplace(dlSpatialTree.inner.data,
+                                         dlSpatialTree.inner.length,
+                                         dlSpatialTree.inner.capacity);
+  dlItems.inner.capacity = 0;
+  dlItems.inner.data = nullptr;
+  dlCache.inner.capacity = 0;
+  dlCache.inner.data = nullptr;
+  dlSpatialTree.inner.capacity = 0;
+  dlSpatialTree.inner.data = nullptr;
+}
+
+Maybe<wr::WrSpatialId> DisplayListBuilder::PushStackingContext(
+    const wr::StackingContextParams& aParams, const wr::LayoutRect& aBounds,
+    const wr::RasterSpace& aRasterSpace) {
+  MOZ_ASSERT(mClipChainLeaf.isNothing(),
+             "Non-empty leaf from clip chain given, but not used with SC!");
+
+  WRDL_LOG(
+      "PushStackingContext b=%s t=%s id=0x%" PRIx64 "\n", mWrState,
+      ToString(aBounds).c_str(),
+      aParams.mTransformPtr ? ToString(*aParams.mTransformPtr).c_str() : "none",
+      aParams.animation ? aParams.animation->id : 0);
+
+  auto spatialId = wr_dp_push_stacking_context(
+      mWrState, aBounds, mCurrentSpaceAndClipChain.space, &aParams,
+      aParams.mTransformPtr, aParams.mFilters.Elements(),
+      aParams.mFilters.Length(), aParams.mFilterDatas.Elements(),
+      aParams.mFilterDatas.Length(), aRasterSpace);
+
+  return spatialId.id != 0 ? Some(spatialId) : Nothing();
+}
+
+void DisplayListBuilder::PopStackingContext(bool aIsReferenceFrame) {
+  WRDL_LOG("PopStackingContext\n", mWrState);
+  wr_dp_pop_stacking_context(mWrState, aIsReferenceFrame);
+}
+
+wr::WrClipChainId DisplayListBuilder::DefineClipChain(
+    const nsTArray<wr::WrClipId>& aClips, bool aParentWithCurrentChain) {
+  CancelGroup();
+
+  const uint64_t* parent = nullptr;
+  if (aParentWithCurrentChain &&
+      mCurrentSpaceAndClipChain.clip_chain != wr::ROOT_CLIP_CHAIN) {
+    parent = &mCurrentSpaceAndClipChain.clip_chain;
+  }
+  uint64_t clipchainId = wr_dp_define_clipchain(
+      mWrState, parent, aClips.Elements(), aClips.Length());
+  if (MOZ_LOG_TEST(sWrDLLog, LogLevel::Debug)) {
+    nsCString message;
+    message.AppendPrintf("DefineClipChain id=%" PRIu64
+                         " clipCount=%zu clipIds=[",
+                         clipchainId, aClips.Length());
+    for (const auto& clip : aClips) {
+      message.AppendPrintf("%" PRIuPTR ",", clip.id);
+    }
+    message.Append("]");
+    WRDL_LOG("%s", mWrState, message.get());
+  }
+  return wr::WrClipChainId{clipchainId};
+}
+
+wr::WrClipId DisplayListBuilder::DefineImageMaskClip(
+    const wr::ImageMask& aMask, const nsTArray<wr::LayoutPoint>& aPoints,
+    wr::FillRule aFillRule) {
+  CancelGroup();
+
+  WrClipId clipId = wr_dp_define_image_mask_clip_with_parent_clip_chain(
+      mWrState, mCurrentSpaceAndClipChain.space, aMask, aPoints.Elements(),
+      aPoints.Length(), aFillRule);
+
+  return clipId;
+}
+
+wr::WrClipId DisplayListBuilder::DefineRoundedRectClip(
+    Maybe<wr::WrSpatialId> aSpace, const wr::ComplexClipRegion& aComplex) {
+  CancelGroup();
+
+  WrClipId clipId;
+  if (aSpace) {
+    clipId = wr_dp_define_rounded_rect_clip(mWrState, *aSpace, aComplex);
+  } else {
+    clipId = wr_dp_define_rounded_rect_clip(
+        mWrState, mCurrentSpaceAndClipChain.space, aComplex);
+  }
+
+  return clipId;
+}
+
+wr::WrClipId DisplayListBuilder::DefineRectClip(Maybe<wr::WrSpatialId> aSpace,
+                                                wr::LayoutRect aClipRect) {
+  CancelGroup();
+
+  WrClipId clipId;
+  if (aSpace) {
+    clipId = wr_dp_define_rect_clip(mWrState, *aSpace, aClipRect);
+  } else {
+    clipId = wr_dp_define_rect_clip(mWrState, mCurrentSpaceAndClipChain.space,
+                                    aClipRect);
+  }
+
+  return clipId;
+}
+
+wr::WrSpatialId DisplayListBuilder::DefineStickyFrame(
+    const wr::LayoutRect& aContentRect, const float* aTopMargin,
+    const float* aRightMargin, const float* aBottomMargin,
+    const float* aLeftMargin, const StickyOffsetBounds& aVerticalBounds,
+    const StickyOffsetBounds& aHorizontalBounds,
+    const wr::LayoutVector2D& aAppliedOffset, wr::SpatialTreeItemKey aKey) {
+  auto spatialId = wr_dp_define_sticky_frame(
+      mWrState, mCurrentSpaceAndClipChain.space, aContentRect, aTopMargin,
+      aRightMargin, aBottomMargin, aLeftMargin, aVerticalBounds,
+      aHorizontalBounds, aAppliedOffset, aKey);
+
+  WRDL_LOG("DefineSticky id=%zu c=%s t=%s r=%s b=%s l=%s v=%s h=%s a=%s\n",
+           mWrState, spatialId.id, ToString(aContentRect).c_str(),
+           aTopMargin ? ToString(*aTopMargin).c_str() : "none",
+           aRightMargin ? ToString(*aRightMargin).c_str() : "none",
+           aBottomMargin ? ToString(*aBottomMargin).c_str() : "none",
+           aLeftMargin ? ToString(*aLeftMargin).c_str() : "none",
+           ToString(aVerticalBounds).c_str(),
+           ToString(aHorizontalBounds).c_str(),
+           ToString(aAppliedOffset).c_str());
+
+  return spatialId;
+}
+
+Maybe<wr::WrSpatialId> DisplayListBuilder::GetScrollIdForDefinedScrollLayer(
+    layers::ScrollableLayerGuid::ViewID aViewId) const {
+  if (aViewId == layers::ScrollableLayerGuid::NULL_SCROLL_ID) {
+    return Some(wr::RootScrollNode());
+  }
+
+  auto it = mScrollIds.find(aViewId);
+  if (it == mScrollIds.end()) {
+    return Nothing();
+  }
+
+  return Some(it->second);
+}
+
+wr::WrSpatialId DisplayListBuilder::DefineScrollLayer(
+    const layers::ScrollableLayerGuid::ViewID& aViewId,
+    const Maybe<wr::WrSpatialId>& aParent, const wr::LayoutRect& aContentRect,
+    const wr::LayoutRect& aClipRect, const wr::LayoutVector2D& aScrollOffset,
+    wr::APZScrollGeneration aScrollOffsetGeneration,
+    wr::HasScrollLinkedEffect aHasScrollLinkedEffect,
+    wr::SpatialTreeItemKey aKey) {
+  auto it = mScrollIds.find(aViewId);
+  if (it != mScrollIds.end()) {
+    return it->second;
+  }
+
+  // We haven't defined aViewId before, so let's define it now.
+  wr::WrSpatialId defaultParent = mCurrentSpaceAndClipChain.space;
+
+  auto space = wr_dp_define_scroll_layer(
+      mWrState, aViewId, aParent ? aParent.ptr() : &defaultParent, aContentRect,
+      aClipRect, aScrollOffset, aScrollOffsetGeneration, aHasScrollLinkedEffect,
+      aKey);
+
+  WRDL_LOG("DefineScrollLayer id=%" PRIu64
+           "/%zu p=%s co=%s cl=%s generation=%s hasScrollLinkedEffect=%s\n",
+           mWrState, aViewId, space.id,
+           aParent ? ToString(aParent->id).c_str() : "(nil)",
+           ToString(aContentRect).c_str(), ToString(aClipRect).c_str(),
+           ToString(aScrollOffsetGeneration).c_str(),
+           ToString(aHasScrollLinkedEffect).c_str());
+
+  mScrollIds[aViewId] = space;
+  return space;
+}
+
+void DisplayListBuilder::PushRect(const wr::LayoutRect& aBounds,
+                                  const wr::LayoutRect& aClip,
+                                  bool aIsBackfaceVisible,
+                                  bool aForceAntiAliasing, bool aIsCheckerboard,
+                                  const wr::ColorF& aColor) {
+  wr::LayoutRect clip = MergeClipLeaf(aClip);
+  WRDL_LOG("PushRect b=%s cl=%s c=%s\n", mWrState, ToString(aBounds).c_str(),
+           ToString(clip).c_str(), ToString(aColor).c_str());
+  wr_dp_push_rect(mWrState, aBounds, clip, aIsBackfaceVisible,
+                  aForceAntiAliasing, aIsCheckerboard,
+                  &mCurrentSpaceAndClipChain, aColor);
+}
+
+void DisplayListBuilder::PushRoundedRect(const wr::LayoutRect& aBounds,
+                                         const wr::LayoutRect& aClip,
+                                         bool aIsBackfaceVisible,
+                                         const wr::ColorF& aColor) {
+  wr::LayoutRect clip = MergeClipLeaf(aClip);
+  WRDL_LOG("PushRoundedRect b=%s cl=%s c=%s\n", mWrState,
+           ToString(aBounds).c_str(), ToString(clip).c_str(),
+           ToString(aColor).c_str());
+
+  // Draw the rounded rectangle as a border with rounded corners. We could also
+  // draw this as a rectangle clipped to a rounded rectangle, but:
+  // - clips are not cached; borders are
+  // - a simple border like this will be drawn as an image
+  // - Processing lots of clips is not WebRender's strong point.
+  //
+  // Made the borders thicker than one half the width/height, to avoid
+  // little white dots at the center at some magnifications.
+  wr::BorderSide side = {aColor, wr::BorderStyle::Solid};
+  float h = aBounds.width() * 0.6f;
+  float v = aBounds.height() * 0.6f;
+  wr::LayoutSideOffsets widths = {v, h, v, h};
+  wr::BorderRadius radii = {{h, v}, {h, v}, {h, v}, {h, v}};
+
+  // Anti-aliased borders are required for rounded borders.
+  wr_dp_push_border(mWrState, aBounds, clip, aIsBackfaceVisible,
+                    &mCurrentSpaceAndClipChain, wr::AntialiasBorder::Yes,
+                    widths, side, side, side, side, radii);
+}
+
+void DisplayListBuilder::PushHitTest(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible,
+    const layers::ScrollableLayerGuid::ViewID& aScrollId,
+    const gfx::CompositorHitTestInfo& aHitInfo, SideBits aSideBits) {
+  wr::LayoutRect clip = MergeClipLeaf(aClip);
+  WRDL_LOG("PushHitTest b=%s cl=%s\n", mWrState, ToString(aBounds).c_str(),
+           ToString(clip).c_str());
+
+  static_assert(gfx::DoesCompositorHitTestInfoFitIntoBits<12>(),
+                "CompositorHitTestFlags MAX value has to be less than number "
+                "of bits in uint16_t minus 4 for SideBitsPacked");
+
+  uint16_t hitInfoBits = static_cast<uint16_t>(aHitInfo.serialize()) |
+                         (static_cast<uint16_t>(aSideBits) << 12);
+
+  wr_dp_push_hit_test(mWrState, aBounds, clip, aIsBackfaceVisible,
+                      &mCurrentSpaceAndClipChain, aScrollId, hitInfoBits);
+}
+
+void DisplayListBuilder::PushRectWithAnimation(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::ColorF& aColor,
+    const WrAnimationProperty* aAnimation) {
+  wr::LayoutRect clip = MergeClipLeaf(aClip);
+  WRDL_LOG("PushRectWithAnimation b=%s cl=%s c=%s\n", mWrState,
+           ToString(aBounds).c_str(), ToString(clip).c_str(),
+           ToString(aColor).c_str());
+
+  wr_dp_push_rect_with_animation(mWrState, aBounds, clip, aIsBackfaceVisible,
+                                 &mCurrentSpaceAndClipChain, aColor,
+                                 aAnimation);
+}
+
+void DisplayListBuilder::PushClearRect(const wr::LayoutRect& aBounds) {
+  wr::LayoutRect clip = MergeClipLeaf(aBounds);
+  WRDL_LOG("PushClearRect b=%s c=%s\n", mWrState, ToString(aBounds).c_str(),
+           ToString(clip).c_str());
+  wr_dp_push_clear_rect(mWrState, aBounds, clip, &mCurrentSpaceAndClipChain);
+}
+
+void DisplayListBuilder::PushBackdropFilter(
+    const wr::LayoutRect& aBounds, const wr::ComplexClipRegion& aRegion,
+    const nsTArray<wr::FilterOp>& aFilters,
+    const nsTArray<wr::WrFilterData>& aFilterDatas, bool aIsBackfaceVisible) {
+  wr::LayoutRect clip = MergeClipLeaf(aBounds);
+  WRDL_LOG("PushBackdropFilter b=%s c=%s\n", mWrState,
+           ToString(aBounds).c_str(), ToString(clip).c_str());
+
+  auto clipId = DefineRoundedRectClip(Nothing(), aRegion);
+  auto clipChainId = DefineClipChain({clipId}, true);
+  auto spaceAndClip =
+      WrSpaceAndClipChain{mCurrentSpaceAndClipChain.space, clipChainId.id};
+
+  wr_dp_push_backdrop_filter(mWrState, aBounds, clip, aIsBackfaceVisible,
+                             &spaceAndClip, aFilters.Elements(),
+                             aFilters.Length(), aFilterDatas.Elements(),
+                             aFilterDatas.Length());
+}
+
+void DisplayListBuilder::PushLinearGradient(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::LayoutPoint& aStartPoint,
+    const wr::LayoutPoint& aEndPoint, const nsTArray<wr::GradientStop>& aStops,
+    wr::ExtendMode aExtendMode, const wr::LayoutSize aTileSize,
+    const wr::LayoutSize aTileSpacing) {
+  wr_dp_push_linear_gradient(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aStartPoint, aEndPoint, aStops.Elements(),
+      aStops.Length(), aExtendMode, aTileSize, aTileSpacing);
+}
+
+void DisplayListBuilder::PushRadialGradient(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::LayoutPoint& aCenter,
+    const wr::LayoutSize& aRadius, const nsTArray<wr::GradientStop>& aStops,
+    wr::ExtendMode aExtendMode, const wr::LayoutSize aTileSize,
+    const wr::LayoutSize aTileSpacing) {
+  wr_dp_push_radial_gradient(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aCenter, aRadius, aStops.Elements(),
+      aStops.Length(), aExtendMode, aTileSize, aTileSpacing);
+}
+
+void DisplayListBuilder::PushConicGradient(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::LayoutPoint& aCenter, const float aAngle,
+    const nsTArray<wr::GradientStop>& aStops, wr::ExtendMode aExtendMode,
+    const wr::LayoutSize aTileSize, const wr::LayoutSize aTileSpacing) {
+  wr_dp_push_conic_gradient(mWrState, aBounds, MergeClipLeaf(aClip),
+                            aIsBackfaceVisible, &mCurrentSpaceAndClipChain,
+                            aCenter, aAngle, aStops.Elements(), aStops.Length(),
+                            aExtendMode, aTileSize, aTileSpacing);
+}
+
+void DisplayListBuilder::PushImage(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, bool aForceAntiAliasing,
+    wr::ImageRendering aFilter, wr::ImageKey aImage, bool aPremultipliedAlpha,
+    const wr::ColorF& aColor, bool aPreferCompositorSurface,
+    bool aSupportsExternalCompositing) {
+  wr::LayoutRect clip = MergeClipLeaf(aClip);
+  WRDL_LOG("PushImage b=%s cl=%s\n", mWrState, ToString(aBounds).c_str(),
+           ToString(clip).c_str());
+  wr_dp_push_image(mWrState, aBounds, clip, aIsBackfaceVisible,
+                   aForceAntiAliasing, &mCurrentSpaceAndClipChain, aFilter,
+                   aImage, aPremultipliedAlpha, aColor,
+                   aPreferCompositorSurface, aSupportsExternalCompositing);
+}
+
+void DisplayListBuilder::PushRepeatingImage(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::LayoutSize& aStretchSize,
+    const wr::LayoutSize& aTileSpacing, wr::ImageRendering aFilter,
+    wr::ImageKey aImage, bool aPremultipliedAlpha, const wr::ColorF& aColor) {
+  wr::LayoutRect clip = MergeClipLeaf(aClip);
+  WRDL_LOG("PushImage b=%s cl=%s s=%s t=%s\n", mWrState,
+           ToString(aBounds).c_str(), ToString(clip).c_str(),
+           ToString(aStretchSize).c_str(), ToString(aTileSpacing).c_str());
+  wr_dp_push_repeating_image(
+      mWrState, aBounds, clip, aIsBackfaceVisible, &mCurrentSpaceAndClipChain,
+      aStretchSize, aTileSpacing, aFilter, aImage, aPremultipliedAlpha, aColor);
+}
+
+void DisplayListBuilder::PushYCbCrPlanarImage(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, wr::ImageKey aImageChannel0,
+    wr::ImageKey aImageChannel1, wr::ImageKey aImageChannel2,
+    wr::WrColorDepth aColorDepth, wr::WrYuvColorSpace aColorSpace,
+    wr::WrColorRange aColorRange, wr::ImageRendering aRendering,
+    bool aPreferCompositorSurface, bool aSupportsExternalCompositing) {
+  wr_dp_push_yuv_planar_image(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aImageChannel0, aImageChannel1,
+      aImageChannel2, aColorDepth, aColorSpace, aColorRange, aRendering,
+      aPreferCompositorSurface, aSupportsExternalCompositing);
+}
+
+void DisplayListBuilder::PushNV12Image(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, wr::ImageKey aImageChannel0,
+    wr::ImageKey aImageChannel1, wr::WrColorDepth aColorDepth,
+    wr::WrYuvColorSpace aColorSpace, wr::WrColorRange aColorRange,
+    wr::ImageRendering aRendering, bool aPreferCompositorSurface,
+    bool aSupportsExternalCompositing) {
+  wr_dp_push_yuv_NV12_image(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aImageChannel0, aImageChannel1, aColorDepth,
+      aColorSpace, aColorRange, aRendering, aPreferCompositorSurface,
+      aSupportsExternalCompositing);
+}
+
+void DisplayListBuilder::PushP010Image(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, wr::ImageKey aImageChannel0,
+    wr::ImageKey aImageChannel1, wr::WrColorDepth aColorDepth,
+    wr::WrYuvColorSpace aColorSpace, wr::WrColorRange aColorRange,
+    wr::ImageRendering aRendering, bool aPreferCompositorSurface,
+    bool aSupportsExternalCompositing) {
+  wr_dp_push_yuv_P010_image(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aImageChannel0, aImageChannel1, aColorDepth,
+      aColorSpace, aColorRange, aRendering, aPreferCompositorSurface,
+      aSupportsExternalCompositing);
+}
+
+void DisplayListBuilder::PushYCbCrInterleavedImage(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, wr::ImageKey aImageChannel0,
+    wr::WrColorDepth aColorDepth, wr::WrYuvColorSpace aColorSpace,
+    wr::WrColorRange aColorRange, wr::ImageRendering aRendering,
+    bool aPreferCompositorSurface, bool aSupportsExternalCompositing) {
+  wr_dp_push_yuv_interleaved_image(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aImageChannel0, aColorDepth, aColorSpace,
+      aColorRange, aRendering, aPreferCompositorSurface,
+      aSupportsExternalCompositing);
+}
+
+void DisplayListBuilder::PushIFrame(const LayoutDeviceRect& aDevPxBounds,
+                                    bool aIsBackfaceVisible,
+                                    PipelineId aPipeline,
+                                    bool aIgnoreMissingPipeline) {
+  // If the incoming bounds size has decimals (As it could when zoom is
+  // involved), and is pushed straight through here, the compositor would end up
+  // calculating the destination rect to paint the rendered iframe into
+  // with those decimal values, rounding the result, instead of snapping. This
+  // can cause the rendered iframe rect and its destination rect to be
+  // mismatched, resulting in interpolation artifacts.
+  auto snapped = aDevPxBounds;
+  auto tl = snapped.TopLeft().Round();
+  auto br = snapped.BottomRight().Round();
+
+  snapped.SizeTo(LayoutDeviceSize(br.x - tl.x, br.y - tl.y));
+
+  const auto bounds = wr::ToLayoutRect(snapped);
+  wr_dp_push_iframe(mWrState, bounds, MergeClipLeaf(bounds), aIsBackfaceVisible,
+                    &mCurrentSpaceAndClipChain, aPipeline,
+                    aIgnoreMissingPipeline);
+}
+
+void DisplayListBuilder::PushBorder(const wr::LayoutRect& aBounds,
+                                    const wr::LayoutRect& aClip,
+                                    bool aIsBackfaceVisible,
+                                    const wr::LayoutSideOffsets& aWidths,
+                                    const Range<const wr::BorderSide>& aSides,
+                                    const wr::BorderRadius& aRadius,
+                                    wr::AntialiasBorder aAntialias) {
+  MOZ_ASSERT(aSides.length() == 4);
+  if (aSides.length() != 4) {
+    return;
+  }
+  wr_dp_push_border(mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+                    &mCurrentSpaceAndClipChain, aAntialias, aWidths, aSides[0],
+                    aSides[1], aSides[2], aSides[3], aRadius);
+}
+
+void DisplayListBuilder::PushBorderImage(const wr::LayoutRect& aBounds,
+                                         const wr::LayoutRect& aClip,
+                                         bool aIsBackfaceVisible,
+                                         const wr::WrBorderImage& aParams) {
+  wr_dp_push_border_image(mWrState, aBounds, MergeClipLeaf(aClip),
+                          aIsBackfaceVisible, &mCurrentSpaceAndClipChain,
+                          &aParams);
+}
+
+void DisplayListBuilder::PushBorderGradient(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths,
+    const int32_t aWidth, const int32_t aHeight, bool aFill,
+    const wr::DeviceIntSideOffsets& aSlice, const wr::LayoutPoint& aStartPoint,
+    const wr::LayoutPoint& aEndPoint, const nsTArray<wr::GradientStop>& aStops,
+    wr::ExtendMode aExtendMode) {
+  wr_dp_push_border_gradient(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aWidths, aWidth, aHeight, aFill, aSlice,
+      aStartPoint, aEndPoint, aStops.Elements(), aStops.Length(), aExtendMode);
+}
+
+void DisplayListBuilder::PushBorderRadialGradient(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, bool aFill,
+    const wr::LayoutPoint& aCenter, const wr::LayoutSize& aRadius,
+    const nsTArray<wr::GradientStop>& aStops, wr::ExtendMode aExtendMode) {
+  wr_dp_push_border_radial_gradient(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aWidths, aFill, aCenter, aRadius,
+      aStops.Elements(), aStops.Length(), aExtendMode);
+}
+
+void DisplayListBuilder::PushBorderConicGradient(
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, bool aFill,
+    const wr::LayoutPoint& aCenter, const float aAngle,
+    const nsTArray<wr::GradientStop>& aStops, wr::ExtendMode aExtendMode) {
+  wr_dp_push_border_conic_gradient(
+      mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+      &mCurrentSpaceAndClipChain, aWidths, aFill, aCenter, aAngle,
+      aStops.Elements(), aStops.Length(), aExtendMode);
+}
+
+void DisplayListBuilder::PushText(const wr::LayoutRect& aBounds,
+                                  const wr::LayoutRect& aClip,
+                                  bool aIsBackfaceVisible,
+                                  const wr::ColorF& aColor,
+                                  wr::FontInstanceKey aFontKey,
+                                  Range<const wr::GlyphInstance> aGlyphBuffer,
+                                  const wr::GlyphOptions* aGlyphOptions) {
+  wr_dp_push_text(mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible,
+                  &mCurrentSpaceAndClipChain, aColor, aFontKey,
+                  &aGlyphBuffer[0], aGlyphBuffer.length(), aGlyphOptions);
+}
+
+void DisplayListBuilder::PushLine(const wr::LayoutRect& aClip,
+                                  bool aIsBackfaceVisible,
+                                  const wr::Line& aLine) {
+  wr::LayoutRect clip = MergeClipLeaf(aClip);
+  wr_dp_push_line(mWrState, &clip, aIsBackfaceVisible,
+                  &mCurrentSpaceAndClipChain, &aLine.bounds,
+                  aLine.wavyLineThickness, aLine.orientation, &aLine.color,
+                  aLine.style);
+}
+
+void DisplayListBuilder::PushShadow(const wr::LayoutRect& aRect,
+                                    const wr::LayoutRect& aClip,
+                                    bool aIsBackfaceVisible,
+                                    const wr::Shadow& aShadow,
+                                    bool aShouldInflate) {
+  // Local clip_rects are translated inside of shadows, as they are assumed to
+  // be part of the element drawing itself, and not a parent frame clipping it.
+  // As such, it is not sound to apply the MergeClipLeaf optimization inside of
+  // shadows. So we disable the optimization when we encounter a shadow.
+  // Shadows don't span frames, so we don't have to worry about MergeClipLeaf
+  // being re-enabled mid-shadow. The optimization is restored in PopAllShadows.
+  SuspendClipLeafMerging();
+  wr_dp_push_shadow(mWrState, aRect, aClip, aIsBackfaceVisible,
+                    &mCurrentSpaceAndClipChain, aShadow, aShouldInflate);
+}
+
+void DisplayListBuilder::PopAllShadows() {
+  wr_dp_pop_all_shadows(mWrState);
+  ResumeClipLeafMerging();
+}
+
+void DisplayListBuilder::SuspendClipLeafMerging() {
+  if (mClipChainLeaf) {
+    // No one should reinitialize mClipChainLeaf while we're suspended
+    MOZ_ASSERT(!mSuspendedClipChainLeaf);
+
+    mSuspendedClipChainLeaf = mClipChainLeaf;
+    mSuspendedSpaceAndClipChain = Some(mCurrentSpaceAndClipChain);
+
+    auto clipId = DefineRectClip(Nothing(), *mClipChainLeaf);
+    auto clipChainId = DefineClipChain({clipId}, true);
+
+    mCurrentSpaceAndClipChain.clip_chain = clipChainId.id;
+    mClipChainLeaf = Nothing();
+  }
+}
+
+void DisplayListBuilder::ResumeClipLeafMerging() {
+  if (mSuspendedClipChainLeaf) {
+    mCurrentSpaceAndClipChain = *mSuspendedSpaceAndClipChain;
+    mClipChainLeaf = mSuspendedClipChainLeaf;
+
+    mSuspendedClipChainLeaf = Nothing();
+    mSuspendedSpaceAndClipChain = Nothing();
+  }
+}
+
+void DisplayListBuilder::PushBoxShadow(
+    const wr::LayoutRect& aRect, const wr::LayoutRect& aClip,
+    bool aIsBackfaceVisible, const wr::LayoutRect& aBoxBounds,
+    const wr::LayoutVector2D& aOffset, const wr::ColorF& aColor,
+    const float& aBlurRadius, const float& aSpreadRadius,
+    const wr::BorderRadius& aBorderRadius,
+    const wr::BoxShadowClipMode& aClipMode) {
+  wr_dp_push_box_shadow(mWrState, aRect, MergeClipLeaf(aClip),
+                        aIsBackfaceVisible, &mCurrentSpaceAndClipChain,
+                        aBoxBounds, aOffset, aColor, aBlurRadius, aSpreadRadius,
+                        aBorderRadius, aClipMode);
+}
+
+void DisplayListBuilder::StartGroup(nsPaintedDisplayItem* aItem) {
+  if (!mDisplayItemCache || mDisplayItemCache->IsFull()) {
+    return;
+  }
+
+  MOZ_ASSERT(!mCurrentCacheSlot);
+  mCurrentCacheSlot = mDisplayItemCache->AssignSlot(aItem);
+
+  if (mCurrentCacheSlot) {
+    wr_dp_start_item_group(mWrState);
+  }
+}
+
+void DisplayListBuilder::CancelGroup(const bool aDiscard) {
+  if (!mDisplayItemCache || !mCurrentCacheSlot) {
+    return;
+  }
+
+  wr_dp_cancel_item_group(mWrState, aDiscard);
+  mCurrentCacheSlot = Nothing();
+}
+
+void DisplayListBuilder::FinishGroup() {
+  if (!mDisplayItemCache || !mCurrentCacheSlot) {
+    return;
+  }
+
+  MOZ_ASSERT(mCurrentCacheSlot);
+
+  if (wr_dp_finish_item_group(mWrState, mCurrentCacheSlot.ref())) {
+    mDisplayItemCache->MarkSlotOccupied(mCurrentCacheSlot.ref(),
+                                        CurrentSpaceAndClipChain());
+    mDisplayItemCache->Stats().AddCached();
+  }
+
+  mCurrentCacheSlot = Nothing();
+}
+
+bool DisplayListBuilder::ReuseItem(nsPaintedDisplayItem* aItem) {
+  if (!mDisplayItemCache) {
+    return false;
+  }
+
+  mDisplayItemCache->Stats().AddTotal();
+
+  if (mDisplayItemCache->IsEmpty()) {
+    return false;
+  }
+
+  Maybe<uint16_t> slot =
+      mDisplayItemCache->CanReuseItem(aItem, CurrentSpaceAndClipChain());
+
+  if (slot) {
+    mDisplayItemCache->Stats().AddReused();
+    wr_dp_push_reuse_items(mWrState, slot.ref());
+    return true;
+  }
+
+  return false;
+}
+
+Maybe<layers::ScrollableLayerGuid::ViewID>
+DisplayListBuilder::GetContainingFixedPosScrollTarget(
+    const ActiveScrolledRoot* aAsr) {
+  return mActiveFixedPosTracker
+             ? mActiveFixedPosTracker->GetScrollTargetForASR(aAsr)
+             : Nothing();
+}
+
+Maybe<SideBits> DisplayListBuilder::GetContainingFixedPosSideBits(
+    const ActiveScrolledRoot* aAsr) {
+  return mActiveFixedPosTracker
+             ? mActiveFixedPosTracker->GetSideBitsForASR(aAsr)
+             : Nothing();
+}
+
+DisplayListBuilder::FixedPosScrollTargetTracker::FixedPosScrollTargetTracker(
+    DisplayListBuilder& aBuilder, const ActiveScrolledRoot* aAsr,
+    layers::ScrollableLayerGuid::ViewID aScrollId, SideBits aSideBits)
+    : mParentTracker(aBuilder.mActiveFixedPosTracker),
+      mBuilder(aBuilder),
+      mAsr(aAsr),
+      mScrollId(aScrollId),
+      mSideBits(aSideBits) {
+  aBuilder.mActiveFixedPosTracker = this;
+}
+
+DisplayListBuilder::FixedPosScrollTargetTracker::
+    ~FixedPosScrollTargetTracker() {
+  mBuilder.mActiveFixedPosTracker = mParentTracker;
+}
+
+Maybe<layers::ScrollableLayerGuid::ViewID>
+DisplayListBuilder::FixedPosScrollTargetTracker::GetScrollTargetForASR(
+    const ActiveScrolledRoot* aAsr) {
+  return aAsr == mAsr ? Some(mScrollId) : Nothing();
+}
+
+Maybe<SideBits>
+DisplayListBuilder::FixedPosScrollTargetTracker::GetSideBitsForASR(
+    const ActiveScrolledRoot* aAsr) {
+  return aAsr == mAsr ? Some(mSideBits) : Nothing();
+}
+
+gfxContext* DisplayListBuilder::GetTextContext(
+    wr::IpcResourceUpdateQueue& aResources,
+    const layers::StackingContextHelper& aSc,
+    layers::RenderRootStateManager* aManager, nsDisplayItem* aItem,
+    nsRect& aBounds, const gfx::Point& aDeviceOffset) {
+  if (!mCachedTextDT) {
+    mCachedTextDT = new layout::TextDrawTarget(*this, aResources, aSc, aManager,
+                                               aItem, aBounds);
+    if (mCachedTextDT->IsValid()) {
+      mCachedContext = MakeUnique<gfxContext>(mCachedTextDT, aDeviceOffset);
+    }
+  } else {
+    mCachedTextDT->Reinitialize(aResources, aSc, aManager, aItem, aBounds);
+    mCachedContext->SetDeviceOffset(aDeviceOffset);
+    mCachedContext->SetMatrix(gfx::Matrix());
+  }
+
+  return mCachedContext.get();
+}
+
+void DisplayListBuilder::PushInheritedClipChain(
+    nsDisplayListBuilder* aBuilder, const DisplayItemClipChain* aClipChain) {
+  if (!aClipChain || mInheritedClipChain == aClipChain) {
+    return;
+  }
+  if (!mInheritedClipChain) {
+    mInheritedClipChain = aClipChain;
+    return;
+  }
+
+  mInheritedClipChain =
+      aBuilder->CreateClipChainIntersection(mInheritedClipChain, aClipChain);
+}
+
+}  // namespace wr
+}  // namespace mozilla
+
+extern "C" {
+
+void wr_transaction_notification_notified(uintptr_t aHandler,
+                                          mozilla::wr::Checkpoint aWhen) {
+  auto handler = reinterpret_cast<mozilla::wr::NotificationHandler*>(aHandler);
+  handler->Notify(aWhen);
+  // TODO: it would be better to get a callback when the object is destroyed on
+  // the rust side and delete then.
+  delete handler;
+}
+
+void wr_register_thread_local_arena() {
+#ifdef MOZ_MEMORY
+  jemalloc_thread_local_arena(true);
+#endif
+}
+
+}  // extern C
diff --git a/gfx/webrender_bindings/WebRenderAPI.h b/gfx/webrender_bindings/WebRenderAPI.h
new file mode 100644
index 0000000000..16a9acc0ab
--- /dev/null
+++ b/gfx/webrender_bindings/WebRenderAPI.h
@@ -0,0 +1,958 @@
+/* -*- 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_LAYERS_WEBRENDERAPI_H
+#define MOZILLA_LAYERS_WEBRENDERAPI_H
+
+#include <queue>
+#include <stdint.h>
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/gfx/CompositorHitTestInfo.h"
+#include "mozilla/layers/AsyncImagePipelineOp.h"
+#include "mozilla/layers/IpcResourceUpdateQueue.h"
+#include "mozilla/layers/RemoteTextureMap.h"
+#include "mozilla/layers/ScrollableLayerGuid.h"
+#include "mozilla/layers/SyncObject.h"
+#include "mozilla/layers/CompositionRecorder.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/Range.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/VsyncDispatcher.h"
+#include "mozilla/webrender/webrender_ffi.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "nsString.h"
+#include "GLTypes.h"
+#include "Units.h"
+
+class gfxContext;
+
+#undef None
+
+namespace mozilla {
+
+class nsDisplayItem;
+class nsPaintedDisplayItem;
+class nsDisplayTransform;
+class nsDisplayListBuilder;
+struct DisplayItemClipChain;
+
+struct ActiveScrolledRoot;
+
+namespace widget {
+class CompositorWidget;
+}
+
+namespace layers {
+class CompositorBridgeParent;
+class DisplayItemCache;
+class WebRenderBridgeParent;
+class RenderRootStateManager;
+class StackingContextHelper;
+struct DisplayListData;
+}  // namespace layers
+
+namespace layout {
+class TextDrawTarget;
+}
+
+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.
+struct Line {
+  wr::LayoutRect bounds;
+  float wavyLineThickness;
+  wr::LineOrientation orientation;
+  wr::ColorF color;
+  wr::LineStyle style;
+};
+
+/// A handler that can be bundled into a transaction and notified at specific
+/// points in the rendering pipeline, such as after scene building or after
+/// frame building.
+///
+/// If for any reason the handler is dropped before reaching the requested
+/// point, it is notified with the value Checkpoint::TransactionDropped.
+/// So it is safe to assume that the handler will be notified "at some point".
+class NotificationHandler {
+ public:
+  virtual void Notify(wr::Checkpoint aCheckpoint) = 0;
+  virtual ~NotificationHandler() = default;
+};
+
+struct WrHitResult {
+  layers::LayersId mLayersId;
+  layers::ScrollableLayerGuid::ViewID mScrollId;
+  gfx::CompositorHitTestInfo mHitInfo;
+  SideBits mSideBits;
+  Maybe<uint64_t> mAnimationId;
+};
+
+class TransactionBuilder final {
+ public:
+  explicit TransactionBuilder(WebRenderAPI* aApi,
+                              bool aUseSceneBuilderThread = true);
+
+  TransactionBuilder(WebRenderAPI* aApi, Transaction* aTxn,
+                     bool aUseSceneBuilderThread, bool aOwnsData);
+
+  ~TransactionBuilder();
+
+  void SetLowPriority(bool aIsLowPriority);
+
+  void UpdateEpoch(PipelineId aPipelineId, Epoch aEpoch);
+
+  void SetRootPipeline(PipelineId aPipelineId);
+
+  void RemovePipeline(PipelineId aPipelineId);
+
+  void SetDisplayList(Epoch aEpoch, wr::WrPipelineId pipeline_id,
+                      wr::BuiltDisplayListDescriptor dl_descriptor,
+                      wr::Vec<uint8_t>& dl_items_data,
+                      wr::Vec<uint8_t>& dl_cache_data,
+                      wr::Vec<uint8_t>& dl_spatial_tree);
+
+  void ClearDisplayList(Epoch aEpoch, wr::WrPipelineId aPipeline);
+
+  void GenerateFrame(const VsyncId& aVsyncId, wr::RenderReasons aReasons);
+
+  void InvalidateRenderedFrame(wr::RenderReasons aReasons);
+
+  void SetDocumentView(const LayoutDeviceIntRect& aDocRect);
+
+  bool IsEmpty() const;
+
+  bool IsResourceUpdatesEmpty() const;
+
+  bool IsRenderedFrameInvalidated() const;
+
+  void AddImage(wr::ImageKey aKey, const ImageDescriptor& aDescriptor,
+                wr::Vec<uint8_t>& aBytes);
+
+  void AddBlobImage(wr::BlobImageKey aKey, const ImageDescriptor& aDescriptor,
+                    uint16_t aTileSize, wr::Vec<uint8_t>& aBytes,
+                    const wr::DeviceIntRect& aVisibleRect);
+
+  void AddExternalImageBuffer(ImageKey key, const ImageDescriptor& aDescriptor,
+                              ExternalImageId aHandle);
+
+  void AddExternalImage(ImageKey key, const ImageDescriptor& aDescriptor,
+                        ExternalImageId aExtID,
+                        wr::ExternalImageType aImageType,
+                        uint8_t aChannelIndex = 0);
+
+  void UpdateImageBuffer(wr::ImageKey aKey, const ImageDescriptor& aDescriptor,
+                         wr::Vec<uint8_t>& aBytes);
+
+  void UpdateBlobImage(wr::BlobImageKey aKey,
+                       const ImageDescriptor& aDescriptor,
+                       wr::Vec<uint8_t>& aBytes,
+                       const wr::DeviceIntRect& aVisibleRect,
+                       const wr::LayoutIntRect& aDirtyRect);
+
+  void UpdateExternalImage(ImageKey aKey, const ImageDescriptor& aDescriptor,
+                           ExternalImageId aExtID,
+                           wr::ExternalImageType aImageType,
+                           uint8_t aChannelIndex = 0);
+
+  void UpdateExternalImageWithDirtyRect(ImageKey aKey,
+                                        const ImageDescriptor& aDescriptor,
+                                        ExternalImageId aExtID,
+                                        wr::ExternalImageType aImageType,
+                                        const wr::DeviceIntRect& aDirtyRect,
+                                        uint8_t aChannelIndex = 0);
+
+  void SetBlobImageVisibleArea(BlobImageKey aKey,
+                               const wr::DeviceIntRect& aArea);
+
+  void DeleteImage(wr::ImageKey aKey);
+
+  void DeleteBlobImage(wr::BlobImageKey aKey);
+
+  void AddRawFont(wr::FontKey aKey, wr::Vec<uint8_t>& aBytes, uint32_t aIndex);
+
+  void AddFontDescriptor(wr::FontKey aKey, wr::Vec<uint8_t>& aBytes,
+                         uint32_t aIndex);
+
+  void DeleteFont(wr::FontKey aKey);
+
+  void AddFontInstance(wr::FontInstanceKey aKey, wr::FontKey aFontKey,
+                       float aGlyphSize,
+                       const wr::FontInstanceOptions* aOptions,
+                       const wr::FontInstancePlatformOptions* aPlatformOptions,
+                       wr::Vec<uint8_t>& aVariations);
+
+  void DeleteFontInstance(wr::FontInstanceKey aKey);
+
+  void UpdateQualitySettings(bool aForceSubpixelAAWherePossible);
+
+  void Notify(wr::Checkpoint aWhen, UniquePtr<NotificationHandler> aHandler);
+
+  void Clear();
+
+  Transaction* Take();
+
+  bool UseSceneBuilderThread() const { return mUseSceneBuilderThread; }
+  layers::WebRenderBackend GetBackendType() { return mApiBackend; }
+  Transaction* Raw() { return mTxn; }
+
+ protected:
+  Transaction* mTxn;
+  bool mUseSceneBuilderThread;
+  layers::WebRenderBackend mApiBackend;
+  bool mOwnsData;
+};
+
+class TransactionWrapper final {
+ public:
+  explicit TransactionWrapper(Transaction* aTxn);
+
+  void AppendDynamicProperties(
+      const nsTArray<wr::WrOpacityProperty>& aOpacityArray,
+      const nsTArray<wr::WrTransformProperty>& aTransformArray,
+      const nsTArray<wr::WrColorProperty>& aColorArray);
+  void AppendTransformProperties(
+      const nsTArray<wr::WrTransformProperty>& aTransformArray);
+  void UpdateScrollPosition(
+      const wr::ExternalScrollId& aScrollId,
+      const nsTArray<wr::SampledScrollOffset>& aSampledOffsets);
+  void UpdateIsTransformAsyncZooming(uint64_t aAnimationId, bool aIsZooming);
+  void AddMinimapData(const wr::ExternalScrollId& aScrollId,
+                      const MinimapData& aMinimapData);
+
+ private:
+  Transaction* mTxn;
+};
+
+class WebRenderAPI final {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderAPI);
+
+ public:
+  /// This can be called on the compositor thread only.
+  static already_AddRefed<WebRenderAPI> Create(
+      layers::CompositorBridgeParent* aBridge,
+      RefPtr<widget::CompositorWidget>&& aWidget,
+      const wr::WrWindowId& aWindowId, LayoutDeviceIntSize aSize,
+      layers::WindowKind aWindowKind, nsACString& aError);
+
+  already_AddRefed<WebRenderAPI> Clone();
+
+  void DestroyRenderer();
+
+  wr::WindowId GetId() const { return mId; }
+
+  /// Do a non-blocking hit-testing query on a shared version of the hit
+  /// testing information.
+  std::vector<WrHitResult> HitTest(const wr::WorldPoint& aPoint);
+
+  void SendTransaction(TransactionBuilder& aTxn);
+
+  void SetFrameStartTime(const TimeStamp& aTime);
+
+  void RunOnRenderThread(UniquePtr<RendererEvent> aEvent);
+
+  void Readback(const TimeStamp& aStartTime, gfx::IntSize aSize,
+                const gfx::SurfaceFormat& aFormat,
+                const Range<uint8_t>& aBuffer, bool* aNeedsYFlip);
+
+  void ClearAllCaches();
+  void EnableNativeCompositor(bool aEnable);
+  void SetBatchingLookback(uint32_t aCount);
+  void SetBool(wr::BoolParameter, bool value);
+  void SetInt(wr::IntParameter, int32_t value);
+
+  void SetClearColor(const gfx::DeviceColor& aColor);
+  void SetProfilerUI(const nsACString& aUIString);
+
+  void Pause();
+  bool Resume();
+
+  void WakeSceneBuilder();
+  void FlushSceneBuilder();
+
+  void NotifyMemoryPressure();
+  void AccumulateMemoryReport(wr::MemoryReport*);
+
+  wr::WrIdNamespace GetNamespace();
+  layers::WebRenderBackend GetBackendType() { return mBackend; }
+  layers::WebRenderCompositor GetCompositorType() { return mCompositor; }
+  uint32_t GetMaxTextureSize() const { return mMaxTextureSize; }
+  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();
+
+  void StartCaptureSequence(const nsACString& aPath, uint32_t aFlags);
+  void StopCaptureSequence();
+
+  void BeginRecording(const TimeStamp& aRecordingStart,
+                      wr::PipelineId aRootPipelineId);
+
+  typedef MozPromise<layers::FrameRecording, nsresult, true>
+      EndRecordingPromise;
+
+  RefPtr<EndRecordingPromise> EndRecording();
+
+  layers::RemoteTextureInfoList* GetPendingRemoteTextureInfoList();
+  layers::AsyncImagePipelineOps* GetPendingAsyncImagePipelineOps(
+      TransactionBuilder& aTxn);
+
+  void FlushPendingWrTransactionEventsWithoutWait();
+  void FlushPendingWrTransactionEventsWithWait();
+
+  wr::WebRenderAPI* GetRootAPI();
+
+ protected:
+  WebRenderAPI(wr::DocumentHandle* aHandle, wr::WindowId aId,
+               layers::WebRenderBackend aBackend,
+               layers::WebRenderCompositor aCompositor,
+               uint32_t aMaxTextureSize, bool aUseANGLE, bool aUseDComp,
+               bool aUseTripleBuffering, bool aSupportsExternalBufferTextures,
+               layers::SyncHandle aSyncHandle,
+               wr::WebRenderAPI* aRootApi = nullptr,
+               wr::WebRenderAPI* aRootDocumentApi = nullptr);
+
+  ~WebRenderAPI();
+  // Should be used only for shutdown handling
+  void WaitFlushed();
+
+  void UpdateDebugFlags(uint32_t aFlags);
+  bool CheckIsRemoteTextureReady(layers::RemoteTextureInfoList* aList,
+                                 const TimeStamp& aTimeStamp);
+  void WaitRemoteTextureReady(layers::RemoteTextureInfoList* aList);
+
+  enum class RemoteTextureWaitType : uint8_t {
+    AsyncWait = 0,
+    FlushWithWait = 1,
+    FlushWithoutWait = 2
+  };
+
+  void HandleWrTransactionEvents(RemoteTextureWaitType aType);
+
+  class WrTransactionEvent {
+   public:
+    enum class Tag {
+      Transaction,
+      PendingRemoteTextures,
+      PendingAsyncImagePipelineOps,
+    };
+    const Tag mTag;
+    const TimeStamp mTimeStamp;
+
+   private:
+    WrTransactionEvent(const Tag aTag,
+                       UniquePtr<TransactionBuilder>&& aTransaction)
+        : mTag(aTag),
+          mTimeStamp(TimeStamp::Now()),
+          mTransaction(std::move(aTransaction)) {
+      MOZ_ASSERT(mTag == Tag::Transaction);
+    }
+    WrTransactionEvent(
+        const Tag aTag,
+        UniquePtr<layers::RemoteTextureInfoList>&& aPendingRemoteTextures)
+        : mTag(aTag),
+          mTimeStamp(TimeStamp::Now()),
+          mPendingRemoteTextures(std::move(aPendingRemoteTextures)) {
+      MOZ_ASSERT(mTag == Tag::PendingRemoteTextures);
+    }
+    WrTransactionEvent(const Tag aTag,
+                       UniquePtr<layers::AsyncImagePipelineOps>&&
+                           aPendingAsyncImagePipelineOps,
+                       UniquePtr<TransactionBuilder>&& aTransaction)
+        : mTag(aTag),
+          mTimeStamp(TimeStamp::Now()),
+          mPendingAsyncImagePipelineOps(
+              std::move(aPendingAsyncImagePipelineOps)),
+          mTransaction(std::move(aTransaction)) {
+      MOZ_ASSERT(mTag == Tag::PendingAsyncImagePipelineOps);
+    }
+
+    UniquePtr<layers::RemoteTextureInfoList> mPendingRemoteTextures;
+    UniquePtr<layers::AsyncImagePipelineOps> mPendingAsyncImagePipelineOps;
+    UniquePtr<TransactionBuilder> mTransaction;
+
+   public:
+    static WrTransactionEvent Transaction(WebRenderAPI* aApi,
+                                          wr::Transaction* aTxn,
+                                          bool aUseSceneBuilderThread) {
+      auto transaction = MakeUnique<TransactionBuilder>(
+          aApi, aTxn, aUseSceneBuilderThread, /* aOwnsData */ true);
+      return WrTransactionEvent(Tag::Transaction, std::move(transaction));
+    }
+
+    static WrTransactionEvent PendingRemoteTextures(
+        UniquePtr<layers::RemoteTextureInfoList>&& aPendingRemoteTextures) {
+      return WrTransactionEvent(Tag::PendingRemoteTextures,
+                                std::move(aPendingRemoteTextures));
+    }
+
+    static WrTransactionEvent PendingAsyncImagePipelineOps(
+        UniquePtr<layers::AsyncImagePipelineOps>&&
+            aPendingAsyncImagePipelineOps,
+        WebRenderAPI* aApi, wr::Transaction* aTxn,
+        bool aUseSceneBuilderThread) {
+      auto transaction = MakeUnique<TransactionBuilder>(
+          aApi, aTxn, aUseSceneBuilderThread, /* aOwnsData */ false);
+      return WrTransactionEvent(Tag::PendingAsyncImagePipelineOps,
+                                std::move(aPendingAsyncImagePipelineOps),
+                                std::move(transaction));
+    }
+
+    wr::Transaction* RawTransaction() {
+      if (mTag == Tag::Transaction) {
+        return mTransaction->Raw();
+      }
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+      return nullptr;
+    }
+
+    TransactionBuilder* GetTransactionBuilder() {
+      if (mTag == Tag::PendingAsyncImagePipelineOps) {
+        return mTransaction.get();
+      }
+      MOZ_CRASH("Should not be called");
+      return nullptr;
+    }
+
+    bool UseSceneBuilderThread() {
+      if (mTag == Tag::Transaction) {
+        return mTransaction->UseSceneBuilderThread();
+      }
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+      return true;
+    }
+
+    layers::RemoteTextureInfoList* RemoteTextureInfoList() {
+      if (mTag == Tag::PendingRemoteTextures) {
+        MOZ_ASSERT(mPendingRemoteTextures);
+        return mPendingRemoteTextures.get();
+      }
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+      return nullptr;
+    }
+
+    layers::AsyncImagePipelineOps* AsyncImagePipelineOps() {
+      if (mTag == Tag::PendingAsyncImagePipelineOps) {
+        MOZ_ASSERT(mPendingAsyncImagePipelineOps);
+        return mPendingAsyncImagePipelineOps.get();
+      }
+      MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+      return nullptr;
+    }
+  };
+
+  wr::DocumentHandle* mDocHandle;
+  wr::WindowId mId;
+  layers::WebRenderBackend mBackend;
+  layers::WebRenderCompositor mCompositor;
+  int32_t mMaxTextureSize;
+  bool mUseANGLE;
+  bool mUseDComp;
+  bool mUseTripleBuffering;
+  bool mSupportsExternalBufferTextures;
+  bool mCaptureSequence;
+  layers::SyncHandle mSyncHandle;
+  bool mRendererDestroyed;
+
+  UniquePtr<layers::RemoteTextureInfoList> mPendingRemoteTextureInfoList;
+  UniquePtr<layers::AsyncImagePipelineOps> mPendingAsyncImagePipelineOps;
+  std::queue<WrTransactionEvent> mPendingWrTransactionEvents;
+
+  // We maintain alive the root api to know when to shut the render backend
+  // down, and the root api for the document to know when to delete the
+  // document. mRootApi is null for the api object that owns the channel (and is
+  // responsible for shutting it down), and mRootDocumentApi is null for the api
+  // object owning (and responsible for destroying) a given document. All api
+  // objects in the same window use the same channel, and some api objects write
+  // to the same document (but there is only one owner for each channel and for
+  // each document).
+  const RefPtr<wr::WebRenderAPI> mRootApi;
+  const RefPtr<wr::WebRenderAPI> mRootDocumentApi;
+
+  friend class DisplayListBuilder;
+  friend class layers::WebRenderBridgeParent;
+};
+
+// This is a RAII class that automatically sends the transaction on
+// destruction. This is useful for code that has multiple exit points and we
+// want to ensure that the stuff accumulated in the transaction gets sent
+// regardless of which exit we take. Note that if the caller explicitly calls
+// mApi->SendTransaction() that's fine too because that empties out the
+// TransactionBuilder and leaves it as a valid empty transaction, so calling
+// SendTransaction on it again ends up being a no-op.
+class MOZ_RAII AutoTransactionSender {
+ public:
+  AutoTransactionSender(WebRenderAPI* aApi, TransactionBuilder* aTxn)
+      : mApi(aApi), mTxn(aTxn) {
+    MOZ_RELEASE_ASSERT(mApi);
+    MOZ_RELEASE_ASSERT(aTxn);
+  }
+
+  ~AutoTransactionSender() { mApi->SendTransaction(*mTxn); }
+
+ private:
+  WebRenderAPI* mApi;
+  TransactionBuilder* mTxn;
+};
+
+/**
+ * A set of optional parameters for stacking context creation.
+ */
+struct MOZ_STACK_CLASS StackingContextParams : public WrStackingContextParams {
+  StackingContextParams()
+      : WrStackingContextParams{
+            WrStackingContextClip::None(),
+            nullptr,
+            nullptr,
+            nullptr,
+            wr::TransformStyle::Flat,
+            wr::WrReferenceFrameKind::Transform,
+            false,
+            false,
+            false,
+            nullptr,
+            /* prim_flags = */ wr::PrimitiveFlags::IS_BACKFACE_VISIBLE,
+            wr::MixBlendMode::Normal,
+            wr::StackingContextFlags{0}} {}
+
+  void SetPreserve3D(bool aPreserve) {
+    transform_style =
+        aPreserve ? wr::TransformStyle::Preserve3D : wr::TransformStyle::Flat;
+  }
+
+  // Fill this in only if this is for the root StackingContextHelper.
+  nsIFrame* mRootReferenceFrame = nullptr;
+  nsTArray<wr::FilterOp> mFilters;
+  nsTArray<wr::WrFilterData> mFilterDatas;
+  wr::LayoutRect mBounds = wr::ToLayoutRect(LayoutDeviceRect());
+  const gfx::Matrix4x4* mBoundTransform = nullptr;
+  const wr::WrTransformInfo* mTransformPtr = nullptr;
+  nsDisplayTransform* mDeferredTransformItem = nullptr;
+  // Whether the stacking context is possibly animated. This alters how
+  // coordinates are transformed/snapped to invalidate less when transforms
+  // change frequently.
+  bool mAnimated = false;
+  // Whether items should be rasterized in a local space that is (mostly)
+  // invariant to transforms, i.e. disabling subpixel AA and screen space pixel
+  // snapping on text runs that would only make sense in screen space.
+  bool mRasterizeLocally = false;
+};
+
+/// This is a simple C++ wrapper around WrState defined in the rust bindings.
+/// We may want to turn this into a direct wrapper on top of
+/// WebRenderFrameBuilder instead, so the interface may change a bit.
+class DisplayListBuilder final {
+ public:
+  explicit DisplayListBuilder(wr::PipelineId aId,
+                              layers::WebRenderBackend aBackend);
+  DisplayListBuilder(DisplayListBuilder&&) = default;
+
+  ~DisplayListBuilder();
+
+  void Save();
+  void Restore();
+  void ClearSave();
+
+  usize Dump(usize aIndent, const Maybe<usize>& aStart,
+             const Maybe<usize>& aEnd);
+  void DumpSerializedDisplayList();
+
+  void Begin(layers::DisplayItemCache* aCache = nullptr);
+  void End(wr::BuiltDisplayList& aOutDisplayList);
+  void End(layers::DisplayListData& aOutTransaction);
+
+  Maybe<wr::WrSpatialId> PushStackingContext(
+      const StackingContextParams& aParams, const wr::LayoutRect& aBounds,
+      const wr::RasterSpace& aRasterSpace);
+  void PopStackingContext(bool aIsReferenceFrame);
+
+  wr::WrClipChainId DefineClipChain(const nsTArray<wr::WrClipId>& aClips,
+                                    bool aParentWithCurrentChain = false);
+
+  wr::WrClipId DefineImageMaskClip(const wr::ImageMask& aMask,
+                                   const nsTArray<wr::LayoutPoint>&,
+                                   wr::FillRule);
+  wr::WrClipId DefineRoundedRectClip(Maybe<wr::WrSpatialId> aSpace,
+                                     const wr::ComplexClipRegion& aComplex);
+  wr::WrClipId DefineRectClip(Maybe<wr::WrSpatialId> aSpace,
+                              wr::LayoutRect aClipRect);
+
+  wr::WrSpatialId DefineStickyFrame(
+      const wr::LayoutRect& aContentRect, const float* aTopMargin,
+      const float* aRightMargin, const float* aBottomMargin,
+      const float* aLeftMargin, const StickyOffsetBounds& aVerticalBounds,
+      const StickyOffsetBounds& aHorizontalBounds,
+      const wr::LayoutVector2D& aAppliedOffset, wr::SpatialTreeItemKey aKey);
+
+  Maybe<wr::WrSpatialId> GetScrollIdForDefinedScrollLayer(
+      layers::ScrollableLayerGuid::ViewID aViewId) const;
+  wr::WrSpatialId DefineScrollLayer(
+      const layers::ScrollableLayerGuid::ViewID& aViewId,
+      const Maybe<wr::WrSpatialId>& aParent, const wr::LayoutRect& aContentRect,
+      const wr::LayoutRect& aClipRect, const wr::LayoutVector2D& aScrollOffset,
+      wr::APZScrollGeneration aScrollOffsetGeneration,
+      wr::HasScrollLinkedEffect aHasScrollLinkedEffect,
+      wr::SpatialTreeItemKey aKey);
+
+  void PushRect(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                bool aIsBackfaceVisible, bool aForceAntiAliasing,
+                bool aIsCheckerboard, const wr::ColorF& aColor);
+  void PushRectWithAnimation(const wr::LayoutRect& aBounds,
+                             const wr::LayoutRect& aClip,
+                             bool aIsBackfaceVisible, const wr::ColorF& aColor,
+                             const WrAnimationProperty* aAnimation);
+  void PushRoundedRect(const wr::LayoutRect& aBounds,
+                       const wr::LayoutRect& aClip, bool aIsBackfaceVisible,
+                       const wr::ColorF& aColor);
+  void PushHitTest(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                   bool aIsBackfaceVisible,
+                   const layers::ScrollableLayerGuid::ViewID& aScrollId,
+                   const gfx::CompositorHitTestInfo& aHitInfo,
+                   SideBits aSideBits);
+  void PushClearRect(const wr::LayoutRect& aBounds);
+
+  void PushBackdropFilter(const wr::LayoutRect& aBounds,
+                          const wr::ComplexClipRegion& aRegion,
+                          const nsTArray<wr::FilterOp>& aFilters,
+                          const nsTArray<wr::WrFilterData>& aFilterDatas,
+                          bool aIsBackfaceVisible);
+
+  void PushLinearGradient(const wr::LayoutRect& aBounds,
+                          const wr::LayoutRect& aClip, bool aIsBackfaceVisible,
+                          const wr::LayoutPoint& aStartPoint,
+                          const wr::LayoutPoint& aEndPoint,
+                          const nsTArray<wr::GradientStop>& aStops,
+                          wr::ExtendMode aExtendMode,
+                          const wr::LayoutSize aTileSize,
+                          const wr::LayoutSize aTileSpacing);
+
+  void PushRadialGradient(const wr::LayoutRect& aBounds,
+                          const wr::LayoutRect& aClip, bool aIsBackfaceVisible,
+                          const wr::LayoutPoint& aCenter,
+                          const wr::LayoutSize& aRadius,
+                          const nsTArray<wr::GradientStop>& aStops,
+                          wr::ExtendMode aExtendMode,
+                          const wr::LayoutSize aTileSize,
+                          const wr::LayoutSize aTileSpacing);
+
+  void PushConicGradient(const wr::LayoutRect& aBounds,
+                         const wr::LayoutRect& aClip, bool aIsBackfaceVisible,
+                         const wr::LayoutPoint& aCenter, const float aAngle,
+                         const nsTArray<wr::GradientStop>& aStops,
+                         wr::ExtendMode aExtendMode,
+                         const wr::LayoutSize aTileSize,
+                         const wr::LayoutSize aTileSpacing);
+
+  void PushImage(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                 bool aIsBackfaceVisible, bool aForceAntiAliasing,
+                 wr::ImageRendering aFilter, wr::ImageKey aImage,
+                 bool aPremultipliedAlpha = true,
+                 const wr::ColorF& aColor = wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f},
+                 bool aPreferCompositorSurface = false,
+                 bool aSupportsExternalCompositing = false);
+
+  void PushRepeatingImage(
+      const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+      bool aIsBackfaceVisible, const wr::LayoutSize& aStretchSize,
+      const wr::LayoutSize& aTileSpacing, wr::ImageRendering aFilter,
+      wr::ImageKey aImage, bool aPremultipliedAlpha = true,
+      const wr::ColorF& aColor = wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f});
+
+  void PushYCbCrPlanarImage(
+      const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+      bool aIsBackfaceVisible, wr::ImageKey aImageChannel0,
+      wr::ImageKey aImageChannel1, wr::ImageKey aImageChannel2,
+      wr::WrColorDepth aColorDepth, wr::WrYuvColorSpace aColorSpace,
+      wr::WrColorRange aColorRange, wr::ImageRendering aFilter,
+      bool aPreferCompositorSurface = false,
+      bool aSupportsExternalCompositing = false);
+
+  void PushNV12Image(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                     bool aIsBackfaceVisible, wr::ImageKey aImageChannel0,
+                     wr::ImageKey aImageChannel1, wr::WrColorDepth aColorDepth,
+                     wr::WrYuvColorSpace aColorSpace,
+                     wr::WrColorRange aColorRange, wr::ImageRendering aFilter,
+                     bool aPreferCompositorSurface = false,
+                     bool aSupportsExternalCompositing = false);
+
+  void PushP010Image(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                     bool aIsBackfaceVisible, wr::ImageKey aImageChannel0,
+                     wr::ImageKey aImageChannel1, wr::WrColorDepth aColorDepth,
+                     wr::WrYuvColorSpace aColorSpace,
+                     wr::WrColorRange aColorRange, wr::ImageRendering aFilter,
+                     bool aPreferCompositorSurface = false,
+                     bool aSupportsExternalCompositing = false);
+
+  void PushYCbCrInterleavedImage(
+      const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+      bool aIsBackfaceVisible, wr::ImageKey aImageChannel0,
+      wr::WrColorDepth aColorDepth, wr::WrYuvColorSpace aColorSpace,
+      wr::WrColorRange aColorRange, wr::ImageRendering aFilter,
+      bool aPreferCompositorSurface = false,
+      bool aSupportsExternalCompositing = false);
+
+  void PushIFrame(const LayoutDeviceRect& aDevPxBounds, bool aIsBackfaceVisible,
+                  wr::PipelineId aPipeline, bool aIgnoreMissingPipeline);
+
+  // XXX WrBorderSides are passed with Range.
+  // It is just to bypass compiler bug. See Bug 1357734.
+  void PushBorder(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                  bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths,
+                  const Range<const wr::BorderSide>& aSides,
+                  const wr::BorderRadius& aRadius,
+                  wr::AntialiasBorder = wr::AntialiasBorder::Yes);
+
+  void PushBorderImage(const wr::LayoutRect& aBounds,
+                       const wr::LayoutRect& aClip, bool aIsBackfaceVisible,
+                       const wr::WrBorderImage& aParams);
+
+  void PushBorderGradient(const wr::LayoutRect& aBounds,
+                          const wr::LayoutRect& aClip, bool aIsBackfaceVisible,
+                          const wr::LayoutSideOffsets& aWidths,
+                          const int32_t aWidth, const int32_t aHeight,
+                          bool aFill, const wr::DeviceIntSideOffsets& aSlice,
+                          const wr::LayoutPoint& aStartPoint,
+                          const wr::LayoutPoint& aEndPoint,
+                          const nsTArray<wr::GradientStop>& aStops,
+                          wr::ExtendMode aExtendMode);
+
+  void PushBorderRadialGradient(
+      const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+      bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, bool aFill,
+      const wr::LayoutPoint& aCenter, const wr::LayoutSize& aRadius,
+      const nsTArray<wr::GradientStop>& aStops, wr::ExtendMode aExtendMode);
+
+  void PushBorderConicGradient(
+      const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+      bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, bool aFill,
+      const wr::LayoutPoint& aCenter, const float aAngle,
+      const nsTArray<wr::GradientStop>& aStops, wr::ExtendMode aExtendMode);
+
+  void PushText(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                bool aIsBackfaceVisible, const wr::ColorF& aColor,
+                wr::FontInstanceKey aFontKey,
+                Range<const wr::GlyphInstance> aGlyphBuffer,
+                const wr::GlyphOptions* aGlyphOptions = nullptr);
+
+  void PushLine(const wr::LayoutRect& aClip, bool aIsBackfaceVisible,
+                const wr::Line& aLine);
+
+  void PushShadow(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                  bool aIsBackfaceVisible, const wr::Shadow& aShadow,
+                  bool aShouldInflate);
+
+  void PopAllShadows();
+
+  void PushBoxShadow(const wr::LayoutRect& aRect, const wr::LayoutRect& aClip,
+                     bool aIsBackfaceVisible, const wr::LayoutRect& aBoxBounds,
+                     const wr::LayoutVector2D& aOffset,
+                     const wr::ColorF& aColor, const float& aBlurRadius,
+                     const float& aSpreadRadius,
+                     const wr::BorderRadius& aBorderRadius,
+                     const wr::BoxShadowClipMode& aClipMode);
+
+  /**
+   * Notifies the DisplayListBuilder that it can group together WR display items
+   * that are pushed until |CancelGroup()| or |FinishGroup()| call.
+   */
+  void StartGroup(nsPaintedDisplayItem* aItem);
+
+  /**
+   * Cancels grouping of the display items and discards all the display items
+   * pushed between the |StartGroup()| and |CancelGroup()| calls.
+   */
+  void CancelGroup(const bool aDiscard = false);
+
+  /**
+   * Finishes the display item group. The group is stored in WebRender backend,
+   * and can be reused with |ReuseItem()|, if the Gecko display item is reused.
+   */
+  void FinishGroup();
+
+  /**
+   * Try to reuse the previously created WebRender display items for the given
+   * Gecko display item |aItem|.
+   * Returns true if the items were reused, otherwise returns false.
+   */
+  bool ReuseItem(nsPaintedDisplayItem* aItem);
+
+  uint64_t CurrentClipChainId() const {
+    return mCurrentSpaceAndClipChain.clip_chain;
+  }
+
+  const wr::WrSpaceAndClipChain& CurrentSpaceAndClipChain() const {
+    return mCurrentSpaceAndClipChain;
+  }
+
+  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.
+  // Otherwise, it returns Nothing().
+  Maybe<layers::ScrollableLayerGuid::ViewID> GetContainingFixedPosScrollTarget(
+      const ActiveScrolledRoot* aAsr);
+
+  Maybe<SideBits> GetContainingFixedPosSideBits(const ActiveScrolledRoot* aAsr);
+
+  gfxContext* GetTextContext(wr::IpcResourceUpdateQueue& aResources,
+                             const layers::StackingContextHelper& aSc,
+                             layers::RenderRootStateManager* aManager,
+                             nsDisplayItem* aItem, nsRect& aBounds,
+                             const gfx::Point& aDeviceOffset);
+
+  // Try to avoid using this when possible.
+  wr::WrState* Raw() { return mWrState; }
+
+  void SetClipChainLeaf(const Maybe<wr::LayoutRect>& aClipRect) {
+    mClipChainLeaf = aClipRect;
+  }
+
+  // Used for opacity flattening. When we flatten away an opacity item,
+  // we push the opacity value onto the builder.
+  // Descendant items should pull the inherited opacity during
+  // their CreateWebRenderCommands implementation. This can only happen if all
+  // descendant items reported supporting this functionality, via
+  // nsDisplayItem::CanApplyOpacity.
+  float GetInheritedOpacity() { return mInheritedOpacity; }
+  void SetInheritedOpacity(float aOpacity) { mInheritedOpacity = aOpacity; }
+  const DisplayItemClipChain* GetInheritedClipChain() {
+    return mInheritedClipChain;
+  }
+  void PushInheritedClipChain(nsDisplayListBuilder* aBuilder,
+                              const DisplayItemClipChain* aClipChain);
+  void SetInheritedClipChain(const DisplayItemClipChain* aClipChain) {
+    mInheritedClipChain = aClipChain;
+  }
+
+  layers::DisplayItemCache* GetDisplayItemCache() { return mDisplayItemCache; }
+
+  // A chain of RAII objects, each holding a (ASR, ViewID, SideBits) tuple of
+  // data. The topmost object is pointed to by the mActiveFixedPosTracker
+  // pointer in the wr::DisplayListBuilder.
+  class MOZ_RAII FixedPosScrollTargetTracker final {
+   public:
+    FixedPosScrollTargetTracker(DisplayListBuilder& aBuilder,
+                                const ActiveScrolledRoot* aAsr,
+                                layers::ScrollableLayerGuid::ViewID aScrollId,
+                                SideBits aSideBits);
+    ~FixedPosScrollTargetTracker();
+    Maybe<layers::ScrollableLayerGuid::ViewID> GetScrollTargetForASR(
+        const ActiveScrolledRoot* aAsr);
+    Maybe<SideBits> GetSideBitsForASR(const ActiveScrolledRoot* aAsr);
+
+   private:
+    FixedPosScrollTargetTracker* mParentTracker;
+    DisplayListBuilder& mBuilder;
+    const ActiveScrolledRoot* mAsr;
+    layers::ScrollableLayerGuid::ViewID mScrollId;
+    SideBits mSideBits;
+  };
+
+ protected:
+  wr::LayoutRect MergeClipLeaf(const wr::LayoutRect& aClip) {
+    if (mClipChainLeaf) {
+      return wr::IntersectLayoutRect(*mClipChainLeaf, aClip);
+    }
+    return aClip;
+  }
+
+  // See the implementation of PushShadow for details on these methods.
+  void SuspendClipLeafMerging();
+  void ResumeClipLeafMerging();
+
+  wr::WrState* mWrState;
+
+  // Track each scroll id that we encountered. We use this structure to
+  // ensure that we don't define a particular scroll layer multiple times,
+  // as that results in undefined behaviour in WR.
+  std::unordered_map<layers::ScrollableLayerGuid::ViewID, wr::WrSpatialId>
+      mScrollIds;
+
+  wr::WrSpaceAndClipChain mCurrentSpaceAndClipChain;
+
+  // Contains the current leaf of the clip chain to be merged with the
+  // display item's clip rect when pushing an item. May be set to Nothing() if
+  // there is no clip rect to merge with.
+  Maybe<wr::LayoutRect> mClipChainLeaf;
+
+  // Versions of the above that are on hold while SuspendClipLeafMerging is on
+  // (see the implementation of PushShadow for details).
+  Maybe<wr::WrSpaceAndClipChain> mSuspendedSpaceAndClipChain;
+  Maybe<wr::LayoutRect> mSuspendedClipChainLeaf;
+
+  RefPtr<layout::TextDrawTarget> mCachedTextDT;
+  mozilla::UniquePtr<gfxContext> mCachedContext;
+
+  FixedPosScrollTargetTracker* mActiveFixedPosTracker;
+
+  wr::PipelineId mPipelineId;
+  layers::WebRenderBackend mBackend;
+
+  layers::DisplayItemCache* mDisplayItemCache;
+  Maybe<uint16_t> mCurrentCacheSlot;
+  float mInheritedOpacity = 1.0f;
+  const DisplayItemClipChain* mInheritedClipChain = nullptr;
+
+  friend class WebRenderAPI;
+  friend class SpaceAndClipChainHelper;
+};
+
+// This is a RAII class that overrides the current Wr's SpatialId and
+// ClipChainId.
+class MOZ_RAII SpaceAndClipChainHelper final {
+ public:
+  SpaceAndClipChainHelper(DisplayListBuilder& aBuilder,
+                          wr::WrSpaceAndClipChain aSpaceAndClipChain)
+      : mBuilder(aBuilder),
+        mOldSpaceAndClipChain(aBuilder.mCurrentSpaceAndClipChain) {
+    aBuilder.mCurrentSpaceAndClipChain = aSpaceAndClipChain;
+  }
+  SpaceAndClipChainHelper(DisplayListBuilder& aBuilder,
+                          wr::WrSpatialId aSpatialId)
+      : mBuilder(aBuilder),
+        mOldSpaceAndClipChain(aBuilder.mCurrentSpaceAndClipChain) {
+    aBuilder.mCurrentSpaceAndClipChain.space = aSpatialId;
+  }
+  SpaceAndClipChainHelper(DisplayListBuilder& aBuilder,
+                          wr::WrClipChainId aClipChainId)
+      : mBuilder(aBuilder),
+        mOldSpaceAndClipChain(aBuilder.mCurrentSpaceAndClipChain) {
+    aBuilder.mCurrentSpaceAndClipChain.clip_chain = aClipChainId.id;
+  }
+
+  ~SpaceAndClipChainHelper() {
+    mBuilder.mCurrentSpaceAndClipChain = mOldSpaceAndClipChain;
+  }
+
+ private:
+  SpaceAndClipChainHelper(const SpaceAndClipChainHelper&) = delete;
+
+  DisplayListBuilder& mBuilder;
+  wr::WrSpaceAndClipChain mOldSpaceAndClipChain;
+};
+
+Maybe<wr::ImageFormat> SurfaceFormatToImageFormat(gfx::SurfaceFormat aFormat);
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/webrender_bindings/WebRenderTypes.cpp b/gfx/webrender_bindings/WebRenderTypes.cpp
new file mode 100644
index 0000000000..3fa81d2a81
--- /dev/null
+++ b/gfx/webrender_bindings/WebRenderTypes.cpp
@@ -0,0 +1,110 @@
+/* -*- 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 "WebRenderTypes.h"
+
+#include "mozilla/ipc/ByteBuf.h"
+#include "nsStyleConsts.h"
+
+namespace mozilla {
+namespace wr {
+
+WindowId NewWindowId() {
+  static uint64_t sNextId = 1;
+
+  WindowId id;
+  id.mHandle = sNextId++;
+  return id;
+}
+
+BorderStyle ToBorderStyle(StyleBorderStyle aStyle) {
+  switch (aStyle) {
+    case StyleBorderStyle::None:
+      return wr::BorderStyle::None;
+    case StyleBorderStyle::Solid:
+      return wr::BorderStyle::Solid;
+    case StyleBorderStyle::Double:
+      return wr::BorderStyle::Double;
+    case StyleBorderStyle::Dotted:
+      return wr::BorderStyle::Dotted;
+    case StyleBorderStyle::Dashed:
+      return wr::BorderStyle::Dashed;
+    case StyleBorderStyle::Hidden:
+      return wr::BorderStyle::Hidden;
+    case StyleBorderStyle::Groove:
+      return wr::BorderStyle::Groove;
+    case StyleBorderStyle::Ridge:
+      return wr::BorderStyle::Ridge;
+    case StyleBorderStyle::Inset:
+      return wr::BorderStyle::Inset;
+    case StyleBorderStyle::Outset:
+      return wr::BorderStyle::Outset;
+  }
+  return wr::BorderStyle::None;
+}
+
+wr::RepeatMode ToRepeatMode(StyleBorderImageRepeat aRepeat) {
+  switch (aRepeat) {
+    case StyleBorderImageRepeat::Stretch:
+      return wr::RepeatMode::Stretch;
+    case StyleBorderImageRepeat::Repeat:
+      return wr::RepeatMode::Repeat;
+    case StyleBorderImageRepeat::Round:
+      return wr::RepeatMode::Round;
+    case StyleBorderImageRepeat::Space:
+      return wr::RepeatMode::Space;
+    default:
+      MOZ_ASSERT(false);
+  }
+
+  return wr::RepeatMode::Stretch;
+}
+
+ImageRendering ToImageRendering(StyleImageRendering aImageRendering) {
+  switch (aImageRendering) {
+    case StyleImageRendering::Auto:
+    case StyleImageRendering::Smooth:
+    case StyleImageRendering::Optimizequality:
+      return wr::ImageRendering::Auto;
+    case StyleImageRendering::CrispEdges:
+      // FIXME(bug 1728831): Historically we've returned Pixelated here, but
+      // this should arguably pass CrispEdges to WebRender?
+      // return wr::ImageRendering::CrispEdges;
+      [[fallthrough]];
+    case StyleImageRendering::Optimizespeed:
+    case StyleImageRendering::Pixelated:
+      return wr::ImageRendering::Pixelated;
+  }
+  return wr::ImageRendering::Auto;
+}
+
+void Assign_WrVecU8(wr::WrVecU8& aVec, mozilla::ipc::ByteBuf&& aOther) {
+  aVec.data = aOther.mData;
+  aVec.length = aOther.mLen;
+  aVec.capacity = aOther.mCapacity;
+  aOther.mData = nullptr;
+  aOther.mLen = 0;
+  aOther.mCapacity = 0;
+}
+
+WrSpatialId RootScrollNode() { return wr_root_scroll_node_id(); }
+
+WrSpaceAndClipChain RootScrollNodeWithChain() {
+  WrSpaceAndClipChain sacc;
+  sacc.clip_chain = wr::ROOT_CLIP_CHAIN;
+  sacc.space = wr_root_scroll_node_id();
+  return sacc;
+}
+
+WrSpaceAndClipChain InvalidScrollNodeWithChain() {
+  WrSpaceAndClipChain sacc;
+  sacc.clip_chain = std::numeric_limits<uint64_t>::max();
+  sacc.space = wr_root_scroll_node_id();
+  return sacc;
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/webrender_bindings/WebRenderTypes.h b/gfx/webrender_bindings/WebRenderTypes.h
new file mode 100644
index 0000000000..3216a0afd6
--- /dev/null
+++ b/gfx/webrender_bindings/WebRenderTypes.h
@@ -0,0 +1,920 @@
+/* -*- 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 GFX_WEBRENDERTYPES_H
+#define GFX_WEBRENDERTYPES_H
+
+#include "ImageTypes.h"
+#include "mozilla/webrender/webrender_ffi.h"
+#include "mozilla/EnumSet.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/gfx/Matrix.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/gfx/Tools.h"
+#include "mozilla/gfx/Rect.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/PodOperations.h"
+#include "mozilla/Range.h"
+#include "mozilla/ScrollGeneration.h"
+#include "Units.h"
+#include "nsIWidgetListener.h"
+
+namespace mozilla {
+
+enum class StyleBorderStyle : uint8_t;
+enum class StyleBorderImageRepeat : uint8_t;
+enum class StyleImageRendering : uint8_t;
+
+namespace ipc {
+class ByteBuf;
+}  // namespace ipc
+
+namespace wr {
+
+// Using uintptr_t in C++ code for "size" types seems weird, so let's use a
+// better-sounding typedef. The name comes from the fact that we generally
+// have to deal with uintptr_t because that's what rust's usize maps to.
+typedef uintptr_t usize;
+
+typedef wr::WrWindowId WindowId;
+typedef wr::WrRemovedPipeline RemovedPipeline;
+
+class RenderedFrameIdType {};
+typedef layers::BaseTransactionId<RenderedFrameIdType> RenderedFrameId;
+
+typedef mozilla::Maybe<mozilla::wr::IdNamespace> MaybeIdNamespace;
+typedef mozilla::Maybe<mozilla::wr::ImageMask> MaybeImageMask;
+typedef Maybe<ExternalImageId> MaybeExternalImageId;
+
+typedef Maybe<FontInstanceOptions> MaybeFontInstanceOptions;
+typedef Maybe<FontInstancePlatformOptions> MaybeFontInstancePlatformOptions;
+
+struct ExternalImageKeyPair {
+  ImageKey key;
+  ExternalImageId id;
+};
+
+/* Generate a brand new window id and return it. */
+WindowId NewWindowId();
+
+inline bool WindowSizeSanityCheck(int32_t aWidth, int32_t aHeight) {
+  if (aWidth < 0 || aWidth > wr::MAX_RENDER_TASK_SIZE || aHeight < 0 ||
+      aHeight > wr::MAX_RENDER_TASK_SIZE) {
+    return false;
+  }
+  return true;
+}
+
+inline DebugFlags NewDebugFlags(uint32_t aFlags) { return {aFlags}; }
+
+inline Maybe<wr::ImageFormat> SurfaceFormatToImageFormat(
+    gfx::SurfaceFormat aFormat) {
+  switch (aFormat) {
+    case gfx::SurfaceFormat::R8G8B8X8:
+      // WebRender not support RGBX8. Assert here.
+      MOZ_ASSERT(false);
+      return Nothing();
+    case gfx::SurfaceFormat::R8G8B8A8:
+      return Some(wr::ImageFormat::RGBA8);
+    case gfx::SurfaceFormat::B8G8R8X8:
+      // TODO: WebRender will have a BGRA + opaque flag for this but does not
+      // have it yet (cf. issue #732).
+    case gfx::SurfaceFormat::B8G8R8A8:
+      return Some(wr::ImageFormat::BGRA8);
+    case gfx::SurfaceFormat::A8:
+      return Some(wr::ImageFormat::R8);
+    case gfx::SurfaceFormat::A16:
+      return Some(wr::ImageFormat::R16);
+    case gfx::SurfaceFormat::R8G8:
+      return Some(wr::ImageFormat::RG8);
+    case gfx::SurfaceFormat::R16G16:
+      return Some(wr::ImageFormat::RG16);
+    case gfx::SurfaceFormat::UNKNOWN:
+    default:
+      return Nothing();
+  }
+}
+
+inline gfx::SurfaceFormat ImageFormatToSurfaceFormat(ImageFormat aFormat) {
+  switch (aFormat) {
+    case ImageFormat::BGRA8:
+      return gfx::SurfaceFormat::B8G8R8A8;
+    case ImageFormat::R8:
+      return gfx::SurfaceFormat::A8;
+    case ImageFormat::R16:
+      return gfx::SurfaceFormat::A16;
+    default:
+      return gfx::SurfaceFormat::UNKNOWN;
+  }
+}
+
+// This extra piece of data is used to differentiate when spatial nodes that are
+// created by Gecko that have the same mFrame and PerFrameKey. This currently
+// only occurs with sticky display list items that are also zoomable, which
+// results in Gecko creating both a sticky spatial node, and then a property
+// animated reference frame for APZ
+enum class SpatialKeyKind : uint32_t {
+  Transform,
+  Perspective,
+  Scroll,
+  Sticky,
+  ImagePipeline,
+  APZ,
+};
+
+// Construct a unique, persistent spatial key based on the frame tree pointer,
+// per-frame key and a spatial key kind. For now, this covers all the ways Gecko
+// creates spatial nodes. In future, we may need to be more clever with the
+// SpatialKeyKind.
+inline wr::SpatialTreeItemKey SpatialKey(uint64_t aFrame, uint32_t aPerFrameKey,
+                                         SpatialKeyKind aKind) {
+  return wr::SpatialTreeItemKey{
+      aFrame, uint64_t(aPerFrameKey) | (uint64_t(aKind) << 32)};
+}
+
+struct ImageDescriptor : public wr::WrImageDescriptor {
+  // We need a default constructor for ipdl serialization.
+  ImageDescriptor() {
+    format = (ImageFormat)0;
+    width = 0;
+    height = 0;
+    stride = 0;
+    opacity = OpacityType::HasAlphaChannel;
+    prefer_compositor_surface = false;
+  }
+
+  ImageDescriptor(const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat,
+                  bool aPreferCompositorSurface = false) {
+    format = wr::SurfaceFormatToImageFormat(aFormat).valueOr((ImageFormat)0);
+    width = aSize.width;
+    height = aSize.height;
+    stride = 0;
+    opacity = gfx::IsOpaque(aFormat) ? OpacityType::Opaque
+                                     : OpacityType::HasAlphaChannel;
+    prefer_compositor_surface = aPreferCompositorSurface;
+  }
+
+  ImageDescriptor(const gfx::IntSize& aSize, uint32_t aByteStride,
+                  gfx::SurfaceFormat aFormat,
+                  bool aPreferCompositorSurface = false) {
+    format = wr::SurfaceFormatToImageFormat(aFormat).valueOr((ImageFormat)0);
+    width = aSize.width;
+    height = aSize.height;
+    stride = aByteStride;
+    opacity = gfx::IsOpaque(aFormat) ? OpacityType::Opaque
+                                     : OpacityType::HasAlphaChannel;
+    prefer_compositor_surface = aPreferCompositorSurface;
+  }
+
+  ImageDescriptor(const gfx::IntSize& aSize, uint32_t aByteStride,
+                  gfx::SurfaceFormat aFormat, OpacityType aOpacity,
+                  bool aPreferCompositorSurface = false) {
+    format = wr::SurfaceFormatToImageFormat(aFormat).valueOr((ImageFormat)0);
+    width = aSize.width;
+    height = aSize.height;
+    stride = aByteStride;
+    opacity = aOpacity;
+    prefer_compositor_surface = aPreferCompositorSurface;
+  }
+};
+
+inline uint64_t AsUint64(const NativeSurfaceId& aId) {
+  return static_cast<uint64_t>(aId._0);
+}
+
+// Whenever possible, use wr::WindowId instead of manipulating uint64_t.
+inline uint64_t AsUint64(const WindowId& aId) {
+  return static_cast<uint64_t>(aId.mHandle);
+}
+
+// Whenever possible, use wr::ImageKey instead of manipulating uint64_t.
+inline uint64_t AsUint64(const ImageKey& aId) {
+  return (static_cast<uint64_t>(aId.mNamespace.mHandle) << 32) +
+         static_cast<uint64_t>(aId.mHandle);
+}
+
+inline ImageKey AsImageKey(const uint64_t& aId) {
+  ImageKey imageKey;
+  imageKey.mNamespace.mHandle = aId >> 32;
+  imageKey.mHandle = aId;
+  return imageKey;
+}
+
+// Whenever possible, use wr::FontKey instead of manipulating uint64_t.
+inline uint64_t AsUint64(const FontKey& aId) {
+  return (static_cast<uint64_t>(aId.mNamespace.mHandle) << 32) +
+         static_cast<uint64_t>(aId.mHandle);
+}
+
+inline FontKey AsFontKey(const uint64_t& aId) {
+  FontKey fontKey;
+  fontKey.mNamespace.mHandle = aId >> 32;
+  fontKey.mHandle = aId;
+  return fontKey;
+}
+
+// Whenever possible, use wr::FontInstanceKey instead of manipulating uint64_t.
+inline uint64_t AsUint64(const FontInstanceKey& aId) {
+  return (static_cast<uint64_t>(aId.mNamespace.mHandle) << 32) +
+         static_cast<uint64_t>(aId.mHandle);
+}
+
+inline FontInstanceKey AsFontInstanceKey(const uint64_t& aId) {
+  FontInstanceKey instanceKey;
+  instanceKey.mNamespace.mHandle = aId >> 32;
+  instanceKey.mHandle = aId;
+  return instanceKey;
+}
+
+// Whenever possible, use wr::PipelineId instead of manipulating uint64_t.
+inline uint64_t AsUint64(const PipelineId& aId) {
+  return (static_cast<uint64_t>(aId.mNamespace) << 32) +
+         static_cast<uint64_t>(aId.mHandle);
+}
+
+inline PipelineId AsPipelineId(const uint64_t& aId) {
+  PipelineId pipeline;
+  pipeline.mNamespace = aId >> 32;
+  pipeline.mHandle = aId;
+  return pipeline;
+}
+
+inline mozilla::layers::LayersId AsLayersId(const PipelineId& aId) {
+  return mozilla::layers::LayersId{AsUint64(aId)};
+}
+
+inline PipelineId AsPipelineId(const mozilla::layers::LayersId& aId) {
+  return AsPipelineId(uint64_t(aId));
+}
+
+ImageRendering ToImageRendering(StyleImageRendering);
+
+static inline FontRenderMode ToFontRenderMode(gfx::AntialiasMode aMode,
+                                              bool aPermitSubpixelAA = true) {
+  switch (aMode) {
+    case gfx::AntialiasMode::NONE:
+      return FontRenderMode::Mono;
+    case gfx::AntialiasMode::GRAY:
+      return FontRenderMode::Alpha;
+    case gfx::AntialiasMode::SUBPIXEL:
+    default:
+      return aPermitSubpixelAA ? FontRenderMode::Subpixel
+                               : FontRenderMode::Alpha;
+  }
+}
+
+static inline MixBlendMode ToMixBlendMode(gfx::CompositionOp compositionOp) {
+  switch (compositionOp) {
+    case gfx::CompositionOp::OP_MULTIPLY:
+      return MixBlendMode::Multiply;
+    case gfx::CompositionOp::OP_SCREEN:
+      return MixBlendMode::Screen;
+    case gfx::CompositionOp::OP_OVERLAY:
+      return MixBlendMode::Overlay;
+    case gfx::CompositionOp::OP_DARKEN:
+      return MixBlendMode::Darken;
+    case gfx::CompositionOp::OP_LIGHTEN:
+      return MixBlendMode::Lighten;
+    case gfx::CompositionOp::OP_COLOR_DODGE:
+      return MixBlendMode::ColorDodge;
+    case gfx::CompositionOp::OP_COLOR_BURN:
+      return MixBlendMode::ColorBurn;
+    case gfx::CompositionOp::OP_HARD_LIGHT:
+      return MixBlendMode::HardLight;
+    case gfx::CompositionOp::OP_SOFT_LIGHT:
+      return MixBlendMode::SoftLight;
+    case gfx::CompositionOp::OP_DIFFERENCE:
+      return MixBlendMode::Difference;
+    case gfx::CompositionOp::OP_EXCLUSION:
+      return MixBlendMode::Exclusion;
+    case gfx::CompositionOp::OP_HUE:
+      return MixBlendMode::Hue;
+    case gfx::CompositionOp::OP_SATURATION:
+      return MixBlendMode::Saturation;
+    case gfx::CompositionOp::OP_COLOR:
+      return MixBlendMode::Color;
+    case gfx::CompositionOp::OP_LUMINOSITY:
+      return MixBlendMode::Luminosity;
+    case gfx::CompositionOp::OP_ADD:
+      return MixBlendMode::PlusLighter;
+    default:
+      return MixBlendMode::Normal;
+  }
+}
+
+static inline wr::ColorF ToColorF(const gfx::DeviceColor& color) {
+  wr::ColorF c;
+  c.r = color.r;
+  c.g = color.g;
+  c.b = color.b;
+  c.a = color.a;
+  return c;
+}
+
+static inline wr::LayoutPoint ToLayoutPoint(
+    const mozilla::LayoutDevicePoint& point) {
+  wr::LayoutPoint p;
+  p.x = point.x;
+  p.y = point.y;
+  return p;
+}
+
+static inline wr::LayoutPoint ToLayoutPoint(
+    const mozilla::LayoutDeviceIntPoint& point) {
+  return ToLayoutPoint(LayoutDevicePoint(point));
+}
+
+static inline wr::WorldPoint ToWorldPoint(const mozilla::ScreenPoint& point) {
+  wr::WorldPoint p;
+  p.x = point.x;
+  p.y = point.y;
+  return p;
+}
+
+static inline wr::LayoutVector2D ToLayoutVector2D(
+    const mozilla::LayoutDevicePoint& point) {
+  wr::LayoutVector2D p;
+  p.x = point.x;
+  p.y = point.y;
+  return p;
+}
+
+static inline wr::LayoutVector2D ToLayoutVector2D(
+    const mozilla::LayoutDeviceIntPoint& point) {
+  return ToLayoutVector2D(LayoutDevicePoint(point));
+}
+
+static inline wr::LayoutRect ToLayoutRect(
+    const mozilla::LayoutDeviceRect& rect) {
+  wr::LayoutRect r;
+  r.min.x = rect.X();
+  r.min.y = rect.Y();
+  r.max.x = rect.X() + rect.Width();
+  r.max.y = rect.Y() + rect.Height();
+  return r;
+}
+
+static inline wr::LayoutRect ToLayoutRect(const gfx::Rect& rect) {
+  wr::LayoutRect r;
+  r.min.x = rect.X();
+  r.min.y = rect.Y();
+  r.max.x = rect.X() + rect.Width();
+  r.max.y = rect.Y() + rect.Height();
+  return r;
+}
+
+static inline wr::DeviceIntRect ToDeviceIntRect(
+    const mozilla::ImageIntRect& rect) {
+  wr::DeviceIntRect r;
+  r.min.x = rect.X();
+  r.min.y = rect.Y();
+  r.max.x = rect.X() + rect.Width();
+  r.max.y = rect.Y() + rect.Height();
+  return r;
+}
+
+// TODO: should be const LayoutDeviceIntRect instead of ImageIntRect
+static inline wr::LayoutIntRect ToLayoutIntRect(
+    const mozilla::ImageIntRect& rect) {
+  wr::LayoutIntRect r;
+  r.min.x = rect.X();
+  r.min.y = rect.Y();
+  r.max.x = rect.X() + rect.Width();
+  r.max.y = rect.Y() + rect.Height();
+  return r;
+}
+
+static inline wr::LayoutRect ToLayoutRect(
+    const mozilla::LayoutDeviceIntRect& rect) {
+  return ToLayoutRect(IntRectToRect(rect));
+}
+
+static inline wr::LayoutRect IntersectLayoutRect(const wr::LayoutRect& aRect,
+                                                 const wr::LayoutRect& aOther) {
+  wr::LayoutRect r;
+  r.min.x = std::max(aRect.min.x, aOther.min.x);
+  r.min.y = std::max(aRect.min.y, aOther.min.y);
+  r.max.x = std::min(aRect.max.x, aOther.max.x);
+  r.max.y = std::min(aRect.max.y, aOther.max.y);
+
+  if (r.max.x < r.min.x || r.max.y < r.min.y) {
+    r.max.x = r.min.x;
+    r.max.y = r.min.y;
+  }
+  return r;
+}
+
+static inline wr::LayoutSize ToLayoutSize(
+    const mozilla::LayoutDeviceSize& size) {
+  wr::LayoutSize ls;
+  ls.width = size.width;
+  ls.height = size.height;
+  return ls;
+}
+
+static inline wr::ComplexClipRegion ToComplexClipRegion(
+    const gfx::RoundedRect& rect) {
+  wr::ComplexClipRegion ret;
+  ret.rect = ToLayoutRect(rect.rect);
+  ret.radii.top_left = ToLayoutSize(LayoutDeviceSize::FromUnknownSize(
+      rect.corners.radii[mozilla::eCornerTopLeft]));
+  ret.radii.top_right = ToLayoutSize(LayoutDeviceSize::FromUnknownSize(
+      rect.corners.radii[mozilla::eCornerTopRight]));
+  ret.radii.bottom_left = ToLayoutSize(LayoutDeviceSize::FromUnknownSize(
+      rect.corners.radii[mozilla::eCornerBottomLeft]));
+  ret.radii.bottom_right = ToLayoutSize(LayoutDeviceSize::FromUnknownSize(
+      rect.corners.radii[mozilla::eCornerBottomRight]));
+  ret.mode = wr::ClipMode::Clip;
+  return ret;
+}
+
+static inline wr::ComplexClipRegion SimpleRadii(const wr::LayoutRect& aRect,
+                                                float aRadii) {
+  wr::ComplexClipRegion ret;
+  wr::LayoutSize radii{aRadii, aRadii};
+  ret.rect = aRect;
+  ret.radii.top_left = radii;
+  ret.radii.top_right = radii;
+  ret.radii.bottom_left = radii;
+  ret.radii.bottom_right = radii;
+  ret.mode = wr::ClipMode::Clip;
+  return ret;
+}
+
+static inline wr::LayoutSize ToLayoutSize(
+    const mozilla::LayoutDeviceIntSize& size) {
+  return ToLayoutSize(LayoutDeviceSize(size));
+}
+
+template <class S, class T>
+static inline wr::LayoutTransform ToLayoutTransform(
+    const gfx::Matrix4x4Typed<S, T>& m) {
+  wr::LayoutTransform transform;
+  transform.m11 = m._11;
+  transform.m12 = m._12;
+  transform.m13 = m._13;
+  transform.m14 = m._14;
+  transform.m21 = m._21;
+  transform.m22 = m._22;
+  transform.m23 = m._23;
+  transform.m24 = m._24;
+  transform.m31 = m._31;
+  transform.m32 = m._32;
+  transform.m33 = m._33;
+  transform.m34 = m._34;
+  transform.m41 = m._41;
+  transform.m42 = m._42;
+  transform.m43 = m._43;
+  transform.m44 = m._44;
+  return transform;
+}
+
+wr::BorderStyle ToBorderStyle(StyleBorderStyle style);
+
+static inline wr::BorderSide ToBorderSide(const gfx::DeviceColor& color,
+                                          StyleBorderStyle style) {
+  wr::BorderSide bs;
+  bs.color = ToColorF(color);
+  bs.style = ToBorderStyle(style);
+  return bs;
+}
+
+static inline wr::BorderRadius EmptyBorderRadius() {
+  wr::BorderRadius br;
+  PodZero(&br);
+  return br;
+}
+
+static inline wr::BorderRadius ToBorderRadius(
+    const LayoutDeviceSize& topLeft, const LayoutDeviceSize& topRight,
+    const LayoutDeviceSize& bottomLeft, const LayoutDeviceSize& bottomRight) {
+  wr::BorderRadius br;
+  br.top_left = ToLayoutSize(topLeft);
+  br.top_right = ToLayoutSize(topRight);
+  br.bottom_left = ToLayoutSize(bottomLeft);
+  br.bottom_right = ToLayoutSize(bottomRight);
+  return br;
+}
+
+static inline wr::BorderRadius ToBorderRadius(
+    const gfx::RectCornerRadii& aRadii) {
+  return ToBorderRadius(LayoutDeviceSize::FromUnknownSize(aRadii[0]),
+                        LayoutDeviceSize::FromUnknownSize(aRadii[1]),
+                        LayoutDeviceSize::FromUnknownSize(aRadii[3]),
+                        LayoutDeviceSize::FromUnknownSize(aRadii[2]));
+}
+
+static inline wr::ComplexClipRegion ToComplexClipRegion(
+    const nsRect& aRect, const nscoord* aRadii, int32_t aAppUnitsPerDevPixel) {
+  wr::ComplexClipRegion ret;
+  ret.rect =
+      ToLayoutRect(LayoutDeviceRect::FromAppUnits(aRect, aAppUnitsPerDevPixel));
+  ret.radii = ToBorderRadius(
+      LayoutDeviceSize::FromAppUnits(
+          nsSize(aRadii[eCornerTopLeftX], aRadii[eCornerTopLeftY]),
+          aAppUnitsPerDevPixel),
+      LayoutDeviceSize::FromAppUnits(
+          nsSize(aRadii[eCornerTopRightX], aRadii[eCornerTopRightY]),
+          aAppUnitsPerDevPixel),
+      LayoutDeviceSize::FromAppUnits(
+          nsSize(aRadii[eCornerBottomLeftX], aRadii[eCornerBottomLeftY]),
+          aAppUnitsPerDevPixel),
+      LayoutDeviceSize::FromAppUnits(
+          nsSize(aRadii[eCornerBottomRightX], aRadii[eCornerBottomRightY]),
+          aAppUnitsPerDevPixel));
+  ret.mode = ClipMode::Clip;
+  return ret;
+}
+
+static inline wr::LayoutSideOffsets ToBorderWidths(float top, float right,
+                                                   float bottom, float left) {
+  wr::LayoutSideOffsets bw;
+  bw.top = top;
+  bw.right = right;
+  bw.bottom = bottom;
+  bw.left = left;
+  return bw;
+}
+
+static inline wr::DeviceIntSideOffsets ToDeviceIntSideOffsets(int32_t top,
+                                                              int32_t right,
+                                                              int32_t bottom,
+                                                              int32_t left) {
+  wr::DeviceIntSideOffsets offset;
+  offset.top = top;
+  offset.right = right;
+  offset.bottom = bottom;
+  offset.left = left;
+  return offset;
+}
+
+static inline wr::LayoutSideOffsets ToLayoutSideOffsets(float top, float right,
+                                                        float bottom,
+                                                        float left) {
+  wr::LayoutSideOffsets offset;
+  offset.top = top;
+  offset.right = right;
+  offset.bottom = bottom;
+  offset.left = left;
+  return offset;
+}
+
+wr::RepeatMode ToRepeatMode(StyleBorderImageRepeat);
+
+template <class S, class T>
+static inline wr::WrTransformProperty ToWrTransformProperty(
+    uint64_t id, const gfx::Matrix4x4Typed<S, T>& transform) {
+  wr::WrTransformProperty prop;
+  prop.id = id;
+  prop.value = ToLayoutTransform(transform);
+  return prop;
+}
+
+static inline wr::WrOpacityProperty ToWrOpacityProperty(uint64_t id,
+                                                        const float opacity) {
+  wr::WrOpacityProperty prop;
+  prop.id = id;
+  prop.value = opacity;
+  return prop;
+}
+
+static inline wr::WrColorProperty ToWrColorProperty(
+    uint64_t id, const gfx::DeviceColor& color) {
+  wr::WrColorProperty prop;
+  prop.id = id;
+  prop.value = ToColorF(color);
+  return prop;
+}
+
+// Whenever possible, use wr::ExternalImageId instead of manipulating uint64_t.
+inline uint64_t AsUint64(const ExternalImageId& aId) {
+  return static_cast<uint64_t>(aId._0);
+}
+
+static inline ExternalImageId ToExternalImageId(uint64_t aID) {
+  ExternalImageId Id;
+  Id._0 = aID;
+  return Id;
+}
+
+static inline wr::WrExternalImage RawDataToWrExternalImage(const uint8_t* aBuff,
+                                                           size_t size) {
+  return wr::WrExternalImage{
+      wr::WrExternalImageType::RawData, 0, 0.0f, 0.0f, 0.0f, 0.0f, aBuff, size};
+}
+
+static inline wr::WrExternalImage NativeTextureToWrExternalImage(
+    uint32_t aHandle, float u0, float v0, float u1, float v1) {
+  return wr::WrExternalImage{wr::WrExternalImageType::NativeTexture,
+                             aHandle,
+                             u0,
+                             v0,
+                             u1,
+                             v1,
+                             nullptr,
+                             0};
+}
+
+static inline wr::WrExternalImage InvalidToWrExternalImage() {
+  return wr::WrExternalImage{
+      wr::WrExternalImageType::Invalid, 0, 0, 0, 0, 0, nullptr, 0};
+}
+
+inline wr::ByteSlice RangeToByteSlice(mozilla::Range<uint8_t> aRange) {
+  return wr::ByteSlice{aRange.begin().get(), aRange.length()};
+}
+
+inline mozilla::Range<const uint8_t> ByteSliceToRange(wr::ByteSlice aWrSlice) {
+  return mozilla::Range<const uint8_t>(aWrSlice.buffer, aWrSlice.len);
+}
+
+inline mozilla::Range<uint8_t> MutByteSliceToRange(wr::MutByteSlice aWrSlice) {
+  return mozilla::Range<uint8_t>(aWrSlice.buffer, aWrSlice.len);
+}
+
+void Assign_WrVecU8(wr::WrVecU8& aVec, mozilla::ipc::ByteBuf&& aOther);
+
+template <typename T>
+struct Vec;
+
+template <>
+struct Vec<uint8_t> final {
+  wr::WrVecU8 inner;
+  Vec() { SetEmpty(); }
+  Vec(Vec&) = delete;
+  Vec(Vec&& src) {
+    inner = src.inner;
+    src.SetEmpty();
+  }
+
+  explicit Vec(mozilla::ipc::ByteBuf&& aSrc) {
+    Assign_WrVecU8(inner, std::move(aSrc));
+  }
+
+  Vec& operator=(Vec&& src) {
+    inner = src.inner;
+    src.SetEmpty();
+    return *this;
+  }
+
+  wr::WrVecU8 Extract() {
+    wr::WrVecU8 ret = inner;
+    SetEmpty();
+    return ret;
+  }
+
+  void SetEmpty() {
+    inner.data = (uint8_t*)1;
+    inner.capacity = 0;
+    inner.length = 0;
+  }
+
+  uint8_t* Data() { return inner.data; }
+
+  size_t Length() { return inner.length; }
+
+  size_t Capacity() { return inner.capacity; }
+
+  Range<uint8_t> GetRange() { return Range<uint8_t>(Data(), Length()); }
+
+  void PushBytes(Range<uint8_t> aBytes) {
+    wr_vec_u8_push_bytes(&inner, RangeToByteSlice(aBytes));
+  }
+
+  void Reserve(size_t aLength) { wr_vec_u8_reserve(&inner, aLength); }
+
+  ~Vec() {
+    if (inner.data) {
+      wr_vec_u8_free(inner);
+    }
+  }
+};
+
+struct ByteBuffer {
+  ByteBuffer(size_t aLength, uint8_t* aData)
+      : mLength(aLength), mData(aData), mOwned(false) {}
+
+  // XXX: this is a bit of hack that assumes
+  // the allocators are the same
+  explicit ByteBuffer(VecU8&& vec) {
+    if (vec.inner.capacity) {
+      mLength = vec.inner.length;
+      mData = vec.inner.data;
+      vec.inner.data = nullptr;
+      vec.inner.capacity = 0;
+      mOwned = true;
+    } else {
+      mOwned = false;
+      mData = nullptr;
+      mLength = 0;
+    }
+  }
+
+  ByteBuffer(ByteBuffer&& aFrom)
+      : mLength(aFrom.mLength), mData(aFrom.mData), mOwned(aFrom.mOwned) {
+    aFrom.mLength = 0;
+    aFrom.mData = nullptr;
+    aFrom.mOwned = false;
+  }
+
+  ByteBuffer(ByteBuffer& aFrom)
+      : mLength(aFrom.mLength), mData(aFrom.mData), mOwned(aFrom.mOwned) {
+    aFrom.mLength = 0;
+    aFrom.mData = nullptr;
+    aFrom.mOwned = false;
+  }
+
+  ByteBuffer() : mLength(0), mData(nullptr), mOwned(false) {}
+
+  bool Allocate(size_t aLength) {
+    MOZ_ASSERT(mData == nullptr);
+    mData = (uint8_t*)malloc(aLength);
+    if (!mData) {
+      return false;
+    }
+    mLength = aLength;
+    mOwned = true;
+    return true;
+  }
+
+  ~ByteBuffer() {
+    if (mData && mOwned) {
+      free(mData);
+    }
+  }
+
+  const Range<uint8_t> AsSlice() const {
+    return Range<uint8_t>(mData, mLength);
+  }
+
+  Range<uint8_t> AsSlice() { return Range<uint8_t>(mData, mLength); }
+
+  bool operator==(const ByteBuffer& other) const {
+    return mLength == other.mLength && !(memcmp(mData, other.mData, mLength));
+  }
+
+  size_t mLength;
+  uint8_t* mData;
+  bool mOwned;
+};
+
+struct BuiltDisplayList {
+  wr::VecU8 dl_items;
+  wr::VecU8 dl_cache;
+  wr::VecU8 dl_spatial_tree;
+  wr::BuiltDisplayListDescriptor dl_desc;
+};
+
+// Corresponds to a clip id for a clip chain in webrender. Similar to
+// WrClipId but a separate struct so we don't get them mixed up in C++.
+struct WrClipChainId {
+  uint64_t id;
+
+  bool operator==(const WrClipChainId& other) const { return id == other.id; }
+
+  static WrClipChainId Empty() {
+    WrClipChainId id = {0};
+    return id;
+  }
+};
+
+WrSpatialId RootScrollNode();
+WrSpaceAndClipChain RootScrollNodeWithChain();
+WrSpaceAndClipChain InvalidScrollNodeWithChain();
+
+enum class WebRenderError : int8_t {
+  INITIALIZE = 0,
+  MAKE_CURRENT,
+  RENDER,
+  NEW_SURFACE,
+  BEGIN_DRAW,
+  VIDEO_OVERLAY,
+  VIDEO_HW_OVERLAY,
+  VIDEO_SW_OVERLAY,
+  EXCESSIVE_RESETS,
+
+  Sentinel /* this must be last for serialization purposes. */
+};
+
+static inline wr::WrYuvColorSpace ToWrYuvColorSpace(
+    gfx::YUVColorSpace aYUVColorSpace) {
+  switch (aYUVColorSpace) {
+    case gfx::YUVColorSpace::BT601:
+      return wr::WrYuvColorSpace::Rec601;
+    case gfx::YUVColorSpace::BT709:
+      return wr::WrYuvColorSpace::Rec709;
+    case gfx::YUVColorSpace::BT2020:
+      return wr::WrYuvColorSpace::Rec2020;
+    case gfx::YUVColorSpace::Identity:
+      return wr::WrYuvColorSpace::Identity;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Tried to convert invalid YUVColorSpace.");
+  }
+  return wr::WrYuvColorSpace::Rec601;
+}
+
+// TODO: Use YUVRangedColorSpace instead of assuming ColorRange::LIMITED.
+static inline wr::YuvRangedColorSpace ToWrYuvRangedColorSpace(
+    gfx::YUVRangedColorSpace aFrom) {
+  switch (aFrom) {
+    case gfx::YUVRangedColorSpace::BT601_Narrow:
+      return wr::YuvRangedColorSpace::Rec601Narrow;
+    case gfx::YUVRangedColorSpace::BT601_Full:
+      return wr::YuvRangedColorSpace::Rec601Full;
+    case gfx::YUVRangedColorSpace::BT709_Narrow:
+      return wr::YuvRangedColorSpace::Rec709Narrow;
+    case gfx::YUVRangedColorSpace::BT709_Full:
+      return wr::YuvRangedColorSpace::Rec709Full;
+    case gfx::YUVRangedColorSpace::BT2020_Narrow:
+      return wr::YuvRangedColorSpace::Rec2020Narrow;
+    case gfx::YUVRangedColorSpace::BT2020_Full:
+      return wr::YuvRangedColorSpace::Rec2020Full;
+    case gfx::YUVRangedColorSpace::GbrIdentity:
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Tried to convert invalid YUVColorSpace.");
+      break;
+  }
+  return wr::YuvRangedColorSpace::GbrIdentity;
+}
+
+static inline wr::WrColorDepth ToWrColorDepth(gfx::ColorDepth aColorDepth) {
+  switch (aColorDepth) {
+    case gfx::ColorDepth::COLOR_8:
+      return wr::WrColorDepth::Color8;
+    case gfx::ColorDepth::COLOR_10:
+      return wr::WrColorDepth::Color10;
+    case gfx::ColorDepth::COLOR_12:
+      return wr::WrColorDepth::Color12;
+    case gfx::ColorDepth::COLOR_16:
+      return wr::WrColorDepth::Color16;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Tried to convert invalid color depth value.");
+  }
+  return wr::WrColorDepth::Color8;
+}
+
+static inline wr::WrColorRange ToWrColorRange(gfx::ColorRange aColorRange) {
+  switch (aColorRange) {
+    case gfx::ColorRange::LIMITED:
+      return wr::WrColorRange::Limited;
+    case gfx::ColorRange::FULL:
+      return wr::WrColorRange::Full;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Tried to convert invalid color range value.");
+      return wr ::WrColorRange::Limited;
+  }
+}
+
+static inline wr::SyntheticItalics DegreesToSyntheticItalics(float aDegrees) {
+  wr::SyntheticItalics synthetic_italics;
+  synthetic_italics.angle =
+      int16_t(std::min(std::max(aDegrees, -89.0f), 89.0f) * 256.0f);
+  return synthetic_italics;
+}
+
+static inline wr::WindowSizeMode ToWrWindowSizeMode(nsSizeMode aSizeMode) {
+  switch (aSizeMode) {
+    case nsSizeMode_Normal:
+      return wr::WindowSizeMode::Normal;
+    case nsSizeMode_Minimized:
+      return wr::WindowSizeMode::Minimized;
+    case nsSizeMode_Maximized:
+      return wr::WindowSizeMode::Maximized;
+    case nsSizeMode_Fullscreen:
+      return wr::WindowSizeMode::Fullscreen;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Tried to convert invalid size mode.");
+      return wr::WindowSizeMode::Invalid;
+  }
+}
+
+static inline wr::APZScrollGeneration ToWrAPZScrollGeneration(
+    const mozilla::APZScrollGeneration& aGeneration) {
+  return wr::APZScrollGeneration(aGeneration.Raw());
+}
+
+static inline wr::HasScrollLinkedEffect ToWrHasScrollLinkedEffect(
+    bool aHasScrollLinkedEffect) {
+  return aHasScrollLinkedEffect ? wr::HasScrollLinkedEffect::Yes
+                                : wr::HasScrollLinkedEffect::No;
+}
+
+enum class ExternalImageSource : uint8_t { Unknown = 0, SharedSurfaces, Last };
+
+}  // namespace wr
+}  // namespace mozilla
+
+namespace std {
+template <>
+struct hash<mozilla::wr::WrSpatialId> {
+  std::size_t operator()(mozilla::wr::WrSpatialId const& aKey) const noexcept {
+    return std::hash<size_t>{}(aKey.id);
+  }
+};
+}  // namespace std
+
+#endif /* GFX_WEBRENDERTYPES_H */
diff --git a/gfx/webrender_bindings/cbindgen.toml b/gfx/webrender_bindings/cbindgen.toml
new file mode 100644
index 0000000000..c11ddebe41
--- /dev/null
+++ b/gfx/webrender_bindings/cbindgen.toml
@@ -0,0 +1,55 @@
+header = """/* 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/. */"""
+autogen_warning = """/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.
+ * To generate this file:
+ *   1. Get the latest cbindgen using `cargo install --force cbindgen`
+ *      a. Alternatively, you can clone `https://github.com/eqrion/cbindgen` and use a tagged release
+ *   2. Run `rustup run nightly cbindgen toolkit/library/rust/ --lockfile Cargo.lock --crate webrender_bindings -o gfx/webrender_bindings/webrender_ffi_generated.h`
+ */"""
+include_version = true
+braces = "SameLine"
+line_length = 100
+tab_width = 2
+language = "C++"
+namespaces = ["mozilla", "wr"]
+
+[export]
+item_types = ["globals", "enums", "structs", "unions", "typedefs", "opaque", "functions", "constants"]
+include = ["POLYGON_CLIP_VERTEX_MAX"]
+
+[parse]
+parse_deps = true
+extra_bindings = ["webrender_api"]
+include = ["log", "euclid", "webrender", "webrender_api"]
+
+[fn]
+args = "Vertical"
+rename_args = "GeckoCase"
+
+[struct]
+associated_constants_in_body = true
+derive_eq = true
+derive_ostream = true
+
+[enum]
+add_sentinel = true
+derive_helper_methods = true
+derive_ostream = true
+
+[macro_expansion]
+bitflags = true
+
+[defines]
+"target_os = windows" = "XP_WIN"
+"target_os = macos" = "XP_MACOSX"
+"target_os = android" = "ANDROID"
+
+[export.rename]
+"ThinVec" = "nsTArray"
+
+[export.body]
+"Box2D" = """
+  inline T width() const { return max.x - min.x; }
+  inline T height() const { return max.y - min.y; }
+"""
diff --git a/gfx/webrender_bindings/moz.build b/gfx/webrender_bindings/moz.build
new file mode 100644
index 0000000000..f17c77e4cb
--- /dev/null
+++ b/gfx/webrender_bindings/moz.build
@@ -0,0 +1,137 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "Graphics: WebRender")
+
+EXPORTS.mozilla.webrender += [
+    "RenderBufferTextureHost.h",
+    "RenderCompositor.h",
+    "RenderCompositorEGL.h",
+    "RenderCompositorLayersSWGL.h",
+    "RenderCompositorOGL.h",
+    "RenderCompositorOGLSWGL.h",
+    "RenderCompositorSWGL.h",
+    "RenderEGLImageTextureHost.h",
+    "RendererOGL.h",
+    "RendererScreenshotGrabber.h",
+    "RenderExternalTextureHost.h",
+    "RenderSharedSurfaceTextureHost.h",
+    "RenderTextureHost.h",
+    "RenderTextureHostSWGL.h",
+    "RenderTextureHostWrapper.h",
+    "RenderThread.h",
+    "webrender_ffi.h",
+    "WebRenderAPI.h",
+    "WebRenderTypes.h",
+]
+
+UNIFIED_SOURCES += [
+    "Moz2DImageRenderer.cpp",
+    "RenderBufferTextureHost.cpp",
+    "RenderCompositor.cpp",
+    "RenderCompositorEGL.cpp",
+    "RenderCompositorLayersSWGL.cpp",
+    "RenderCompositorOGL.cpp",
+    "RenderCompositorOGLSWGL.cpp",
+    "RenderCompositorSWGL.cpp",
+    "RenderEGLImageTextureHost.cpp",
+    "RendererOGL.cpp",
+    "RendererScreenshotGrabber.cpp",
+    "RenderExternalTextureHost.cpp",
+    "RenderSharedSurfaceTextureHost.cpp",
+    "RenderTextureHost.cpp",
+    "RenderTextureHostSWGL.cpp",
+    "RenderTextureHostWrapper.cpp",
+    "RenderThread.cpp",
+    "WebRenderAPI.cpp",
+    "WebRenderTypes.cpp",
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "cocoa":
+    EXPORTS.mozilla.webrender += [
+        "RenderCompositorNative.h",
+        "RenderMacIOSurfaceTextureHost.h",
+    ]
+    UNIFIED_SOURCES += [
+        "RenderCompositorNative.cpp",
+        "RenderMacIOSurfaceTextureHost.cpp",
+    ]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+    EXPORTS.mozilla.webrender += [
+        "RenderAndroidHardwareBufferTextureHost.h",
+        "RenderAndroidSurfaceTextureHost.h",
+    ]
+    UNIFIED_SOURCES += [
+        "RenderAndroidHardwareBufferTextureHost.cpp",
+        "RenderAndroidSurfaceTextureHost.cpp",
+    ]
+
+if CONFIG["MOZ_ENABLE_D3D10_LAYER"]:
+    DEFINES["MOZ_ENABLE_D3D10_LAYER"] = True
+    EXPORTS.mozilla.webrender += [
+        "DCLayerTree.h",
+        "RenderCompositorANGLE.h",
+        "RenderCompositorD3D11SWGL.h",
+        "RenderD3D11TextureHost.h",
+        "RenderDcompSurfaceTextureHost.h",
+    ]
+    UNIFIED_SOURCES += [
+        "DCLayerTree.cpp",
+        "RenderCompositorANGLE.cpp",
+        "RenderCompositorD3D11SWGL.cpp",
+        "RenderD3D11TextureHost.cpp",
+    ]
+    SOURCES += [
+        "RenderDcompSurfaceTextureHost.cpp",
+    ]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk":
+    EXPORTS.mozilla.webrender += [
+        "RenderDMABUFTextureHost.h",
+    ]
+    SOURCES += [
+        "RenderDMABUFTextureHost.cpp",
+    ]
+
+if CONFIG["MOZ_WAYLAND"]:
+    EXPORTS.mozilla.webrender += [
+        "RenderCompositorNative.h",
+    ]
+    SOURCES += [
+        "RenderCompositorNative.cpp",
+    ]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] in ("android", "gtk"):
+    CXXFLAGS += CONFIG["CAIRO_FT_CFLAGS"]
+
+if CONFIG["COMPILE_ENVIRONMENT"]:
+    EXPORTS.mozilla.webrender += [
+        "!webrender_ffi_generated.h",
+    ]
+
+    CbindgenHeader(
+        "webrender_ffi_generated.h",
+        inputs=[
+            "/gfx/webrender_bindings",
+            "/gfx/wr/webrender",
+            "/gfx/wr/webrender_api",
+        ],
+    )
+
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
+
+LOCAL_INCLUDES += [
+    "/gfx/cairo/cairo/src",
+]
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk":
+    CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+
+CXXFLAGS += ["-Werror=switch"]
diff --git a/gfx/webrender_bindings/rustfmt.toml b/gfx/webrender_bindings/rustfmt.toml
new file mode 100644
index 0000000000..1d15550e6c
--- /dev/null
+++ b/gfx/webrender_bindings/rustfmt.toml
@@ -0,0 +1,16 @@
+ideal_width = 80
+max_width = 120
+
+newline_style = "Unix"
+normalize_comments = false
+
+force_explicit_abi = true
+fn_args_density = "Vertical"
+
+chain_indent = "Visual"
+chain_one_line_max = 90
+
+struct_lit_multiline_style = "ForceMulti"
+
+match_block_trailing_comma = true
+where_trailing_comma = true
diff --git a/gfx/webrender_bindings/src/bindings.rs b/gfx/webrender_bindings/src/bindings.rs
new file mode 100644
index 0000000000..1f3bca644a
--- /dev/null
+++ b/gfx/webrender_bindings/src/bindings.rs
@@ -0,0 +1,4046 @@
+/* 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/. */
+
+#![allow(clippy::missing_safety_doc)]
+#![allow(clippy::not_unsafe_ptr_arg_deref)]
+
+use gleam::gl;
+use std::cell::RefCell;
+#[cfg(not(target_os = "macos"))]
+use std::ffi::OsString;
+use std::ffi::{CStr, CString};
+use std::io::Cursor;
+use std::marker::PhantomData;
+use std::ops::Range;
+#[cfg(target_os = "android")]
+use std::os::raw::c_int;
+use std::os::raw::{c_char, c_float, c_void};
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+use std::os::unix::ffi::OsStringExt;
+#[cfg(target_os = "windows")]
+use std::os::windows::ffi::OsStringExt;
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+use std::{env, mem, ptr, slice};
+use thin_vec::ThinVec;
+
+use euclid::SideOffsets2D;
+use moz2d_renderer::Moz2dBlobImageHandler;
+use nsstring::nsAString;
+use num_cpus;
+use program_cache::{remove_disk_cache, WrProgramCache};
+use rayon;
+use tracy_rs::register_thread_with_profiler;
+use webrender::sw_compositor::SwCompositor;
+use webrender::{
+    api::units::*, api::*, create_webrender_instance, render_api::*, set_profiler_hooks, AsyncPropertySampler,
+    AsyncScreenshotHandle, Compositor, CompositorCapabilities, CompositorConfig, CompositorSurfaceTransform,
+    DebugFlags, Device, MappableCompositor, MappedTileInfo, NativeSurfaceId, NativeSurfaceInfo, NativeTileId,
+    PartialPresentCompositor, PipelineInfo, ProfilerHooks, RecordedFrameHandle, Renderer, RendererStats,
+    SWGLCompositeSurfaceInfo, SceneBuilderHooks, ShaderPrecacheFlags, Shaders, SharedShaders, TextureCacheConfig,
+    UploadMethod, WebRenderOptions, WindowVisibility, ONE_TIME_USAGE_HINT,
+};
+use wr_malloc_size_of::MallocSizeOfOps;
+
+extern "C" {
+    #[cfg(target_os = "android")]
+    fn __android_log_write(prio: c_int, tag: *const c_char, text: *const c_char) -> c_int;
+}
+
+/// The unique id for WR resource identification.
+static NEXT_NAMESPACE_ID: AtomicUsize = AtomicUsize::new(1);
+
+/// Special value handled in this wrapper layer to signify a redundant clip chain.
+pub const ROOT_CLIP_CHAIN: u64 = !0;
+
+fn next_namespace_id() -> IdNamespace {
+    IdNamespace(NEXT_NAMESPACE_ID.fetch_add(1, Ordering::Relaxed) as u32)
+}
+
+/// Whether a border should be antialiased.
+#[repr(C)]
+#[derive(Eq, PartialEq, Copy, Clone)]
+pub enum AntialiasBorder {
+    No = 0,
+    Yes,
+}
+
+/// Used to indicate if an image is opaque, or has an alpha channel.
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum OpacityType {
+    Opaque = 0,
+    HasAlphaChannel = 1,
+}
+
+/// cbindgen:field-names=[mHandle]
+/// cbindgen:derive-lt=true
+/// cbindgen:derive-lte=true
+/// cbindgen:derive-neq=true
+type WrEpoch = Epoch;
+/// cbindgen:field-names=[mHandle]
+/// cbindgen:derive-lt=true
+/// cbindgen:derive-lte=true
+/// cbindgen:derive-neq=true
+pub type WrIdNamespace = IdNamespace;
+
+/// cbindgen:field-names=[mNamespace, mHandle]
+type WrDocumentId = DocumentId;
+/// cbindgen:field-names=[mNamespace, mHandle]
+type WrPipelineId = PipelineId;
+/// cbindgen:field-names=[mNamespace, mHandle]
+/// cbindgen:derive-neq=true
+type WrImageKey = ImageKey;
+/// cbindgen:field-names=[mNamespace, mHandle]
+pub type WrFontKey = FontKey;
+/// cbindgen:field-names=[mNamespace, mHandle]
+pub type WrFontInstanceKey = FontInstanceKey;
+/// cbindgen:field-names=[mNamespace, mHandle]
+type WrYuvColorSpace = YuvColorSpace;
+/// cbindgen:field-names=[mNamespace, mHandle]
+type WrColorDepth = ColorDepth;
+/// cbindgen:field-names=[mNamespace, mHandle]
+type WrColorRange = ColorRange;
+
+#[inline]
+fn clip_chain_id_to_webrender(id: u64, pipeline_id: WrPipelineId) -> ClipChainId {
+    if id == ROOT_CLIP_CHAIN {
+        ClipChainId::INVALID
+    } else {
+        ClipChainId(id, pipeline_id)
+    }
+}
+
+#[repr(C)]
+pub struct WrSpaceAndClipChain {
+    space: WrSpatialId,
+    clip_chain: u64,
+}
+
+impl WrSpaceAndClipChain {
+    fn to_webrender(&self, pipeline_id: WrPipelineId) -> SpaceAndClipInfo {
+        //Warning: special case here to support dummy clip chain
+        SpaceAndClipInfo {
+            spatial_id: self.space.to_webrender(pipeline_id),
+            clip_chain_id: clip_chain_id_to_webrender(self.clip_chain, pipeline_id),
+        }
+    }
+}
+
+#[repr(C)]
+pub enum WrStackingContextClip {
+    None,
+    ClipChain(u64),
+}
+
+impl WrStackingContextClip {
+    fn to_webrender(&self, pipeline_id: WrPipelineId) -> Option<ClipChainId> {
+        match *self {
+            WrStackingContextClip::None => None,
+            WrStackingContextClip::ClipChain(id) => {
+                if id == ROOT_CLIP_CHAIN {
+                    None
+                } else {
+                    Some(ClipChainId(id, pipeline_id))
+                }
+            },
+        }
+    }
+}
+
+unsafe fn make_slice<'a, T>(ptr: *const T, len: usize) -> &'a [T] {
+    if ptr.is_null() {
+        &[]
+    } else {
+        slice::from_raw_parts(ptr, len)
+    }
+}
+
+unsafe fn make_slice_mut<'a, T>(ptr: *mut T, len: usize) -> &'a mut [T] {
+    if ptr.is_null() {
+        &mut []
+    } else {
+        slice::from_raw_parts_mut(ptr, len)
+    }
+}
+
+pub struct DocumentHandle {
+    api: RenderApi,
+    document_id: DocumentId,
+    // One of the two options below is Some and the other None at all times.
+    // It would be nice to model with an enum, however it is tricky to express
+    // moving a variant's content into another variant without moving the
+    // containing enum.
+    hit_tester_request: Option<HitTesterRequest>,
+    hit_tester: Option<Arc<dyn ApiHitTester>>,
+}
+
+impl DocumentHandle {
+    pub fn new(
+        api: RenderApi,
+        hit_tester: Option<Arc<dyn ApiHitTester>>,
+        size: DeviceIntSize,
+        id: u32,
+    ) -> DocumentHandle {
+        let doc = api.add_document_with_id(size, id);
+        let hit_tester_request = if hit_tester.is_none() {
+            // Request the hit tester early to reduce the likelihood of blocking on the
+            // first hit testing query.
+            Some(api.request_hit_tester(doc))
+        } else {
+            None
+        };
+
+        DocumentHandle {
+            api,
+            document_id: doc,
+            hit_tester_request,
+            hit_tester,
+        }
+    }
+
+    fn ensure_hit_tester(&mut self) -> &Arc<dyn ApiHitTester> {
+        if let Some(ref ht) = self.hit_tester {
+            return ht;
+        }
+        self.hit_tester = Some(self.hit_tester_request.take().unwrap().resolve());
+        self.hit_tester.as_ref().unwrap()
+    }
+}
+
+#[repr(C)]
+pub struct WrVecU8 {
+    data: *mut u8,
+    length: usize,
+    capacity: usize,
+}
+
+impl WrVecU8 {
+    fn into_vec(self) -> Vec<u8> {
+        unsafe { Vec::from_raw_parts(self.data, self.length, self.capacity) }
+    }
+
+    // Equivalent to `into_vec` but clears self instead of consuming the value.
+    fn flush_into_vec(&mut self) -> Vec<u8> {
+        self.convert_into_vec::<u8>()
+    }
+
+    // Like flush_into_vec, but also does an unsafe conversion to the desired type.
+    fn convert_into_vec<T>(&mut self) -> Vec<T> {
+        let vec = unsafe {
+            Vec::from_raw_parts(
+                self.data as *mut T,
+                self.length / mem::size_of::<T>(),
+                self.capacity / mem::size_of::<T>(),
+            )
+        };
+        self.data = ptr::null_mut();
+        self.length = 0;
+        self.capacity = 0;
+        vec
+    }
+
+    fn from_vec(mut v: Vec<u8>) -> WrVecU8 {
+        let w = WrVecU8 {
+            data: v.as_mut_ptr(),
+            length: v.len(),
+            capacity: v.capacity(),
+        };
+        mem::forget(v);
+        w
+    }
+
+    fn reserve(&mut self, len: usize) {
+        let mut vec = self.flush_into_vec();
+        vec.reserve(len);
+        *self = Self::from_vec(vec);
+    }
+
+    fn push_bytes(&mut self, bytes: &[u8]) {
+        let mut vec = self.flush_into_vec();
+        vec.extend_from_slice(bytes);
+        *self = Self::from_vec(vec);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_vec_u8_push_bytes(v: &mut WrVecU8, bytes: ByteSlice) {
+    v.push_bytes(bytes.as_slice());
+}
+
+#[no_mangle]
+pub extern "C" fn wr_vec_u8_reserve(v: &mut WrVecU8, len: usize) {
+    v.reserve(len);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_vec_u8_free(v: WrVecU8) {
+    v.into_vec();
+}
+
+#[repr(C)]
+pub struct ByteSlice<'a> {
+    buffer: *const u8,
+    len: usize,
+    _phantom: PhantomData<&'a ()>,
+}
+
+impl<'a> ByteSlice<'a> {
+    pub fn new(slice: &'a [u8]) -> ByteSlice<'a> {
+        ByteSlice {
+            buffer: slice.as_ptr(),
+            len: slice.len(),
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn as_slice(&self) -> &'a [u8] {
+        unsafe { make_slice(self.buffer, self.len) }
+    }
+}
+
+#[repr(C)]
+pub struct MutByteSlice<'a> {
+    buffer: *mut u8,
+    len: usize,
+    _phantom: PhantomData<&'a ()>,
+}
+
+impl<'a> MutByteSlice<'a> {
+    pub fn new(slice: &'a mut [u8]) -> MutByteSlice<'a> {
+        let len = slice.len();
+        MutByteSlice {
+            buffer: slice.as_mut_ptr(),
+            len,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn as_mut_slice(&mut self) -> &'a mut [u8] {
+        unsafe { make_slice_mut(self.buffer, self.len) }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct WrImageDescriptor {
+    pub format: ImageFormat,
+    pub width: i32,
+    pub height: i32,
+    pub stride: i32,
+    pub opacity: OpacityType,
+    // TODO(gw): Remove this flag (use prim flags instead).
+    pub prefer_compositor_surface: bool,
+}
+
+impl<'a> From<&'a WrImageDescriptor> for ImageDescriptor {
+    fn from(desc: &'a WrImageDescriptor) -> ImageDescriptor {
+        let mut flags = ImageDescriptorFlags::empty();
+
+        if desc.opacity == OpacityType::Opaque {
+            flags |= ImageDescriptorFlags::IS_OPAQUE;
+        }
+
+        ImageDescriptor {
+            size: DeviceIntSize::new(desc.width, desc.height),
+            stride: if desc.stride != 0 { Some(desc.stride) } else { None },
+            format: desc.format,
+            offset: 0,
+            flags,
+        }
+    }
+}
+
+#[repr(u32)]
+#[allow(dead_code)]
+enum WrExternalImageType {
+    RawData,
+    NativeTexture,
+    Invalid,
+}
+
+#[repr(C)]
+struct WrExternalImage {
+    image_type: WrExternalImageType,
+
+    // external texture handle
+    handle: u32,
+    // external texture coordinate
+    u0: f32,
+    v0: f32,
+    u1: f32,
+    v1: f32,
+
+    // external image buffer
+    buff: *const u8,
+    size: usize,
+}
+
+extern "C" {
+    fn wr_renderer_lock_external_image(
+        renderer: *mut c_void,
+        external_image_id: ExternalImageId,
+        channel_index: u8,
+    ) -> WrExternalImage;
+    fn wr_renderer_unlock_external_image(renderer: *mut c_void, external_image_id: ExternalImageId, channel_index: u8);
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct WrExternalImageHandler {
+    external_image_obj: *mut c_void,
+}
+
+impl ExternalImageHandler for WrExternalImageHandler {
+    fn lock(&mut self, id: ExternalImageId, channel_index: u8) -> ExternalImage {
+        let image = unsafe { wr_renderer_lock_external_image(self.external_image_obj, id, channel_index) };
+        ExternalImage {
+            uv: TexelRect::new(image.u0, image.v0, image.u1, image.v1),
+            source: match image.image_type {
+                WrExternalImageType::NativeTexture => ExternalImageSource::NativeTexture(image.handle),
+                WrExternalImageType::RawData => {
+                    ExternalImageSource::RawData(unsafe { make_slice(image.buff, image.size) })
+                },
+                WrExternalImageType::Invalid => ExternalImageSource::Invalid,
+            },
+        }
+    }
+
+    fn unlock(&mut self, id: ExternalImageId, channel_index: u8) {
+        unsafe {
+            wr_renderer_unlock_external_image(self.external_image_obj, id, channel_index);
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+// Used for ComponentTransfer only
+pub struct WrFilterData {
+    funcR_type: ComponentTransferFuncType,
+    R_values: *mut c_float,
+    R_values_count: usize,
+    funcG_type: ComponentTransferFuncType,
+    G_values: *mut c_float,
+    G_values_count: usize,
+    funcB_type: ComponentTransferFuncType,
+    B_values: *mut c_float,
+    B_values_count: usize,
+    funcA_type: ComponentTransferFuncType,
+    A_values: *mut c_float,
+    A_values_count: usize,
+}
+
+#[repr(u32)]
+#[derive(Debug)]
+pub enum WrAnimationType {
+    Transform = 0,
+    Opacity = 1,
+    BackgroundColor = 2,
+}
+
+#[repr(C)]
+pub struct WrAnimationProperty {
+    effect_type: WrAnimationType,
+    id: u64,
+    key: SpatialTreeItemKey,
+}
+
+/// cbindgen:derive-eq=false
+#[repr(C)]
+#[derive(Debug)]
+pub struct WrAnimationPropertyValue<T> {
+    pub id: u64,
+    pub value: T,
+}
+
+pub type WrTransformProperty = WrAnimationPropertyValue<LayoutTransform>;
+pub type WrOpacityProperty = WrAnimationPropertyValue<f32>;
+pub type WrColorProperty = WrAnimationPropertyValue<ColorF>;
+
+/// cbindgen:field-names=[mHandle]
+/// cbindgen:derive-lt=true
+/// cbindgen:derive-lte=true
+#[repr(C)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct WrWindowId(u64);
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct WrComputedTransformData {
+    pub scale_from: LayoutSize,
+    pub vertical_flip: bool,
+    pub rotation: WrRotation,
+    pub key: SpatialTreeItemKey,
+}
+
+#[repr(C)]
+pub struct WrTransformInfo {
+    pub transform: LayoutTransform,
+    pub key: SpatialTreeItemKey,
+}
+
+fn get_proc_address(glcontext_ptr: *mut c_void, name: &str) -> *const c_void {
+    extern "C" {
+        fn get_proc_address_from_glcontext(glcontext_ptr: *mut c_void, procname: *const c_char) -> *const c_void;
+    }
+
+    let symbol_name = CString::new(name).unwrap();
+    let symbol = unsafe { get_proc_address_from_glcontext(glcontext_ptr, symbol_name.as_ptr()) };
+    symbol as *const _
+}
+
+#[repr(C)]
+pub enum TelemetryProbe {
+    SceneBuildTime = 0,
+    SceneSwapTime = 1,
+    FrameBuildTime = 2,
+}
+
+extern "C" {
+    fn is_in_compositor_thread() -> bool;
+    fn is_in_render_thread() -> bool;
+    fn is_in_main_thread() -> bool;
+    fn is_glcontext_gles(glcontext_ptr: *mut c_void) -> bool;
+    fn is_glcontext_angle(glcontext_ptr: *mut c_void) -> bool;
+    fn gfx_wr_resource_path_override() -> *const c_char;
+    fn gfx_wr_use_optimized_shaders() -> bool;
+    // TODO: make gfx_critical_error() work.
+    // We still have problem to pass the error message from render/render_backend
+    // thread to main thread now.
+    #[allow(dead_code)]
+    fn gfx_critical_error(msg: *const c_char);
+    fn gfx_critical_note(msg: *const c_char);
+    fn gfx_wr_set_crash_annotation(annotation: CrashAnnotation, value: *const c_char);
+    fn gfx_wr_clear_crash_annotation(annotation: CrashAnnotation);
+}
+
+struct CppNotifier {
+    window_id: WrWindowId,
+}
+
+unsafe impl Send for CppNotifier {}
+
+extern "C" {
+    fn wr_notifier_wake_up(window_id: WrWindowId, composite_needed: bool);
+    fn wr_notifier_new_frame_ready(window_id: WrWindowId, composite_needed: bool, publish_id: FramePublishId);
+    fn wr_notifier_external_event(window_id: WrWindowId, raw_event: usize);
+    fn wr_schedule_render(window_id: WrWindowId, reasons: RenderReasons);
+    // NOTE: This moves away from pipeline_info.
+    fn wr_finished_scene_build(window_id: WrWindowId, pipeline_info: &mut WrPipelineInfo);
+
+    fn wr_transaction_notification_notified(handler: usize, when: Checkpoint);
+}
+
+impl RenderNotifier for CppNotifier {
+    fn clone(&self) -> Box<dyn RenderNotifier> {
+        Box::new(CppNotifier {
+            window_id: self.window_id,
+        })
+    }
+
+    fn wake_up(&self, composite_needed: bool) {
+        unsafe {
+            wr_notifier_wake_up(self.window_id, composite_needed);
+        }
+    }
+
+    fn new_frame_ready(&self, _: DocumentId, _scrolled: bool, composite_needed: bool, publish_id: FramePublishId) {
+        unsafe {
+            wr_notifier_new_frame_ready(self.window_id, composite_needed, publish_id);
+        }
+    }
+
+    fn external_event(&self, event: ExternalEvent) {
+        unsafe {
+            wr_notifier_external_event(self.window_id, event.unwrap());
+        }
+    }
+}
+
+struct MozCrashAnnotator;
+
+unsafe impl Send for MozCrashAnnotator {}
+
+impl CrashAnnotator for MozCrashAnnotator {
+    fn set(&self, annotation: CrashAnnotation, value: &std::ffi::CStr) {
+        unsafe {
+            gfx_wr_set_crash_annotation(annotation, value.as_ptr());
+        }
+    }
+
+    fn clear(&self, annotation: CrashAnnotation) {
+        unsafe {
+            gfx_wr_clear_crash_annotation(annotation);
+        }
+    }
+
+    fn box_clone(&self) -> Box<dyn CrashAnnotator> {
+        Box::new(MozCrashAnnotator)
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_set_clear_color(renderer: &mut Renderer, color: ColorF) {
+    renderer.set_clear_color(color);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_set_external_image_handler(
+    renderer: &mut Renderer,
+    external_image_handler: &mut WrExternalImageHandler,
+) {
+    renderer.set_external_image_handler(Box::new(*external_image_handler));
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_update(renderer: &mut Renderer) {
+    renderer.update();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_set_target_frame_publish_id(renderer: &mut Renderer, publish_id: FramePublishId) {
+    renderer.set_target_frame_publish_id(publish_id);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_render(
+    renderer: &mut Renderer,
+    width: i32,
+    height: i32,
+    buffer_age: usize,
+    out_stats: &mut RendererStats,
+    out_dirty_rects: &mut ThinVec<DeviceIntRect>,
+) -> bool {
+    match renderer.render(DeviceIntSize::new(width, height), buffer_age) {
+        Ok(results) => {
+            *out_stats = results.stats;
+            out_dirty_rects.extend(results.dirty_rects);
+            true
+        },
+        Err(errors) => {
+            for e in errors {
+                warn!(" Failed to render: {:?}", e);
+                let msg = CString::new(format!("wr_renderer_render: {:?}", e)).unwrap();
+                unsafe {
+                    gfx_critical_note(msg.as_ptr());
+                }
+            }
+            false
+        },
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_force_redraw(renderer: &mut Renderer) {
+    renderer.force_redraw();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_record_frame(
+    renderer: &mut Renderer,
+    image_format: ImageFormat,
+    out_handle: &mut RecordedFrameHandle,
+    out_width: &mut i32,
+    out_height: &mut i32,
+) -> bool {
+    if let Some((handle, size)) = renderer.record_frame(image_format) {
+        *out_handle = handle;
+        *out_width = size.width;
+        *out_height = size.height;
+
+        true
+    } else {
+        false
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_map_recorded_frame(
+    renderer: &mut Renderer,
+    handle: RecordedFrameHandle,
+    dst_buffer: *mut u8,
+    dst_buffer_len: usize,
+    dst_stride: usize,
+) -> bool {
+    renderer.map_recorded_frame(
+        handle,
+        unsafe { make_slice_mut(dst_buffer, dst_buffer_len) },
+        dst_stride,
+    )
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_release_composition_recorder_structures(renderer: &mut Renderer) {
+    renderer.release_composition_recorder_structures();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_get_screenshot_async(
+    renderer: &mut Renderer,
+    window_x: i32,
+    window_y: i32,
+    window_width: i32,
+    window_height: i32,
+    buffer_width: i32,
+    buffer_height: i32,
+    image_format: ImageFormat,
+    screenshot_width: *mut i32,
+    screenshot_height: *mut i32,
+) -> AsyncScreenshotHandle {
+    assert!(!screenshot_width.is_null());
+    assert!(!screenshot_height.is_null());
+
+    let (handle, size) = renderer.get_screenshot_async(
+        DeviceIntRect::from_origin_and_size(
+            DeviceIntPoint::new(window_x, window_y),
+            DeviceIntSize::new(window_width, window_height),
+        ),
+        DeviceIntSize::new(buffer_width, buffer_height),
+        image_format,
+    );
+
+    unsafe {
+        *screenshot_width = size.width;
+        *screenshot_height = size.height;
+    }
+
+    handle
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_map_and_recycle_screenshot(
+    renderer: &mut Renderer,
+    handle: AsyncScreenshotHandle,
+    dst_buffer: *mut u8,
+    dst_buffer_len: usize,
+    dst_stride: usize,
+) -> bool {
+    renderer.map_and_recycle_screenshot(
+        handle,
+        unsafe { make_slice_mut(dst_buffer, dst_buffer_len) },
+        dst_stride,
+    )
+}
+
+#[no_mangle]
+pub extern "C" fn wr_renderer_release_profiler_structures(renderer: &mut Renderer) {
+    renderer.release_profiler_structures();
+}
+
+// Call wr_renderer_render() before calling this function.
+#[no_mangle]
+pub unsafe extern "C" fn wr_renderer_readback(
+    renderer: &mut Renderer,
+    width: i32,
+    height: i32,
+    format: ImageFormat,
+    dst_buffer: *mut u8,
+    buffer_size: usize,
+) {
+    assert!(is_in_render_thread());
+
+    let mut slice = make_slice_mut(dst_buffer, buffer_size);
+    renderer.read_pixels_into(FramebufferIntSize::new(width, height).into(), format, &mut slice);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_renderer_set_profiler_ui(renderer: &mut Renderer, ui_str: *const u8, ui_str_len: usize) {
+    let slice = std::slice::from_raw_parts(ui_str, ui_str_len);
+    if let Ok(ui_str) = std::str::from_utf8(slice) {
+        renderer.set_profiler_ui(ui_str);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_renderer_delete(renderer: *mut Renderer) {
+    let renderer = Box::from_raw(renderer);
+    renderer.deinit();
+    // let renderer go out of scope and get dropped
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_renderer_accumulate_memory_report(
+    renderer: &mut Renderer,
+    report: &mut MemoryReport,
+    swgl: *mut c_void,
+) {
+    *report += renderer.report_memory(swgl);
+}
+
+// cbindgen doesn't support tuples, so we have a little struct instead, with
+// an Into implementation to convert from the tuple to the struct.
+#[repr(C)]
+pub struct WrPipelineEpoch {
+    pipeline_id: WrPipelineId,
+    document_id: WrDocumentId,
+    epoch: WrEpoch,
+}
+
+impl<'a> From<(&'a (WrPipelineId, WrDocumentId), &'a WrEpoch)> for WrPipelineEpoch {
+    fn from(tuple: (&(WrPipelineId, WrDocumentId), &WrEpoch)) -> WrPipelineEpoch {
+        WrPipelineEpoch {
+            pipeline_id: (tuple.0).0,
+            document_id: (tuple.0).1,
+            epoch: *tuple.1,
+        }
+    }
+}
+
+#[repr(C)]
+pub struct WrPipelineIdAndEpoch {
+    pipeline_id: WrPipelineId,
+    epoch: WrEpoch,
+}
+
+impl<'a> From<(&WrPipelineId, &WrEpoch)> for WrPipelineIdAndEpoch {
+    fn from(tuple: (&WrPipelineId, &WrEpoch)) -> WrPipelineIdAndEpoch {
+        WrPipelineIdAndEpoch {
+            pipeline_id: *tuple.0,
+            epoch: *tuple.1,
+        }
+    }
+}
+
+#[repr(C)]
+pub struct WrRemovedPipeline {
+    pipeline_id: WrPipelineId,
+    document_id: WrDocumentId,
+}
+
+impl<'a> From<&'a (WrPipelineId, WrDocumentId)> for WrRemovedPipeline {
+    fn from(tuple: &(WrPipelineId, WrDocumentId)) -> WrRemovedPipeline {
+        WrRemovedPipeline {
+            pipeline_id: tuple.0,
+            document_id: tuple.1,
+        }
+    }
+}
+
+#[repr(C)]
+pub struct WrPipelineInfo {
+    /// This contains an entry for each pipeline that was rendered, along with
+    /// the epoch at which it was rendered. Rendered pipelines include the root
+    /// pipeline and any other pipelines that were reachable via IFrame display
+    /// items from the root pipeline.
+    epochs: ThinVec<WrPipelineEpoch>,
+    /// This contains an entry for each pipeline that was removed during the
+    /// last transaction. These pipelines would have been explicitly removed by
+    /// calling remove_pipeline on the transaction object; the pipeline showing
+    /// up in this array means that the data structures have been torn down on
+    /// the webrender side, and so any remaining data structures on the caller
+    /// side can now be torn down also.
+    removed_pipelines: ThinVec<WrRemovedPipeline>,
+}
+
+impl WrPipelineInfo {
+    fn new(info: &PipelineInfo) -> Self {
+        WrPipelineInfo {
+            epochs: info.epochs.iter().map(WrPipelineEpoch::from).collect(),
+            removed_pipelines: info.removed_pipelines.iter().map(WrRemovedPipeline::from).collect(),
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_renderer_flush_pipeline_info(renderer: &mut Renderer, out: &mut WrPipelineInfo) {
+    let info = renderer.flush_pipeline_info();
+    *out = WrPipelineInfo::new(&info);
+}
+
+extern "C" {
+    pub fn gecko_profiler_thread_is_being_profiled() -> bool;
+}
+
+pub fn gecko_profiler_start_marker(name: &str) {
+    use gecko_profiler::{gecko_profiler_category, MarkerOptions, MarkerTiming, ProfilerTime, Tracing};
+    gecko_profiler::add_marker(
+        name,
+        gecko_profiler_category!(Graphics),
+        MarkerOptions {
+            timing: MarkerTiming::interval_start(ProfilerTime::now()),
+            ..Default::default()
+        },
+        Tracing("Webrender".to_string()),
+    );
+}
+pub fn gecko_profiler_end_marker(name: &str) {
+    use gecko_profiler::{gecko_profiler_category, MarkerOptions, MarkerTiming, ProfilerTime, Tracing};
+    gecko_profiler::add_marker(
+        name,
+        gecko_profiler_category!(Graphics),
+        MarkerOptions {
+            timing: MarkerTiming::interval_end(ProfilerTime::now()),
+            ..Default::default()
+        },
+        Tracing("Webrender".to_string()),
+    );
+}
+
+pub fn gecko_profiler_event_marker(name: &str) {
+    use gecko_profiler::{gecko_profiler_category, Tracing};
+    gecko_profiler::add_marker(
+        name,
+        gecko_profiler_category!(Graphics),
+        Default::default(),
+        Tracing("Webrender".to_string()),
+    );
+}
+
+pub fn gecko_profiler_add_text_marker(name: &str, text: &str, microseconds: f64) {
+    use gecko_profiler::{gecko_profiler_category, MarkerOptions, MarkerTiming, ProfilerTime};
+    if !gecko_profiler::can_accept_markers() {
+        return;
+    }
+
+    let now = ProfilerTime::now();
+    let start = now.clone().subtract_microseconds(microseconds);
+    gecko_profiler::add_text_marker(
+        name,
+        gecko_profiler_category!(Graphics),
+        MarkerOptions {
+            timing: MarkerTiming::interval(start, now),
+            ..Default::default()
+        },
+        text,
+    );
+}
+
+/// Simple implementation of the WR ProfilerHooks trait to allow profile
+/// markers to be seen in the Gecko profiler.
+struct GeckoProfilerHooks;
+
+impl ProfilerHooks for GeckoProfilerHooks {
+    fn register_thread(&self, thread_name: &str) {
+        gecko_profiler::register_thread(thread_name);
+    }
+
+    fn unregister_thread(&self) {
+        gecko_profiler::unregister_thread();
+    }
+
+    fn begin_marker(&self, label: &str) {
+        gecko_profiler_start_marker(label);
+    }
+
+    fn end_marker(&self, label: &str) {
+        gecko_profiler_end_marker(label);
+    }
+
+    fn event_marker(&self, label: &str) {
+        gecko_profiler_event_marker(label);
+    }
+
+    fn add_text_marker(&self, label: &str, text: &str, duration: Duration) {
+        let micros = duration.as_micros() as f64;
+        gecko_profiler_add_text_marker(label, text, micros);
+    }
+
+    fn thread_is_being_profiled(&self) -> bool {
+        unsafe { gecko_profiler_thread_is_being_profiled() }
+    }
+}
+
+static PROFILER_HOOKS: GeckoProfilerHooks = GeckoProfilerHooks {};
+
+#[allow(improper_ctypes)] // this is needed so that rustc doesn't complain about passing the &mut Transaction to an extern function
+extern "C" {
+    // These callbacks are invoked from the scene builder thread (aka the APZ
+    // updater thread)
+    fn apz_register_updater(window_id: WrWindowId);
+    fn apz_pre_scene_swap(window_id: WrWindowId);
+    fn apz_post_scene_swap(window_id: WrWindowId, pipeline_info: &WrPipelineInfo);
+    fn apz_run_updater(window_id: WrWindowId);
+    fn apz_deregister_updater(window_id: WrWindowId);
+
+    // These callbacks are invoked from the render backend thread (aka the APZ
+    // sampler thread)
+    fn apz_register_sampler(window_id: WrWindowId);
+    fn apz_sample_transforms(window_id: WrWindowId, generated_frame_id: *const u64, transaction: &mut Transaction);
+    fn apz_deregister_sampler(window_id: WrWindowId);
+
+    fn omta_register_sampler(window_id: WrWindowId);
+    fn omta_sample(window_id: WrWindowId, transaction: &mut Transaction);
+    fn omta_deregister_sampler(window_id: WrWindowId);
+}
+
+struct APZCallbacks {
+    window_id: WrWindowId,
+}
+
+impl APZCallbacks {
+    pub fn new(window_id: WrWindowId) -> Self {
+        APZCallbacks { window_id }
+    }
+}
+
+impl SceneBuilderHooks for APZCallbacks {
+    fn register(&self) {
+        unsafe { apz_register_updater(self.window_id) }
+    }
+
+    fn pre_scene_build(&self) {
+        gecko_profiler_start_marker("SceneBuilding");
+    }
+
+    fn pre_scene_swap(&self) {
+        unsafe {
+            apz_pre_scene_swap(self.window_id);
+        }
+    }
+
+    fn post_scene_swap(&self, _document_ids: &Vec<DocumentId>, info: PipelineInfo) {
+        let mut info = WrPipelineInfo::new(&info);
+        unsafe {
+            apz_post_scene_swap(self.window_id, &info);
+        }
+
+        // After a scene swap we should schedule a render for the next vsync,
+        // otherwise there's no guarantee that the new scene will get rendered
+        // anytime soon
+        unsafe { wr_finished_scene_build(self.window_id, &mut info) }
+        gecko_profiler_end_marker("SceneBuilding");
+    }
+
+    fn post_resource_update(&self, _document_ids: &Vec<DocumentId>) {
+        unsafe { wr_schedule_render(self.window_id, RenderReasons::POST_RESOURCE_UPDATES_HOOK) }
+        gecko_profiler_end_marker("SceneBuilding");
+    }
+
+    fn post_empty_scene_build(&self) {
+        gecko_profiler_end_marker("SceneBuilding");
+    }
+
+    fn poke(&self) {
+        unsafe { apz_run_updater(self.window_id) }
+    }
+
+    fn deregister(&self) {
+        unsafe { apz_deregister_updater(self.window_id) }
+    }
+}
+
+struct SamplerCallback {
+    window_id: WrWindowId,
+}
+
+impl SamplerCallback {
+    pub fn new(window_id: WrWindowId) -> Self {
+        SamplerCallback { window_id }
+    }
+}
+
+impl AsyncPropertySampler for SamplerCallback {
+    fn register(&self) {
+        unsafe {
+            apz_register_sampler(self.window_id);
+            omta_register_sampler(self.window_id);
+        }
+    }
+
+    fn sample(&self, _document_id: DocumentId, generated_frame_id: Option<u64>) -> Vec<FrameMsg> {
+        let generated_frame_id_value;
+        let generated_frame_id: *const u64 = match generated_frame_id {
+            Some(id) => {
+                generated_frame_id_value = id;
+                &generated_frame_id_value
+            },
+            None => ptr::null_mut(),
+        };
+        let mut transaction = Transaction::new();
+        // Reset the pending properties first because omta_sample and apz_sample_transforms
+        // may be failed to reset them due to null samplers.
+        transaction.reset_dynamic_properties();
+        unsafe {
+            apz_sample_transforms(self.window_id, generated_frame_id, &mut transaction);
+            omta_sample(self.window_id, &mut transaction);
+        };
+        transaction.get_frame_ops()
+    }
+
+    fn deregister(&self) {
+        unsafe {
+            apz_deregister_sampler(self.window_id);
+            omta_deregister_sampler(self.window_id);
+        }
+    }
+}
+
+extern "C" {
+    fn wr_register_thread_local_arena();
+}
+
+pub struct WrThreadPool(Arc<rayon::ThreadPool>);
+
+#[no_mangle]
+pub extern "C" fn wr_thread_pool_new(low_priority: bool) -> *mut WrThreadPool {
+    // Clamp the number of workers between 1 and 4/8. We get diminishing returns
+    // with high worker counts and extra overhead because of rayon and font
+    // management.
+
+    // We clamp to 4 high priority threads because contention and memory usage
+    // make it not worth going higher
+    let max = if low_priority { 8 } else { 4 };
+    let num_threads = num_cpus::get().min(max);
+
+    let priority_tag = if low_priority { "LP" } else { "" };
+
+    let worker = rayon::ThreadPoolBuilder::new()
+        .thread_name(move |idx| format!("WRWorker{}#{}", priority_tag, idx))
+        .num_threads(num_threads)
+        .start_handler(move |idx| {
+            unsafe {
+                wr_register_thread_local_arena();
+            }
+            let name = format!("WRWorker{}#{}", priority_tag, idx);
+            register_thread_with_profiler(name.clone());
+            gecko_profiler::register_thread(&name);
+        })
+        .exit_handler(|_idx| {
+            gecko_profiler::unregister_thread();
+        })
+        .build();
+
+    let workers = Arc::new(worker.unwrap());
+
+    Box::into_raw(Box::new(WrThreadPool(workers)))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_thread_pool_delete(thread_pool: *mut WrThreadPool) {
+    mem::drop(Box::from_raw(thread_pool));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_program_cache_new(
+    prof_path: &nsAString,
+    thread_pool: *mut WrThreadPool,
+) -> *mut WrProgramCache {
+    let workers = &(*thread_pool).0;
+    let program_cache = WrProgramCache::new(prof_path, workers);
+    Box::into_raw(Box::new(program_cache))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_program_cache_delete(program_cache: *mut WrProgramCache) {
+    mem::drop(Box::from_raw(program_cache));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_try_load_startup_shaders_from_disk(program_cache: *mut WrProgramCache) {
+    (*program_cache).try_load_startup_shaders_from_disk();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn remove_program_binary_disk_cache(prof_path: &nsAString) -> bool {
+    match remove_disk_cache(prof_path) {
+        Ok(_) => true,
+        Err(_) => {
+            error!("Failed to remove program binary disk cache");
+            false
+        },
+    }
+}
+
+// This matches IsEnvSet in gfxEnv.h
+fn env_var_to_bool(key: &'static str) -> bool {
+    env::var(key).ok().map_or(false, |v| !v.is_empty())
+}
+
+// Call MakeCurrent before this.
+fn wr_device_new(gl_context: *mut c_void, pc: Option<&mut WrProgramCache>) -> Device {
+    assert!(unsafe { is_in_render_thread() });
+
+    let gl;
+    if unsafe { is_glcontext_gles(gl_context) } {
+        gl = unsafe { gl::GlesFns::load_with(|symbol| get_proc_address(gl_context, symbol)) };
+    } else {
+        gl = unsafe { gl::GlFns::load_with(|symbol| get_proc_address(gl_context, symbol)) };
+    }
+
+    let version = gl.get_string(gl::VERSION);
+
+    info!("WebRender - OpenGL version new {}", version);
+
+    let upload_method = if unsafe { is_glcontext_angle(gl_context) } {
+        UploadMethod::Immediate
+    } else {
+        UploadMethod::PixelBuffer(ONE_TIME_USAGE_HINT)
+    };
+
+    let resource_override_path = unsafe {
+        let override_charptr = gfx_wr_resource_path_override();
+        if override_charptr.is_null() {
+            None
+        } else {
+            match CStr::from_ptr(override_charptr).to_str() {
+                Ok(override_str) => Some(PathBuf::from(override_str)),
+                _ => None,
+            }
+        }
+    };
+
+    let use_optimized_shaders = unsafe { gfx_wr_use_optimized_shaders() };
+
+    let cached_programs = pc.map(|cached_programs| Rc::clone(cached_programs.rc_get()));
+
+    Device::new(
+        gl,
+        Some(Box::new(MozCrashAnnotator)),
+        resource_override_path,
+        use_optimized_shaders,
+        upload_method,
+        512 * 512,
+        cached_programs,
+        true,
+        true,
+        None,
+        false,
+        false,
+    )
+}
+
+extern "C" {
+    fn wr_compositor_create_surface(
+        compositor: *mut c_void,
+        id: NativeSurfaceId,
+        virtual_offset: DeviceIntPoint,
+        tile_size: DeviceIntSize,
+        is_opaque: bool,
+    );
+    fn wr_compositor_create_external_surface(compositor: *mut c_void, id: NativeSurfaceId, is_opaque: bool);
+    fn wr_compositor_create_backdrop_surface(compositor: *mut c_void, id: NativeSurfaceId, color: ColorF);
+    fn wr_compositor_destroy_surface(compositor: *mut c_void, id: NativeSurfaceId);
+    fn wr_compositor_create_tile(compositor: *mut c_void, id: NativeSurfaceId, x: i32, y: i32);
+    fn wr_compositor_destroy_tile(compositor: *mut c_void, id: NativeSurfaceId, x: i32, y: i32);
+    fn wr_compositor_attach_external_image(
+        compositor: *mut c_void,
+        id: NativeSurfaceId,
+        external_image: ExternalImageId,
+    );
+    fn wr_compositor_bind(
+        compositor: *mut c_void,
+        id: NativeTileId,
+        offset: &mut DeviceIntPoint,
+        fbo_id: &mut u32,
+        dirty_rect: DeviceIntRect,
+        valid_rect: DeviceIntRect,
+    );
+    fn wr_compositor_unbind(compositor: *mut c_void);
+    fn wr_compositor_begin_frame(compositor: *mut c_void);
+    fn wr_compositor_add_surface(
+        compositor: *mut c_void,
+        id: NativeSurfaceId,
+        transform: &CompositorSurfaceTransform,
+        clip_rect: DeviceIntRect,
+        image_rendering: ImageRendering,
+    );
+    fn wr_compositor_start_compositing(
+        compositor: *mut c_void,
+        clear_color: ColorF,
+        dirty_rects: *const DeviceIntRect,
+        num_dirty_rects: usize,
+        opaque_rects: *const DeviceIntRect,
+        num_opaque_rects: usize,
+    );
+    fn wr_compositor_end_frame(compositor: *mut c_void);
+    fn wr_compositor_enable_native_compositor(compositor: *mut c_void, enable: bool);
+    fn wr_compositor_deinit(compositor: *mut c_void);
+    fn wr_compositor_get_capabilities(compositor: *mut c_void, caps: *mut CompositorCapabilities);
+    fn wr_compositor_get_window_visibility(compositor: *mut c_void, caps: *mut WindowVisibility);
+    fn wr_compositor_map_tile(
+        compositor: *mut c_void,
+        id: NativeTileId,
+        dirty_rect: DeviceIntRect,
+        valid_rect: DeviceIntRect,
+        data: &mut *mut c_void,
+        stride: &mut i32,
+    );
+    fn wr_compositor_unmap_tile(compositor: *mut c_void);
+
+    fn wr_partial_present_compositor_set_buffer_damage_region(
+        compositor: *mut c_void,
+        rects: *const DeviceIntRect,
+        n_rects: usize,
+    );
+}
+
+pub struct WrCompositor(*mut c_void);
+
+impl Compositor for WrCompositor {
+    fn create_surface(
+        &mut self,
+        _device: &mut Device,
+        id: NativeSurfaceId,
+        virtual_offset: DeviceIntPoint,
+        tile_size: DeviceIntSize,
+        is_opaque: bool,
+    ) {
+        unsafe {
+            wr_compositor_create_surface(self.0, id, virtual_offset, tile_size, is_opaque);
+        }
+    }
+
+    fn create_external_surface(&mut self, _device: &mut Device, id: NativeSurfaceId, is_opaque: bool) {
+        unsafe {
+            wr_compositor_create_external_surface(self.0, id, is_opaque);
+        }
+    }
+
+    fn create_backdrop_surface(&mut self, _device: &mut Device, id: NativeSurfaceId, color: ColorF) {
+        unsafe {
+            wr_compositor_create_backdrop_surface(self.0, id, color);
+        }
+    }
+
+    fn destroy_surface(&mut self, _device: &mut Device, id: NativeSurfaceId) {
+        unsafe {
+            wr_compositor_destroy_surface(self.0, id);
+        }
+    }
+
+    fn create_tile(&mut self, _device: &mut Device, id: NativeTileId) {
+        unsafe {
+            wr_compositor_create_tile(self.0, id.surface_id, id.x, id.y);
+        }
+    }
+
+    fn destroy_tile(&mut self, _device: &mut Device, id: NativeTileId) {
+        unsafe {
+            wr_compositor_destroy_tile(self.0, id.surface_id, id.x, id.y);
+        }
+    }
+
+    fn attach_external_image(&mut self, _device: &mut Device, id: NativeSurfaceId, external_image: ExternalImageId) {
+        unsafe {
+            wr_compositor_attach_external_image(self.0, id, external_image);
+        }
+    }
+
+    fn bind(
+        &mut self,
+        _device: &mut Device,
+        id: NativeTileId,
+        dirty_rect: DeviceIntRect,
+        valid_rect: DeviceIntRect,
+    ) -> NativeSurfaceInfo {
+        let mut surface_info = NativeSurfaceInfo {
+            origin: DeviceIntPoint::zero(),
+            fbo_id: 0,
+        };
+
+        unsafe {
+            wr_compositor_bind(
+                self.0,
+                id,
+                &mut surface_info.origin,
+                &mut surface_info.fbo_id,
+                dirty_rect,
+                valid_rect,
+            );
+        }
+
+        surface_info
+    }
+
+    fn unbind(&mut self, _device: &mut Device) {
+        unsafe {
+            wr_compositor_unbind(self.0);
+        }
+    }
+
+    fn begin_frame(&mut self, _device: &mut Device) {
+        unsafe {
+            wr_compositor_begin_frame(self.0);
+        }
+    }
+
+    fn add_surface(
+        &mut self,
+        _device: &mut Device,
+        id: NativeSurfaceId,
+        transform: CompositorSurfaceTransform,
+        clip_rect: DeviceIntRect,
+        image_rendering: ImageRendering,
+    ) {
+        unsafe {
+            wr_compositor_add_surface(self.0, id, &transform, clip_rect, image_rendering);
+        }
+    }
+
+    fn start_compositing(
+        &mut self,
+        _device: &mut Device,
+        clear_color: ColorF,
+        dirty_rects: &[DeviceIntRect],
+        opaque_rects: &[DeviceIntRect],
+    ) {
+        unsafe {
+            wr_compositor_start_compositing(
+                self.0,
+                clear_color,
+                dirty_rects.as_ptr(),
+                dirty_rects.len(),
+                opaque_rects.as_ptr(),
+                opaque_rects.len(),
+            );
+        }
+    }
+
+    fn end_frame(&mut self, _device: &mut Device) {
+        unsafe {
+            wr_compositor_end_frame(self.0);
+        }
+    }
+
+    fn enable_native_compositor(&mut self, _device: &mut Device, enable: bool) {
+        unsafe {
+            wr_compositor_enable_native_compositor(self.0, enable);
+        }
+    }
+
+    fn deinit(&mut self, _device: &mut Device) {
+        unsafe {
+            wr_compositor_deinit(self.0);
+        }
+    }
+
+    fn get_capabilities(&self, _device: &mut Device) -> CompositorCapabilities {
+        unsafe {
+            let mut caps: CompositorCapabilities = Default::default();
+            wr_compositor_get_capabilities(self.0, &mut caps);
+            caps
+        }
+    }
+
+    fn get_window_visibility(&self, _device: &mut Device) -> WindowVisibility {
+        unsafe {
+            let mut visibility: WindowVisibility = Default::default();
+            wr_compositor_get_window_visibility(self.0, &mut visibility);
+            visibility
+        }
+    }
+}
+
+extern "C" {
+    fn wr_swgl_lock_composite_surface(
+        ctx: *mut c_void,
+        external_image_id: ExternalImageId,
+        composite_info: *mut SWGLCompositeSurfaceInfo,
+    ) -> bool;
+    fn wr_swgl_unlock_composite_surface(ctx: *mut c_void, external_image_id: ExternalImageId);
+}
+
+impl MappableCompositor for WrCompositor {
+    /// Map a tile's underlying buffer so it can be used as the backing for
+    /// a SWGL framebuffer. This is intended to be a replacement for 'bind'
+    /// in any compositors that intend to directly interoperate with SWGL
+    /// while supporting some form of native layers.
+    fn map_tile(
+        &mut self,
+        _device: &mut Device,
+        id: NativeTileId,
+        dirty_rect: DeviceIntRect,
+        valid_rect: DeviceIntRect,
+    ) -> Option<MappedTileInfo> {
+        let mut tile_info = MappedTileInfo {
+            data: ptr::null_mut(),
+            stride: 0,
+        };
+
+        unsafe {
+            wr_compositor_map_tile(
+                self.0,
+                id,
+                dirty_rect,
+                valid_rect,
+                &mut tile_info.data,
+                &mut tile_info.stride,
+            );
+        }
+
+        if !tile_info.data.is_null() && tile_info.stride != 0 {
+            Some(tile_info)
+        } else {
+            None
+        }
+    }
+
+    /// Unmap a tile that was was previously mapped via map_tile to signal
+    /// that SWGL is done rendering to the buffer.
+    fn unmap_tile(&mut self, _device: &mut Device) {
+        unsafe {
+            wr_compositor_unmap_tile(self.0);
+        }
+    }
+
+    fn lock_composite_surface(
+        &mut self,
+        _device: &mut Device,
+        ctx: *mut c_void,
+        external_image_id: ExternalImageId,
+        composite_info: *mut SWGLCompositeSurfaceInfo,
+    ) -> bool {
+        unsafe { wr_swgl_lock_composite_surface(ctx, external_image_id, composite_info) }
+    }
+    fn unlock_composite_surface(&mut self, _device: &mut Device, ctx: *mut c_void, external_image_id: ExternalImageId) {
+        unsafe { wr_swgl_unlock_composite_surface(ctx, external_image_id) }
+    }
+}
+
+pub struct WrPartialPresentCompositor(*mut c_void);
+
+impl PartialPresentCompositor for WrPartialPresentCompositor {
+    fn set_buffer_damage_region(&mut self, rects: &[DeviceIntRect]) {
+        unsafe {
+            wr_partial_present_compositor_set_buffer_damage_region(self.0, rects.as_ptr(), rects.len());
+        }
+    }
+}
+
+/// A wrapper around a strong reference to a Shaders object.
+pub struct WrShaders(SharedShaders);
+
+// Call MakeCurrent before this.
+#[no_mangle]
+pub extern "C" fn wr_window_new(
+    window_id: WrWindowId,
+    window_width: i32,
+    window_height: i32,
+    is_main_window: bool,
+    support_low_priority_transactions: bool,
+    support_low_priority_threadpool: bool,
+    allow_texture_swizzling: bool,
+    allow_scissored_cache_clears: bool,
+    swgl_context: *mut c_void,
+    gl_context: *mut c_void,
+    surface_origin_is_top_left: bool,
+    program_cache: Option<&mut WrProgramCache>,
+    shaders: Option<&mut WrShaders>,
+    thread_pool: *mut WrThreadPool,
+    thread_pool_low_priority: *mut WrThreadPool,
+    size_of_op: VoidPtrToSizeFn,
+    enclosing_size_of_op: VoidPtrToSizeFn,
+    document_id: u32,
+    compositor: *mut c_void,
+    use_native_compositor: bool,
+    use_partial_present: bool,
+    max_partial_present_rects: usize,
+    draw_previous_partial_present_regions: bool,
+    out_handle: &mut *mut DocumentHandle,
+    out_renderer: &mut *mut Renderer,
+    out_max_texture_size: *mut i32,
+    out_err: &mut *mut c_char,
+    enable_gpu_markers: bool,
+    panic_on_gl_error: bool,
+    picture_tile_width: i32,
+    picture_tile_height: i32,
+    reject_software_rasterizer: bool,
+    low_quality_pinch_zoom: bool,
+    max_shared_surface_size: i32,
+    enable_subpixel_aa: bool,
+) -> bool {
+    assert!(unsafe { is_in_render_thread() });
+
+    // Ensure the WR profiler callbacks are hooked up to the Gecko profiler.
+    set_profiler_hooks(Some(&PROFILER_HOOKS));
+
+    let software = !swgl_context.is_null();
+    let (gl, sw_gl) = if software {
+        let ctx = swgl::Context::from(swgl_context);
+        ctx.make_current();
+        (Rc::new(ctx) as Rc<dyn gl::Gl>, Some(ctx))
+    } else {
+        let gl = unsafe {
+            if gl_context.is_null() {
+                panic!("Native GL context required when not using SWGL!");
+            } else if is_glcontext_gles(gl_context) {
+                gl::GlesFns::load_with(|symbol| get_proc_address(gl_context, symbol))
+            } else {
+                gl::GlFns::load_with(|symbol| get_proc_address(gl_context, symbol))
+            }
+        };
+        (gl, None)
+    };
+
+    let version = gl.get_string(gl::VERSION);
+
+    info!("WebRender - OpenGL version new {}", version);
+
+    let workers = unsafe { Arc::clone(&(*thread_pool).0) };
+    let workers_low_priority = unsafe {
+        if support_low_priority_threadpool {
+            Arc::clone(&(*thread_pool_low_priority).0)
+        } else {
+            Arc::clone(&(*thread_pool).0)
+        }
+    };
+
+    let upload_method = if !gl_context.is_null() && unsafe { is_glcontext_angle(gl_context) } {
+        UploadMethod::Immediate
+    } else {
+        UploadMethod::PixelBuffer(ONE_TIME_USAGE_HINT)
+    };
+
+    let precache_flags = if env_var_to_bool("MOZ_WR_PRECACHE_SHADERS") {
+        ShaderPrecacheFlags::FULL_COMPILE
+    } else {
+        ShaderPrecacheFlags::empty()
+    };
+
+    let cached_programs = program_cache.map(|program_cache| Rc::clone(&program_cache.rc_get()));
+
+    let color = if cfg!(target_os = "android") {
+        // The color is for avoiding black flash before receiving display list.
+        ColorF::new(1.0, 1.0, 1.0, 1.0)
+    } else {
+        ColorF::new(0.0, 0.0, 0.0, 0.0)
+    };
+
+    let compositor_config = if software {
+        CompositorConfig::Native {
+            compositor: Box::new(SwCompositor::new(
+                sw_gl.unwrap(),
+                Box::new(WrCompositor(compositor)),
+                use_native_compositor,
+            )),
+        }
+    } else if use_native_compositor {
+        CompositorConfig::Native {
+            compositor: Box::new(WrCompositor(compositor)),
+        }
+    } else {
+        CompositorConfig::Draw {
+            max_partial_present_rects,
+            draw_previous_partial_present_regions,
+            partial_present: if use_partial_present {
+                Some(Box::new(WrPartialPresentCompositor(compositor)))
+            } else {
+                None
+            },
+        }
+    };
+
+    let picture_tile_size = if picture_tile_width > 0 && picture_tile_height > 0 {
+        Some(DeviceIntSize::new(picture_tile_width, picture_tile_height))
+    } else {
+        None
+    };
+
+    let texture_cache_config = if is_main_window {
+        TextureCacheConfig::DEFAULT
+    } else {
+        TextureCacheConfig {
+            color8_linear_texture_size: 512,
+            color8_nearest_texture_size: 512,
+            color8_glyph_texture_size: 512,
+            alpha8_texture_size: 512,
+            alpha8_glyph_texture_size: 512,
+            alpha16_texture_size: 512,
+        }
+    };
+
+    let opts = WebRenderOptions {
+        enable_aa: true,
+        enable_subpixel_aa,
+        support_low_priority_transactions,
+        allow_texture_swizzling,
+        blob_image_handler: Some(Box::new(Moz2dBlobImageHandler::new(
+            workers.clone(),
+            workers_low_priority,
+        ))),
+        crash_annotator: Some(Box::new(MozCrashAnnotator)),
+        workers: Some(workers),
+        size_of_op: Some(size_of_op),
+        enclosing_size_of_op: Some(enclosing_size_of_op),
+        cached_programs,
+        resource_override_path: unsafe {
+            let override_charptr = gfx_wr_resource_path_override();
+            if override_charptr.is_null() {
+                None
+            } else {
+                match CStr::from_ptr(override_charptr).to_str() {
+                    Ok(override_str) => Some(PathBuf::from(override_str)),
+                    _ => None,
+                }
+            }
+        },
+        use_optimized_shaders: unsafe { gfx_wr_use_optimized_shaders() },
+        renderer_id: Some(window_id.0),
+        upload_method,
+        scene_builder_hooks: Some(Box::new(APZCallbacks::new(window_id))),
+        sampler: Some(Box::new(SamplerCallback::new(window_id))),
+        max_internal_texture_size: Some(8192), // We want to tile if larger than this
+        clear_color: color,
+        precache_flags,
+        namespace_alloc_by_client: true,
+        // Font namespace must be allocated by the client
+        shared_font_namespace: Some(next_namespace_id()),
+        // SWGL doesn't support the GL_ALWAYS depth comparison function used by
+        // `clear_caches_with_quads`, but scissored clears work well.
+        clear_caches_with_quads: !software && !allow_scissored_cache_clears,
+        // SWGL supports KHR_blend_equation_advanced safely, but we haven't yet
+        // tested other HW platforms determine if it is safe to allow them.
+        allow_advanced_blend_equation: software,
+        surface_origin_is_top_left,
+        compositor_config,
+        enable_gpu_markers,
+        panic_on_gl_error,
+        picture_tile_size,
+        texture_cache_config,
+        reject_software_rasterizer,
+        low_quality_pinch_zoom,
+        max_shared_surface_size,
+        ..Default::default()
+    };
+
+    let window_size = DeviceIntSize::new(window_width, window_height);
+    let notifier = Box::new(CppNotifier { window_id });
+    let (renderer, sender) = match create_webrender_instance(gl, notifier, opts, shaders.map(|sh| &sh.0)) {
+        Ok((renderer, sender)) => (renderer, sender),
+        Err(e) => {
+            warn!(" Failed to create a Renderer: {:?}", e);
+            let msg = CString::new(format!("wr_window_new: {:?}", e)).unwrap();
+            unsafe {
+                gfx_critical_note(msg.as_ptr());
+            }
+            *out_err = msg.into_raw();
+            return false;
+        },
+    };
+
+    unsafe {
+        *out_max_texture_size = renderer.get_max_texture_size();
+    }
+    *out_handle = Box::into_raw(Box::new(DocumentHandle::new(
+        sender.create_api_by_client(next_namespace_id()),
+        None,
+        window_size,
+        document_id,
+    )));
+    *out_renderer = Box::into_raw(Box::new(renderer));
+
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_free_error_msg(msg: *mut c_char) {
+    if !msg.is_null() {
+        drop(CString::from_raw(msg));
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_delete_document(dh: &mut DocumentHandle) {
+    dh.api.delete_document(dh.document_id);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_clone(dh: &mut DocumentHandle, out_handle: &mut *mut DocumentHandle) {
+    assert!(unsafe { is_in_compositor_thread() });
+
+    let hit_tester = dh.ensure_hit_tester().clone();
+
+    let handle = DocumentHandle {
+        api: dh.api.create_sender().create_api_by_client(next_namespace_id()),
+        document_id: dh.document_id,
+        hit_tester: Some(hit_tester),
+        hit_tester_request: None,
+    };
+    *out_handle = Box::into_raw(Box::new(handle));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_delete(dh: *mut DocumentHandle) {
+    let _ = Box::from_raw(dh);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_stop_render_backend(dh: &mut DocumentHandle) {
+    dh.api.stop_render_backend();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_shut_down(dh: &mut DocumentHandle) {
+    dh.api.shut_down(true);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_notify_memory_pressure(dh: &mut DocumentHandle) {
+    dh.api.notify_memory_pressure();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_set_debug_flags(dh: &mut DocumentHandle, flags: DebugFlags) {
+    dh.api.set_debug_flags(flags);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_set_bool(dh: &mut DocumentHandle, param_name: BoolParameter, val: bool) {
+    dh.api.set_parameter(Parameter::Bool(param_name, val));
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_set_int(dh: &mut DocumentHandle, param_name: IntParameter, val: i32) {
+    dh.api.set_parameter(Parameter::Int(param_name, val));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_accumulate_memory_report(
+    dh: &mut DocumentHandle,
+    report: &mut MemoryReport,
+    // we manually expand VoidPtrToSizeFn here because cbindgen otherwise fails to fold the Option<fn()>
+    // https://github.com/eqrion/cbindgen/issues/552
+    size_of_op: unsafe extern "C" fn(ptr: *const c_void) -> usize,
+    enclosing_size_of_op: Option<unsafe extern "C" fn(ptr: *const c_void) -> usize>,
+) {
+    let ops = MallocSizeOfOps::new(size_of_op, enclosing_size_of_op);
+    *report += dh.api.report_memory(ops);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_clear_all_caches(dh: &mut DocumentHandle) {
+    dh.api.send_debug_cmd(DebugCommand::ClearCaches(ClearCache::all()));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_enable_native_compositor(dh: &mut DocumentHandle, enable: bool) {
+    dh.api.send_debug_cmd(DebugCommand::EnableNativeCompositor(enable));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_set_batching_lookback(dh: &mut DocumentHandle, count: u32) {
+    dh.api.send_debug_cmd(DebugCommand::SetBatchingLookback(count));
+}
+
+fn make_transaction(do_async: bool) -> Transaction {
+    let mut transaction = Transaction::new();
+    // Ensure that we either use async scene building or not based on the
+    // gecko pref, regardless of what the default is. We can remove this once
+    // the scene builder thread is enabled everywhere and working well.
+    if do_async {
+        transaction.use_scene_builder_thread();
+    } else {
+        transaction.skip_scene_builder();
+    }
+    transaction
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_new(do_async: bool) -> *mut Transaction {
+    Box::into_raw(Box::new(make_transaction(do_async)))
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_delete(txn: *mut Transaction) {
+    unsafe {
+        let _ = Box::from_raw(txn);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_set_low_priority(txn: &mut Transaction, low_priority: bool) {
+    txn.set_low_priority(low_priority);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_is_empty(txn: &Transaction) -> bool {
+    txn.is_empty()
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_resource_updates_is_empty(txn: &Transaction) -> bool {
+    txn.resource_updates.is_empty()
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_is_rendered_frame_invalidated(txn: &Transaction) -> bool {
+    txn.invalidate_rendered_frame
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_notify(txn: &mut Transaction, when: Checkpoint, event: usize) {
+    struct GeckoNotification(usize);
+    impl NotificationHandler for GeckoNotification {
+        fn notify(&self, when: Checkpoint) {
+            unsafe {
+                wr_transaction_notification_notified(self.0, when);
+            }
+        }
+    }
+
+    let handler = Box::new(GeckoNotification(event));
+    txn.notify(NotificationRequest::new(when, handler));
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_update_epoch(txn: &mut Transaction, pipeline_id: WrPipelineId, epoch: WrEpoch) {
+    txn.update_epoch(pipeline_id, epoch);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_set_root_pipeline(txn: &mut Transaction, pipeline_id: WrPipelineId) {
+    txn.set_root_pipeline(pipeline_id);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_remove_pipeline(txn: &mut Transaction, pipeline_id: WrPipelineId) {
+    txn.remove_pipeline(pipeline_id);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_set_display_list(
+    txn: &mut Transaction,
+    epoch: WrEpoch,
+    pipeline_id: WrPipelineId,
+    dl_descriptor: BuiltDisplayListDescriptor,
+    dl_items_data: &mut WrVecU8,
+    dl_cache_data: &mut WrVecU8,
+    dl_spatial_tree_data: &mut WrVecU8,
+) {
+    let payload = DisplayListPayload {
+        items_data: dl_items_data.flush_into_vec(),
+        cache_data: dl_cache_data.flush_into_vec(),
+        spatial_tree: dl_spatial_tree_data.flush_into_vec(),
+    };
+
+    let dl = BuiltDisplayList::from_data(payload, dl_descriptor);
+
+    txn.set_display_list(epoch, (pipeline_id, dl));
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_set_document_view(txn: &mut Transaction, doc_rect: &DeviceIntRect) {
+    txn.set_document_view(*doc_rect);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_generate_frame(txn: &mut Transaction, id: u64, reasons: RenderReasons) {
+    txn.generate_frame(id, reasons);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_invalidate_rendered_frame(txn: &mut Transaction, reasons: RenderReasons) {
+    txn.invalidate_rendered_frame(reasons);
+}
+
+fn wr_animation_properties_into_vec<T>(
+    animation_array: *const WrAnimationPropertyValue<T>,
+    array_count: usize,
+    vec: &mut Vec<PropertyValue<T>>,
+) where
+    T: Copy,
+{
+    if array_count > 0 {
+        debug_assert!(
+            vec.capacity() - vec.len() >= array_count,
+            "The Vec should have fufficient free capacity"
+        );
+        let slice = unsafe { make_slice(animation_array, array_count) };
+
+        for element in slice.iter() {
+            let prop = PropertyValue {
+                key: PropertyBindingKey::new(element.id),
+                value: element.value,
+            };
+
+            vec.push(prop);
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_append_dynamic_properties(
+    txn: &mut Transaction,
+    opacity_array: *const WrOpacityProperty,
+    opacity_count: usize,
+    transform_array: *const WrTransformProperty,
+    transform_count: usize,
+    color_array: *const WrColorProperty,
+    color_count: usize,
+) {
+    if opacity_count == 0 && transform_count == 0 && color_count == 0 {
+        return;
+    }
+
+    let mut properties = DynamicProperties {
+        transforms: Vec::with_capacity(transform_count),
+        floats: Vec::with_capacity(opacity_count),
+        colors: Vec::with_capacity(color_count),
+    };
+
+    wr_animation_properties_into_vec(transform_array, transform_count, &mut properties.transforms);
+
+    wr_animation_properties_into_vec(opacity_array, opacity_count, &mut properties.floats);
+
+    wr_animation_properties_into_vec(color_array, color_count, &mut properties.colors);
+
+    txn.append_dynamic_properties(properties);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_append_transform_properties(
+    txn: &mut Transaction,
+    transform_array: *const WrTransformProperty,
+    transform_count: usize,
+) {
+    if transform_count == 0 {
+        return;
+    }
+
+    let mut transforms = Vec::with_capacity(transform_count);
+    wr_animation_properties_into_vec(transform_array, transform_count, &mut transforms);
+
+    txn.append_dynamic_transform_properties(transforms);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_scroll_layer(
+    txn: &mut Transaction,
+    scroll_id: ExternalScrollId,
+    sampled_scroll_offsets: &ThinVec<SampledScrollOffset>,
+) {
+    txn.set_scroll_offsets(scroll_id, sampled_scroll_offsets.to_vec());
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_set_is_transform_async_zooming(
+    txn: &mut Transaction,
+    animation_id: u64,
+    is_zooming: bool,
+) {
+    txn.set_is_transform_async_zooming(is_zooming, PropertyBindingId::new(animation_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_add_minimap_data(
+    txn: &mut Transaction,
+    scroll_id: ExternalScrollId,
+    minimap_data: MinimapData,
+) {
+    txn.set_minimap_data(scroll_id, minimap_data);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_transaction_set_quality_settings(txn: &mut Transaction, force_subpixel_aa_where_possible: bool) {
+    txn.set_quality_settings(QualitySettings {
+        force_subpixel_aa_where_possible,
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_add_image(
+    txn: &mut Transaction,
+    image_key: WrImageKey,
+    descriptor: &WrImageDescriptor,
+    bytes: &mut WrVecU8,
+) {
+    txn.add_image(
+        image_key,
+        descriptor.into(),
+        ImageData::new(bytes.flush_into_vec()),
+        None,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_add_blob_image(
+    txn: &mut Transaction,
+    image_key: BlobImageKey,
+    descriptor: &WrImageDescriptor,
+    tile_size: u16,
+    bytes: &mut WrVecU8,
+    visible_rect: DeviceIntRect,
+) {
+    // If we're at risk of generating an excessive number of tiles, try making
+    // them larger so as to reduce the total number. This helps avoid swamping
+    // the Moz2dBlobRasterizer with too many parallel requests.
+    const TILE_COUNT_LIMIT: i64 = 8192;
+    const TILE_SIZE_LIMIT: u16 = 2048;
+    let mut adjusted = tile_size;
+    // Rather than some tricky computation involving the image dimensions, just
+    // keep doubling tile_size until the estimated count is reasonable, or size
+    // gets too big. The size limit means this loop won't execute more than a
+    // handful of times even in extreme cases.
+    while adjusted < TILE_SIZE_LIMIT
+        && ((descriptor.height / adjusted as i32 + 1) as i64 * (descriptor.width / adjusted as i32 + 1) as i64)
+            > TILE_COUNT_LIMIT
+    {
+        adjusted = adjusted * 2;
+    }
+
+    txn.add_blob_image(
+        image_key,
+        descriptor.into(),
+        Arc::new(bytes.flush_into_vec()),
+        visible_rect,
+        if descriptor.format == ImageFormat::BGRA8 || adjusted > tile_size {
+            Some(adjusted)
+        } else {
+            None
+        },
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_add_external_image(
+    txn: &mut Transaction,
+    image_key: WrImageKey,
+    descriptor: &WrImageDescriptor,
+    external_image_id: ExternalImageId,
+    image_type: &ExternalImageType,
+    channel_index: u8,
+) {
+    txn.add_image(
+        image_key,
+        descriptor.into(),
+        ImageData::External(ExternalImageData {
+            id: external_image_id,
+            channel_index,
+            image_type: *image_type,
+        }),
+        None,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_update_image(
+    txn: &mut Transaction,
+    key: WrImageKey,
+    descriptor: &WrImageDescriptor,
+    bytes: &mut WrVecU8,
+) {
+    txn.update_image(
+        key,
+        descriptor.into(),
+        ImageData::new(bytes.flush_into_vec()),
+        &DirtyRect::All,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_set_blob_image_visible_area(
+    txn: &mut Transaction,
+    key: BlobImageKey,
+    area: &DeviceIntRect,
+) {
+    txn.set_blob_image_visible_area(key, *area);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_update_external_image(
+    txn: &mut Transaction,
+    key: WrImageKey,
+    descriptor: &WrImageDescriptor,
+    external_image_id: ExternalImageId,
+    image_type: &ExternalImageType,
+    channel_index: u8,
+) {
+    txn.update_image(
+        key,
+        descriptor.into(),
+        ImageData::External(ExternalImageData {
+            id: external_image_id,
+            channel_index,
+            image_type: *image_type,
+        }),
+        &DirtyRect::All,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_update_external_image_with_dirty_rect(
+    txn: &mut Transaction,
+    key: WrImageKey,
+    descriptor: &WrImageDescriptor,
+    external_image_id: ExternalImageId,
+    image_type: &ExternalImageType,
+    channel_index: u8,
+    dirty_rect: DeviceIntRect,
+) {
+    txn.update_image(
+        key,
+        descriptor.into(),
+        ImageData::External(ExternalImageData {
+            id: external_image_id,
+            channel_index,
+            image_type: *image_type,
+        }),
+        &DirtyRect::Partial(dirty_rect),
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_update_blob_image(
+    txn: &mut Transaction,
+    image_key: BlobImageKey,
+    descriptor: &WrImageDescriptor,
+    bytes: &mut WrVecU8,
+    visible_rect: DeviceIntRect,
+    dirty_rect: LayoutIntRect,
+) {
+    txn.update_blob_image(
+        image_key,
+        descriptor.into(),
+        Arc::new(bytes.flush_into_vec()),
+        visible_rect,
+        &DirtyRect::Partial(dirty_rect),
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_delete_image(txn: &mut Transaction, key: WrImageKey) {
+    txn.delete_image(key);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_delete_blob_image(txn: &mut Transaction, key: BlobImageKey) {
+    txn.delete_blob_image(key);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_send_transaction(dh: &mut DocumentHandle, transaction: &mut Transaction, is_async: bool) {
+    if transaction.is_empty() {
+        return;
+    }
+    let new_txn = make_transaction(is_async);
+    let txn = mem::replace(transaction, new_txn);
+    dh.api.send_transaction(dh.document_id, txn);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_transaction_clear_display_list(
+    txn: &mut Transaction,
+    epoch: WrEpoch,
+    pipeline_id: WrPipelineId,
+) {
+    let mut frame_builder = WebRenderFrameBuilder::new(pipeline_id);
+    frame_builder.dl_builder.begin();
+
+    txn.set_display_list(epoch, frame_builder.dl_builder.end());
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_send_external_event(dh: &mut DocumentHandle, evt: usize) {
+    assert!(unsafe { !is_in_render_thread() });
+
+    dh.api.send_external_event(ExternalEvent::from_raw(evt));
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_add_raw_font(
+    txn: &mut Transaction,
+    key: WrFontKey,
+    bytes: &mut WrVecU8,
+    index: u32,
+) {
+    txn.add_raw_font(key, bytes.flush_into_vec(), index);
+}
+
+fn generate_capture_path(path: *const c_char) -> Option<PathBuf> {
+    use std::fs::{create_dir_all, File};
+    use std::io::Write;
+
+    let cstr = unsafe { CStr::from_ptr(path) };
+    let local_dir = PathBuf::from(&*cstr.to_string_lossy());
+
+    // On Android we need to write into a particular folder on external
+    // storage so that (a) it can be written without requiring permissions
+    // and (b) it can be pulled off via `adb pull`. This env var is set
+    // in GeckoLoader.java.
+    // When running in Firefox CI, the MOZ_UPLOAD_DIR variable is set to a path
+    // that taskcluster will export artifacts from, so let's put it there.
+    let mut path = if let Ok(storage_path) = env::var("PUBLIC_STORAGE") {
+        PathBuf::from(storage_path).join(local_dir)
+    } else if let Ok(storage_path) = env::var("MOZ_UPLOAD_DIR") {
+        PathBuf::from(storage_path).join(local_dir)
+    } else if let Some(storage_path) = dirs::home_dir() {
+        storage_path.join(local_dir)
+    } else {
+        local_dir
+    };
+
+    // Increment the extension until we find a fresh path
+    while path.is_dir() {
+        let count: u32 = path
+            .extension()
+            .and_then(|x| x.to_str())
+            .and_then(|x| x.parse().ok())
+            .unwrap_or(0);
+        path.set_extension((count + 1).to_string());
+    }
+
+    // Use warn! so that it gets emitted to logcat on android as well
+    let border = "--------------------------\n";
+    warn!("{} Capturing WR state to: {:?}\n{}", &border, &path, &border);
+
+    let _ = create_dir_all(&path);
+    match File::create(path.join("wr.txt")) {
+        Ok(mut file) => {
+            // The Gecko HG revision is available at compile time
+            if let Some(moz_revision) = option_env!("GECKO_HEAD_REV") {
+                writeln!(file, "mozilla-central {}", moz_revision).unwrap();
+            }
+            Some(path)
+        },
+        Err(e) => {
+            warn!("Unable to create path '{:?}' for capture: {:?}", path, e);
+            None
+        },
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_capture(dh: &mut DocumentHandle, path: *const c_char, bits_raw: u32) {
+    if let Some(path) = generate_capture_path(path) {
+        let bits = CaptureBits::from_bits(bits_raw as _).unwrap();
+        dh.api.save_capture(path, bits);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_start_capture_sequence(dh: &mut DocumentHandle, path: *const c_char, bits_raw: u32) {
+    if let Some(path) = generate_capture_path(path) {
+        let bits = CaptureBits::from_bits(bits_raw as _).unwrap();
+        dh.api.start_capture_sequence(path, bits);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_stop_capture_sequence(dh: &mut DocumentHandle) {
+    let border = "--------------------------\n";
+    warn!("{} Stop capturing WR state\n{}", &border, &border);
+    dh.api.stop_capture_sequence();
+}
+
+#[cfg(target_os = "windows")]
+fn read_font_descriptor(bytes: &mut WrVecU8, index: u32) -> NativeFontHandle {
+    let wchars = bytes.convert_into_vec::<u16>();
+    NativeFontHandle {
+        path: PathBuf::from(OsString::from_wide(&wchars)),
+        index,
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn read_font_descriptor(bytes: &mut WrVecU8, index: u32) -> NativeFontHandle {
+    // On macOS, the descriptor string is a concatenation of the PostScript name
+    // and the font file path (to disambiguate cases where there are multiple
+    // faces with the same psname present). The index is the length of the psname
+    // portion of the descriptor (= starting offset of the path).
+    // Here, we split the descriptor into its two components for further use.
+    let chars = bytes.flush_into_vec();
+    NativeFontHandle {
+        name: String::from_utf8(chars[..index as usize].to_vec()).unwrap_or("".to_string()),
+        path: String::from_utf8(chars[index as usize..].to_vec()).unwrap_or("".to_string()),
+    }
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+fn read_font_descriptor(bytes: &mut WrVecU8, index: u32) -> NativeFontHandle {
+    let chars = bytes.flush_into_vec();
+    NativeFontHandle {
+        path: PathBuf::from(OsString::from_vec(chars)),
+        index,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_add_font_descriptor(
+    txn: &mut Transaction,
+    key: WrFontKey,
+    bytes: &mut WrVecU8,
+    index: u32,
+) {
+    let native_font_handle = read_font_descriptor(bytes, index);
+    txn.add_native_font(key, native_font_handle);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_delete_font(txn: &mut Transaction, key: WrFontKey) {
+    txn.delete_font(key);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_add_font_instance(
+    txn: &mut Transaction,
+    key: WrFontInstanceKey,
+    font_key: WrFontKey,
+    glyph_size: f32,
+    options: *const FontInstanceOptions,
+    platform_options: *const FontInstancePlatformOptions,
+    variations: &mut WrVecU8,
+) {
+    txn.add_font_instance(
+        key,
+        font_key,
+        glyph_size,
+        unsafe { options.as_ref().cloned() },
+        unsafe { platform_options.as_ref().cloned() },
+        variations.convert_into_vec::<FontVariation>(),
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_delete_font_instance(txn: &mut Transaction, key: WrFontInstanceKey) {
+    txn.delete_font_instance(key);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_resource_updates_clear(txn: &mut Transaction) {
+    txn.resource_updates.clear();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_get_namespace(dh: &mut DocumentHandle) -> WrIdNamespace {
+    dh.api.get_namespace_id()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_wake_scene_builder(dh: &mut DocumentHandle) {
+    dh.api.wake_scene_builder();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_flush_scene_builder(dh: &mut DocumentHandle) {
+    dh.api.flush_scene_builder();
+}
+
+// RenderThread WIP notes:
+// In order to separate the compositor thread (or ipc receiver) and the render
+// thread, some of the logic below needs to be rewritten. In particular
+// the WrWindowState and Notifier implementations aren't designed to work with
+// a separate render thread.
+// As part of that I am moving the bindings closer to WebRender's API boundary,
+// and moving more of the logic in C++ land.
+// This work is tracked by bug 1328602.
+//
+// See RenderThread.h for some notes about how the pieces fit together.
+
+pub struct WebRenderFrameBuilder {
+    pub root_pipeline_id: WrPipelineId,
+    pub dl_builder: DisplayListBuilder,
+}
+
+impl WebRenderFrameBuilder {
+    pub fn new(root_pipeline_id: WrPipelineId) -> WebRenderFrameBuilder {
+        WebRenderFrameBuilder {
+            root_pipeline_id,
+            dl_builder: DisplayListBuilder::new(root_pipeline_id),
+        }
+    }
+}
+
+pub struct WrState {
+    pipeline_id: WrPipelineId,
+    frame_builder: WebRenderFrameBuilder,
+}
+
+#[no_mangle]
+pub extern "C" fn wr_state_new(pipeline_id: WrPipelineId) -> *mut WrState {
+    assert!(unsafe { !is_in_render_thread() });
+
+    let state = Box::new(WrState {
+        pipeline_id,
+        frame_builder: WebRenderFrameBuilder::new(pipeline_id),
+    });
+
+    Box::into_raw(state)
+}
+
+#[no_mangle]
+pub extern "C" fn wr_state_delete(state: *mut WrState) {
+    assert!(unsafe { !is_in_render_thread() });
+
+    unsafe {
+        mem::drop(Box::from_raw(state));
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_save(state: &mut WrState) {
+    state.frame_builder.dl_builder.save();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_restore(state: &mut WrState) {
+    state.frame_builder.dl_builder.restore();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_clear_save(state: &mut WrState) {
+    state.frame_builder.dl_builder.clear_save();
+}
+
+#[repr(u8)]
+#[derive(PartialEq, Eq, Debug)]
+pub enum WrReferenceFrameKind {
+    Transform,
+    Perspective,
+}
+
+#[repr(u8)]
+#[derive(PartialEq, Eq, Debug)]
+pub enum WrRotation {
+    Degree0,
+    Degree90,
+    Degree180,
+    Degree270,
+}
+
+/// IMPORTANT: If you add fields to this struct, you need to also add initializers
+/// for those fields in WebRenderAPI.h.
+#[repr(C)]
+pub struct WrStackingContextParams {
+    pub clip: WrStackingContextClip,
+    pub animation: *const WrAnimationProperty,
+    pub opacity: *const f32,
+    pub computed_transform: *const WrComputedTransformData,
+    pub transform_style: TransformStyle,
+    pub reference_frame_kind: WrReferenceFrameKind,
+    pub is_2d_scale_translation: bool,
+    pub should_snap: bool,
+    pub paired_with_perspective: bool,
+    pub scrolling_relative_to: *const u64,
+    pub prim_flags: PrimitiveFlags,
+    pub mix_blend_mode: MixBlendMode,
+    pub flags: StackingContextFlags,
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_stacking_context(
+    state: &mut WrState,
+    bounds: LayoutRect,
+    spatial_id: WrSpatialId,
+    params: &WrStackingContextParams,
+    transform: *const WrTransformInfo,
+    filters: *const FilterOp,
+    filter_count: usize,
+    filter_datas: *const WrFilterData,
+    filter_datas_count: usize,
+    glyph_raster_space: RasterSpace,
+) -> WrSpatialId {
+    debug_assert!(unsafe { !is_in_render_thread() });
+
+    let c_filters = unsafe { make_slice(filters, filter_count) };
+    let mut filters: Vec<FilterOp> = c_filters.iter().copied().collect();
+
+    let c_filter_datas = unsafe { make_slice(filter_datas, filter_datas_count) };
+    let r_filter_datas: Vec<FilterData> = c_filter_datas
+        .iter()
+        .map(|c_filter_data| FilterData {
+            func_r_type: c_filter_data.funcR_type,
+            r_values: unsafe { make_slice(c_filter_data.R_values, c_filter_data.R_values_count).to_vec() },
+            func_g_type: c_filter_data.funcG_type,
+            g_values: unsafe { make_slice(c_filter_data.G_values, c_filter_data.G_values_count).to_vec() },
+            func_b_type: c_filter_data.funcB_type,
+            b_values: unsafe { make_slice(c_filter_data.B_values, c_filter_data.B_values_count).to_vec() },
+            func_a_type: c_filter_data.funcA_type,
+            a_values: unsafe { make_slice(c_filter_data.A_values, c_filter_data.A_values_count).to_vec() },
+        })
+        .collect();
+
+    let transform_ref = unsafe { transform.as_ref() };
+    let mut transform_binding = transform_ref.map(|info| (PropertyBinding::Value(info.transform), info.key));
+
+    let computed_ref = unsafe { params.computed_transform.as_ref() };
+    let opacity_ref = unsafe { params.opacity.as_ref() };
+    let mut has_opacity_animation = false;
+    let anim = unsafe { params.animation.as_ref() };
+    if let Some(anim) = anim {
+        debug_assert!(anim.id > 0);
+        match anim.effect_type {
+            WrAnimationType::Opacity => {
+                filters.push(FilterOp::Opacity(
+                    PropertyBinding::Binding(
+                        PropertyBindingKey::new(anim.id),
+                        // We have to set the static opacity value as
+                        // the value for the case where the animation is
+                        // in not in-effect (e.g. in the delay phase
+                        // with no corresponding fill mode).
+                        opacity_ref.cloned().unwrap_or(1.0),
+                    ),
+                    1.0,
+                ));
+                has_opacity_animation = true;
+            },
+            WrAnimationType::Transform => {
+                transform_binding = Some((
+                    PropertyBinding::Binding(
+                        PropertyBindingKey::new(anim.id),
+                        // Same as above opacity case.
+                        transform_ref
+                            .map(|info| info.transform)
+                            .unwrap_or_else(LayoutTransform::identity),
+                    ),
+                    anim.key,
+                ));
+            },
+            _ => unreachable!("{:?} should not create a stacking context", anim.effect_type),
+        }
+    }
+
+    if let Some(opacity) = opacity_ref {
+        if !has_opacity_animation && *opacity < 1.0 {
+            filters.push(FilterOp::Opacity(PropertyBinding::Value(*opacity), *opacity));
+        }
+    }
+
+    let mut wr_spatial_id = spatial_id.to_webrender(state.pipeline_id);
+    let wr_clip_id = params.clip.to_webrender(state.pipeline_id);
+
+    let mut origin = bounds.min;
+
+    // Note: 0 has special meaning in WR land, standing for ROOT_REFERENCE_FRAME.
+    // However, it is never returned by `push_reference_frame`, and we need to return
+    // an option here across FFI, so we take that 0 value for the None semantics.
+    // This is resolved into proper `Maybe<WrSpatialId>` inside `WebRenderAPI::PushStackingContext`.
+    let mut result = WrSpatialId { id: 0 };
+    if let Some(transform_binding) = transform_binding {
+        let scrolling_relative_to = match unsafe { params.scrolling_relative_to.as_ref() } {
+            Some(scroll_id) => {
+                debug_assert_eq!(params.reference_frame_kind, WrReferenceFrameKind::Perspective);
+                Some(ExternalScrollId(*scroll_id, state.pipeline_id))
+            },
+            None => None,
+        };
+
+        let reference_frame_kind = match params.reference_frame_kind {
+            WrReferenceFrameKind::Transform => ReferenceFrameKind::Transform {
+                is_2d_scale_translation: params.is_2d_scale_translation,
+                should_snap: params.should_snap,
+                paired_with_perspective: params.paired_with_perspective,
+            },
+            WrReferenceFrameKind::Perspective => ReferenceFrameKind::Perspective { scrolling_relative_to },
+        };
+        wr_spatial_id = state.frame_builder.dl_builder.push_reference_frame(
+            origin,
+            wr_spatial_id,
+            params.transform_style,
+            transform_binding.0,
+            reference_frame_kind,
+            transform_binding.1,
+        );
+
+        origin = LayoutPoint::zero();
+        result.id = wr_spatial_id.0;
+        assert_ne!(wr_spatial_id.0, 0);
+    } else if let Some(data) = computed_ref {
+        let rotation = match data.rotation {
+            WrRotation::Degree0 => Rotation::Degree0,
+            WrRotation::Degree90 => Rotation::Degree90,
+            WrRotation::Degree180 => Rotation::Degree180,
+            WrRotation::Degree270 => Rotation::Degree270,
+        };
+        wr_spatial_id = state.frame_builder.dl_builder.push_computed_frame(
+            origin,
+            wr_spatial_id,
+            Some(data.scale_from),
+            data.vertical_flip,
+            rotation,
+            data.key,
+        );
+
+        origin = LayoutPoint::zero();
+        result.id = wr_spatial_id.0;
+        assert_ne!(wr_spatial_id.0, 0);
+    }
+
+    state.frame_builder.dl_builder.push_stacking_context(
+        origin,
+        wr_spatial_id,
+        params.prim_flags,
+        wr_clip_id,
+        params.transform_style,
+        params.mix_blend_mode,
+        &filters,
+        &r_filter_datas,
+        &[],
+        glyph_raster_space,
+        params.flags,
+    );
+
+    result
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_pop_stacking_context(state: &mut WrState, is_reference_frame: bool) {
+    debug_assert!(unsafe { !is_in_render_thread() });
+    state.frame_builder.dl_builder.pop_stacking_context();
+    if is_reference_frame {
+        state.frame_builder.dl_builder.pop_reference_frame();
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_define_clipchain(
+    state: &mut WrState,
+    parent_clipchain_id: *const u64,
+    clips: *const WrClipId,
+    clips_count: usize,
+) -> u64 {
+    debug_assert!(unsafe { is_in_main_thread() });
+    let parent = unsafe { parent_clipchain_id.as_ref() }.map(|id| ClipChainId(*id, state.pipeline_id));
+
+    let pipeline_id = state.pipeline_id;
+    let clips = unsafe { make_slice(clips, clips_count) }
+        .iter()
+        .map(|clip_id| clip_id.to_webrender(pipeline_id));
+
+    let clipchain_id = state.frame_builder.dl_builder.define_clip_chain(parent, clips);
+    assert!(clipchain_id.1 == state.pipeline_id);
+    clipchain_id.0
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_define_image_mask_clip_with_parent_clip_chain(
+    state: &mut WrState,
+    space: WrSpatialId,
+    mask: ImageMask,
+    points: *const LayoutPoint,
+    point_count: usize,
+    fill_rule: FillRule,
+) -> WrClipId {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let c_points = unsafe { make_slice(points, point_count) };
+    let points: Vec<LayoutPoint> = c_points.iter().copied().collect();
+
+    let clip_id = state.frame_builder.dl_builder.define_clip_image_mask(
+        space.to_webrender(state.pipeline_id),
+        mask,
+        &points,
+        fill_rule,
+    );
+    WrClipId::from_webrender(clip_id)
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_define_rounded_rect_clip(
+    state: &mut WrState,
+    space: WrSpatialId,
+    complex: ComplexClipRegion,
+) -> WrClipId {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let clip_id = state
+        .frame_builder
+        .dl_builder
+        .define_clip_rounded_rect(space.to_webrender(state.pipeline_id), complex);
+    WrClipId::from_webrender(clip_id)
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_define_rect_clip(state: &mut WrState, space: WrSpatialId, clip_rect: LayoutRect) -> WrClipId {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let clip_id = state
+        .frame_builder
+        .dl_builder
+        .define_clip_rect(space.to_webrender(state.pipeline_id), clip_rect);
+    WrClipId::from_webrender(clip_id)
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_define_sticky_frame(
+    state: &mut WrState,
+    parent_spatial_id: WrSpatialId,
+    content_rect: LayoutRect,
+    top_margin: *const f32,
+    right_margin: *const f32,
+    bottom_margin: *const f32,
+    left_margin: *const f32,
+    vertical_bounds: StickyOffsetBounds,
+    horizontal_bounds: StickyOffsetBounds,
+    applied_offset: LayoutVector2D,
+    key: SpatialTreeItemKey,
+) -> WrSpatialId {
+    assert!(unsafe { is_in_main_thread() });
+    let spatial_id = state.frame_builder.dl_builder.define_sticky_frame(
+        parent_spatial_id.to_webrender(state.pipeline_id),
+        content_rect,
+        SideOffsets2D::new(
+            unsafe { top_margin.as_ref() }.cloned(),
+            unsafe { right_margin.as_ref() }.cloned(),
+            unsafe { bottom_margin.as_ref() }.cloned(),
+            unsafe { left_margin.as_ref() }.cloned(),
+        ),
+        vertical_bounds,
+        horizontal_bounds,
+        applied_offset,
+        key,
+    );
+
+    WrSpatialId { id: spatial_id.0 }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_define_scroll_layer(
+    state: &mut WrState,
+    external_scroll_id: u64,
+    parent: &WrSpatialId,
+    content_rect: LayoutRect,
+    clip_rect: LayoutRect,
+    scroll_offset: LayoutVector2D,
+    scroll_offset_generation: APZScrollGeneration,
+    has_scroll_linked_effect: HasScrollLinkedEffect,
+    key: SpatialTreeItemKey,
+) -> WrSpatialId {
+    assert!(unsafe { is_in_main_thread() });
+
+    let space_and_clip = state.frame_builder.dl_builder.define_scroll_frame(
+        parent.to_webrender(state.pipeline_id),
+        ExternalScrollId(external_scroll_id, state.pipeline_id),
+        content_rect,
+        clip_rect,
+        scroll_offset,
+        scroll_offset_generation,
+        has_scroll_linked_effect,
+        key,
+    );
+
+    WrSpatialId::from_webrender(space_and_clip)
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_iframe(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    _is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    pipeline_id: WrPipelineId,
+    ignore_missing_pipeline: bool,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    state.frame_builder.dl_builder.push_iframe(
+        rect,
+        clip,
+        &parent.to_webrender(state.pipeline_id),
+        pipeline_id,
+        ignore_missing_pipeline,
+    );
+}
+
+// A helper fn to construct a PrimitiveFlags
+fn prim_flags(is_backface_visible: bool, prefer_compositor_surface: bool) -> PrimitiveFlags {
+    let mut flags = PrimitiveFlags::empty();
+
+    if is_backface_visible {
+        flags |= PrimitiveFlags::IS_BACKFACE_VISIBLE;
+    }
+
+    if prefer_compositor_surface {
+        flags |= PrimitiveFlags::PREFER_COMPOSITOR_SURFACE;
+    }
+
+    flags
+}
+
+fn prim_flags2(
+    is_backface_visible: bool,
+    prefer_compositor_surface: bool,
+    supports_external_compositing: bool,
+) -> PrimitiveFlags {
+    let mut flags = PrimitiveFlags::empty();
+
+    if supports_external_compositing {
+        flags |= PrimitiveFlags::SUPPORTS_EXTERNAL_COMPOSITOR_SURFACE;
+    }
+
+    flags | prim_flags(is_backface_visible, prefer_compositor_surface)
+}
+
+fn common_item_properties_for_rect(
+    state: &mut WrState,
+    clip_rect: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+) -> CommonItemProperties {
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    CommonItemProperties {
+        // NB: the damp-e10s talos-test will frequently crash on startup if we
+        // early-return here for empty rects. I couldn't figure out why, but
+        // it's pretty harmless to feed these through, so, uh, we do?
+        clip_rect,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_rect(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    force_antialiasing: bool,
+    is_checkerboard: bool,
+    parent: &WrSpaceAndClipChain,
+    color: ColorF,
+) {
+    debug_assert!(unsafe { !is_in_render_thread() });
+
+    let mut prim_info = common_item_properties_for_rect(state, clip, is_backface_visible, parent);
+    if force_antialiasing {
+        prim_info.flags |= PrimitiveFlags::ANTIALISED;
+    }
+    if is_checkerboard {
+        prim_info.flags |= PrimitiveFlags::CHECKERBOARD_BACKGROUND;
+    }
+
+    state.frame_builder.dl_builder.push_rect(&prim_info, rect, color);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_rect_with_animation(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    color: ColorF,
+    animation: *const WrAnimationProperty,
+) {
+    debug_assert!(unsafe { !is_in_render_thread() });
+
+    let prim_info = common_item_properties_for_rect(state, clip, is_backface_visible, parent);
+
+    let anim = unsafe { animation.as_ref() };
+    if let Some(anim) = anim {
+        debug_assert!(anim.id > 0);
+        match anim.effect_type {
+            WrAnimationType::BackgroundColor => state.frame_builder.dl_builder.push_rect_with_animation(
+                &prim_info,
+                rect,
+                PropertyBinding::Binding(PropertyBindingKey::new(anim.id), color),
+            ),
+            _ => unreachable!("Didn't expect {:?} animation", anim.effect_type),
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_backdrop_filter(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    filters: *const FilterOp,
+    filter_count: usize,
+    filter_datas: *const WrFilterData,
+    filter_datas_count: usize,
+) {
+    debug_assert!(unsafe { !is_in_render_thread() });
+
+    let c_filters = unsafe { make_slice(filters, filter_count) };
+    let filters: Vec<FilterOp> = c_filters.iter().copied().collect();
+
+    let c_filter_datas = unsafe { make_slice(filter_datas, filter_datas_count) };
+    let filter_datas: Vec<FilterData> = c_filter_datas
+        .iter()
+        .map(|c_filter_data| FilterData {
+            func_r_type: c_filter_data.funcR_type,
+            r_values: unsafe { make_slice(c_filter_data.R_values, c_filter_data.R_values_count).to_vec() },
+            func_g_type: c_filter_data.funcG_type,
+            g_values: unsafe { make_slice(c_filter_data.G_values, c_filter_data.G_values_count).to_vec() },
+            func_b_type: c_filter_data.funcB_type,
+            b_values: unsafe { make_slice(c_filter_data.B_values, c_filter_data.B_values_count).to_vec() },
+            func_a_type: c_filter_data.funcA_type,
+            a_values: unsafe { make_slice(c_filter_data.A_values, c_filter_data.A_values_count).to_vec() },
+        })
+        .collect();
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let clip_rect = clip.intersection(&rect);
+    if clip_rect.is_none() {
+        return;
+    }
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip_rect.unwrap(),
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_backdrop_filter(&prim_info, &filters, &filter_datas, &[]);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_clear_rect(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip_rect: LayoutRect,
+    parent: &WrSpaceAndClipChain,
+) {
+    debug_assert!(unsafe { !is_in_render_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(true, /* prefer_compositor_surface */ false),
+    };
+
+    state.frame_builder.dl_builder.push_clear_rect(&prim_info, rect);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_hit_test(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    scroll_id: u64,
+    hit_info: u16,
+) {
+    debug_assert!(unsafe { !is_in_render_thread() });
+
+    let clip_rect = clip.intersection(&rect);
+    if clip_rect.is_none() {
+        return;
+    }
+    let tag = (scroll_id, hit_info);
+
+    let spatial_id = parent.space.to_webrender(state.pipeline_id);
+
+    let clip_chain_id = if parent.clip_chain == ROOT_CLIP_CHAIN {
+        ClipChainId::INVALID
+    } else {
+        ClipChainId(parent.clip_chain, state.pipeline_id)
+    };
+
+    state.frame_builder.dl_builder.push_hit_test(
+        clip_rect.unwrap(),
+        clip_chain_id,
+        spatial_id,
+        prim_flags(is_backface_visible, false),
+        tag,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_image(
+    state: &mut WrState,
+    bounds: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    force_antialiasing: bool,
+    parent: &WrSpaceAndClipChain,
+    image_rendering: ImageRendering,
+    key: WrImageKey,
+    premultiplied_alpha: bool,
+    color: ColorF,
+    prefer_compositor_surface: bool,
+    supports_external_compositing: bool,
+) {
+    debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let mut flags = prim_flags2(
+        is_backface_visible,
+        prefer_compositor_surface,
+        supports_external_compositing,
+    );
+
+    if force_antialiasing {
+        flags |= PrimitiveFlags::ANTIALISED;
+    }
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags,
+    };
+
+    let alpha_type = if premultiplied_alpha {
+        AlphaType::PremultipliedAlpha
+    } else {
+        AlphaType::Alpha
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_image(&prim_info, bounds, image_rendering, alpha_type, key, color);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_repeating_image(
+    state: &mut WrState,
+    bounds: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    stretch_size: LayoutSize,
+    tile_spacing: LayoutSize,
+    image_rendering: ImageRendering,
+    key: WrImageKey,
+    premultiplied_alpha: bool,
+    color: ColorF,
+) {
+    debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    let alpha_type = if premultiplied_alpha {
+        AlphaType::PremultipliedAlpha
+    } else {
+        AlphaType::Alpha
+    };
+
+    state.frame_builder.dl_builder.push_repeating_image(
+        &prim_info,
+        bounds,
+        stretch_size,
+        tile_spacing,
+        image_rendering,
+        alpha_type,
+        key,
+        color,
+    );
+}
+
+/// Push a 3 planar yuv image.
+#[no_mangle]
+pub extern "C" fn wr_dp_push_yuv_planar_image(
+    state: &mut WrState,
+    bounds: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    image_key_0: WrImageKey,
+    image_key_1: WrImageKey,
+    image_key_2: WrImageKey,
+    color_depth: WrColorDepth,
+    color_space: WrYuvColorSpace,
+    color_range: WrColorRange,
+    image_rendering: ImageRendering,
+    prefer_compositor_surface: bool,
+    supports_external_compositing: bool,
+) {
+    debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags2(
+            is_backface_visible,
+            prefer_compositor_surface,
+            supports_external_compositing,
+        ),
+    };
+
+    state.frame_builder.dl_builder.push_yuv_image(
+        &prim_info,
+        bounds,
+        YuvData::PlanarYCbCr(image_key_0, image_key_1, image_key_2),
+        color_depth,
+        color_space,
+        color_range,
+        image_rendering,
+    );
+}
+
+/// Push a 2 planar NV12 image.
+#[no_mangle]
+pub extern "C" fn wr_dp_push_yuv_NV12_image(
+    state: &mut WrState,
+    bounds: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    image_key_0: WrImageKey,
+    image_key_1: WrImageKey,
+    color_depth: WrColorDepth,
+    color_space: WrYuvColorSpace,
+    color_range: WrColorRange,
+    image_rendering: ImageRendering,
+    prefer_compositor_surface: bool,
+    supports_external_compositing: bool,
+) {
+    debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags2(
+            is_backface_visible,
+            prefer_compositor_surface,
+            supports_external_compositing,
+        ),
+    };
+
+    state.frame_builder.dl_builder.push_yuv_image(
+        &prim_info,
+        bounds,
+        YuvData::NV12(image_key_0, image_key_1),
+        color_depth,
+        color_space,
+        color_range,
+        image_rendering,
+    );
+}
+
+/// Push a 2 planar P010 image.
+#[no_mangle]
+pub extern "C" fn wr_dp_push_yuv_P010_image(
+    state: &mut WrState,
+    bounds: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    image_key_0: WrImageKey,
+    image_key_1: WrImageKey,
+    color_depth: WrColorDepth,
+    color_space: WrYuvColorSpace,
+    color_range: WrColorRange,
+    image_rendering: ImageRendering,
+    prefer_compositor_surface: bool,
+    supports_external_compositing: bool,
+) {
+    debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags2(
+            is_backface_visible,
+            prefer_compositor_surface,
+            supports_external_compositing,
+        ),
+    };
+
+    state.frame_builder.dl_builder.push_yuv_image(
+        &prim_info,
+        bounds,
+        YuvData::P010(image_key_0, image_key_1),
+        color_depth,
+        color_space,
+        color_range,
+        image_rendering,
+    );
+}
+
+/// Push a yuv interleaved image.
+#[no_mangle]
+pub extern "C" fn wr_dp_push_yuv_interleaved_image(
+    state: &mut WrState,
+    bounds: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    image_key_0: WrImageKey,
+    color_depth: WrColorDepth,
+    color_space: WrYuvColorSpace,
+    color_range: WrColorRange,
+    image_rendering: ImageRendering,
+    prefer_compositor_surface: bool,
+    supports_external_compositing: bool,
+) {
+    debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags2(
+            is_backface_visible,
+            prefer_compositor_surface,
+            supports_external_compositing,
+        ),
+    };
+
+    state.frame_builder.dl_builder.push_yuv_image(
+        &prim_info,
+        bounds,
+        YuvData::InterleavedYCbCr(image_key_0),
+        color_depth,
+        color_space,
+        color_range,
+        image_rendering,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_text(
+    state: &mut WrState,
+    bounds: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    color: ColorF,
+    font_key: WrFontInstanceKey,
+    glyphs: *const GlyphInstance,
+    glyph_count: u32,
+    glyph_options: *const GlyphOptions,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let glyph_slice = unsafe { make_slice(glyphs, glyph_count as usize) };
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        spatial_id: space_and_clip.spatial_id,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_text(&prim_info, bounds, &glyph_slice, font_key, color, unsafe {
+            glyph_options.as_ref().cloned()
+        });
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_shadow(
+    state: &mut WrState,
+    _bounds: LayoutRect,
+    _clip: LayoutRect,
+    _is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    shadow: Shadow,
+    should_inflate: bool,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_shadow(&parent.to_webrender(state.pipeline_id), shadow, should_inflate);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_pop_all_shadows(state: &mut WrState) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    state.frame_builder.dl_builder.pop_all_shadows();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_line(
+    state: &mut WrState,
+    clip: &LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    bounds: &LayoutRect,
+    wavy_line_thickness: f32,
+    orientation: LineOrientation,
+    color: &ColorF,
+    style: LineStyle,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: *clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_line(&prim_info, bounds, wavy_line_thickness, orientation, color, style);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_border(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    do_aa: AntialiasBorder,
+    widths: LayoutSideOffsets,
+    top: BorderSide,
+    right: BorderSide,
+    bottom: BorderSide,
+    left: BorderSide,
+    radius: BorderRadius,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let border_details = BorderDetails::Normal(NormalBorder {
+        left,
+        right,
+        top,
+        bottom,
+        radius,
+        do_aa: do_aa == AntialiasBorder::Yes,
+    });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_border(&prim_info, rect, widths, border_details);
+}
+
+#[repr(C)]
+pub struct WrBorderImage {
+    widths: LayoutSideOffsets,
+    image: WrImageKey,
+    image_rendering: ImageRendering,
+    width: i32,
+    height: i32,
+    fill: bool,
+    slice: DeviceIntSideOffsets,
+    repeat_horizontal: RepeatMode,
+    repeat_vertical: RepeatMode,
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_border_image(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    params: &WrBorderImage,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+    let border_details = BorderDetails::NinePatch(NinePatchBorder {
+        source: NinePatchBorderSource::Image(params.image, params.image_rendering),
+        width: params.width,
+        height: params.height,
+        slice: params.slice,
+        fill: params.fill,
+        repeat_horizontal: params.repeat_horizontal,
+        repeat_vertical: params.repeat_vertical,
+    });
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_border(&prim_info, rect, params.widths, border_details);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_border_gradient(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    widths: LayoutSideOffsets,
+    width: i32,
+    height: i32,
+    fill: bool,
+    slice: DeviceIntSideOffsets,
+    start_point: LayoutPoint,
+    end_point: LayoutPoint,
+    stops: *const GradientStop,
+    stops_count: usize,
+    extend_mode: ExtendMode,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let stops_slice = unsafe { make_slice(stops, stops_count) };
+    let stops_vector = stops_slice.to_owned();
+
+    let gradient = state
+        .frame_builder
+        .dl_builder
+        .create_gradient(start_point, end_point, stops_vector, extend_mode);
+
+    let border_details = BorderDetails::NinePatch(NinePatchBorder {
+        source: NinePatchBorderSource::Gradient(gradient),
+        width,
+        height,
+        slice,
+        fill,
+        repeat_horizontal: RepeatMode::Stretch,
+        repeat_vertical: RepeatMode::Stretch,
+    });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_border(&prim_info, rect, widths, border_details);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_border_radial_gradient(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    widths: LayoutSideOffsets,
+    fill: bool,
+    center: LayoutPoint,
+    radius: LayoutSize,
+    stops: *const GradientStop,
+    stops_count: usize,
+    extend_mode: ExtendMode,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let stops_slice = unsafe { make_slice(stops, stops_count) };
+    let stops_vector = stops_slice.to_owned();
+
+    let slice = SideOffsets2D::new(
+        widths.top as i32,
+        widths.right as i32,
+        widths.bottom as i32,
+        widths.left as i32,
+    );
+
+    let gradient = state
+        .frame_builder
+        .dl_builder
+        .create_radial_gradient(center, radius, stops_vector, extend_mode);
+
+    let border_details = BorderDetails::NinePatch(NinePatchBorder {
+        source: NinePatchBorderSource::RadialGradient(gradient),
+        width: rect.width() as i32,
+        height: rect.height() as i32,
+        slice,
+        fill,
+        repeat_horizontal: RepeatMode::Stretch,
+        repeat_vertical: RepeatMode::Stretch,
+    });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_border(&prim_info, rect, widths, border_details);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_border_conic_gradient(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    widths: LayoutSideOffsets,
+    fill: bool,
+    center: LayoutPoint,
+    angle: f32,
+    stops: *const GradientStop,
+    stops_count: usize,
+    extend_mode: ExtendMode,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let stops_slice = unsafe { make_slice(stops, stops_count) };
+    let stops_vector = stops_slice.to_owned();
+
+    let slice = SideOffsets2D::new(
+        widths.top as i32,
+        widths.right as i32,
+        widths.bottom as i32,
+        widths.left as i32,
+    );
+
+    let gradient = state
+        .frame_builder
+        .dl_builder
+        .create_conic_gradient(center, angle, stops_vector, extend_mode);
+
+    let border_details = BorderDetails::NinePatch(NinePatchBorder {
+        source: NinePatchBorderSource::ConicGradient(gradient),
+        width: rect.width() as i32,
+        height: rect.height() as i32,
+        slice,
+        fill,
+        repeat_horizontal: RepeatMode::Stretch,
+        repeat_vertical: RepeatMode::Stretch,
+    });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_border(&prim_info, rect, widths, border_details);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_linear_gradient(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    start_point: LayoutPoint,
+    end_point: LayoutPoint,
+    stops: *const GradientStop,
+    stops_count: usize,
+    extend_mode: ExtendMode,
+    tile_size: LayoutSize,
+    tile_spacing: LayoutSize,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let stops_slice = unsafe { make_slice(stops, stops_count) };
+    let stops_vector = stops_slice.to_owned();
+
+    let gradient = state
+        .frame_builder
+        .dl_builder
+        .create_gradient(start_point, end_point, stops_vector, extend_mode);
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_gradient(&prim_info, rect, gradient, tile_size, tile_spacing);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_radial_gradient(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    center: LayoutPoint,
+    radius: LayoutSize,
+    stops: *const GradientStop,
+    stops_count: usize,
+    extend_mode: ExtendMode,
+    tile_size: LayoutSize,
+    tile_spacing: LayoutSize,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let stops_slice = unsafe { make_slice(stops, stops_count) };
+    let stops_vector = stops_slice.to_owned();
+
+    let gradient = state
+        .frame_builder
+        .dl_builder
+        .create_radial_gradient(center, radius, stops_vector, extend_mode);
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_radial_gradient(&prim_info, rect, gradient, tile_size, tile_spacing);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_conic_gradient(
+    state: &mut WrState,
+    rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    center: LayoutPoint,
+    angle: f32,
+    stops: *const GradientStop,
+    stops_count: usize,
+    extend_mode: ExtendMode,
+    tile_size: LayoutSize,
+    tile_spacing: LayoutSize,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let stops_slice = unsafe { make_slice(stops, stops_count) };
+    let stops_vector = stops_slice.to_owned();
+
+    let gradient = state
+        .frame_builder
+        .dl_builder
+        .create_conic_gradient(center, angle, stops_vector, extend_mode);
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state
+        .frame_builder
+        .dl_builder
+        .push_conic_gradient(&prim_info, rect, gradient, tile_size, tile_spacing);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_box_shadow(
+    state: &mut WrState,
+    _rect: LayoutRect,
+    clip: LayoutRect,
+    is_backface_visible: bool,
+    parent: &WrSpaceAndClipChain,
+    box_bounds: LayoutRect,
+    offset: LayoutVector2D,
+    color: ColorF,
+    blur_radius: f32,
+    spread_radius: f32,
+    border_radius: BorderRadius,
+    clip_mode: BoxShadowClipMode,
+) {
+    debug_assert!(unsafe { is_in_main_thread() });
+
+    let space_and_clip = parent.to_webrender(state.pipeline_id);
+
+    let prim_info = CommonItemProperties {
+        clip_rect: clip,
+        clip_chain_id: space_and_clip.clip_chain_id,
+        spatial_id: space_and_clip.spatial_id,
+        flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false),
+    };
+
+    state.frame_builder.dl_builder.push_box_shadow(
+        &prim_info,
+        box_bounds,
+        offset,
+        color,
+        blur_radius,
+        spread_radius,
+        border_radius,
+        clip_mode,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_start_item_group(state: &mut WrState) {
+    state.frame_builder.dl_builder.start_item_group();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_cancel_item_group(state: &mut WrState, discard: bool) {
+    state.frame_builder.dl_builder.cancel_item_group(discard);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_finish_item_group(state: &mut WrState, key: ItemKey) -> bool {
+    state.frame_builder.dl_builder.finish_item_group(key)
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_push_reuse_items(state: &mut WrState, key: ItemKey) {
+    state.frame_builder.dl_builder.push_reuse_items(key);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dp_set_cache_size(state: &mut WrState, cache_size: usize) {
+    state.frame_builder.dl_builder.set_cache_size(cache_size);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dump_display_list(
+    state: &mut WrState,
+    indent: usize,
+    start: *const usize,
+    end: *const usize,
+) -> usize {
+    let start = unsafe { start.as_ref().cloned() };
+    let end = unsafe { end.as_ref().cloned() };
+    let range = Range { start, end };
+    let mut sink = Cursor::new(Vec::new());
+    let index = state
+        .frame_builder
+        .dl_builder
+        .emit_display_list(indent, range, &mut sink);
+
+    // For Android, dump to logcat instead of stderr. This is the same as
+    // what printf_stderr does on the C++ side.
+
+    #[cfg(target_os = "android")]
+    unsafe {
+        let gecko = CString::new("Gecko").unwrap();
+        let sink = CString::new(sink.into_inner()).unwrap();
+        __android_log_write(4 /* info */, gecko.as_ptr(), sink.as_ptr());
+    }
+
+    #[cfg(not(target_os = "android"))]
+    eprint!("{}", String::from_utf8(sink.into_inner()).unwrap());
+
+    index
+}
+
+#[no_mangle]
+pub extern "C" fn wr_dump_serialized_display_list(state: &mut WrState) {
+    state.frame_builder.dl_builder.dump_serialized_display_list();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_begin_builder(state: &mut WrState) {
+    state.frame_builder.dl_builder.begin();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_api_end_builder(
+    state: &mut WrState,
+    dl_descriptor: &mut BuiltDisplayListDescriptor,
+    dl_items_data: &mut WrVecU8,
+    dl_cache_data: &mut WrVecU8,
+    dl_spatial_tree: &mut WrVecU8,
+) {
+    let (_, dl) = state.frame_builder.dl_builder.end();
+    let (payload, descriptor) = dl.into_data();
+    *dl_items_data = WrVecU8::from_vec(payload.items_data);
+    *dl_cache_data = WrVecU8::from_vec(payload.cache_data);
+    *dl_spatial_tree = WrVecU8::from_vec(payload.spatial_tree);
+    *dl_descriptor = descriptor;
+}
+
+#[repr(C)]
+pub struct HitResult {
+    pipeline_id: WrPipelineId,
+    scroll_id: u64,
+    animation_id: u64,
+    hit_info: u16,
+}
+
+#[no_mangle]
+pub extern "C" fn wr_api_hit_test(dh: &mut DocumentHandle, point: WorldPoint, out_results: &mut ThinVec<HitResult>) {
+    let result = dh.ensure_hit_tester().hit_test(point);
+    for item in &result.items {
+        out_results.push(HitResult {
+            pipeline_id: item.pipeline,
+            scroll_id: item.tag.0,
+            animation_id: item.animation_id,
+            hit_info: item.tag.1,
+        });
+    }
+}
+
+pub type VecU8 = Vec<u8>;
+pub type ArcVecU8 = Arc<VecU8>;
+
+#[no_mangle]
+pub extern "C" fn wr_add_ref_arc(arc: &ArcVecU8) -> *const VecU8 {
+    Arc::into_raw(arc.clone())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_dec_ref_arc(arc: *const VecU8) {
+    Arc::from_raw(arc);
+}
+
+// TODO: nical
+// Update for the new blob image interface changes.
+//
+extern "C" {
+    // TODO: figure out the API for tiled blob images.
+    pub fn wr_moz2d_render_cb(
+        blob: ByteSlice,
+        format: ImageFormat,
+        render_rect: &LayoutIntRect,
+        visible_rect: &DeviceIntRect,
+        tile_size: u16,
+        tile_offset: &TileOffset,
+        dirty_rect: Option<&LayoutIntRect>,
+        output: MutByteSlice,
+    ) -> bool;
+}
+
+#[no_mangle]
+pub extern "C" fn wr_root_scroll_node_id() -> WrSpatialId {
+    // The PipelineId doesn't matter here, since we just want the numeric part of the id
+    // produced for any given root reference frame.
+    WrSpatialId {
+        id: SpatialId::root_scroll_node(PipelineId(0, 0)).0,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wr_root_clip_id() -> WrClipId {
+    // The PipelineId doesn't matter here, since we just want the numeric part of the id
+    // produced for any given root reference frame.
+    WrClipId::from_webrender(ClipId::root(PipelineId(0, 0)))
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct WrClipId {
+    id: usize,
+}
+
+impl WrClipId {
+    fn to_webrender(&self, pipeline_id: WrPipelineId) -> ClipId {
+        ClipId(self.id, pipeline_id)
+    }
+
+    fn from_webrender(clip_id: ClipId) -> Self {
+        WrClipId { id: clip_id.0 }
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct WrSpatialId {
+    id: usize,
+}
+
+impl WrSpatialId {
+    fn to_webrender(&self, pipeline_id: WrPipelineId) -> SpatialId {
+        SpatialId::new(self.id, pipeline_id)
+    }
+
+    fn from_webrender(id: SpatialId) -> Self {
+        WrSpatialId { id: id.0 }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_device_delete(device: *mut Device) {
+    mem::drop(Box::from_raw(device));
+}
+
+// Call MakeCurrent before this.
+#[no_mangle]
+pub extern "C" fn wr_shaders_new(
+    gl_context: *mut c_void,
+    program_cache: Option<&mut WrProgramCache>,
+    precache_shaders: bool,
+) -> *mut WrShaders {
+    let mut device = wr_device_new(gl_context, program_cache);
+
+    let precache_flags = if precache_shaders || env_var_to_bool("MOZ_WR_PRECACHE_SHADERS") {
+        ShaderPrecacheFlags::FULL_COMPILE
+    } else {
+        ShaderPrecacheFlags::ASYNC_COMPILE
+    };
+
+    let opts = WebRenderOptions {
+        precache_flags,
+        ..Default::default()
+    };
+
+    let gl_type = device.gl().get_type();
+    device.begin_frame();
+
+    let shaders = Rc::new(RefCell::new(match Shaders::new(&mut device, gl_type, &opts) {
+        Ok(shaders) => shaders,
+        Err(e) => {
+            warn!(" Failed to create a Shaders: {:?}", e);
+            let msg = CString::new(format!("wr_shaders_new: {:?}", e)).unwrap();
+            unsafe {
+                gfx_critical_note(msg.as_ptr());
+            }
+            return ptr::null_mut();
+        },
+    }));
+
+    let shaders = WrShaders(shaders);
+
+    device.end_frame();
+    Box::into_raw(Box::new(shaders))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_shaders_delete(shaders: *mut WrShaders, gl_context: *mut c_void) {
+    let mut device = wr_device_new(gl_context, None);
+    let shaders = Box::from_raw(shaders);
+    if let Ok(shaders) = Rc::try_unwrap(shaders.0) {
+        shaders.into_inner().deinit(&mut device);
+    }
+    // let shaders go out of scope and get dropped
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wr_program_cache_report_memory(
+    cache: *const WrProgramCache,
+    size_of_op: VoidPtrToSizeFn,
+) -> usize {
+    (*cache).program_cache.report_memory(size_of_op)
+}
diff --git a/gfx/webrender_bindings/src/lib.rs b/gfx/webrender_bindings/src/lib.rs
new file mode 100644
index 0000000000..9e94302e0f
--- /dev/null
+++ b/gfx/webrender_bindings/src/lib.rs
@@ -0,0 +1,43 @@
+/* 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/. */
+
+#![deny(warnings)]
+
+extern crate app_units;
+extern crate bincode;
+extern crate euclid;
+extern crate fxhash;
+extern crate gecko_profiler;
+extern crate gleam;
+extern crate nsstring;
+extern crate num_cpus;
+extern crate rayon;
+extern crate swgl;
+extern crate thin_vec;
+extern crate tracy_rs;
+extern crate uuid;
+extern crate webrender;
+extern crate wr_malloc_size_of;
+
+#[macro_use]
+extern crate log;
+
+#[cfg(target_os = "windows")]
+extern crate dwrote;
+#[cfg(target_os = "windows")]
+extern crate winapi;
+
+#[cfg(target_os = "macos")]
+extern crate core_foundation;
+#[cfg(target_os = "macos")]
+extern crate core_graphics;
+#[cfg(target_os = "macos")]
+extern crate foreign_types;
+
+mod program_cache;
+
+#[allow(non_snake_case)]
+pub mod bindings;
+pub mod moz2d_renderer;
+mod swgl_bindings;
diff --git a/gfx/webrender_bindings/src/moz2d_renderer.rs b/gfx/webrender_bindings/src/moz2d_renderer.rs
new file mode 100644
index 0000000000..4c7a32c912
--- /dev/null
+++ b/gfx/webrender_bindings/src/moz2d_renderer.rs
@@ -0,0 +1,871 @@
+/* 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/. */
+#![deny(missing_docs)]
+
+//! Provides the webrender-side implementation of gecko blob images.
+//!
+//! Pretty much this is just a shim that calls back into Moz2DImageRenderer, but
+//! it also handles merging "partial" blob images (see `merge_blob_images`) and
+//! registering fonts found in the blob (see `prepare_request`).
+
+use bindings::{
+    gecko_profiler_end_marker, gecko_profiler_start_marker, wr_moz2d_render_cb, ArcVecU8, ByteSlice, MutByteSlice,
+};
+use gecko_profiler::gecko_profiler_label;
+use rayon::prelude::*;
+use rayon::ThreadPool;
+use webrender::api::units::{BlobDirtyRect, BlobToDeviceTranslation, DeviceIntRect};
+use webrender::api::*;
+
+use euclid::point2;
+use std;
+use std::collections::btree_map::BTreeMap;
+use std::collections::hash_map;
+use std::collections::hash_map::HashMap;
+use std::collections::Bound::Included;
+use std::i32;
+use std::mem;
+use std::os::raw::c_void;
+use std::ptr;
+use std::sync::Arc;
+
+#[cfg(target_os = "windows")]
+use dwrote;
+
+#[cfg(target_os = "macos")]
+use core_foundation::string::CFString;
+#[cfg(target_os = "macos")]
+use core_graphics::font::CGFont;
+#[cfg(target_os = "macos")]
+use foreign_types::ForeignType;
+
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+use std::ffi::CString;
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+use std::os::unix::ffi::OsStrExt;
+
+/// Local print-debugging utility
+macro_rules! dlog {
+    ($($e:expr),*) => { {$(let _ = $e;)*} }
+    //($($t:tt)*) => { println!($($t)*) }
+}
+
+/// Debug prints a blob's item bounds, indicating whether the bounds are dirty or not.
+fn dump_bounds(blob: &[u8], dirty_rect: DeviceIntRect) {
+    let mut index = BlobReader::new(blob);
+    while index.reader.has_more() {
+        let e = index.read_entry();
+        dlog!(
+            "  {:?} {}",
+            e.bounds,
+            if dirty_rect.contains_box(&e.bounds) { "*" } else { "" }
+        );
+    }
+}
+
+/// Debug prints a blob's metadata.
+fn dump_index(blob: &[u8]) {
+    let mut index = BlobReader::new(blob);
+    // we might get an empty result here because sub groups are not tightly bound
+    // and we'll sometimes have display items that end up with empty bounds in
+    // the blob image.
+    while index.reader.has_more() {
+        let e = index.read_entry();
+        dlog!("result bounds: {} {} {:?}", e.end, e.extra_end, e.bounds);
+    }
+}
+
+/// Handles the interpretation and rasterization of gecko-based (moz2d) WR blob images.
+pub struct Moz2dBlobImageHandler {
+    workers: Arc<ThreadPool>,
+    workers_low_priority: Arc<ThreadPool>,
+    blob_commands: HashMap<BlobImageKey, BlobCommand>,
+    enable_multithreading: bool,
+}
+
+/// Transmute some bytes into a value.
+///
+/// FIXME: kill this with fire and/or do a super robust security audit
+unsafe fn convert_from_bytes<T: Copy>(slice: &[u8]) -> T {
+    assert!(mem::size_of::<T>() <= slice.len());
+    ptr::read_unaligned(slice.as_ptr() as *const T)
+}
+
+/// Transmute a value into some bytes.
+fn convert_to_bytes<T>(x: &T) -> &[u8] {
+    unsafe {
+        let ip: *const T = x;
+        let bp: *const u8 = ip as *const _;
+        ::std::slice::from_raw_parts(bp, mem::size_of::<T>())
+    }
+}
+
+/// A simple helper for deserializing a bunch of transmuted POD data from bytes.
+struct BufReader<'a> {
+    /// The buffer to read from.
+    buf: &'a [u8],
+    /// Where we currently are reading from.
+    pos: usize,
+}
+
+impl<'a> BufReader<'a> {
+    /// Creates a reader over the given input.
+    fn new(buf: &'a [u8]) -> BufReader<'a> {
+        BufReader { buf, pos: 0 }
+    }
+
+    /// Transmute-deserializes a value of type T from the stream.
+    ///
+    /// !!! SUPER DANGEROUS !!!
+    ///
+    /// To limit the scope of this unsafety, please don't call this directly.
+    /// Make a helper method for each whitelisted type.
+    unsafe fn read<T: Copy>(&mut self) -> T {
+        let ret = convert_from_bytes(&self.buf[self.pos..]);
+        self.pos += mem::size_of::<T>();
+        ret
+    }
+
+    /// Deserializes a BlobFont.
+    fn read_blob_font(&mut self) -> BlobFont {
+        unsafe { self.read::<BlobFont>() }
+    }
+
+    /// Deserializes a usize.
+    fn read_usize(&mut self) -> usize {
+        unsafe { self.read::<usize>() }
+    }
+
+    /// Deserializes a rectangle.
+    fn read_box(&mut self) -> DeviceIntRect {
+        unsafe { self.read::<DeviceIntRect>() }
+    }
+
+    /// Returns whether the buffer has more data to deserialize.
+    fn has_more(&self) -> bool {
+        self.pos < self.buf.len()
+    }
+}
+
+/// Reads the metadata of a blob image.
+///
+/// Blob stream format:
+/// { data[..], index[..], offset in the stream of the index array }
+///
+/// An 'item' has 'data' and 'extra_data'
+///  - In our case the 'data' is the stream produced by DrawTargetRecording
+///    and the 'extra_data' includes things like webrender font keys
+///
+/// The index is an array of entries of the following form:
+/// { end, extra_end, bounds }
+///
+/// - end is the offset of the end of an item's data
+///   an item's data goes from the begining of the stream or
+///   the begining of the last item til end
+/// - extra_end is the offset of the end of an item's extra data
+///   an item's extra data goes from 'end' until 'extra_end'
+/// - bounds is a set of 4 ints { min.x, min.y, max.x, max.y }
+///
+/// The offsets in the index should be monotonically increasing.
+///
+/// Design rationale:
+///  - the index is smaller so we append it to the end of the data array
+///  during construction. This makes it more likely that we'll fit inside
+///  the data Vec
+///  - we use indices/offsets instead of sizes to avoid having to deal with any
+///  arithmetic that might overflow.
+struct BlobReader<'a> {
+    /// The buffer of the blob.
+    reader: BufReader<'a>,
+    /// Where the buffer head is.
+    begin: usize,
+}
+
+#[derive(PartialEq, Debug, Eq, Clone, Copy)]
+struct IntPoint {
+    x: i32,
+    y: i32,
+}
+
+/// The metadata for each display item in a blob image (doesn't match the serialized layout).
+///
+/// See BlobReader above for detailed docs of the blob image format.
+struct Entry {
+    /// The bounds of the display item.
+    bounds: DeviceIntRect,
+    /// Where the item's recorded drawing commands start.
+    begin: usize,
+    /// Where the item's recorded drawing commands end, and its extra data starts.
+    end: usize,
+    /// Where the item's extra data ends, and the next item's `begin`.
+    extra_end: usize,
+}
+
+impl<'a> BlobReader<'a> {
+    /// Creates a new BlobReader for the given buffer.
+    fn new(buf: &'a [u8]) -> BlobReader<'a> {
+        // The offset of the index is at the end of the buffer.
+        let index_offset_pos = buf.len() - mem::size_of::<usize>();
+        assert!(index_offset_pos < buf.len());
+        let index_offset = unsafe { convert_from_bytes::<usize>(&buf[index_offset_pos..]) };
+
+        BlobReader {
+            reader: BufReader::new(&buf[index_offset..index_offset_pos]),
+            begin: 0,
+        }
+    }
+
+    /// Reads the next display item's metadata.
+    fn read_entry(&mut self) -> Entry {
+        let end = self.reader.read_usize();
+        let extra_end = self.reader.read_usize();
+        let bounds = self.reader.read_box();
+        let ret = Entry {
+            begin: self.begin,
+            end,
+            extra_end,
+            bounds,
+        };
+        self.begin = extra_end;
+        ret
+    }
+}
+
+/// Writes new blob images.
+///
+/// In our case this is the result of merging an old one and a new one
+struct BlobWriter {
+    /// The buffer that the data and extra data for the items is accumulated.
+    data: Vec<u8>,
+    /// The buffer that the metadata for the items is accumulated.
+    index: Vec<u8>,
+}
+
+impl BlobWriter {
+    /// Creates an empty BlobWriter.
+    fn new() -> BlobWriter {
+        BlobWriter {
+            data: Vec::new(),
+            index: Vec::new(),
+        }
+    }
+
+    /// Writes a display item to the blob.
+    fn new_entry(&mut self, extra_size: usize, bounds: DeviceIntRect, data: &[u8]) {
+        self.data.extend_from_slice(data);
+        // Write 'end' to the index: the offset where the regular data ends and the extra data starts.
+        self.index
+            .extend_from_slice(convert_to_bytes(&(self.data.len() - extra_size)));
+        // Write 'extra_end' to the index: the offset where the extra data ends.
+        self.index.extend_from_slice(convert_to_bytes(&self.data.len()));
+        // XXX: we can aggregate these writes
+        // Write the bounds to the index.
+        self.index.extend_from_slice(convert_to_bytes(&bounds.min.x));
+        self.index.extend_from_slice(convert_to_bytes(&bounds.min.y));
+        self.index.extend_from_slice(convert_to_bytes(&bounds.max.x));
+        self.index.extend_from_slice(convert_to_bytes(&bounds.max.y));
+    }
+
+    /// Completes the blob image, producing a single buffer containing it.
+    fn finish(mut self) -> Vec<u8> {
+        // Append the index to the end of the buffer
+        // and then append the offset to the beginning of the index.
+        let index_begin = self.data.len();
+        self.data.extend_from_slice(&self.index);
+        self.data.extend_from_slice(convert_to_bytes(&index_begin));
+        self.data
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct CacheKey {
+    x1: i32,
+    y1: i32,
+    x2: i32,
+    y2: i32,
+    cache_order: u32,
+}
+
+impl CacheKey {
+    pub fn new(bounds: DeviceIntRect, cache_order: u32) -> Self {
+        CacheKey {
+            x1: bounds.min.x,
+            y1: bounds.min.y,
+            x2: bounds.max.x,
+            y2: bounds.max.y,
+            cache_order,
+        }
+    }
+}
+
+/// Provides an API for looking up the display items in a blob image by bounds, yielding items
+/// with equal bounds in their original relative ordering.
+///
+/// This is used to implement `merge_blobs_images`.
+///
+/// We use a BTree as a kind of multi-map, by appending an integer "cache_order" to the key.
+/// This lets us use multiple items with matching bounds in the map and allows
+/// us to fetch and remove them while retaining the ordering of the original list.
+struct CachedReader<'a> {
+    /// Wrapped reader.
+    reader: BlobReader<'a>,
+    /// Cached entries that have been read but not yet requested by our consumer.
+    cache: BTreeMap<CacheKey, Entry>,
+    /// The current number of internally read display items, used to preserve list order.
+    cache_index_counter: u32,
+}
+
+impl<'a> CachedReader<'a> {
+    /// Creates a new CachedReader.
+    pub fn new(buf: &'a [u8]) -> CachedReader {
+        CachedReader {
+            reader: BlobReader::new(buf),
+            cache: BTreeMap::new(),
+            cache_index_counter: 0,
+        }
+    }
+
+    /// Tries to find the given bounds in the cache of internally read items, removing it if found.
+    fn take_entry_with_bounds_from_cache(&mut self, bounds: &DeviceIntRect) -> Option<Entry> {
+        if self.cache.is_empty() {
+            return None;
+        }
+
+        let key_to_delete = match self
+            .cache
+            .range((
+                Included(CacheKey::new(*bounds, 0u32)),
+                Included(CacheKey::new(*bounds, std::u32::MAX)),
+            ))
+            .next()
+        {
+            Some((&key, _)) => key,
+            None => return None,
+        };
+
+        Some(
+            self.cache
+                .remove(&key_to_delete)
+                .expect("We just got this key from range, it needs to be present"),
+        )
+    }
+
+    /// Yields the next item in the blob image with the given bounds.
+    ///
+    /// If the given bounds aren't found in the blob, this panics. `merge_blob_images` should
+    /// avoid this by construction if the blob images are well-formed.
+    pub fn next_entry_with_bounds(&mut self, bounds: &DeviceIntRect, ignore_rect: &DeviceIntRect) -> Entry {
+        if let Some(entry) = self.take_entry_with_bounds_from_cache(bounds) {
+            return entry;
+        }
+
+        loop {
+            // This will panic if we run through the whole list without finding our bounds.
+            let old = self.reader.read_entry();
+            if old.bounds == *bounds {
+                return old;
+            } else if !ignore_rect.contains_box(&old.bounds) {
+                self.cache
+                    .insert(CacheKey::new(old.bounds, self.cache_index_counter), old);
+                self.cache_index_counter += 1;
+            }
+        }
+    }
+}
+
+/// Merges a new partial blob image into an existing complete one.
+///
+/// A blob image represents a recording of the drawing commands needed to render
+/// (part of) a display list. A partial blob image is a diff between the old display
+/// list and a new one. It contains an entry for every display item in the new list, but
+/// the actual drawing commands are missing for any item that isn't strictly contained
+/// in the dirty rect. This is possible because not being contained in the dirty
+/// rect implies that the item is unchanged between the old and new list, so we can
+/// just grab the drawing commands from the old list.
+///
+/// The dirty rect strictly contains the bounds of every item that has been inserted
+/// into or deleted from the old list to create the new list. (For simplicity
+/// you may think of any other update as deleting and reinserting the item).
+///
+/// Partial blobs are based on gecko's "retained display list" system, and
+/// in particular rely on one key property: if two items have overlapping bounds
+/// and *aren't* contained in the dirty rect, then their relative order in both
+/// the old and new list will not change. This lets us uniquely identify a display
+/// item using only its bounds and relative order in the list.
+///
+/// That is, the first non-dirty item in the new list with bounds (10, 15, 100, 100)
+/// is *also* the first non-dirty item in the old list with those bounds.
+///
+/// Note that *every* item contained inside the dirty rect will be fully recorded in
+/// the new list, even if it is actually unchanged from the old list.
+///
+/// All of this together gives us a fairly simple merging algorithm: all we need
+/// to do is walk through the new (partial) list, determine which of the two lists
+/// has the recording for that item, and copy the recording into the result.
+///
+/// If an item is contained in the dirty rect, then the new list contains the
+/// correct recording for that item, so we always copy it from there. Otherwise, we find
+/// the first not-yet-copied item with those bounds in the old list and copy that.
+/// Any items found in the old list but not the new one can be safely assumed to
+/// have been deleted.
+fn merge_blob_images(
+    old_buf: &[u8],
+    new_buf: &[u8],
+    dirty_rect: DeviceIntRect,
+    old_visible_rect: DeviceIntRect,
+    new_visible_rect: DeviceIntRect,
+) -> Vec<u8> {
+    let mut result = BlobWriter::new();
+    dlog!("dirty rect: {:?}", dirty_rect);
+    dlog!("old:");
+    dump_bounds(old_buf, dirty_rect);
+    dlog!("new:");
+    dump_bounds(new_buf, dirty_rect);
+    dlog!("old visibile rect: {:?}", old_visible_rect);
+    dlog!("new visibile rect: {:?}", new_visible_rect);
+
+    let mut old_reader = CachedReader::new(old_buf);
+    let mut new_reader = BlobReader::new(new_buf);
+    let preserved_rect = old_visible_rect.intersection_unchecked(&new_visible_rect);
+
+    // Loop over both new and old entries merging them.
+    // Both new and old must have the same number of entries that
+    // overlap but are not contained by the dirty rect, and they
+    // must be in the same order.
+    while new_reader.reader.has_more() {
+        let new = new_reader.read_entry();
+        dlog!("bounds: {} {} {:?}", new.end, new.extra_end, new.bounds);
+        let preserved_bounds = new.bounds.intersection_unchecked(&preserved_rect);
+        if dirty_rect.contains_box(&preserved_bounds) {
+            result.new_entry(new.extra_end - new.end, new.bounds, &new_buf[new.begin..new.extra_end]);
+        } else {
+            let old = old_reader.next_entry_with_bounds(&new.bounds, &dirty_rect);
+            result.new_entry(old.extra_end - old.end, new.bounds, &old_buf[old.begin..old.extra_end])
+        }
+    }
+
+    // XXX: future work: ensure that items that have been deleted but aren't in the blob's visible
+    // rect don't affect the dirty rect -- this allows us to scroll content out of view while only
+    // updating the areas where items have been scrolled *into* view. This is very important for
+    // the performance of blobs that are larger than the viewport. When this is done this
+    // assertion will need to be modified to factor in the visible rect, or removed.
+
+    // Ensure all remaining items will be discarded
+    while old_reader.reader.reader.has_more() {
+        let old = old_reader.reader.read_entry();
+        dlog!("new bounds: {} {} {:?}", old.end, old.extra_end, old.bounds);
+        //assert!(dirty_rect.contains_box(&old.bounds));
+    }
+
+    //assert!(old_reader.cache.is_empty());
+
+    let result = result.finish();
+    dump_index(&result);
+    result
+}
+
+/// A font used by a blob image.
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct BlobFont {
+    /// The font key.
+    font_instance_key: FontInstanceKey,
+    /// A pointer to the scaled font.
+    scaled_font_ptr: u64,
+}
+
+/// A blob image and extra data provided by webrender on how to rasterize it.
+#[derive(Clone)]
+struct BlobCommand {
+    /// The blob.
+    data: Arc<BlobImageData>,
+    /// What part of the blob should be rasterized (visible_rect's top-left corresponds to
+    /// (0,0) in the blob's rasterization)
+    visible_rect: DeviceIntRect,
+    /// The size of the tiles to use in rasterization.
+    tile_size: TileSize,
+}
+
+struct Job {
+    request: BlobImageRequest,
+    descriptor: BlobImageDescriptor,
+    commands: Arc<BlobImageData>,
+    dirty_rect: BlobDirtyRect,
+    visible_rect: DeviceIntRect,
+    tile_size: TileSize,
+}
+
+/// Rasterizes gecko blob images.
+struct Moz2dBlobRasterizer {
+    /// Pool of rasterizers.
+    workers: Arc<ThreadPool>,
+    /// Pool of low priority rasterizers.
+    workers_low_priority: Arc<ThreadPool>,
+    /// Blobs to rasterize.
+    blob_commands: HashMap<BlobImageKey, BlobCommand>,
+    ///
+    enable_multithreading: bool,
+}
+
+struct GeckoProfilerMarker {
+    name: &'static str,
+}
+
+impl GeckoProfilerMarker {
+    pub fn new(name: &'static str) -> GeckoProfilerMarker {
+        gecko_profiler_start_marker(name);
+        GeckoProfilerMarker { name }
+    }
+}
+
+impl Drop for GeckoProfilerMarker {
+    fn drop(&mut self) {
+        gecko_profiler_end_marker(self.name);
+    }
+}
+
+impl AsyncBlobImageRasterizer for Moz2dBlobRasterizer {
+    fn rasterize(
+        &mut self,
+        requests: &[BlobImageParams],
+        low_priority: bool,
+    ) -> Vec<(BlobImageRequest, BlobImageResult)> {
+        // All we do here is spin up our workers to callback into gecko to replay the drawing commands.
+        gecko_profiler_label!(Graphics, Rasterization);
+        let _marker = GeckoProfilerMarker::new("BlobRasterization");
+
+        let requests: Vec<Job> = requests
+            .iter()
+            .map(|params| {
+                let command = &self.blob_commands[&params.request.key];
+                let blob = Arc::clone(&command.data);
+                assert!(!params.descriptor.rect.is_empty());
+
+                Job {
+                    request: params.request,
+                    descriptor: params.descriptor,
+                    commands: blob,
+                    visible_rect: command.visible_rect,
+                    dirty_rect: params.dirty_rect,
+                    tile_size: command.tile_size,
+                }
+            })
+            .collect();
+
+        // If we don't have a lot of blobs it is probably not worth the initial cost
+        // of installing work on rayon's thread pool so we do it serially on this thread.
+        let should_parallelize = if !self.enable_multithreading {
+            false
+        } else if low_priority {
+            requests.len() > 2
+        } else {
+            // For high priority requests we don't "risk" the potential priority inversion of
+            // dispatching to a thread pool full of low priority jobs unless it is really
+            // appealing.
+            requests.len() > 4
+        };
+
+        if should_parallelize {
+            // Parallel version synchronously installs a job on the thread pool which will
+            // try to do the work in parallel.
+            // This thread is blocked until the thread pool is done doing the work.
+            let lambda = || requests.into_par_iter().map(rasterize_blob).collect();
+            if low_priority {
+                //TODO --bpe runtime flag to A/B test these two
+                self.workers_low_priority.install(lambda)
+            //self.workers.install(lambda)
+            } else {
+                self.workers.install(lambda)
+            }
+        } else {
+            requests.into_iter().map(rasterize_blob).collect()
+        }
+    }
+}
+
+// a cross platform wrapper that creates an autorelease pool
+// on macOS
+fn autoreleasepool<T, F: FnOnce() -> T>(f: F) -> T {
+    #[cfg(target_os = "macos")]
+    {
+        objc::rc::autoreleasepool(f)
+    }
+    #[cfg(not(target_os = "macos"))]
+    {
+        f()
+    }
+}
+
+fn rasterize_blob(job: Job) -> (BlobImageRequest, BlobImageResult) {
+    gecko_profiler_label!(Graphics, Rasterization);
+    let descriptor = job.descriptor;
+    let buf_size = (descriptor.rect.area() * descriptor.format.bytes_per_pixel()) as usize;
+
+    let mut output = vec![0u8; buf_size];
+
+    let dirty_rect = match job.dirty_rect {
+        DirtyRect::Partial(rect) => Some(rect),
+        DirtyRect::All => None,
+    };
+    assert!(!descriptor.rect.is_empty());
+
+    let result = autoreleasepool(|| {
+        unsafe {
+            if wr_moz2d_render_cb(
+                ByteSlice::new(&job.commands[..]),
+                descriptor.format,
+                &descriptor.rect,
+                &job.visible_rect,
+                job.tile_size,
+                &job.request.tile,
+                dirty_rect.as_ref(),
+                MutByteSlice::new(output.as_mut_slice()),
+            ) {
+                // We want the dirty rect local to the tile rather than the whole image.
+                // TODO(nical): move that up and avoid recomupting the tile bounds in the callback
+                let dirty_rect = job.dirty_rect.to_subrect_of(&descriptor.rect);
+                let tx: BlobToDeviceTranslation = (-descriptor.rect.min.to_vector()).into();
+                let rasterized_rect = tx.transform_box(&dirty_rect);
+
+                Ok(RasterizedBlobImage {
+                    rasterized_rect,
+                    data: Arc::new(output),
+                })
+            } else {
+                panic!("Moz2D replay problem");
+            }
+        }
+    });
+
+    (job.request, result)
+}
+
+impl BlobImageHandler for Moz2dBlobImageHandler {
+    fn create_similar(&self) -> Box<dyn BlobImageHandler> {
+        Box::new(Self::new(
+            Arc::clone(&self.workers),
+            Arc::clone(&self.workers_low_priority),
+        ))
+    }
+
+    fn add(&mut self, key: BlobImageKey, data: Arc<BlobImageData>, visible_rect: &DeviceIntRect, tile_size: TileSize) {
+        {
+            let index = BlobReader::new(&data);
+            assert!(index.reader.has_more());
+        }
+        self.blob_commands.insert(
+            key,
+            BlobCommand {
+                data: Arc::clone(&data),
+                visible_rect: *visible_rect,
+                tile_size,
+            },
+        );
+    }
+
+    fn update(
+        &mut self,
+        key: BlobImageKey,
+        data: Arc<BlobImageData>,
+        visible_rect: &DeviceIntRect,
+        dirty_rect: &BlobDirtyRect,
+    ) {
+        match self.blob_commands.entry(key) {
+            hash_map::Entry::Occupied(mut e) => {
+                let command = e.get_mut();
+                let dirty_rect = if let DirtyRect::Partial(rect) = *dirty_rect {
+                    rect.cast_unit()
+                } else {
+                    DeviceIntRect {
+                        min: point2(i32::MIN, i32::MIN),
+                        max: point2(i32::MAX, i32::MAX),
+                    }
+                };
+                command.data = Arc::new(merge_blob_images(
+                    &command.data,
+                    &data,
+                    dirty_rect,
+                    command.visible_rect,
+                    *visible_rect,
+                ));
+                command.visible_rect = *visible_rect;
+            },
+            _ => {
+                panic!("missing image key");
+            },
+        }
+    }
+
+    fn delete(&mut self, key: BlobImageKey) {
+        self.blob_commands.remove(&key);
+    }
+
+    fn create_blob_rasterizer(&mut self) -> Box<dyn AsyncBlobImageRasterizer> {
+        Box::new(Moz2dBlobRasterizer {
+            workers: Arc::clone(&self.workers),
+            workers_low_priority: Arc::clone(&self.workers_low_priority),
+            blob_commands: self.blob_commands.clone(),
+            enable_multithreading: self.enable_multithreading,
+        })
+    }
+
+    fn delete_font(&mut self, font: FontKey) {
+        unsafe {
+            DeleteFontData(font);
+        }
+    }
+
+    fn delete_font_instance(&mut self, key: FontInstanceKey) {
+        unsafe {
+            DeleteBlobFont(key);
+        }
+    }
+
+    fn clear_namespace(&mut self, namespace: IdNamespace) {
+        unsafe {
+            ClearBlobImageResources(namespace);
+        }
+    }
+
+    fn prepare_resources(&mut self, resources: &dyn BlobImageResources, requests: &[BlobImageParams]) {
+        for params in requests {
+            let commands = &self.blob_commands[&params.request.key];
+            let blob = Arc::clone(&commands.data);
+            self.prepare_request(&blob, resources);
+        }
+    }
+
+    fn enable_multithreading(&mut self, enable: bool) {
+        self.enable_multithreading = enable;
+    }
+}
+
+use bindings::{WrFontInstanceKey, WrFontKey, WrIdNamespace};
+
+#[allow(improper_ctypes)] // this is needed so that rustc doesn't complain about passing the &Arc<Vec> to an extern function
+extern "C" {
+    fn HasFontData(key: WrFontKey) -> bool;
+    fn AddFontData(key: WrFontKey, data: *const u8, size: usize, index: u32, vec: &ArcVecU8);
+    fn AddNativeFontHandle(key: WrFontKey, handle: *mut c_void, index: u32);
+    fn DeleteFontData(key: WrFontKey);
+    fn AddBlobFont(
+        instance_key: WrFontInstanceKey,
+        font_key: WrFontKey,
+        size: f32,
+        options: Option<&FontInstanceOptions>,
+        platform_options: Option<&FontInstancePlatformOptions>,
+        variations: *const FontVariation,
+        num_variations: usize,
+    );
+    fn DeleteBlobFont(key: WrFontInstanceKey);
+    fn ClearBlobImageResources(namespace: WrIdNamespace);
+
+}
+
+impl Moz2dBlobImageHandler {
+    /// Create a new BlobImageHandler with the given thread pool.
+    pub fn new(workers: Arc<ThreadPool>, workers_low_priority: Arc<ThreadPool>) -> Self {
+        Moz2dBlobImageHandler {
+            blob_commands: HashMap::new(),
+            workers,
+            workers_low_priority,
+            enable_multithreading: true,
+        }
+    }
+
+    /// Does early preprocessing of a blob's resources.
+    ///
+    /// Currently just sets up fonts found in the blob.
+    fn prepare_request(&self, blob: &[u8], resources: &dyn BlobImageResources) {
+        #[cfg(target_os = "windows")]
+        fn process_native_font_handle(key: FontKey, handle: &NativeFontHandle) {
+            let file = dwrote::FontFile::new_from_path(&handle.path).unwrap();
+            let face = file
+                .create_face(handle.index, dwrote::DWRITE_FONT_SIMULATIONS_NONE)
+                .unwrap();
+            unsafe { AddNativeFontHandle(key, face.as_ptr() as *mut c_void, 0) };
+        }
+
+        #[cfg(target_os = "macos")]
+        fn process_native_font_handle(key: FontKey, handle: &NativeFontHandle) {
+            let font = match CGFont::from_name(&CFString::new(&handle.name)) {
+                Ok(font) => font,
+                Err(_) => {
+                    // If for some reason we failed to load a font descriptor, then our
+                    // only options are to either abort or substitute a fallback font.
+                    // It is preferable to use a fallback font instead so that rendering
+                    // can at least still proceed in some fashion without erroring.
+                    // Lucida Grande is the fallback font in Gecko, so use that here.
+                    CGFont::from_name(&CFString::from_static_string("Lucida Grande"))
+                        .expect("Failed reading font descriptor and could not load fallback font")
+                },
+            };
+            unsafe { AddNativeFontHandle(key, font.as_ptr() as *mut c_void, 0) };
+        }
+
+        #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+        fn process_native_font_handle(key: FontKey, handle: &NativeFontHandle) {
+            let cstr = CString::new(handle.path.as_os_str().as_bytes()).unwrap();
+            unsafe { AddNativeFontHandle(key, cstr.as_ptr() as *mut c_void, handle.index) };
+        }
+
+        fn process_fonts(
+            mut extra_data: BufReader,
+            resources: &dyn BlobImageResources,
+            unscaled_fonts: &mut Vec<FontKey>,
+            scaled_fonts: &mut Vec<FontInstanceKey>,
+        ) {
+            let font_count = extra_data.read_usize();
+            for _ in 0..font_count {
+                let font = extra_data.read_blob_font();
+                if scaled_fonts.contains(&font.font_instance_key) {
+                    continue;
+                }
+                scaled_fonts.push(font.font_instance_key);
+                if let Some(instance) = resources.get_font_instance_data(font.font_instance_key) {
+                    if !unscaled_fonts.contains(&instance.font_key) {
+                        unscaled_fonts.push(instance.font_key);
+                        if !unsafe { HasFontData(instance.font_key) } {
+                            let template = resources.get_font_data(instance.font_key).unwrap();
+                            match template {
+                                FontTemplate::Raw(ref data, ref index) => unsafe {
+                                    AddFontData(instance.font_key, data.as_ptr(), data.len(), *index, data);
+                                },
+                                FontTemplate::Native(ref handle) => {
+                                    process_native_font_handle(instance.font_key, handle);
+                                },
+                            }
+                        }
+                    }
+                    unsafe {
+                        AddBlobFont(
+                            font.font_instance_key,
+                            instance.font_key,
+                            instance.size,
+                            instance.options.as_ref(),
+                            instance.platform_options.as_ref(),
+                            instance.variations.as_ptr(),
+                            instance.variations.len(),
+                        );
+                    }
+                }
+            }
+        }
+
+        {
+            let mut index = BlobReader::new(blob);
+            let mut unscaled_fonts = Vec::new();
+            let mut scaled_fonts = Vec::new();
+            while index.reader.pos < index.reader.buf.len() {
+                let e = index.read_entry();
+                process_fonts(
+                    BufReader::new(&blob[e.end..e.extra_end]),
+                    resources,
+                    &mut unscaled_fonts,
+                    &mut scaled_fonts,
+                );
+            }
+        }
+    }
+}
diff --git a/gfx/webrender_bindings/src/program_cache.rs b/gfx/webrender_bindings/src/program_cache.rs
new file mode 100644
index 0000000000..5db61fc8b5
--- /dev/null
+++ b/gfx/webrender_bindings/src/program_cache.rs
@@ -0,0 +1,355 @@
+/* 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/. */
+
+use std::cell::RefCell;
+use std::ffi::OsString;
+use std::fs::{create_dir_all, read_dir, read_to_string, File};
+use std::io::{Error, ErrorKind};
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::rc::Rc;
+use std::sync::Arc;
+
+use bincode;
+use fxhash;
+use nsstring::nsAString;
+use rayon::ThreadPool;
+use webrender::{ProgramBinary, ProgramCache, ProgramCacheObserver, ProgramSourceDigest};
+
+const MAX_LOAD_TIME_MS: u64 = 400;
+
+fn deserialize_program_binary(path: &Path) -> Result<Arc<ProgramBinary>, Error> {
+    let mut buf = vec![];
+    let mut file = File::open(path)?;
+    file.read_to_end(&mut buf)?;
+
+    if buf.len() <= 8 + 4 {
+        return Err(Error::new(ErrorKind::InvalidData, "File size is too small"));
+    }
+    let magic = &buf[0..4];
+    let hash = &buf[4..8 + 4];
+    let data = &buf[8 + 4..];
+
+    // Check if magic + version are correct.
+    let mv: u32 = bincode::deserialize(&magic).unwrap();
+    if mv != MAGIC_AND_VERSION {
+        return Err(Error::new(
+            ErrorKind::InvalidData,
+            "File data is invalid (magic+version)",
+        ));
+    }
+
+    // Check if hash is correct
+    let hash: u64 = bincode::deserialize(&hash).unwrap();
+    let hash_data = fxhash::hash64(&data);
+    if hash != hash_data {
+        return Err(Error::new(ErrorKind::InvalidData, "File data is invalid (hash)"));
+    }
+
+    // Deserialize ProgramBinary
+    let binary = match bincode::deserialize(&data) {
+        Ok(binary) => binary,
+        Err(_) => {
+            return Err(Error::new(
+                ErrorKind::InvalidData,
+                "Failed to deserialize ProgramBinary",
+            ))
+        },
+    };
+
+    Ok(Arc::new(binary))
+}
+
+#[cfg(target_os = "windows")]
+fn get_cache_path_from_prof_path(prof_path: &nsAString) -> Option<PathBuf> {
+    if prof_path.is_empty() {
+        // Empty means that we do not use disk cache.
+        return None;
+    }
+
+    use std::os::windows::prelude::*;
+
+    let prof_path = OsString::from_wide(prof_path.as_ref());
+    let mut cache_path = PathBuf::from(&prof_path);
+    cache_path.push("shader-cache");
+
+    Some(cache_path)
+}
+
+#[cfg(not(target_os = "windows"))]
+fn get_cache_path_from_prof_path(prof_path: &nsAString) -> Option<PathBuf> {
+    if prof_path.is_empty() {
+        // Empty means that we do not use disk cache.
+        return None;
+    }
+
+    let utf8 = String::from_utf16(prof_path.as_ref()).unwrap();
+    let prof_path = OsString::from(utf8);
+    let mut cache_path = PathBuf::from(&prof_path);
+    cache_path.push("shader-cache");
+
+    Some(cache_path)
+}
+
+struct WrProgramBinaryDiskCache {
+    cache_path: PathBuf,
+    workers: Arc<ThreadPool>,
+    cached_shader_filenames: Vec<OsString>,
+}
+
+// Magic number + version. Increment the version when the binary format changes.
+const MAGIC: u32 = 0xB154AD30; // BI-SHADE + version.
+const VERSION: u32 = 2;
+const MAGIC_AND_VERSION: u32 = MAGIC + VERSION;
+
+const WHITELIST_FILENAME: &str = "startup_shaders";
+const WHITELIST_SEPARATOR: &str = "\n";
+
+/// Helper to convert a closure returning a `Result` to one that returns void.
+/// This allows the enclosed code to use the question-mark operator in a
+/// context where the calling function doesn't expect a `Result`.
+#[allow(unused_must_use)]
+fn result_to_void<F: FnOnce() -> Result<(), ()>>(f: F) {
+    f();
+}
+
+impl WrProgramBinaryDiskCache {
+    #[allow(dead_code)]
+    fn new(cache_path: PathBuf, workers: &Arc<ThreadPool>) -> Self {
+        WrProgramBinaryDiskCache {
+            cache_path,
+            workers: Arc::clone(workers),
+            cached_shader_filenames: Vec::new(),
+        }
+    }
+
+    /// Saves the specified binaries to the on-disk shader cache.
+    fn save_shaders_to_disk(&mut self, entries: Vec<Arc<ProgramBinary>>) {
+        info!("Saving binaries to on-disk shader cache");
+
+        // Write the entries to disk on a worker thread.
+        for entry in entries {
+            let file_name = entry.source_digest().to_string();
+            let file_path = self.cache_path.join(&file_name);
+
+            self.workers.spawn(move || {
+                result_to_void(move || {
+                    info!("Writing shader: {}", file_name);
+
+                    use std::time::Instant;
+                    let start = Instant::now();
+
+                    let data: Vec<u8> =
+                        bincode::serialize(&*entry).map_err(|e| error!("shader-cache: Failed to serialize: {}", e))?;
+
+                    let mut file =
+                        File::create(&file_path).map_err(|e| error!("shader-cache: Failed to create file: {}", e))?;
+
+                    // Write magic + version.
+                    let mv = MAGIC_AND_VERSION;
+                    let mv = bincode::serialize(&mv).unwrap();
+                    assert!(mv.len() == 4);
+                    file.write_all(&mv)
+                        .map_err(|e| error!("shader-cache: Failed to write magic + version: {}", e))?;
+
+                    // Write hash
+                    let hash = fxhash::hash64(&data);
+                    let hash = bincode::serialize(&hash).unwrap();
+                    assert!(hash.len() == 8);
+                    file.write_all(&hash)
+                        .map_err(|e| error!("shader-cache: Failed to write hash: {}", e))?;
+
+                    // Write serialized data
+                    file.write_all(&data)
+                        .map_err(|e| error!("shader-cache: Failed to write program binary: {}", e))?;
+
+                    info!("Wrote shader {} in {:?}", file_name, start.elapsed());
+                    Ok(())
+                })
+            });
+        }
+    }
+
+    /// Writes the whitelist containing the set of startup shaders to disk.
+    fn set_startup_shaders(&mut self, entries: Vec<Arc<ProgramBinary>>) {
+        let whitelist = entries
+            .iter()
+            .map(|e| e.source_digest().to_string())
+            .collect::<Vec<String>>()
+            .join(WHITELIST_SEPARATOR);
+
+        let mut whitelist_path = self.cache_path.clone();
+        whitelist_path.push(WHITELIST_FILENAME);
+        self.workers.spawn(move || {
+            result_to_void(move || {
+                info!("Writing startup shader whitelist");
+                File::create(&whitelist_path)
+                    .and_then(|mut file| file.write_all(whitelist.as_bytes()))
+                    .map_err(|e| error!("shader-cache: Failed to write startup whitelist: {}", e))?;
+                Ok(())
+            })
+        });
+    }
+
+    pub fn try_load_shader_from_disk(&mut self, filename: &str, program_cache: &Rc<ProgramCache>) {
+        if let Some(index) = self.cached_shader_filenames.iter().position(|e| e == filename) {
+            let mut path = self.cache_path.clone();
+            path.push(filename);
+
+            self.cached_shader_filenames.swap_remove(index);
+
+            info!("Loading shader: {}", filename);
+
+            match deserialize_program_binary(&path) {
+                Ok(program) => {
+                    program_cache.load_program_binary(program);
+                },
+                Err(err) => {
+                    error!("shader-cache: Failed to deserialize program binary: {}", err);
+                },
+            };
+        } else {
+            info!("shader-cache: Program binary not found in disk cache");
+        }
+    }
+
+    pub fn try_load_startup_shaders_from_disk(&mut self, program_cache: &Rc<ProgramCache>) {
+        use std::time::Instant;
+        let start = Instant::now();
+
+        // Load and parse the whitelist if it exists
+        let mut whitelist_path = self.cache_path.clone();
+        whitelist_path.push(WHITELIST_FILENAME);
+        let whitelist = match read_to_string(&whitelist_path) {
+            Ok(whitelist) => whitelist
+                .split(WHITELIST_SEPARATOR)
+                .map(|s| s.to_string())
+                .collect::<Vec<String>>(),
+            Err(err) => {
+                info!("shader-cache: Could not read startup whitelist: {}", err);
+                Vec::new()
+            },
+        };
+        info!("Loaded startup shader whitelist in {:?}", start.elapsed());
+
+        self.cached_shader_filenames = read_dir(&self.cache_path)
+            .map_err(|err| {
+                error!(
+                    "shader-cache: Error reading directory whilst loading startup shaders: {}",
+                    err
+                )
+            })
+            .into_iter()
+            .flatten()
+            .filter_map(Result::ok)
+            .map(|entry| entry.file_name())
+            .filter(|filename| filename != WHITELIST_FILENAME)
+            .collect::<Vec<OsString>>();
+
+        // Load whitelisted program binaries if they exist
+        for entry in &whitelist {
+            self.try_load_shader_from_disk(&entry, program_cache);
+
+            let elapsed = start.elapsed();
+            info!("Loaded shader in {:?}", elapsed);
+            let elapsed_ms = (elapsed.as_secs() * 1_000) + elapsed.subsec_millis() as u64;
+
+            if elapsed_ms > MAX_LOAD_TIME_MS {
+                // Loading the startup shaders is taking too long, so bail out now.
+                // Additionally clear the list of remaining shaders cached on disk,
+                // so that we do not attempt to load any on demand during rendering.
+                error!("shader-cache: Timed out before finishing loads");
+                self.cached_shader_filenames.clear();
+                break;
+            }
+        }
+    }
+}
+
+pub struct WrProgramCacheObserver {
+    disk_cache: Rc<RefCell<WrProgramBinaryDiskCache>>,
+}
+
+impl WrProgramCacheObserver {
+    #[allow(dead_code)]
+    fn new(disk_cache: Rc<RefCell<WrProgramBinaryDiskCache>>) -> Self {
+        WrProgramCacheObserver { disk_cache }
+    }
+}
+
+impl ProgramCacheObserver for WrProgramCacheObserver {
+    fn save_shaders_to_disk(&self, entries: Vec<Arc<ProgramBinary>>) {
+        self.disk_cache.borrow_mut().save_shaders_to_disk(entries);
+    }
+
+    fn set_startup_shaders(&self, entries: Vec<Arc<ProgramBinary>>) {
+        self.disk_cache.borrow_mut().set_startup_shaders(entries);
+    }
+
+    fn try_load_shader_from_disk(&self, digest: &ProgramSourceDigest, program_cache: &Rc<ProgramCache>) {
+        let filename = digest.to_string();
+        self.disk_cache
+            .borrow_mut()
+            .try_load_shader_from_disk(&filename, program_cache);
+    }
+
+    fn notify_program_binary_failed(&self, _program_binary: &Arc<ProgramBinary>) {
+        error!("shader-cache: Failed program_binary");
+    }
+}
+
+pub struct WrProgramCache {
+    pub program_cache: Rc<ProgramCache>,
+    disk_cache: Option<Rc<RefCell<WrProgramBinaryDiskCache>>>,
+}
+
+impl WrProgramCache {
+    pub fn new(prof_path: &nsAString, workers: &Arc<ThreadPool>) -> Self {
+        let cache_path = get_cache_path_from_prof_path(prof_path);
+        let use_disk_cache = cache_path.as_ref().map_or(false, |p| create_dir_all(p).is_ok());
+        let (disk_cache, program_cache_observer) = if use_disk_cache {
+            let cache = Rc::new(RefCell::new(WrProgramBinaryDiskCache::new(
+                cache_path.unwrap(),
+                workers,
+            )));
+            let obs = Box::new(WrProgramCacheObserver::new(Rc::clone(&cache))) as Box<dyn ProgramCacheObserver>;
+            (Some(cache), Some(obs))
+        } else {
+            (None, None)
+        };
+        let program_cache = ProgramCache::new(program_cache_observer);
+
+        WrProgramCache {
+            program_cache,
+            disk_cache,
+        }
+    }
+
+    pub fn rc_get(&self) -> &Rc<ProgramCache> {
+        &self.program_cache
+    }
+
+    pub fn try_load_startup_shaders_from_disk(&self) {
+        if let Some(ref disk_cache) = self.disk_cache {
+            disk_cache
+                .borrow_mut()
+                .try_load_startup_shaders_from_disk(&self.program_cache);
+        } else {
+            error!("shader-cache: Shader disk cache is not supported");
+        }
+    }
+}
+
+pub fn remove_disk_cache(prof_path: &nsAString) -> Result<(), Error> {
+    use std::time::Instant;
+
+    if let Some(cache_path) = get_cache_path_from_prof_path(prof_path) {
+        if cache_path.exists() {
+            let start = Instant::now();
+            remove_dir_all::remove_dir_all(&cache_path)?;
+            info!("removed all disk cache shaders in {:?}", start.elapsed());
+        }
+    }
+    Ok(())
+}
diff --git a/gfx/webrender_bindings/src/swgl_bindings.rs b/gfx/webrender_bindings/src/swgl_bindings.rs
new file mode 100644
index 0000000000..b1e7684a69
--- /dev/null
+++ b/gfx/webrender_bindings/src/swgl_bindings.rs
@@ -0,0 +1,101 @@
+/* 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/. */
+
+use gleam::gl::Gl;
+
+use std::os::raw::c_void;
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_create_context() -> *mut c_void {
+    swgl::Context::create().into()
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_reference_context(ctx: *mut c_void) {
+    swgl::Context::from(ctx).reference();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_destroy_context(ctx: *mut c_void) {
+    swgl::Context::from(ctx).destroy();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_make_current(ctx: *mut c_void) {
+    swgl::Context::from(ctx).make_current();
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_init_default_framebuffer(
+    ctx: *mut c_void,
+    x: i32,
+    y: i32,
+    width: i32,
+    height: i32,
+    stride: i32,
+    buf: *mut c_void,
+) {
+    swgl::Context::from(ctx).init_default_framebuffer(x, y, width, height, stride, buf);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_resolve_framebuffer(ctx: *mut c_void, fbo: u32) {
+    swgl::Context::from(ctx).resolve_framebuffer(fbo);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_gen_texture(ctx: *mut c_void) -> u32 {
+    swgl::Context::from(ctx).gen_textures(1)[0]
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_delete_texture(ctx: *mut c_void, tex: u32) {
+    swgl::Context::from(ctx).delete_textures(&[tex]);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_set_texture_parameter(ctx: *mut c_void, tex: u32, pname: u32, param: i32) {
+    swgl::Context::from(ctx).set_texture_parameter(tex, pname, param);
+}
+
+#[no_mangle]
+pub extern "C" fn wr_swgl_set_texture_buffer(
+    ctx: *mut c_void,
+    tex: u32,
+    internal_format: u32,
+    width: i32,
+    height: i32,
+    stride: i32,
+    buf: *mut c_void,
+    min_width: i32,
+    min_height: i32,
+) {
+    swgl::Context::from(ctx).set_texture_buffer(
+        tex,
+        internal_format,
+        width,
+        height,
+        stride,
+        buf,
+        min_width,
+        min_height,
+    );
+}
+
+#[no_mangle]
+#[allow(clippy::many_single_char_names)]
+pub extern "C" fn wr_swgl_clear_color_rect(
+    ctx: *mut c_void,
+    fbo: u32,
+    x: i32,
+    y: i32,
+    width: i32,
+    height: i32,
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32,
+) {
+    swgl::Context::from(ctx).clear_color_rect(fbo, x, y, width, height, r, g, b, a);
+}
diff --git a/gfx/webrender_bindings/webrender_ffi.h b/gfx/webrender_bindings/webrender_ffi.h
new file mode 100644
index 0000000000..e9c8be1ef4
--- /dev/null
+++ b/gfx/webrender_bindings/webrender_ffi.h
@@ -0,0 +1,123 @@
+/* -*- 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 WR_h
+#define WR_h
+
+#include "mozilla/gfx/Types.h"
+#include "nsTArray.h"
+
+extern "C" {
+
+// ----
+// Functions invoked from Rust code
+// ----
+
+bool is_in_compositor_thread();
+bool is_in_main_thread();
+bool is_in_render_thread();
+bool is_glcontext_gles(void* glcontext_ptr);
+bool is_glcontext_angle(void* glcontext_ptr);
+bool gfx_use_wrench();
+const char* gfx_wr_resource_path_override();
+bool gfx_wr_use_optimized_shaders();
+void gfx_critical_note(const char* msg);
+void gfx_critical_error(const char* msg);
+void gecko_printf_stderr_output(const char* msg);
+void* get_proc_address_from_glcontext(void* glcontext_ptr,
+                                      const char* procname);
+
+bool gecko_profiler_thread_is_being_profiled();
+
+// IMPORTANT: Keep this synchronized with enumerate_interners in
+// gfx/wr/webrender_api
+#define WEBRENDER_FOR_EACH_INTERNER(macro) \
+  macro(clip);                             \
+  macro(prim);                             \
+  macro(normal_border);                    \
+  macro(image_border);                     \
+  macro(image);                            \
+  macro(yuv_image);                        \
+  macro(line_decoration);                  \
+  macro(linear_grad);                      \
+  macro(radial_grad);                      \
+  macro(conic_grad);                       \
+  macro(picture);                          \
+  macro(text_run);                         \
+  macro(filterdata);                       \
+  macro(backdrop_capture);                 \
+  macro(backdrop_render);                  \
+  macro(polyon);
+
+// Prelude of types necessary before including webrender_ffi_generated.h
+namespace mozilla {
+namespace wr {
+
+// Because this struct is macro-generated on the Rust side, cbindgen can't see
+// it. Work around that by re-declaring it here.
+#define DECLARE_MEMBER(id) uintptr_t id;
+struct InternerSubReport {
+  WEBRENDER_FOR_EACH_INTERNER(DECLARE_MEMBER)
+};
+
+#undef DECLARE_MEMBER
+
+struct Transaction;
+struct WrWindowId;
+struct DocumentId;
+struct WrPipelineInfo;
+
+struct WrPipelineIdAndEpoch;
+using WrPipelineIdEpochs = nsTArray<WrPipelineIdAndEpoch>;
+
+}  // namespace wr
+}  // namespace mozilla
+
+void apz_register_updater(mozilla::wr::WrWindowId aWindowId);
+void apz_pre_scene_swap(mozilla::wr::WrWindowId aWindowId);
+void apz_post_scene_swap(mozilla::wr::WrWindowId aWindowId,
+                         const mozilla::wr::WrPipelineInfo* aInfo);
+void apz_run_updater(mozilla::wr::WrWindowId aWindowId);
+void apz_deregister_updater(mozilla::wr::WrWindowId aWindowId);
+
+void apz_register_sampler(mozilla::wr::WrWindowId aWindowId);
+void apz_sample_transforms(mozilla::wr::WrWindowId aWindowId,
+                           const uint64_t* aGeneratedFrameId,
+                           mozilla::wr::Transaction* aTransaction);
+void apz_deregister_sampler(mozilla::wr::WrWindowId aWindowId);
+
+void omta_register_sampler(mozilla::wr::WrWindowId aWindowId);
+void omta_sample(mozilla::wr::WrWindowId aWindowId,
+                 mozilla::wr::Transaction* aTransaction);
+void omta_deregister_sampler(mozilla::wr::WrWindowId aWindowId);
+}  // extern "C"
+
+// Work-around Solaris define which conflcits with WR color constant, see
+// bug 1773491.
+#pragma push_macro("TRANSPARENT")
+#undef TRANSPARENT
+
+#include "webrender_ffi_generated.h"
+
+#pragma pop_macro("TRANSPARENT")
+
+template struct mozilla::wr::Point2D<int32_t, mozilla::wr::DevicePixel>;
+template struct mozilla::wr::Point2D<int, mozilla::wr::WorldPixel>;
+template struct mozilla::wr::Point2D<float, mozilla::wr::WorldPixel>;
+template struct mozilla::wr::Box2D<int32_t, mozilla::wr::DevicePixel>;
+template struct mozilla::wr::Box2D<int, mozilla::wr::LayoutPixel>;
+
+namespace mozilla {
+namespace wr {
+
+// Cast a blob image key into a regular image for use in
+// a display item.
+inline ImageKey AsImageKey(BlobImageKey aKey) { return aKey._0; }
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif  // WR_h