Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

42 files changed, 16481 insertions, 0 deletions

diff --git a/gfx/layers/wr/AsyncImagePipelineManager.cpp b/gfx/layers/wr/AsyncImagePipelineManager.cpp
new file mode 100644
index 0000000000..4849b651a3
--- /dev/null
+++ b/gfx/layers/wr/AsyncImagePipelineManager.cpp
@@ -0,0 +1,771 @@
+/* -*- 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 "AsyncImagePipelineManager.h"
+
+#include <algorithm>
+#include <iterator>
+
+#include "CompositableHost.h"
+#include "gfxEnv.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/RemoteTextureHostWrapper.h"
+#include "mozilla/layers/SharedSurfacesParent.h"
+#include "mozilla/layers/WebRenderImageHost.h"
+#include "mozilla/layers/WebRenderTextureHost.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "mozilla/layers/TextureHostOGL.h"
+#endif
+
+namespace mozilla {
+namespace layers {
+
+AsyncImagePipelineManager::ForwardingExternalImage::~ForwardingExternalImage() {
+  DebugOnly<bool> released = SharedSurfacesParent::Release(mImageId);
+  MOZ_ASSERT(released);
+}
+
+AsyncImagePipelineManager::AsyncImagePipeline::AsyncImagePipeline(
+    wr::PipelineId aPipelineId, layers::WebRenderBackend aBackend)
+    : mInitialised(false),
+      mIsChanged(false),
+      mUseExternalImage(false),
+      mRotation(VideoInfo::Rotation::kDegree_0),
+      mFilter(wr::ImageRendering::Auto),
+      mMixBlendMode(wr::MixBlendMode::Normal),
+      mDLBuilder(aPipelineId, aBackend) {}
+
+AsyncImagePipelineManager::AsyncImagePipelineManager(
+    RefPtr<wr::WebRenderAPI>&& aApi, bool aUseCompositorWnd)
+    : mApi(aApi),
+      mUseCompositorWnd(aUseCompositorWnd),
+      mIdNamespace(mApi->GetNamespace()),
+      mUseTripleBuffering(mApi->GetUseTripleBuffering()),
+      mResourceId(0),
+      mAsyncImageEpoch{0},
+      mWillGenerateFrame(false),
+      mDestroyed(false),
+#ifdef XP_WIN
+      mUseWebRenderDCompVideoOverlayWin(
+          gfx::gfxVars::UseWebRenderDCompVideoOverlayWin()),
+#endif
+      mRenderSubmittedUpdatesLock("SubmittedUpdatesLock"),
+      mLastCompletedFrameId(0) {
+  MOZ_COUNT_CTOR(AsyncImagePipelineManager);
+}
+
+AsyncImagePipelineManager::~AsyncImagePipelineManager() {
+  MOZ_COUNT_DTOR(AsyncImagePipelineManager);
+}
+
+void AsyncImagePipelineManager::Destroy() {
+  MOZ_ASSERT(!mDestroyed);
+  mApi = nullptr;
+  mPipelineTexturesHolders.Clear();
+  mDestroyed = true;
+}
+
+/* static */
+wr::ExternalImageId AsyncImagePipelineManager::GetNextExternalImageId() {
+  static std::atomic<uint64_t> sCounter = 0;
+
+  uint64_t id = ++sCounter;
+  // Upper 32bit(namespace) needs to be 0.
+  // Namespace other than 0 might be used by others.
+  MOZ_RELEASE_ASSERT(id != UINT32_MAX);
+  return wr::ToExternalImageId(id);
+}
+
+void AsyncImagePipelineManager::SetWillGenerateFrame() {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+  mWillGenerateFrame = true;
+}
+
+bool AsyncImagePipelineManager::GetAndResetWillGenerateFrame() {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+  bool ret = mWillGenerateFrame;
+  mWillGenerateFrame = false;
+  return ret;
+}
+
+void AsyncImagePipelineManager::AddPipeline(const wr::PipelineId& aPipelineId,
+                                            WebRenderBridgeParent* aWrBridge) {
+  if (mDestroyed) {
+    return;
+  }
+
+  mPipelineTexturesHolders.WithEntryHandle(
+      wr::AsUint64(aPipelineId), [&](auto&& holder) {
+        if (holder) {
+          // This could happen during tab move between different windows.
+          // Previously removed holder could be still alive for waiting
+          // destroyed.
+          MOZ_ASSERT(holder.Data()->mDestroyedEpoch.isSome());
+          holder.Data()->mDestroyedEpoch = Nothing();  // Revive holder
+          holder.Data()->mWrBridge = aWrBridge;
+          return;
+        }
+
+        holder.Insert(MakeUnique<PipelineTexturesHolder>())->mWrBridge =
+            aWrBridge;
+      });
+}
+
+void AsyncImagePipelineManager::RemovePipeline(
+    const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch) {
+  if (mDestroyed) {
+    return;
+  }
+
+  PipelineTexturesHolder* holder =
+      mPipelineTexturesHolders.Get(wr::AsUint64(aPipelineId));
+  MOZ_ASSERT(holder);
+  if (!holder) {
+    return;
+  }
+  holder->mWrBridge = nullptr;
+  holder->mDestroyedEpoch = Some(aEpoch);
+}
+
+WebRenderBridgeParent* AsyncImagePipelineManager::GetWrBridge(
+    const wr::PipelineId& aPipelineId) {
+  if (mDestroyed) {
+    return nullptr;
+  }
+
+  PipelineTexturesHolder* holder =
+      mPipelineTexturesHolders.Get(wr::AsUint64(aPipelineId));
+  if (!holder) {
+    return nullptr;
+  }
+  if (holder->mWrBridge) {
+    MOZ_ASSERT(holder->mDestroyedEpoch.isNothing());
+    return holder->mWrBridge;
+  }
+
+  return nullptr;
+}
+
+void AsyncImagePipelineManager::AddAsyncImagePipeline(
+    const wr::PipelineId& aPipelineId, WebRenderImageHost* aImageHost) {
+  if (mDestroyed) {
+    return;
+  }
+  MOZ_ASSERT(aImageHost);
+  uint64_t id = wr::AsUint64(aPipelineId);
+
+  MOZ_ASSERT(!mAsyncImagePipelines.Contains(id));
+  auto holder =
+      MakeUnique<AsyncImagePipeline>(aPipelineId, mApi->GetBackendType());
+  holder->mImageHost = aImageHost;
+  mAsyncImagePipelines.InsertOrUpdate(id, std::move(holder));
+  AddPipeline(aPipelineId, /* aWrBridge */ nullptr);
+}
+
+void AsyncImagePipelineManager::RemoveAsyncImagePipeline(
+    const wr::PipelineId& aPipelineId, wr::TransactionBuilder& aTxn) {
+  if (mDestroyed) {
+    return;
+  }
+
+  uint64_t id = wr::AsUint64(aPipelineId);
+  if (auto entry = mAsyncImagePipelines.Lookup(id)) {
+    const auto& holder = entry.Data();
+    wr::Epoch epoch = GetNextImageEpoch();
+    aTxn.ClearDisplayList(epoch, aPipelineId);
+    for (wr::ImageKey key : holder->mKeys) {
+      aTxn.DeleteImage(key);
+    }
+    entry.Remove();
+    RemovePipeline(aPipelineId, epoch);
+  }
+}
+
+void AsyncImagePipelineManager::UpdateAsyncImagePipeline(
+    const wr::PipelineId& aPipelineId, const LayoutDeviceRect& aScBounds,
+    const VideoInfo::Rotation aRotation, const wr::ImageRendering& aFilter,
+    const wr::MixBlendMode& aMixBlendMode) {
+  if (mDestroyed) {
+    return;
+  }
+  AsyncImagePipeline* pipeline =
+      mAsyncImagePipelines.Get(wr::AsUint64(aPipelineId));
+  if (!pipeline) {
+    return;
+  }
+  pipeline->mInitialised = true;
+  pipeline->Update(aScBounds, aRotation, aFilter, aMixBlendMode);
+}
+
+Maybe<TextureHost::ResourceUpdateOp> AsyncImagePipelineManager::UpdateImageKeys(
+    const wr::Epoch& aEpoch, const wr::PipelineId& aPipelineId,
+    AsyncImagePipeline* aPipeline, nsTArray<wr::ImageKey>& aKeys,
+    wr::TransactionBuilder& aSceneBuilderTxn,
+    wr::TransactionBuilder& aMaybeFastTxn, RemoteTextureInfoList* aList) {
+  MOZ_ASSERT(aKeys.IsEmpty());
+  MOZ_ASSERT(aPipeline);
+
+  TextureHost* texture =
+      aPipeline->mImageHost->GetAsTextureHostForComposite(this);
+  TextureHost* previousTexture = aPipeline->mCurrentTexture.get();
+
+  if (texture == previousTexture) {
+    // The texture has not changed, just reuse previous ImageKeys.
+    aKeys = aPipeline->mKeys.Clone();
+    return Nothing();
+  }
+
+  if (!texture || texture->NumSubTextures() == 0) {
+    // We don't have a new texture or texture does not have SubTextures, there
+    // isn't much we can do.
+    aKeys = aPipeline->mKeys.Clone();
+    return Nothing();
+  }
+
+  // Check if pending Remote texture exists.
+  auto* wrapper = texture->AsRemoteTextureHostWrapper();
+  if (aList && wrapper && wrapper->IsReadyForRendering()) {
+    aList->mList.emplace(wrapper->mTextureId, wrapper->mOwnerId,
+                         wrapper->mForPid);
+  }
+
+  aPipeline->mCurrentTexture = texture;
+
+  WebRenderTextureHost* wrTexture = texture->AsWebRenderTextureHost();
+  MOZ_ASSERT(wrTexture);
+  if (!wrTexture) {
+    gfxCriticalNote << "WebRenderTextureHost is not used";
+  }
+
+  bool useExternalImage = !!wrTexture;
+  aPipeline->mUseExternalImage = useExternalImage;
+
+  // The non-external image code path falls back to converting the texture into
+  // an rgb image.
+  auto numKeys = useExternalImage ? texture->NumSubTextures() : 1;
+  MOZ_ASSERT(numKeys > 0);
+
+  // If we already had a texture and the format hasn't changed, better to reuse
+  // the image keys than create new ones.
+  auto backend = aSceneBuilderTxn.GetBackendType();
+  bool canUpdate =
+      !!previousTexture &&
+      previousTexture->GetTextureHostType() == texture->GetTextureHostType() &&
+      previousTexture->GetSize() == texture->GetSize() &&
+      previousTexture->GetFormat() == texture->GetFormat() &&
+      previousTexture->GetColorDepth() == texture->GetColorDepth() &&
+      previousTexture->NeedsYFlip() == texture->NeedsYFlip() &&
+      previousTexture->SupportsExternalCompositing(backend) ==
+          texture->SupportsExternalCompositing(backend) &&
+      aPipeline->mKeys.Length() == numKeys;
+
+  if (!canUpdate) {
+    for (auto key : aPipeline->mKeys) {
+      // Destroy ImageKeys on transaction of scene builder thread, since
+      // DisplayList is updated on SceneBuilder thread. It prevents too early
+      // ImageKey deletion.
+      aSceneBuilderTxn.DeleteImage(key);
+    }
+    aPipeline->mKeys.Clear();
+    for (uint32_t i = 0; i < numKeys; ++i) {
+      aPipeline->mKeys.AppendElement(GenerateImageKey());
+    }
+  }
+
+  aKeys = aPipeline->mKeys.Clone();
+
+  auto op = canUpdate ? TextureHost::UPDATE_IMAGE : TextureHost::ADD_IMAGE;
+
+  if (!useExternalImage) {
+    return UpdateWithoutExternalImage(texture, aKeys[0], op, aMaybeFastTxn);
+  }
+
+  wrTexture->MaybeNotifyForUse(aMaybeFastTxn);
+
+  Range<wr::ImageKey> keys(&aKeys[0], aKeys.Length());
+  auto externalImageKey = wrTexture->GetExternalImageKey();
+  wrTexture->PushResourceUpdates(aMaybeFastTxn, op, keys, externalImageKey);
+
+  return Some(op);
+}
+
+Maybe<TextureHost::ResourceUpdateOp>
+AsyncImagePipelineManager::UpdateWithoutExternalImage(
+    TextureHost* aTexture, wr::ImageKey aKey, TextureHost::ResourceUpdateOp aOp,
+    wr::TransactionBuilder& aTxn) {
+  MOZ_ASSERT(aTexture);
+
+  RefPtr<gfx::DataSourceSurface> dSurf = aTexture->GetAsSurface();
+  if (!dSurf) {
+    NS_ERROR("TextureHost does not return DataSourceSurface");
+    return Nothing();
+  }
+  gfx::DataSourceSurface::MappedSurface map;
+  if (!dSurf->Map(gfx::DataSourceSurface::MapType::READ, &map)) {
+    NS_ERROR("DataSourceSurface failed to map");
+    return Nothing();
+  }
+
+  gfx::IntSize size = dSurf->GetSize();
+  wr::ImageDescriptor descriptor(size, map.mStride, dSurf->GetFormat());
+
+  // Costly copy right here...
+  wr::Vec<uint8_t> bytes;
+  bytes.PushBytes(Range<uint8_t>(map.mData, size.height * map.mStride));
+
+  if (aOp == TextureHost::UPDATE_IMAGE) {
+    aTxn.UpdateImageBuffer(aKey, descriptor, bytes);
+  } else {
+    aTxn.AddImage(aKey, descriptor, bytes);
+  }
+
+  dSurf->Unmap();
+
+  return Some(aOp);
+}
+
+void AsyncImagePipelineManager::ApplyAsyncImagesOfImageBridge(
+    wr::TransactionBuilder& aSceneBuilderTxn,
+    wr::TransactionBuilder& aFastTxn) {
+  if (mDestroyed || mAsyncImagePipelines.Count() == 0) {
+    return;
+  }
+
+#ifdef XP_WIN
+  // UseWebRenderDCompVideoOverlayWin() could be changed from true to false,
+  // when DCompVideoOverlay task is failed. In this case, DisplayItems need to
+  // be re-pushed to WebRender for disabling video overlay.
+  bool isChanged = mUseWebRenderDCompVideoOverlayWin !=
+                   gfx::gfxVars::UseWebRenderDCompVideoOverlayWin();
+  if (isChanged) {
+    mUseWebRenderDCompVideoOverlayWin =
+        gfx::gfxVars::UseWebRenderDCompVideoOverlayWin();
+  }
+#endif
+
+  wr::Epoch epoch = GetNextImageEpoch();
+
+  // We use a pipeline with a very small display list for each video element.
+  // Update each of them if needed.
+  for (const auto& entry : mAsyncImagePipelines) {
+    wr::PipelineId pipelineId = wr::AsPipelineId(entry.GetKey());
+    AsyncImagePipeline* pipeline = entry.GetWeak();
+
+#ifdef XP_WIN
+    if (isChanged) {
+      pipeline->mIsChanged = true;
+    }
+#endif
+
+    // If aync image pipeline does not use ImageBridge, do not need to apply.
+    if (!pipeline->mImageHost->GetAsyncRef()) {
+      continue;
+    }
+    ApplyAsyncImageForPipeline(epoch, pipelineId, pipeline, aSceneBuilderTxn,
+                               aFastTxn, /* aList */ nullptr);
+  }
+}
+
+wr::WrRotation ToWrRotation(VideoInfo::Rotation aRotation) {
+  switch (aRotation) {
+    case VideoInfo::Rotation::kDegree_0:
+      return wr::WrRotation::Degree0;
+    case VideoInfo::Rotation::kDegree_90:
+      return wr::WrRotation::Degree90;
+    case VideoInfo::Rotation::kDegree_180:
+      return wr::WrRotation::Degree180;
+    case VideoInfo::Rotation::kDegree_270:
+      return wr::WrRotation::Degree270;
+  }
+  return wr::WrRotation::Degree0;
+}
+
+void AsyncImagePipelineManager::ApplyAsyncImageForPipeline(
+    const wr::Epoch& aEpoch, const wr::PipelineId& aPipelineId,
+    AsyncImagePipeline* aPipeline, wr::TransactionBuilder& aSceneBuilderTxn,
+    wr::TransactionBuilder& aMaybeFastTxn, RemoteTextureInfoList* aList) {
+  nsTArray<wr::ImageKey> keys;
+  auto op = UpdateImageKeys(aEpoch, aPipelineId, aPipeline, keys,
+                            aSceneBuilderTxn, aMaybeFastTxn, aList);
+
+  bool updateDisplayList =
+      aPipeline->mInitialised &&
+      (aPipeline->mIsChanged || op == Some(TextureHost::ADD_IMAGE)) &&
+      !!aPipeline->mCurrentTexture;
+
+  if (!updateDisplayList) {
+    // We don't need to update the display list, either because we can't or
+    // because the previous one is still up to date. We may, however, have
+    // updated some resources.
+
+    // Use transaction of scene builder thread to notify epoch.
+    // It is for making epoch update consistent.
+    aSceneBuilderTxn.UpdateEpoch(aPipelineId, aEpoch);
+    if (aPipeline->mCurrentTexture) {
+      HoldExternalImage(aPipelineId, aEpoch, aPipeline->mCurrentTexture);
+    }
+    return;
+  }
+
+  aPipeline->mIsChanged = false;
+  aPipeline->mDLBuilder.Begin();
+
+  float opacity = 1.0f;
+  wr::StackingContextParams params;
+  params.opacity = &opacity;
+  params.mix_blend_mode = aPipeline->mMixBlendMode;
+
+  wr::WrComputedTransformData computedTransform;
+  computedTransform.vertical_flip =
+      aPipeline->mCurrentTexture && aPipeline->mCurrentTexture->NeedsYFlip();
+  computedTransform.scale_from = {
+      float(aPipeline->mCurrentTexture->GetSize().width),
+      float(aPipeline->mCurrentTexture->GetSize().height)};
+  computedTransform.rotation = ToWrRotation(aPipeline->mRotation);
+  // We don't have a frame / per-frame key here, but we can use the pipeline id
+  // and the key kind to create a unique stable key.
+  computedTransform.key = wr::SpatialKey(
+      aPipelineId.mNamespace, aPipelineId.mHandle, wr::SpatialKeyKind::APZ);
+  params.computed_transform = &computedTransform;
+
+  Maybe<wr::WrSpatialId> referenceFrameId =
+      aPipeline->mDLBuilder.PushStackingContext(
+          params, wr::ToLayoutRect(aPipeline->mScBounds),
+          // This is fine to do unconditionally because we only push images
+          // here.
+          wr::RasterSpace::Screen());
+
+  Maybe<wr::SpaceAndClipChainHelper> spaceAndClipChainHelper;
+  if (referenceFrameId) {
+    spaceAndClipChainHelper.emplace(aPipeline->mDLBuilder,
+                                    referenceFrameId.ref());
+  }
+
+  if (aPipeline->mCurrentTexture && !keys.IsEmpty()) {
+    LayoutDeviceRect rect(0, 0, aPipeline->mCurrentTexture->GetSize().width,
+                          aPipeline->mCurrentTexture->GetSize().height);
+
+    if (aPipeline->mUseExternalImage) {
+      MOZ_ASSERT(aPipeline->mCurrentTexture->AsWebRenderTextureHost());
+      Range<wr::ImageKey> range_keys(&keys[0], keys.Length());
+      TextureHost::PushDisplayItemFlagSet flags;
+      flags += TextureHost::PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE;
+      if (mApi->SupportsExternalBufferTextures()) {
+        flags +=
+            TextureHost::PushDisplayItemFlag::SUPPORTS_EXTERNAL_BUFFER_TEXTURES;
+      }
+      aPipeline->mCurrentTexture->PushDisplayItems(
+          aPipeline->mDLBuilder, wr::ToLayoutRect(rect), wr::ToLayoutRect(rect),
+          aPipeline->mFilter, range_keys, flags);
+      HoldExternalImage(aPipelineId, aEpoch, aPipeline->mCurrentTexture);
+    } else {
+      MOZ_ASSERT(keys.Length() == 1);
+      aPipeline->mDLBuilder.PushImage(wr::ToLayoutRect(rect),
+                                      wr::ToLayoutRect(rect), true, false,
+                                      aPipeline->mFilter, keys[0]);
+    }
+  }
+
+  spaceAndClipChainHelper.reset();
+  aPipeline->mDLBuilder.PopStackingContext(referenceFrameId.isSome());
+
+  wr::BuiltDisplayList dl;
+  aPipeline->mDLBuilder.End(dl);
+  aSceneBuilderTxn.SetDisplayList(aEpoch, aPipelineId, dl.dl_desc, dl.dl_items,
+                                  dl.dl_cache, dl.dl_spatial_tree);
+}
+
+void AsyncImagePipelineManager::ApplyAsyncImageForPipeline(
+    const wr::PipelineId& aPipelineId, wr::TransactionBuilder& aTxn,
+    wr::TransactionBuilder& aTxnForImageBridge, RemoteTextureInfoList* aList) {
+  AsyncImagePipeline* pipeline =
+      mAsyncImagePipelines.Get(wr::AsUint64(aPipelineId));
+  if (!pipeline) {
+    return;
+  }
+
+  // ready event of RemoteTexture that uses ImageBridge do not need to be
+  // checked here.
+  if (pipeline->mImageHost->GetAsyncRef()) {
+    aList = nullptr;
+  }
+
+  wr::TransactionBuilder fastTxn(mApi, /* aUseSceneBuilderThread */ false);
+  wr::AutoTransactionSender sender(mApi, &fastTxn);
+
+  // Transaction for async image pipeline that uses ImageBridge always need to
+  // be non low priority.
+  auto& sceneBuilderTxn =
+      pipeline->mImageHost->GetAsyncRef() ? aTxnForImageBridge : aTxn;
+
+  // Use transaction of using non scene builder thread when ImageHost uses
+  // ImageBridge. ApplyAsyncImagesOfImageBridge() handles transaction of adding
+  // and updating wr::ImageKeys of ImageHosts that uses ImageBridge. Then
+  // AsyncImagePipelineManager always needs to use non scene builder thread
+  // transaction for adding and updating wr::ImageKeys of ImageHosts that uses
+  // ImageBridge. Otherwise, ordering of wr::ImageKeys updating in webrender
+  // becomes inconsistent.
+  auto& maybeFastTxn = pipeline->mImageHost->GetAsyncRef() ? fastTxn : aTxn;
+
+  wr::Epoch epoch = GetNextImageEpoch();
+
+  ApplyAsyncImageForPipeline(epoch, aPipelineId, pipeline, sceneBuilderTxn,
+                             maybeFastTxn, aList);
+}
+
+void AsyncImagePipelineManager::SetEmptyDisplayList(
+    const wr::PipelineId& aPipelineId, wr::TransactionBuilder& aTxn,
+    wr::TransactionBuilder& aTxnForImageBridge) {
+  AsyncImagePipeline* pipeline =
+      mAsyncImagePipelines.Get(wr::AsUint64(aPipelineId));
+  if (!pipeline) {
+    return;
+  }
+
+  // Transaction for async image pipeline that uses ImageBridge always need to
+  // be non low priority.
+  auto& txn = pipeline->mImageHost->GetAsyncRef() ? aTxnForImageBridge : aTxn;
+
+  wr::Epoch epoch = GetNextImageEpoch();
+  wr::DisplayListBuilder builder(aPipelineId, mApi->GetBackendType());
+  builder.Begin();
+
+  wr::BuiltDisplayList dl;
+  builder.End(dl);
+  txn.SetDisplayList(epoch, aPipelineId, dl.dl_desc, dl.dl_items, dl.dl_cache,
+                     dl.dl_spatial_tree);
+}
+
+void AsyncImagePipelineManager::HoldExternalImage(
+    const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch,
+    TextureHost* aTexture) {
+  if (mDestroyed) {
+    return;
+  }
+  MOZ_ASSERT(aTexture);
+
+  PipelineTexturesHolder* holder =
+      mPipelineTexturesHolders.Get(wr::AsUint64(aPipelineId));
+  MOZ_ASSERT(holder);
+  if (!holder) {
+    return;
+  }
+  if (aTexture->NeedsDeferredDeletion()) {
+    // Hold WebRenderTextureHost until rendering completed.
+    holder->mTextureHostsUntilRenderCompleted.emplace_back(
+        MakeUnique<ForwardingTextureHost>(aEpoch, aTexture));
+  } else {
+    // Hold WebRenderTextureHost until submitted for rendering.
+    holder->mTextureHostsUntilRenderSubmitted.emplace_back(aEpoch, aTexture);
+  }
+}
+
+void AsyncImagePipelineManager::HoldExternalImage(
+    const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch,
+    const wr::ExternalImageId& aImageId) {
+  if (mDestroyed) {
+    SharedSurfacesParent::Release(aImageId);
+    return;
+  }
+
+  PipelineTexturesHolder* holder =
+      mPipelineTexturesHolders.Get(wr::AsUint64(aPipelineId));
+  MOZ_ASSERT(holder);
+  if (!holder) {
+    SharedSurfacesParent::Release(aImageId);
+    return;
+  }
+
+  holder->mExternalImages.emplace_back(
+      MakeUnique<ForwardingExternalImage>(aEpoch, aImageId));
+}
+
+void AsyncImagePipelineManager::NotifyPipelinesUpdated(
+    RefPtr<const wr::WebRenderPipelineInfo> aInfo,
+    wr::RenderedFrameId aLatestFrameId,
+    wr::RenderedFrameId aLastCompletedFrameId, ipc::FileDescriptor&& aFenceFd) {
+  MOZ_ASSERT(wr::RenderThread::IsInRenderThread());
+  MOZ_ASSERT(mLastCompletedFrameId <= aLastCompletedFrameId.mId);
+  MOZ_ASSERT(aLatestFrameId.IsValid());
+
+  mLastCompletedFrameId = aLastCompletedFrameId.mId;
+
+  {
+    // We need to lock for mRenderSubmittedUpdates because it can be accessed
+    // on the compositor thread.
+    MutexAutoLock lock(mRenderSubmittedUpdatesLock);
+
+    // Move the pending updates into the submitted ones.
+    mRenderSubmittedUpdates.emplace_back(
+        aLatestFrameId,
+        WebRenderPipelineInfoHolder(std::move(aInfo), std::move(aFenceFd)));
+  }
+
+  // Queue a runnable on the compositor thread to process the updates.
+  // This will also call CheckForTextureHostsNotUsedByGPU.
+  layers::CompositorThread()->Dispatch(
+      NewRunnableMethod("ProcessPipelineUpdates", this,
+                        &AsyncImagePipelineManager::ProcessPipelineUpdates));
+}
+
+void AsyncImagePipelineManager::ProcessPipelineUpdates() {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+  if (mDestroyed) {
+    return;
+  }
+
+  std::vector<std::pair<wr::RenderedFrameId, WebRenderPipelineInfoHolder>>
+      submittedUpdates;
+  {
+    // We need to lock for mRenderSubmittedUpdates because it can be accessed on
+    // the compositor thread.
+    MutexAutoLock lock(mRenderSubmittedUpdatesLock);
+    mRenderSubmittedUpdates.swap(submittedUpdates);
+  }
+
+  // submittedUpdates is a vector of RenderedFrameIds paired with vectors of
+  // WebRenderPipelineInfo.
+  for (auto update : submittedUpdates) {
+    auto& holder = update.second;
+    const auto& info = holder.mInfo->Raw();
+
+    mReleaseFenceFd = std::move(holder.mFenceFd);
+
+    for (auto& epoch : info.epochs) {
+      ProcessPipelineRendered(epoch.pipeline_id, epoch.epoch, update.first);
+    }
+    for (auto& removedPipeline : info.removed_pipelines) {
+      ProcessPipelineRemoved(removedPipeline, update.first);
+    }
+  }
+  CheckForTextureHostsNotUsedByGPU();
+}
+
+void AsyncImagePipelineManager::ProcessPipelineRendered(
+    const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch,
+    wr::RenderedFrameId aRenderedFrameId) {
+  if (auto entry = mPipelineTexturesHolders.Lookup(wr::AsUint64(aPipelineId))) {
+    const auto& holder = entry.Data();
+    // For TextureHosts that can be released on render submission, using aEpoch
+    // find the first that we can't release and then release all prior to that.
+    auto firstSubmittedHostToKeep = std::find_if(
+        holder->mTextureHostsUntilRenderSubmitted.begin(),
+        holder->mTextureHostsUntilRenderSubmitted.end(),
+        [&aEpoch](const auto& entry) { return aEpoch <= entry.mEpoch; });
+#ifdef MOZ_WIDGET_ANDROID
+    // Set release fence if TextureHost owns AndroidHardwareBuffer.
+    // The TextureHost handled by mTextureHostsUntilRenderSubmitted instead of
+    // mTextureHostsUntilRenderCompleted, since android fence could be used
+    // to wait until its end of usage by GPU.
+    for (auto it = holder->mTextureHostsUntilRenderSubmitted.begin();
+         it != firstSubmittedHostToKeep; ++it) {
+      const auto& entry = it;
+      if (entry->mTexture->GetAndroidHardwareBuffer() &&
+          mReleaseFenceFd.IsValid()) {
+        ipc::FileDescriptor fenceFd = mReleaseFenceFd;
+        entry->mTexture->SetReleaseFence(std::move(fenceFd));
+      }
+    }
+#endif
+    holder->mTextureHostsUntilRenderSubmitted.erase(
+        holder->mTextureHostsUntilRenderSubmitted.begin(),
+        firstSubmittedHostToKeep);
+
+    // For TextureHosts that need to wait until render completed, find the first
+    // that is later than aEpoch and then move all prior to that to
+    // mTexturesInUseByGPU paired with aRenderedFrameId.  These will be released
+    // once rendering has completed for aRenderedFrameId.
+    auto firstCompletedHostToKeep = std::find_if(
+        holder->mTextureHostsUntilRenderCompleted.begin(),
+        holder->mTextureHostsUntilRenderCompleted.end(),
+        [&aEpoch](const auto& entry) { return aEpoch <= entry->mEpoch; });
+    if (firstCompletedHostToKeep !=
+        holder->mTextureHostsUntilRenderCompleted.begin()) {
+      std::vector<UniquePtr<ForwardingTextureHost>> hostsUntilCompleted(
+          std::make_move_iterator(
+              holder->mTextureHostsUntilRenderCompleted.begin()),
+          std::make_move_iterator(firstCompletedHostToKeep));
+      mTexturesInUseByGPU.emplace_back(aRenderedFrameId,
+                                       std::move(hostsUntilCompleted));
+      holder->mTextureHostsUntilRenderCompleted.erase(
+          holder->mTextureHostsUntilRenderCompleted.begin(),
+          firstCompletedHostToKeep);
+    }
+
+    // Using aEpoch, find the first external image that we can't release and
+    // then release all prior to that.
+    auto firstImageToKeep = std::find_if(
+        holder->mExternalImages.begin(), holder->mExternalImages.end(),
+        [&aEpoch](const auto& entry) { return aEpoch <= entry->mEpoch; });
+    holder->mExternalImages.erase(holder->mExternalImages.begin(),
+                                  firstImageToKeep);
+  }
+}
+
+void AsyncImagePipelineManager::ProcessPipelineRemoved(
+    const wr::RemovedPipeline& aRemovedPipeline,
+    wr::RenderedFrameId aRenderedFrameId) {
+  if (mDestroyed) {
+    return;
+  }
+  if (auto entry = mPipelineTexturesHolders.Lookup(
+          wr::AsUint64(aRemovedPipeline.pipeline_id))) {
+    const auto& holder = entry.Data();
+    if (holder->mDestroyedEpoch.isSome()) {
+      if (!holder->mTextureHostsUntilRenderCompleted.empty()) {
+        // Move all TextureHosts that must be held until render completed to
+        // mTexturesInUseByGPU paired with aRenderedFrameId.
+        mTexturesInUseByGPU.emplace_back(
+            aRenderedFrameId,
+            std::move(holder->mTextureHostsUntilRenderCompleted));
+      }
+
+      // Remove Pipeline releasing all remaining TextureHosts and external
+      // images.
+      entry.Remove();
+    }
+
+    // If mDestroyedEpoch contains nothing it means we reused the same pipeline
+    // id (probably because we moved the tab to another window). In this case we
+    // need to keep the holder.
+  }
+}
+
+void AsyncImagePipelineManager::CheckForTextureHostsNotUsedByGPU() {
+  uint64_t lastCompletedFrameId = mLastCompletedFrameId;
+
+  // Find first entry after mLastCompletedFrameId and release all prior ones.
+  auto firstTexturesToKeep =
+      std::find_if(mTexturesInUseByGPU.begin(), mTexturesInUseByGPU.end(),
+                   [lastCompletedFrameId](const auto& entry) {
+                     return lastCompletedFrameId < entry.first.mId;
+                   });
+  mTexturesInUseByGPU.erase(mTexturesInUseByGPU.begin(), firstTexturesToKeep);
+}
+
+wr::Epoch AsyncImagePipelineManager::GetNextImageEpoch() {
+  mAsyncImageEpoch.mHandle++;
+  return mAsyncImageEpoch;
+}
+
+AsyncImagePipelineManager::WebRenderPipelineInfoHolder::
+    WebRenderPipelineInfoHolder(RefPtr<const wr::WebRenderPipelineInfo>&& aInfo,
+                                ipc::FileDescriptor&& aFenceFd)
+    : mInfo(aInfo), mFenceFd(aFenceFd) {}
+
+AsyncImagePipelineManager::WebRenderPipelineInfoHolder::
+    ~WebRenderPipelineInfoHolder() = default;
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/AsyncImagePipelineManager.h b/gfx/layers/wr/AsyncImagePipelineManager.h
new file mode 100644
index 0000000000..1ed144c548
--- /dev/null
+++ b/gfx/layers/wr/AsyncImagePipelineManager.h
@@ -0,0 +1,281 @@
+/* -*- 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_WEBRENDERCOMPOSITABLE_HOLDER_H
+#define MOZILLA_GFX_WEBRENDERCOMPOSITABLE_HOLDER_H
+
+#include <vector>
+
+#include "CompositableHost.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/ipc/FileDescriptor.h"
+#include "mozilla/layers/RemoteTextureMap.h"
+#include "mozilla/layers/TextureHost.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "nsClassHashtable.h"
+
+namespace mozilla {
+
+namespace wr {
+class DisplayListBuilder;
+class WebRenderAPI;
+class WebRenderPipelineInfo;
+}  // namespace wr
+
+namespace layers {
+
+class CompositableHost;
+class CompositorVsyncScheduler;
+class WebRenderImageHost;
+class WebRenderTextureHost;
+
+class AsyncImagePipelineManager final {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AsyncImagePipelineManager)
+
+  explicit AsyncImagePipelineManager(RefPtr<wr::WebRenderAPI>&& aApi,
+                                     bool aUseCompositorWnd);
+
+ protected:
+  ~AsyncImagePipelineManager();
+
+ public:
+  void Destroy();
+
+  bool UseCompositorWnd() const { return mUseCompositorWnd; }
+
+  void AddPipeline(const wr::PipelineId& aPipelineId,
+                   WebRenderBridgeParent* aWrBridge);
+  void RemovePipeline(const wr::PipelineId& aPipelineId,
+                      const wr::Epoch& aEpoch);
+  WebRenderBridgeParent* GetWrBridge(const wr::PipelineId& aPipelineId);
+
+  void HoldExternalImage(const wr::PipelineId& aPipelineId,
+                         const wr::Epoch& aEpoch, TextureHost* aTexture);
+  void HoldExternalImage(const wr::PipelineId& aPipelineId,
+                         const wr::Epoch& aEpoch,
+                         const wr::ExternalImageId& aImageId);
+
+  // This is called from the Renderer thread to notify this class about the
+  // pipelines in the most recently completed update.
+  // @param aInfo PipelineInfo for the update
+  // @param aLatestFrameId RenderedFrameId if a frame has been submitted for
+  //                       rendering, invalid if not
+  // @param aLastCompletedFrameId RenderedFrameId for the last completed frame
+  void NotifyPipelinesUpdated(RefPtr<const wr::WebRenderPipelineInfo> aInfo,
+                              wr::RenderedFrameId aLatestFrameId,
+                              wr::RenderedFrameId aLastCompletedFrameId,
+                              ipc::FileDescriptor&& aFenceFd);
+
+  // This is run on the compositor thread to process mRenderSubmittedUpdates. We
+  // make this public because we need to invoke it from other places.
+  void ProcessPipelineUpdates();
+
+  TimeStamp GetCompositionTime() const { return mCompositionTime; }
+  CompositionOpportunityId GetCompositionOpportunityId() const {
+    return mCompositionOpportunityId;
+  }
+
+  void SetCompositionInfo(TimeStamp aTimeStamp,
+                          CompositionOpportunityId aCompositionOpportunityId) {
+    mCompositionTime = aTimeStamp;
+    mCompositionOpportunityId = aCompositionOpportunityId;
+    if (!mCompositionTime.IsNull() && !mCompositeUntilTime.IsNull() &&
+        mCompositionTime >= mCompositeUntilTime) {
+      mCompositeUntilTime = TimeStamp();
+    }
+  }
+  void CompositeUntil(TimeStamp aTimeStamp) {
+    if (mCompositeUntilTime.IsNull() || mCompositeUntilTime < aTimeStamp) {
+      mCompositeUntilTime = aTimeStamp;
+    }
+  }
+  TimeStamp GetCompositeUntilTime() const { return mCompositeUntilTime; }
+
+  void AddAsyncImagePipeline(const wr::PipelineId& aPipelineId,
+                             WebRenderImageHost* aImageHost);
+  void RemoveAsyncImagePipeline(const wr::PipelineId& aPipelineId,
+                                wr::TransactionBuilder& aTxn);
+
+  void UpdateAsyncImagePipeline(const wr::PipelineId& aPipelineId,
+                                const LayoutDeviceRect& aScBounds,
+                                VideoInfo::Rotation aRotation,
+                                const wr::ImageRendering& aFilter,
+                                const wr::MixBlendMode& aMixBlendMode);
+  void ApplyAsyncImagesOfImageBridge(wr::TransactionBuilder& aSceneBuilderTxn,
+                                     wr::TransactionBuilder& aFastTxn);
+  void ApplyAsyncImageForPipeline(const wr::PipelineId& aPipelineId,
+                                  wr::TransactionBuilder& aTxn,
+                                  wr::TransactionBuilder& aTxnForImageBridge,
+                                  RemoteTextureInfoList* aList);
+
+  void SetEmptyDisplayList(const wr::PipelineId& aPipelineId,
+                           wr::TransactionBuilder& aTxn,
+                           wr::TransactionBuilder& aTxnForImageBridge);
+
+  void AppendImageCompositeNotification(
+      const ImageCompositeNotificationInfo& aNotification) {
+    mImageCompositeNotifications.AppendElement(aNotification);
+  }
+
+  void FlushImageNotifications(
+      nsTArray<ImageCompositeNotificationInfo>* aNotifications) {
+    aNotifications->AppendElements(std::move(mImageCompositeNotifications));
+  }
+
+  void SetWillGenerateFrame();
+  bool GetAndResetWillGenerateFrame();
+
+  static wr::ExternalImageId GetNextExternalImageId();
+
+ private:
+  void ProcessPipelineRendered(const wr::PipelineId& aPipelineId,
+                               const wr::Epoch& aEpoch,
+                               wr::RenderedFrameId aRenderedFrameId);
+  void ProcessPipelineRemoved(const wr::RemovedPipeline& aRemovedPipeline,
+                              wr::RenderedFrameId aRenderedFrameId);
+
+  wr::Epoch GetNextImageEpoch();
+  uint32_t GetNextResourceId() { return ++mResourceId; }
+  wr::IdNamespace GetNamespace() { return mIdNamespace; }
+  wr::ImageKey GenerateImageKey() {
+    wr::ImageKey key;
+    key.mNamespace = GetNamespace();
+    key.mHandle = GetNextResourceId();
+    return key;
+  }
+
+  struct ForwardingTextureHost {
+    ForwardingTextureHost(const wr::Epoch& aEpoch, TextureHost* aTexture)
+        : mEpoch(aEpoch), mTexture(aTexture) {}
+    wr::Epoch mEpoch;
+    CompositableTextureHostRef mTexture;
+  };
+
+  struct ForwardingExternalImage {
+    ForwardingExternalImage(const wr::Epoch& aEpoch,
+                            const wr::ExternalImageId& aImageId)
+        : mEpoch(aEpoch), mImageId(aImageId) {}
+    ~ForwardingExternalImage();
+    wr::Epoch mEpoch;
+    wr::ExternalImageId mImageId;
+  };
+
+  struct PipelineTexturesHolder {
+    // Holds forwarding WebRenderTextureHosts.
+    std::vector<ForwardingTextureHost> mTextureHostsUntilRenderSubmitted;
+    // TextureHosts that must be held until rendering has completed. UniquePtr
+    // is used to make the entries movable, ideally ForwardingTextureHost would
+    // be fully movable.
+    std::vector<UniquePtr<ForwardingTextureHost>>
+        mTextureHostsUntilRenderCompleted;
+    std::vector<UniquePtr<ForwardingExternalImage>> mExternalImages;
+    Maybe<wr::Epoch> mDestroyedEpoch;
+    WebRenderBridgeParent* MOZ_NON_OWNING_REF mWrBridge = nullptr;
+  };
+
+  struct AsyncImagePipeline {
+    AsyncImagePipeline(wr::PipelineId aPipelineId,
+                       layers::WebRenderBackend aBackend);
+    void Update(const LayoutDeviceRect& aScBounds,
+                VideoInfo::Rotation aRotation,
+                const wr::ImageRendering& aFilter,
+                const wr::MixBlendMode& aMixBlendMode) {
+      mIsChanged |= !mScBounds.IsEqualEdges(aScBounds) ||
+                    mRotation != aRotation || mFilter != aFilter ||
+                    mMixBlendMode != aMixBlendMode;
+      mScBounds = aScBounds;
+      mRotation = aRotation;
+      mFilter = aFilter;
+      mMixBlendMode = aMixBlendMode;
+    }
+
+    bool mInitialised;
+    bool mIsChanged;
+    bool mUseExternalImage;
+    LayoutDeviceRect mScBounds;
+    VideoInfo::Rotation mRotation;
+    wr::ImageRendering mFilter;
+    wr::MixBlendMode mMixBlendMode;
+    RefPtr<WebRenderImageHost> mImageHost;
+    CompositableTextureHostRef mCurrentTexture;
+    nsTArray<wr::ImageKey> mKeys;
+    wr::DisplayListBuilder mDLBuilder;
+  };
+
+  void ApplyAsyncImageForPipeline(const wr::Epoch& aEpoch,
+                                  const wr::PipelineId& aPipelineId,
+                                  AsyncImagePipeline* aPipeline,
+                                  wr::TransactionBuilder& aSceneBuilderTxn,
+                                  wr::TransactionBuilder& aMaybeFastTxn,
+                                  RemoteTextureInfoList* aList);
+  Maybe<TextureHost::ResourceUpdateOp> UpdateImageKeys(
+      const wr::Epoch& aEpoch, const wr::PipelineId& aPipelineId,
+      AsyncImagePipeline* aPipeline, nsTArray<wr::ImageKey>& aKeys,
+      wr::TransactionBuilder& aSceneBuilderTxn,
+      wr::TransactionBuilder& aMaybeFastTxn, RemoteTextureInfoList* aList);
+  Maybe<TextureHost::ResourceUpdateOp> UpdateWithoutExternalImage(
+      TextureHost* aTexture, wr::ImageKey aKey, TextureHost::ResourceUpdateOp,
+      wr::TransactionBuilder& aTxn);
+
+  void CheckForTextureHostsNotUsedByGPU();
+
+  RefPtr<wr::WebRenderAPI> mApi;
+  bool mUseCompositorWnd;
+
+  const wr::IdNamespace mIdNamespace;
+  const bool mUseTripleBuffering;
+  uint32_t mResourceId;
+
+  nsClassHashtable<nsUint64HashKey, PipelineTexturesHolder>
+      mPipelineTexturesHolders;
+  nsClassHashtable<nsUint64HashKey, AsyncImagePipeline> mAsyncImagePipelines;
+  wr::Epoch mAsyncImageEpoch;
+  bool mWillGenerateFrame;
+  bool mDestroyed;
+
+#ifdef XP_WIN
+  bool mUseWebRenderDCompVideoOverlayWin;
+#endif
+
+  // Render time for the current composition.
+  TimeStamp mCompositionTime;
+
+  // CompositionOpportunityId of the current composition.
+  CompositionOpportunityId mCompositionOpportunityId;
+
+  // When nonnull, during rendering, some compositable indicated that it will
+  // change its rendering at this time. In order not to miss it, we composite
+  // on every vsync until this time occurs (this is the latest such time).
+  TimeStamp mCompositeUntilTime;
+
+  nsTArray<ImageCompositeNotificationInfo> mImageCompositeNotifications;
+
+  struct WebRenderPipelineInfoHolder {
+    WebRenderPipelineInfoHolder(RefPtr<const wr::WebRenderPipelineInfo>&& aInfo,
+                                ipc::FileDescriptor&& aFenceFd);
+    ~WebRenderPipelineInfoHolder();
+    RefPtr<const wr::WebRenderPipelineInfo> mInfo;
+    ipc::FileDescriptor mFenceFd;
+  };
+
+  std::vector<std::pair<wr::RenderedFrameId, WebRenderPipelineInfoHolder>>
+      mRenderSubmittedUpdates;
+  Mutex mRenderSubmittedUpdatesLock MOZ_UNANNOTATED;
+
+  Atomic<uint64_t> mLastCompletedFrameId;
+  std::vector<std::pair<wr::RenderedFrameId,
+                        std::vector<UniquePtr<ForwardingTextureHost>>>>
+      mTexturesInUseByGPU;
+  ipc::FileDescriptor mReleaseFenceFd;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif /* MOZILLA_GFX_WEBRENDERCOMPOSITABLE_HOLDER_H */
diff --git a/gfx/layers/wr/ClipManager.cpp b/gfx/layers/wr/ClipManager.cpp
new file mode 100644
index 0000000000..d201c85411
--- /dev/null
+++ b/gfx/layers/wr/ClipManager.cpp
@@ -0,0 +1,501 @@
+/* -*- 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/layers/ClipManager.h"
+
+#include "DisplayItemClipChain.h"
+#include "FrameMetrics.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/layers/StackingContextHelper.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "nsDisplayList.h"
+#include "nsRefreshDriver.h"
+#include "nsStyleStructInlines.h"
+#include "UnitTransforms.h"
+
+// clang-format off
+#define CLIP_LOG(...)
+//#define CLIP_LOG(s_, ...) printf_stderr("CLIP(%s): " s_, __func__, ## __VA_ARGS__)
+//#define CLIP_LOG(s_, ...) if (XRE_IsContentProcess()) printf_stderr("CLIP(%s): " s_, __func__, ## __VA_ARGS__)
+// clang-format on
+
+namespace mozilla {
+namespace layers {
+
+ClipManager::ClipManager() : mManager(nullptr), mBuilder(nullptr) {}
+
+void ClipManager::BeginBuild(WebRenderLayerManager* aManager,
+                             wr::DisplayListBuilder& aBuilder) {
+  MOZ_ASSERT(!mManager);
+  mManager = aManager;
+  MOZ_ASSERT(!mBuilder);
+  mBuilder = &aBuilder;
+  MOZ_ASSERT(mCacheStack.empty());
+  mCacheStack.emplace();
+  MOZ_ASSERT(mASROverride.empty());
+  MOZ_ASSERT(mItemClipStack.empty());
+}
+
+void ClipManager::EndBuild() {
+  mBuilder = nullptr;
+  mManager = nullptr;
+  mCacheStack.pop();
+  MOZ_ASSERT(mCacheStack.empty());
+  MOZ_ASSERT(mASROverride.empty());
+  MOZ_ASSERT(mItemClipStack.empty());
+}
+
+void ClipManager::BeginList(const StackingContextHelper& aStackingContext) {
+  CLIP_LOG("begin list %p affects = %d, ref-frame = %d\n", &aStackingContext,
+           aStackingContext.AffectsClipPositioning(),
+           aStackingContext.ReferenceFrameId().isSome());
+
+  ItemClips clips(nullptr, nullptr, 0, false);
+  if (!mItemClipStack.empty()) {
+    clips = mItemClipStack.top();
+  }
+
+  if (aStackingContext.AffectsClipPositioning()) {
+    if (auto referenceFrameId = aStackingContext.ReferenceFrameId()) {
+      PushOverrideForASR(clips.mASR, *referenceFrameId);
+      clips.mScrollId = *referenceFrameId;
+    } else {
+      // Start a new cache
+      mCacheStack.emplace();
+    }
+    if (clips.mChain) {
+      clips.mClipChainId =
+          DefineClipChain(clips.mChain, clips.mAppUnitsPerDevPixel);
+    }
+  }
+
+  CLIP_LOG("  push: clip: %p, asr: %p, scroll = %zu, clip = %zu\n",
+           clips.mChain, clips.mASR, clips.mScrollId.id,
+           clips.mClipChainId.valueOr(wr::WrClipChainId{0}).id);
+
+  mItemClipStack.push(clips);
+}
+
+void ClipManager::EndList(const StackingContextHelper& aStackingContext) {
+  MOZ_ASSERT(!mItemClipStack.empty());
+
+  CLIP_LOG("end list %p\n", &aStackingContext);
+
+  mBuilder->SetClipChainLeaf(Nothing());
+  mItemClipStack.pop();
+
+  if (aStackingContext.AffectsClipPositioning()) {
+    if (aStackingContext.ReferenceFrameId()) {
+      PopOverrideForASR(mItemClipStack.empty() ? nullptr
+                                               : mItemClipStack.top().mASR);
+    } else {
+      MOZ_ASSERT(!mCacheStack.empty());
+      mCacheStack.pop();
+    }
+  }
+}
+
+void ClipManager::PushOverrideForASR(const ActiveScrolledRoot* aASR,
+                                     const wr::WrSpatialId& aSpatialId) {
+  wr::WrSpatialId space = GetScrollLayer(aASR);
+
+  CLIP_LOG("Pushing %p override %zu -> %zu\n", aASR, space.id, aSpatialId.id);
+  auto it = mASROverride.insert({space, std::stack<wr::WrSpatialId>()});
+  it.first->second.push(aSpatialId);
+
+  // Start a new cache
+  mCacheStack.emplace();
+
+  // Fix up our cached item clip if needed.
+  if (!mItemClipStack.empty()) {
+    auto& top = mItemClipStack.top();
+    if (top.mASR == aASR) {
+      top.mScrollId = aSpatialId;
+      if (top.mChain) {
+        top.mClipChainId =
+            DefineClipChain(top.mChain, top.mAppUnitsPerDevPixel);
+      }
+    }
+  }
+}
+
+void ClipManager::PopOverrideForASR(const ActiveScrolledRoot* aASR) {
+  MOZ_ASSERT(!mCacheStack.empty());
+  mCacheStack.pop();
+
+  wr::WrSpatialId space = GetScrollLayer(aASR);
+  auto it = mASROverride.find(space);
+  if (it == mASROverride.end()) {
+    MOZ_ASSERT_UNREACHABLE("Push/PopOverrideForASR should be balanced");
+  } else {
+    CLIP_LOG("Popping %p override %zu -> %zu\n", aASR, space.id,
+             it->second.top().id);
+    it->second.pop();
+  }
+
+  if (!mItemClipStack.empty()) {
+    auto& top = mItemClipStack.top();
+    if (top.mASR == aASR) {
+      top.mScrollId = (it == mASROverride.end() || it->second.empty())
+                          ? space
+                          : it->second.top();
+      if (top.mChain) {
+        top.mClipChainId =
+            DefineClipChain(top.mChain, top.mAppUnitsPerDevPixel);
+      }
+    }
+  }
+
+  if (it != mASROverride.end() && it->second.empty()) {
+    mASROverride.erase(it);
+  }
+}
+
+wr::WrSpatialId ClipManager::SpatialIdAfterOverride(
+    const wr::WrSpatialId& aSpatialId) {
+  auto it = mASROverride.find(aSpatialId);
+  if (it == mASROverride.end()) {
+    return aSpatialId;
+  }
+  MOZ_ASSERT(!it->second.empty());
+  CLIP_LOG("Overriding %zu with %zu\n", aSpatialId.id, it->second.top().id);
+  return it->second.top();
+}
+
+wr::WrSpaceAndClipChain ClipManager::SwitchItem(nsDisplayListBuilder* aBuilder,
+                                                nsDisplayItem* aItem) {
+  const DisplayItemClipChain* clip = aItem->GetClipChain();
+  const DisplayItemClipChain* inheritedClipChain =
+      mBuilder->GetInheritedClipChain();
+  if (inheritedClipChain && inheritedClipChain != clip) {
+    if (!clip) {
+      clip = mBuilder->GetInheritedClipChain();
+    } else {
+      clip = aBuilder->CreateClipChainIntersection(
+          mBuilder->GetInheritedClipChain(), clip);
+    }
+  }
+  const ActiveScrolledRoot* asr = aItem->GetActiveScrolledRoot();
+  DisplayItemType type = aItem->GetType();
+  if (type == DisplayItemType::TYPE_STICKY_POSITION) {
+    // For sticky position items, the ASR is computed differently depending on
+    // whether the item has a fixed descendant or not. But for WebRender
+    // purposes we always want to use the ASR that would have been used if it
+    // didn't have fixed descendants, which is stored as the "container ASR" on
+    // the sticky item.
+    auto* sticky = static_cast<nsDisplayStickyPosition*>(aItem);
+    asr = sticky->GetContainerASR();
+
+    // If the leafmost clip for the sticky item is just the displayport clip,
+    // then skip it. This allows sticky items to remain visible even if the
+    // rest of the content in the enclosing scrollframe is checkerboarding.
+    if (sticky->IsClippedToDisplayPort() && clip && clip->mASR == asr) {
+      clip = clip->mParent;
+    }
+  }
+
+  CLIP_LOG("processing item %p (%s) asr %p clip %p, inherited = %p\n", aItem,
+           DisplayItemTypeName(aItem->GetType()), asr, clip,
+           inheritedClipChain);
+
+  // In most cases we can combine the leaf of the clip chain with the clip rect
+  // of the display item. This reduces the number of clip items, which avoids
+  // some overhead further down the pipeline.
+  bool separateLeaf = false;
+  if (clip && clip->mASR == asr && clip->mClip.GetRoundedRectCount() == 0) {
+    // Container display items are not currently supported because the clip
+    // rect of a stacking context is not handled the same as normal display
+    // items.
+    separateLeaf = !aItem->GetChildren();
+  }
+
+  // Zoom display items report their bounds etc using the parent document's
+  // APD because zoom items act as a conversion layer between the two different
+  // APDs.
+  const int32_t auPerDevPixel = [&] {
+    if (type == DisplayItemType::TYPE_ZOOM) {
+      return static_cast<nsDisplayZoom*>(aItem)->GetParentAppUnitsPerDevPixel();
+    }
+    return aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+  }();
+
+  ItemClips clips(asr, clip, auPerDevPixel, separateLeaf);
+  MOZ_ASSERT(!mItemClipStack.empty());
+  if (clips.HasSameInputs(mItemClipStack.top())) {
+    // Early-exit because if the clips are the same as aItem's previous sibling,
+    // then we don't need to do do the work of popping the old stuff and then
+    // pushing it right back on for the new item. Note that if aItem doesn't
+    // have a previous sibling, that means BeginList would have been called
+    // just before this, which will have pushed a ItemClips(nullptr, nullptr)
+    // onto mItemClipStack, so the HasSameInputs check should return false.
+    CLIP_LOG("\tearly-exit for %p\n", aItem);
+    return mItemClipStack.top().GetSpaceAndClipChain();
+  }
+
+  // Pop aItem's previous sibling's stuff from mBuilder in preparation for
+  // pushing aItem's stuff.
+  mItemClipStack.pop();
+
+  // If the leaf of the clip chain is going to be merged with the display item's
+  // clip rect, then we should create a clip chain id from the leaf's parent.
+  if (separateLeaf) {
+    CLIP_LOG("\tseparate leaf detected, ignoring the last clip\n");
+    clip = clip->mParent;
+  }
+
+  // There are two ASR chains here that we need to be fully defined. One is the
+  // ASR chain pointed to by |asr|. The other is the
+  // ASR chain pointed to by clip->mASR. We pick the leafmost
+  // of these two chains because that one will include the other. Calling
+  // DefineScrollLayers with this leafmost ASR will recursively define all the
+  // ASRs that we care about for this item, but will not actually push
+  // anything onto the WR stack.
+  const ActiveScrolledRoot* leafmostASR = asr;
+  if (clip) {
+    leafmostASR = ActiveScrolledRoot::PickDescendant(leafmostASR, clip->mASR);
+  }
+  Maybe<wr::WrSpatialId> leafmostId = DefineScrollLayers(leafmostASR, aItem);
+  Unused << leafmostId;
+
+  // Define all the clips in the item's clip chain, and obtain a clip chain id
+  // for it.
+  clips.mClipChainId = DefineClipChain(clip, auPerDevPixel);
+
+  wr::WrSpatialId space = GetScrollLayer(asr);
+  clips.mScrollId = SpatialIdAfterOverride(space);
+  CLIP_LOG("\tassigning %d -> %d\n", (int)space.id, (int)clips.mScrollId.id);
+
+  // Now that we have the scroll id and a clip id for the item, push it onto
+  // the WR stack.
+  clips.UpdateSeparateLeaf(*mBuilder, auPerDevPixel);
+  auto spaceAndClipChain = clips.GetSpaceAndClipChain();
+
+  CLIP_LOG("  push: clip: %p, asr: %p, scroll = %zu, clip = %zu\n",
+           clips.mChain, clips.mASR, clips.mScrollId.id,
+           clips.mClipChainId.valueOr(wr::WrClipChainId{0}).id);
+
+  mItemClipStack.push(clips);
+
+  CLIP_LOG("done setup for %p\n", aItem);
+  return spaceAndClipChain;
+}
+
+wr::WrSpatialId ClipManager::GetScrollLayer(const ActiveScrolledRoot* aASR) {
+  for (const ActiveScrolledRoot* asr = aASR; asr; asr = asr->mParent) {
+    Maybe<wr::WrSpatialId> space =
+        mBuilder->GetScrollIdForDefinedScrollLayer(asr->GetViewId());
+    if (space) {
+      return *space;
+    }
+
+    // If this ASR doesn't have a scroll ID, then we should check its ancestor.
+    // There may not be one defined because the ASR may not be scrollable or we
+    // failed to get the scroll metadata.
+  }
+
+  Maybe<wr::WrSpatialId> space = mBuilder->GetScrollIdForDefinedScrollLayer(
+      ScrollableLayerGuid::NULL_SCROLL_ID);
+  MOZ_ASSERT(space.isSome());
+  return *space;
+}
+
+Maybe<wr::WrSpatialId> ClipManager::DefineScrollLayers(
+    const ActiveScrolledRoot* aASR, nsDisplayItem* aItem) {
+  if (!aASR) {
+    // Recursion base case
+    return Nothing();
+  }
+  ScrollableLayerGuid::ViewID viewId = aASR->GetViewId();
+  Maybe<wr::WrSpatialId> space =
+      mBuilder->GetScrollIdForDefinedScrollLayer(viewId);
+  if (space) {
+    // If we've already defined this scroll layer before, we can early-exit
+    return space;
+  }
+  // Recurse to define the ancestors
+  Maybe<wr::WrSpatialId> ancestorSpace =
+      DefineScrollLayers(aASR->mParent, aItem);
+
+  Maybe<ScrollMetadata> metadata =
+      aASR->mScrollableFrame->ComputeScrollMetadata(mManager, aItem->Frame(),
+                                                    aItem->ToReferenceFrame());
+  if (!metadata) {
+    MOZ_ASSERT_UNREACHABLE("Expected scroll metadata to be available!");
+    return ancestorSpace;
+  }
+
+  FrameMetrics& metrics = metadata->GetMetrics();
+  if (!metrics.IsScrollable()) {
+    // This item is a scrolling no-op, skip over it in the ASR chain.
+    return ancestorSpace;
+  }
+
+  nsIScrollableFrame* scrollableFrame = aASR->mScrollableFrame;
+  nsIFrame* scrollFrame = do_QueryFrame(scrollableFrame);
+  nsPoint offset = scrollFrame->GetOffsetToCrossDoc(aItem->Frame()) +
+                   aItem->ToReferenceFrame();
+  int32_t auPerDevPixel = aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+  nsRect scrollPort = scrollableFrame->GetScrollPortRect() + offset;
+  LayoutDeviceRect clipBounds =
+      LayoutDeviceRect::FromAppUnits(scrollPort, auPerDevPixel);
+
+  // The content rect that we hand to PushScrollLayer should be relative to
+  // the same origin as the clipBounds that we hand to PushScrollLayer -
+  // that is, both of them should be relative to the stacking context `aSc`.
+  // However, when we get the scrollable rect from the FrameMetrics, the
+  // origin has nothing to do with the position of the frame but instead
+  // represents the minimum allowed scroll offset of the scrollable content.
+  // While APZ uses this to clamp the scroll position, we don't need to send
+  // this to WebRender at all. Instead, we take the position from the
+  // composition bounds.
+  LayoutDeviceRect contentRect =
+      metrics.GetExpandedScrollableRect() * metrics.GetDevPixelsPerCSSPixel();
+  contentRect.MoveTo(clipBounds.TopLeft());
+
+  Maybe<wr::WrSpatialId> parent = ancestorSpace;
+  if (parent) {
+    *parent = SpatialIdAfterOverride(*parent);
+  }
+  // The external scroll offset is accumulated into the local space positions of
+  // display items inside WR, so that the elements hash (intern) to the same
+  // content ID for quick comparisons. To avoid invalidations when the
+  // auPerDevPixel is not a round value, round here directly from app units.
+  // This guarantees we won't introduce any inaccuracy in the external scroll
+  // offset passed to WR.
+  const bool useRoundedOffset =
+      StaticPrefs::apz_rounded_external_scroll_offset();
+  LayoutDevicePoint scrollOffset =
+      useRoundedOffset
+          ? LayoutDevicePoint::FromAppUnitsRounded(
+                scrollableFrame->GetScrollPosition(), auPerDevPixel)
+          : LayoutDevicePoint::FromAppUnits(
+                scrollableFrame->GetScrollPosition(), auPerDevPixel);
+
+  // Currently we track scroll-linked effects at the granularity of documents,
+  // not scroll frames, so we consider a scroll frame to have a scroll-linked
+  // effect whenever its containing document does.
+  nsPresContext* presContext = aItem->Frame()->PresContext();
+  const bool hasScrollLinkedEffect =
+      !StaticPrefs::apz_disable_for_scroll_linked_effects() &&
+      presContext->Document()->HasScrollLinkedEffect();
+
+  return Some(mBuilder->DefineScrollLayer(
+      viewId, parent, wr::ToLayoutRect(contentRect),
+      wr::ToLayoutRect(clipBounds), wr::ToLayoutVector2D(scrollOffset),
+      wr::ToWrAPZScrollGeneration(scrollableFrame->ScrollGenerationOnApz()),
+      wr::ToWrHasScrollLinkedEffect(hasScrollLinkedEffect),
+      wr::SpatialKey(uint64_t(scrollFrame), 0, wr::SpatialKeyKind::Scroll)));
+}
+
+Maybe<wr::WrClipChainId> ClipManager::DefineClipChain(
+    const DisplayItemClipChain* aChain, int32_t aAppUnitsPerDevPixel) {
+  MOZ_ASSERT(!mCacheStack.empty());
+  AutoTArray<wr::WrClipId, 6> allClipIds;
+  ClipIdMap& cache = mCacheStack.top();
+  // Iterate through the clips in the current item's clip chain, define them
+  // in WR, and put their IDs into |clipIds|.
+  for (const DisplayItemClipChain* chain = aChain; chain;
+       chain = chain->mParent) {
+    if (!chain->mClip.HasClip()) {
+      // This item in the chain is a no-op, skip over it
+      continue;
+    }
+
+    auto emplaceResult = cache.try_emplace(chain);
+    auto& chainClipIds = emplaceResult.first->second;
+    if (!emplaceResult.second) {
+      // Found it in the currently-active cache, so just use the id we have for
+      // it.
+      CLIP_LOG("cache[%p] => hit\n", chain);
+      allClipIds.AppendElements(chainClipIds);
+      continue;
+    }
+
+    LayoutDeviceRect clip = LayoutDeviceRect::FromAppUnits(
+        chain->mClip.GetClipRect(), aAppUnitsPerDevPixel);
+    AutoTArray<wr::ComplexClipRegion, 6> wrRoundedRects;
+    chain->mClip.ToComplexClipRegions(aAppUnitsPerDevPixel, wrRoundedRects);
+
+    wr::WrSpatialId space = GetScrollLayer(chain->mASR);
+    // Define the clip
+    space = SpatialIdAfterOverride(space);
+
+    auto rectClipId =
+        mBuilder->DefineRectClip(Some(space), wr::ToLayoutRect(clip));
+    CLIP_LOG("cache[%p] <= %zu\n", chain, rectClipId.id);
+    chainClipIds.AppendElement(rectClipId);
+
+    for (const auto& complexClip : wrRoundedRects) {
+      auto complexClipId =
+          mBuilder->DefineRoundedRectClip(Some(space), complexClip);
+      CLIP_LOG("cache[%p] <= %zu\n", chain, complexClipId.id);
+      chainClipIds.AppendElement(complexClipId);
+    }
+
+    allClipIds.AppendElements(chainClipIds);
+  }
+
+  if (allClipIds.IsEmpty()) {
+    return Nothing();
+  }
+
+  return Some(mBuilder->DefineClipChain(allClipIds));
+}
+
+ClipManager::~ClipManager() {
+  MOZ_ASSERT(!mBuilder);
+  MOZ_ASSERT(mCacheStack.empty());
+  MOZ_ASSERT(mItemClipStack.empty());
+}
+
+ClipManager::ItemClips::ItemClips(const ActiveScrolledRoot* aASR,
+                                  const DisplayItemClipChain* aChain,
+                                  int32_t aAppUnitsPerDevPixel,
+                                  bool aSeparateLeaf)
+    : mASR(aASR),
+      mChain(aChain),
+      mAppUnitsPerDevPixel(aAppUnitsPerDevPixel),
+      mSeparateLeaf(aSeparateLeaf) {
+  mScrollId = wr::wr_root_scroll_node_id();
+}
+
+void ClipManager::ItemClips::UpdateSeparateLeaf(
+    wr::DisplayListBuilder& aBuilder, int32_t aAppUnitsPerDevPixel) {
+  Maybe<wr::LayoutRect> clipLeaf;
+  if (mSeparateLeaf) {
+    MOZ_ASSERT(mChain);
+    clipLeaf.emplace(wr::ToLayoutRect(LayoutDeviceRect::FromAppUnits(
+        mChain->mClip.GetClipRect(), aAppUnitsPerDevPixel)));
+  }
+
+  aBuilder.SetClipChainLeaf(clipLeaf);
+}
+
+bool ClipManager::ItemClips::HasSameInputs(const ItemClips& aOther) {
+  if (mASR != aOther.mASR || mChain != aOther.mChain ||
+      mSeparateLeaf != aOther.mSeparateLeaf) {
+    return false;
+  }
+  // AUPDP only matters if we have a clip chain, since it's only used to compute
+  // the device space clip rect.
+  if (mChain && mAppUnitsPerDevPixel != aOther.mAppUnitsPerDevPixel) {
+    return false;
+  }
+  return true;
+}
+
+wr::WrSpaceAndClipChain ClipManager::ItemClips::GetSpaceAndClipChain() const {
+  auto spaceAndClipChain = wr::RootScrollNodeWithChain();
+  spaceAndClipChain.space = mScrollId;
+  if (mClipChainId) {
+    spaceAndClipChain.clip_chain = mClipChainId->id;
+  }
+  return spaceAndClipChain;
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/ClipManager.h b/gfx/layers/wr/ClipManager.h
new file mode 100644
index 0000000000..7253fec8bb
--- /dev/null
+++ b/gfx/layers/wr/ClipManager.h
@@ -0,0 +1,150 @@
+/* -*- 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_CLIPMANAGER_H
+#define GFX_CLIPMANAGER_H
+
+#include <stack>
+#include <unordered_map>
+
+#include "mozilla/Attributes.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+
+namespace mozilla {
+
+class nsDisplayItem;
+struct ActiveScrolledRoot;
+struct DisplayItemClipChain;
+
+namespace wr {
+class DisplayListBuilder;
+}
+
+namespace layers {
+
+class StackingContextHelper;
+class WebRenderLayerManager;
+
+/**
+ * This class manages creating and assigning scroll layers and clips in
+ * WebRender based on the gecko display list. It has a few public functions that
+ * are intended to be invoked while traversing the Gecko display list, and it
+ * uses the ASR and clip information from the display list to create the
+ * necessary clip state in WebRender.
+ *
+ * The structure of the clip state in WebRender ends up quite similar to how
+ * it is in Gecko. For each ASR in Gecko, we create a scroll layer (i.e. a
+ * scrolling clip) in WebRender; these form a tree structure similar to the
+ * ASR tree structure. Ancestors of scroll layers are always other scroll
+ * layers, or the root scroll node.
+ * The DisplayItemClipChain list of clips from the gecko display list is
+ * converted to a WR clip chain and pushed on the stack prior to creating
+ * any WR commands for that item, and is popped afterwards. In addition,
+ * the WR clip chain has a parent pointer, which points to the clip chain for
+ * any enclosing stacking context. This again results in a strucuture very
+ * similar to that in Gecko, where the clips from container display items get
+ * applied to the contained display items.
+ */
+class ClipManager {
+ public:
+  ClipManager();
+
+  void BeginBuild(WebRenderLayerManager* aManager,
+                  wr::DisplayListBuilder& aBuilder);
+  void EndBuild();
+
+  void BeginList(const StackingContextHelper& aStackingContext);
+  void EndList(const StackingContextHelper& aStackingContext);
+
+  wr::WrSpaceAndClipChain SwitchItem(nsDisplayListBuilder* aBuilder,
+                                     nsDisplayItem* aItem);
+  ~ClipManager();
+
+  void PushOverrideForASR(const ActiveScrolledRoot* aASR,
+                          const wr::WrSpatialId& aSpatialId);
+  void PopOverrideForASR(const ActiveScrolledRoot* aASR);
+
+ private:
+  wr::WrSpatialId SpatialIdAfterOverride(const wr::WrSpatialId& aSpatialId);
+  wr::WrSpatialId GetScrollLayer(const ActiveScrolledRoot* aASR);
+
+  Maybe<wr::WrSpatialId> DefineScrollLayers(const ActiveScrolledRoot* aASR,
+                                            nsDisplayItem* aItem);
+
+  Maybe<wr::WrClipChainId> DefineClipChain(const DisplayItemClipChain* aChain,
+                                           int32_t aAppUnitsPerDevPixel);
+
+  WebRenderLayerManager* MOZ_NON_OWNING_REF mManager;
+  wr::DisplayListBuilder* mBuilder;
+
+  // Stack of clip caches. Each cache contains a map from gecko
+  // DisplayItemClipChain objects to webrender WrClipIds, which allows us to
+  // avoid redefining identical clips in WR. However, the gecko
+  // DisplayItemClipChain items get deduplicated quite aggressively, without
+  // regard to things like the enclosing reference frame or mask. On the WR
+  // side, we cannot deduplicate clips that aggressively. So what we do is
+  // any time we enter a new reference frame (for example) we create a new clip
+  // cache on mCacheStack. This ensures we continue caching stuff within a given
+  // reference frame, but disallow caching stuff across reference frames. In
+  // general we need to do this anytime PushOverrideForASR is called, as that is
+  // called for the same set of conditions for which we cannot deduplicate
+  // clips.
+  using ClipIdMap = std::unordered_map<const DisplayItemClipChain*,
+                                       AutoTArray<wr::WrClipId, 4>>;
+  std::stack<ClipIdMap> mCacheStack;
+
+  // A map that holds the cache overrides created by (a) "out of band" clips,
+  // i.e. clips that are generated by display items but that ClipManager
+  // doesn't know about and (b) stacking contexts that affect clip positioning.
+  // These are called "cache overrides" because while we're inside these things,
+  // we cannot use the ASR from the gecko display list as-is. Fundamentally this
+  // results from a mismatch between the ASR+clip items on the gecko side and
+  // the ClipScrollTree on the WR side; the WR side incorporates things like
+  // transforms and stacking context origins while the gecko side manages those
+  // differently.
+  // Any time ClipManager wants to define a new clip as a child of ASR X, it
+  // should first check the cache overrides to see if there is a cache override
+  // item ((a) or (b) above) that is already a child of X, and then define that
+  // clip as a child of Y instead. This map stores X -> Y, which allows
+  // ClipManager to do the necessary lookup. Note that there theoretically might
+  // be multiple different "Y" clips (in case of nested cache overrides), which
+  // is why we need a stack.
+  std::unordered_map<wr::WrSpatialId, std::stack<wr::WrSpatialId>> mASROverride;
+
+  // This holds some clip state for a single nsDisplayItem
+  struct ItemClips {
+    ItemClips(const ActiveScrolledRoot* aASR,
+              const DisplayItemClipChain* aChain, int32_t aAppUnitsPerDevPixel,
+              bool aSeparateLeaf);
+
+    // These are the "inputs" - they come from the nsDisplayItem
+    const ActiveScrolledRoot* mASR;
+    const DisplayItemClipChain* mChain;
+    int32_t mAppUnitsPerDevPixel;
+    bool mSeparateLeaf;
+
+    // These are the "outputs" - they are pushed to WR as needed
+    wr::WrSpatialId mScrollId;
+    Maybe<wr::WrClipChainId> mClipChainId;
+
+    void UpdateSeparateLeaf(wr::DisplayListBuilder& aBuilder,
+                            int32_t aAppUnitsPerDevPixel);
+    bool HasSameInputs(const ItemClips& aOther);
+    wr::WrSpaceAndClipChain GetSpaceAndClipChain() const;
+  };
+
+  // A stack of ItemClips corresponding to the nsDisplayItem ancestry. Each
+  // time we recurse into a nsDisplayItem's child list, this stack size
+  // increases by one. The topmost item on the stack is for the display item
+  // we are currently processing and items deeper on the stack are for that
+  // display item's ancestors.
+  std::stack<ItemClips> mItemClipStack;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/layers/wr/DisplayItemCache.cpp b/gfx/layers/wr/DisplayItemCache.cpp
new file mode 100644
index 0000000000..cd55da7424
--- /dev/null
+++ b/gfx/layers/wr/DisplayItemCache.cpp
@@ -0,0 +1,203 @@
+/* -*- 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 "DisplayItemCache.h"
+#include "nsDisplayList.h"
+
+namespace mozilla {
+namespace layers {
+
+DisplayItemCache::DisplayItemCache()
+    : mDisplayList(nullptr),
+      mMaximumSize(0),
+      mPipelineId{},
+      mCaching(false),
+      mInvalid(false),
+      mSuppressed(false) {}
+
+void DisplayItemCache::SetDisplayList(nsDisplayListBuilder* aBuilder,
+                                      nsDisplayList* aList) {
+  if (!IsEnabled()) {
+    return;
+  }
+
+  MOZ_ASSERT(aBuilder);
+  MOZ_ASSERT(aList);
+
+  const bool listChanged = mDisplayList != aList;
+  const bool partialBuild = !aBuilder->PartialBuildFailed();
+
+  if (listChanged && partialBuild) {
+    // If the display list changed during a partial update, it means that
+    // |SetDisplayList()| has missed one rebuilt display list.
+    mDisplayList = nullptr;
+    return;
+  }
+
+  if (listChanged || !partialBuild) {
+    // The display list has been changed or rebuilt.
+    mDisplayList = aList;
+    mInvalid = true;
+  }
+
+  UpdateState();
+}
+
+void DisplayItemCache::SetPipelineId(const wr::PipelineId& aPipelineId) {
+  mInvalid = mInvalid || !(mPipelineId == aPipelineId);
+  mPipelineId = aPipelineId;
+}
+
+void DisplayItemCache::UpdateState() {
+  // |mCaching == true| if:
+  // 1) |SetDisplayList()| is called with a fully rebuilt display list
+  // followed by
+  // 2a) |SetDisplayList()| is called with a partially updated display list
+  // or
+  // 2b) |SkipWaitingForPartialDisplayList()| is called
+  mCaching = !mInvalid;
+
+#if 0
+  Stats().Print();
+  Stats().Reset();
+#endif
+
+  if (IsEmpty()) {
+    // The cache is empty so nothing needs to be updated.
+    mInvalid = false;
+    return;
+  }
+
+  // Clear the cache if the current state is invalid.
+  if (mInvalid) {
+    Clear();
+  } else {
+    FreeUnusedSlots();
+  }
+
+  mInvalid = false;
+}
+
+void DisplayItemCache::Clear() {
+  memset(mSlots.Elements(), 0, mSlots.Length() * sizeof(Slot));
+  mFreeSlots.ClearAndRetainStorage();
+
+  for (size_t i = 0; i < CurrentSize(); ++i) {
+    mFreeSlots.AppendElement(i);
+  }
+}
+
+Maybe<uint16_t> DisplayItemCache::GetNextFreeSlot() {
+  if (mFreeSlots.IsEmpty() && !GrowIfPossible()) {
+    return Nothing();
+  }
+
+  return Some(mFreeSlots.PopLastElement());
+}
+
+bool DisplayItemCache::GrowIfPossible() {
+  if (IsFull()) {
+    return false;
+  }
+
+  const auto currentSize = CurrentSize();
+  MOZ_ASSERT(currentSize <= mMaximumSize);
+
+  // New slots are added one by one, which is amortized O(1) time complexity due
+  // to underlying storage implementation.
+  mSlots.AppendElement();
+  mFreeSlots.AppendElement(currentSize);
+  return true;
+}
+
+void DisplayItemCache::FreeUnusedSlots() {
+  for (size_t i = 0; i < CurrentSize(); ++i) {
+    auto& slot = mSlots[i];
+
+    if (!slot.mUsed && slot.mOccupied) {
+      // This entry contained a cached item, but was not used.
+      slot.mOccupied = false;
+      mFreeSlots.AppendElement(i);
+    }
+
+    slot.mUsed = false;
+  }
+}
+
+void DisplayItemCache::SetCapacity(const size_t aInitialSize,
+                                   const size_t aMaximumSize) {
+  mMaximumSize = aMaximumSize;
+  mSlots.SetLength(aInitialSize);
+  mFreeSlots.SetCapacity(aMaximumSize);
+  Clear();
+}
+
+Maybe<uint16_t> DisplayItemCache::AssignSlot(nsPaintedDisplayItem* aItem) {
+  if (!mCaching || !aItem->CanBeReused() || !aItem->CanBeCached()) {
+    return Nothing();
+  }
+
+  auto& slot = aItem->CacheIndex();
+
+  if (!slot) {
+    slot = GetNextFreeSlot();
+    if (!slot) {
+      // The item does not fit in the cache.
+      return Nothing();
+    }
+  }
+
+  MOZ_ASSERT(slot && CurrentSize() > *slot);
+  return slot;
+}
+
+void DisplayItemCache::MarkSlotOccupied(
+    uint16_t aSlotIndex, const wr::WrSpaceAndClipChain& aSpaceAndClip) {
+  // Caching of the item succeeded, update the slot state.
+  auto& slot = mSlots[aSlotIndex];
+  MOZ_ASSERT(!slot.mOccupied);
+  slot.mOccupied = true;
+  MOZ_ASSERT(!slot.mUsed);
+  slot.mUsed = true;
+  slot.mSpaceAndClip = aSpaceAndClip;
+}
+
+Maybe<uint16_t> DisplayItemCache::CanReuseItem(
+    nsPaintedDisplayItem* aItem, const wr::WrSpaceAndClipChain& aSpaceAndClip) {
+  auto& slotIndex = aItem->CacheIndex();
+  if (!slotIndex) {
+    return Nothing();
+  }
+
+  MOZ_ASSERT(slotIndex && CurrentSize() > *slotIndex);
+
+  auto& slot = mSlots[*slotIndex];
+  if (!slot.mOccupied) {
+    // The display item has a stale cache slot. Recache the item.
+    return Nothing();
+  }
+
+  if (mSuppressed) {
+    slot.mOccupied = false;
+    slotIndex = Nothing();
+    return Nothing();
+  }
+
+  if (!(aSpaceAndClip == slot.mSpaceAndClip)) {
+    // Spatial id and clip id can change between display lists, if items that
+    // generate them change their order.
+    slot.mOccupied = false;
+    aItem->SetCantBeCached();
+    slotIndex = Nothing();
+  } else {
+    slot.mUsed = true;
+  }
+
+  return slotIndex;
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/DisplayItemCache.h b/gfx/layers/wr/DisplayItemCache.h
new file mode 100644
index 0000000000..a44b4a52f5
--- /dev/null
+++ b/gfx/layers/wr/DisplayItemCache.h
@@ -0,0 +1,210 @@
+/* -*- 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_DISPLAY_ITEM_CACHE_H
+#define GFX_DISPLAY_ITEM_CACHE_H
+
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+
+class nsDisplayList;
+class nsDisplayListBuilder;
+class nsPaintedDisplayItem;
+
+namespace wr {
+class DisplayListBuilder;
+}  // namespace wr
+
+namespace layers {
+
+class CacheStats {
+ public:
+  CacheStats() = default;
+
+  void Reset() { mCached = mReused = mTotal = 0; }
+
+  void Print() {
+    static uint64_t avgC = 1;
+    static uint64_t avgR = 1;
+    static uint64_t avgT = 1;
+
+    avgC += mCached;
+    avgR += mReused;
+    avgT += mTotal;
+
+    printf("Cached: %zu (avg: %f), Reused: %zu (avg: %f), Total: %zu\n",
+           mCached, (double)avgC / (double)avgT, mReused,
+           (double)avgR / (double)avgT, mTotal);
+  }
+
+  void AddCached() { mCached++; }
+  void AddReused() { mReused++; }
+  void AddTotal() { mTotal++; }
+
+ private:
+  size_t mCached = 0;
+  size_t mReused = 0;
+  size_t mTotal = 0;
+};
+
+/**
+ * DisplayItemCache keeps track of which Gecko display items have already had
+ * their respective WebRender display items sent to WebRender backend.
+ *
+ * Ideally creating the WR display items for a Gecko display item would not
+ * depend on any external state. However currently pipeline id, clip id, and
+ * spatial id can change between display lists, even if the Gecko display items
+ * have not. This state is tracked by DisplayItemCache.
+ */
+class DisplayItemCache final {
+ public:
+  DisplayItemCache();
+
+  /**
+   * Clears the cache.
+   */
+  void Clear();
+
+  /**
+   * Sets the initial and max cache size to given |aInitialSize| and |aMaxSize|.
+   */
+  void SetCapacity(const size_t aInitialSize, const size_t aMaximumSize);
+
+  /**
+   * Sets the display list used by the cache.
+   */
+  void SetDisplayList(nsDisplayListBuilder* aBuilder, nsDisplayList* aList);
+
+  /**
+   * Sets the pipeline id used by the cache.
+   */
+  void SetPipelineId(const wr::PipelineId& aPipelineId);
+
+  /**
+   * Enables caching immediately if the cache is valid, and display list is set.
+   */
+  void SkipWaitingForPartialDisplayList() {
+    mCaching = mDisplayList && !mInvalid;
+  }
+
+  /**
+   * Returns true if display item caching is enabled, otherwise false.
+   */
+  bool IsEnabled() const { return !mSuppressed && mMaximumSize > 0; }
+
+  /**
+   * Suppress display item caching. This doesn't clear any existing cached
+   * items or change the underlying capacity, it just makes IsEnabled() return
+   * false.
+   * It will also make CanReuseItem return false for the duration of the
+   * suppression.
+   */
+  bool SetSuppressed(bool aSuppressed) {
+    if (aSuppressed == mSuppressed) {
+      return mSuppressed;
+    }
+    mSuppressed = aSuppressed;
+    return !mSuppressed;
+  }
+
+  /**
+   * Returns true if there are no cached items, otherwise false.
+   */
+  bool IsEmpty() const { return mFreeSlots.Length() == CurrentSize(); }
+
+  /**
+   * Returns true if the cache has reached the maximum size, otherwise false.
+   */
+  bool IsFull() const {
+    return mFreeSlots.IsEmpty() && CurrentSize() == mMaximumSize;
+  }
+
+  /**
+   * Returns the current cache size.
+   */
+  size_t CurrentSize() const { return mSlots.Length(); }
+
+  /**
+   * If there are free slots in the cache, assigns a cache slot to the given
+   * display item |aItem| and returns it. Otherwise returns Nothing().
+   */
+  Maybe<uint16_t> AssignSlot(nsPaintedDisplayItem* aItem);
+
+  /**
+   * Marks the slot with the given |slotIndex| occupied and used.
+   * Also stores the current space and clipchain |aSpaceAndClip|.
+   */
+  void MarkSlotOccupied(uint16_t slotIndex,
+                        const wr::WrSpaceAndClipChain& aSpaceAndClip);
+
+  /**
+   * Returns the slot index of the the given display item |aItem|, if the item
+   * can be reused. The current space and clipchain |aSpaceAndClip| is used to
+   * check whether the cached item is still valid.
+   * If the item cannot be reused, returns Nothing().
+   */
+  Maybe<uint16_t> CanReuseItem(nsPaintedDisplayItem* aItem,
+                               const wr::WrSpaceAndClipChain& aSpaceAndClip);
+
+  CacheStats& Stats() { return mCacheStats; }
+
+ private:
+  struct Slot {
+    Slot() : mSpaceAndClip{}, mOccupied(false), mUsed(false) {}
+
+    wr::WrSpaceAndClipChain mSpaceAndClip;
+    bool mOccupied;
+    bool mUsed;
+  };
+
+  void FreeUnusedSlots();
+  Maybe<uint16_t> GetNextFreeSlot();
+  bool GrowIfPossible();
+  void UpdateState();
+
+  // The lifetime of display lists exceed the lifetime of DisplayItemCache.
+  // This pointer stores the address of the display list that is using this
+  // cache, and it is only used for pointer comparisons.
+  nsDisplayList* mDisplayList;
+
+  size_t mMaximumSize;
+  nsTArray<Slot> mSlots;
+  nsTArray<uint16_t> mFreeSlots;
+
+  wr::PipelineId mPipelineId;
+  bool mCaching;
+  bool mInvalid;
+  bool mSuppressed;
+
+  CacheStats mCacheStats;
+};
+
+class MOZ_RAII AutoDisplayItemCacheSuppressor {
+ public:
+  explicit AutoDisplayItemCacheSuppressor(DisplayItemCache* aCache)
+      : mCache(aCache) {
+    mWasSuppressed = mCache->SetSuppressed(true);
+  }
+
+  // Note that this restores the original state rather than unconditionally
+  // unsuppressing the cache for future-proofing/robustification. Currently
+  // we only ever use this RAII in one non-recursive function, but we might
+  // decide to expand its usage to other scenarios and end up with nested
+  // suppressions, in which case restoring the state back to what we found it
+  // is better.
+  ~AutoDisplayItemCacheSuppressor() { mCache->SetSuppressed(mWasSuppressed); }
+
+ private:
+  DisplayItemCache* mCache;
+  bool mWasSuppressed;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif /* GFX_DISPLAY_ITEM_CACHE_H */
diff --git a/gfx/layers/wr/HitTestInfoManager.cpp b/gfx/layers/wr/HitTestInfoManager.cpp
new file mode 100644
index 0000000000..3365a92fbf
--- /dev/null
+++ b/gfx/layers/wr/HitTestInfoManager.cpp
@@ -0,0 +1,135 @@
+/* -*- 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 "HitTestInfoManager.h"
+#include "HitTestInfo.h"
+
+#include "nsDisplayList.h"
+
+#define DEBUG_HITTEST_INFO 0
+#if DEBUG_HITTEST_INFO
+#  define HITTEST_INFO_LOG(...) printf_stderr(__VA_ARGS__)
+#else
+#  define HITTEST_INFO_LOG(...)
+#endif
+
+namespace mozilla::layers {
+
+using ViewID = ScrollableLayerGuid::ViewID;
+
+/**
+ * TODO(miko): This used to be a performance bottle-neck, but it does not show
+ * up in profiles anymore, see bugs 1424637 and 1424968.
+ * A better way of doing this would be to store current app units per dev pixel
+ * in wr::DisplayListBuilder, and update it whenever display items that separate
+ * presshell boundaries are encountered.
+ */
+static int32_t GetAppUnitsFromDisplayItem(nsDisplayItem* aItem) {
+  nsIFrame* frame = aItem->Frame();
+  MOZ_ASSERT(frame);
+  return frame->PresContext()->AppUnitsPerDevPixel();
+}
+
+static void CreateWebRenderCommands(wr::DisplayListBuilder& aBuilder,
+                                    nsDisplayItem* aItem, const nsRect& aArea,
+                                    const gfx::CompositorHitTestInfo& aFlags,
+                                    const ViewID& aViewId) {
+  const Maybe<SideBits> sideBits =
+      aBuilder.GetContainingFixedPosSideBits(aItem->GetActiveScrolledRoot());
+
+  const LayoutDeviceRect devRect =
+      LayoutDeviceRect::FromAppUnits(aArea, GetAppUnitsFromDisplayItem(aItem));
+  const wr::LayoutRect rect = wr::ToLayoutRect(devRect);
+
+  aBuilder.PushHitTest(rect, rect, !aItem->BackfaceIsHidden(), aViewId, aFlags,
+                       sideBits.valueOr(SideBits::eNone));
+}
+
+HitTestInfoManager::HitTestInfoManager()
+    : mArea(nsRect()),
+      mFlags(gfx::CompositorHitTestInvisibleToHit),
+      mViewId(ScrollableLayerGuid::NULL_SCROLL_ID),
+      mSpaceAndClipChain(wr::InvalidScrollNodeWithChain()) {}
+
+void HitTestInfoManager::Reset() {
+  mArea = nsRect();
+  mFlags = gfx::CompositorHitTestInvisibleToHit;
+  mViewId = ScrollableLayerGuid::NULL_SCROLL_ID;
+  mSpaceAndClipChain = wr::InvalidScrollNodeWithChain();
+
+  HITTEST_INFO_LOG("* HitTestInfoManager::Reset\n");
+}
+
+bool HitTestInfoManager::ProcessItem(
+    nsDisplayItem* aItem, wr::DisplayListBuilder& aBuilder,
+    nsDisplayListBuilder* aDisplayListBuilder) {
+  MOZ_ASSERT(aItem);
+
+  HITTEST_INFO_LOG("* HitTestInfoManager::ProcessItem(%d, %s, has=%d)\n",
+                   getpid(), aItem->Frame()->ListTag().get(),
+                   aItem->HasHitTestInfo());
+
+  if (MOZ_UNLIKELY(aItem->GetType() == DisplayItemType::TYPE_REMOTE)) {
+    // Remote frames might contain hit-test-info items inside (but those
+    // aren't processed by this process of course), so we can't optimize out the
+    // next hit-test info item because it might be on top of the iframe.
+    Reset();
+  }
+
+  if (!aItem->HasHitTestInfo()) {
+    return false;
+  }
+
+  const HitTestInfo& hitTestInfo = aItem->GetHitTestInfo();
+  const nsRect& area = hitTestInfo.Area();
+  const gfx::CompositorHitTestInfo& flags = hitTestInfo.Info();
+
+  if (flags == gfx::CompositorHitTestInvisibleToHit || area.IsEmpty()) {
+    return false;
+  }
+
+  const auto viewId =
+      hitTestInfo.GetViewId(aBuilder, aItem->GetActiveScrolledRoot());
+  const auto spaceAndClipChain = aBuilder.CurrentSpaceAndClipChain();
+
+  if (!Update(area, flags, viewId, spaceAndClipChain)) {
+    // The previous hit test information is still valid.
+    return false;
+  }
+
+  HITTEST_INFO_LOG("+ [%d, %d, %d, %d]: flags: 0x%x, viewId: %lu\n", area.x,
+                   area.y, area.width, area.height, flags.serialize(), viewId);
+
+  CreateWebRenderCommands(aBuilder, aItem, area, flags, viewId);
+
+  return true;
+}
+
+/**
+ * Updates the current hit testing information if necessary.
+ * Returns true if the hit testing information was changed.
+ */
+bool HitTestInfoManager::Update(const nsRect& aArea,
+                                const gfx::CompositorHitTestInfo& aFlags,
+                                const ViewID& aViewId,
+                                const wr::WrSpaceAndClipChain& aSpaceAndClip) {
+  if (mViewId == aViewId && mFlags == aFlags && mArea.Contains(aArea) &&
+      mSpaceAndClipChain == aSpaceAndClip) {
+    // The previous hit testing information can be reused.
+    HITTEST_INFO_LOG("s [%d, %d, %d, %d]: flags: 0x%x, viewId: %lu\n", aArea.x,
+                     aArea.y, aArea.width, aArea.height, aFlags.serialize(),
+                     aViewId);
+    return false;
+  }
+
+  mArea = aArea;
+  mFlags = aFlags;
+  mViewId = aViewId;
+  mSpaceAndClipChain = aSpaceAndClip;
+  return true;
+}
+
+}  // namespace mozilla::layers
diff --git a/gfx/layers/wr/HitTestInfoManager.h b/gfx/layers/wr/HitTestInfoManager.h
new file mode 100644
index 0000000000..5ee7b566dc
--- /dev/null
+++ b/gfx/layers/wr/HitTestInfoManager.h
@@ -0,0 +1,66 @@
+/* -*- 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_HITTESTINFOMANAGER_H
+#define GFX_HITTESTINFOMANAGER_H
+
+#include "mozilla/gfx/CompositorHitTestInfo.h"
+#include "mozilla/layers/ScrollableLayerGuid.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "nsRect.h"
+
+namespace mozilla {
+
+class nsDisplayItem;
+class nsDisplayListBuilder;
+
+namespace wr {
+class DisplayListBuilder;
+}
+
+namespace layers {
+
+/**
+ * This class extracts the hit testing information (area, flags, ViewId) from
+ * Gecko display items and pushes them into WebRender display list.
+ *
+ * The hit testing information is deduplicated: a new hit test item is only
+ * added if the new area is not contained in the previous area, or if the flags,
+ * ViewId, or current spatial id is different.
+ */
+class HitTestInfoManager {
+ public:
+  HitTestInfoManager();
+
+  /**
+   * Resets the previous hit testing information.
+   */
+  void Reset();
+
+  /**
+   * Extracts the hit testing information from |aItem|, and if necessary, adds
+   * a new WebRender hit test item using |aBuilder|.
+   *
+   * Returns true if a hit test item was pushed.
+   */
+  bool ProcessItem(nsDisplayItem* aItem, wr::DisplayListBuilder& aBuilder,
+                   nsDisplayListBuilder* aDisplayListBuilder);
+
+ private:
+  bool Update(const nsRect& aArea, const gfx::CompositorHitTestInfo& aFlags,
+              const ScrollableLayerGuid::ViewID& aViewId,
+              const wr::WrSpaceAndClipChain& aSpaceAndClip);
+
+  nsRect mArea;
+  gfx::CompositorHitTestInfo mFlags;
+  ScrollableLayerGuid::ViewID mViewId;
+  wr::WrSpaceAndClipChain mSpaceAndClipChain;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/layers/wr/IpcResourceUpdateQueue.cpp b/gfx/layers/wr/IpcResourceUpdateQueue.cpp
new file mode 100644
index 0000000000..d19dc7f2f9
--- /dev/null
+++ b/gfx/layers/wr/IpcResourceUpdateQueue.cpp
@@ -0,0 +1,484 @@
+/* -*- 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 "IpcResourceUpdateQueue.h"
+#include <string.h>
+#include <algorithm>
+#include "mozilla/Maybe.h"
+#include "mozilla/ipc/SharedMemory.h"
+#include "mozilla/layers/PTextureChild.h"
+#include "mozilla/layers/WebRenderBridgeChild.h"
+
+namespace mozilla {
+namespace wr {
+
+using namespace mozilla::layers;
+
+ShmSegmentsWriter::ShmSegmentsWriter(layers::WebRenderBridgeChild* aAllocator,
+                                     size_t aChunkSize)
+    : mShmAllocator(aAllocator), mCursor(0), mChunkSize(aChunkSize) {
+  MOZ_ASSERT(mShmAllocator);
+}
+
+ShmSegmentsWriter::~ShmSegmentsWriter() { Clear(); }
+
+ShmSegmentsWriter::ShmSegmentsWriter(ShmSegmentsWriter&& aOther) noexcept
+    : mSmallAllocs(std::move(aOther.mSmallAllocs)),
+      mLargeAllocs(std::move(aOther.mLargeAllocs)),
+      mShmAllocator(aOther.mShmAllocator),
+      mCursor(aOther.mCursor),
+      mChunkSize(aOther.mChunkSize) {
+  aOther.mCursor = 0;
+}
+
+ShmSegmentsWriter& ShmSegmentsWriter::operator=(
+    ShmSegmentsWriter&& aOther) noexcept {
+  MOZ_ASSERT(IsEmpty(), "Will forget existing updates!");
+  Clear();
+  mSmallAllocs = std::move(aOther.mSmallAllocs);
+  mLargeAllocs = std::move(aOther.mLargeAllocs);
+  mShmAllocator = aOther.mShmAllocator;
+  mCursor = aOther.mCursor;
+  mChunkSize = aOther.mChunkSize;
+  aOther.mCursor = 0;
+  return *this;
+}
+
+layers::OffsetRange ShmSegmentsWriter::Write(Range<uint8_t> aBytes) {
+  const size_t start = mCursor;
+  const size_t length = aBytes.length();
+
+  if (length >= mChunkSize * 4) {
+    auto range = AllocLargeChunk(length);
+    if (range.length()) {
+      // Allocation was successful
+      uint8_t* dstPtr = mLargeAllocs.LastElement().get<uint8_t>();
+      memcpy(dstPtr, aBytes.begin().get(), length);
+    }
+    return range;
+  }
+
+  int remainingBytesToCopy = length;
+
+  size_t srcCursor = 0;
+  size_t dstCursor = mCursor;
+  size_t currAllocLen = mSmallAllocs.Length();
+
+  while (remainingBytesToCopy > 0) {
+    if (dstCursor >= mSmallAllocs.Length() * mChunkSize) {
+      if (!AllocChunk()) {
+        // Allocation failed, so roll back to the state at the start of this
+        // Write() call and abort.
+        while (mSmallAllocs.Length() > currAllocLen) {
+          RefCountedShmem shm = mSmallAllocs.PopLastElement();
+          RefCountedShm::Dealloc(mShmAllocator, shm);
+        }
+        MOZ_ASSERT(mSmallAllocs.Length() == currAllocLen);
+        return layers::OffsetRange(0, start, 0);
+      }
+      // Allocation succeeded, so dstCursor should now be pointing to
+      // something inside the allocation buffer
+      MOZ_ASSERT(dstCursor < (mSmallAllocs.Length() * mChunkSize));
+    }
+
+    const size_t dstMaxOffset = mChunkSize * mSmallAllocs.Length();
+    const size_t dstBaseOffset = mChunkSize * (mSmallAllocs.Length() - 1);
+
+    MOZ_ASSERT(dstCursor >= dstBaseOffset);
+    MOZ_ASSERT(dstCursor <= dstMaxOffset);
+
+    size_t availableRange = dstMaxOffset - dstCursor;
+    size_t copyRange = std::min<int>(availableRange, remainingBytesToCopy);
+
+    uint8_t* srcPtr = &aBytes[srcCursor];
+    uint8_t* dstPtr = RefCountedShm::GetBytes(mSmallAllocs.LastElement()) +
+                      (dstCursor - dstBaseOffset);
+
+    memcpy(dstPtr, srcPtr, copyRange);
+
+    srcCursor += copyRange;
+    dstCursor += copyRange;
+    remainingBytesToCopy -= copyRange;
+
+    // sanity check
+    MOZ_ASSERT(remainingBytesToCopy >= 0);
+  }
+
+  mCursor += length;
+
+  return layers::OffsetRange(0, start, length);
+}
+
+bool ShmSegmentsWriter::AllocChunk() {
+  RefCountedShmem shm;
+  if (!mShmAllocator->AllocResourceShmem(mChunkSize, shm)) {
+    gfxCriticalNote << "ShmSegmentsWriter failed to allocate chunk #"
+                    << mSmallAllocs.Length();
+    MOZ_ASSERT(false, "ShmSegmentsWriter fails to allocate chunk");
+    return false;
+  }
+  RefCountedShm::AddRef(shm);
+  mSmallAllocs.AppendElement(shm);
+  return true;
+}
+
+layers::OffsetRange ShmSegmentsWriter::AllocLargeChunk(size_t aSize) {
+  ipc::Shmem shm;
+  if (!mShmAllocator->AllocShmem(aSize, &shm)) {
+    gfxCriticalNote
+        << "ShmSegmentsWriter failed to allocate large chunk of size " << aSize;
+    MOZ_ASSERT(false, "ShmSegmentsWriter fails to allocate large chunk");
+    return layers::OffsetRange(0, 0, 0);
+  }
+  mLargeAllocs.AppendElement(shm);
+
+  return layers::OffsetRange(mLargeAllocs.Length(), 0, aSize);
+}
+
+void ShmSegmentsWriter::Flush(nsTArray<RefCountedShmem>& aSmallAllocs,
+                              nsTArray<ipc::Shmem>& aLargeAllocs) {
+  MOZ_ASSERT(aSmallAllocs.IsEmpty());
+  MOZ_ASSERT(aLargeAllocs.IsEmpty());
+  aSmallAllocs = std::move(mSmallAllocs);
+  aLargeAllocs = std::move(mLargeAllocs);
+  mCursor = 0;
+}
+
+bool ShmSegmentsWriter::IsEmpty() const { return mCursor == 0; }
+
+void ShmSegmentsWriter::Clear() {
+  if (mShmAllocator) {
+    IpcResourceUpdateQueue::ReleaseShmems(mShmAllocator, mSmallAllocs);
+    IpcResourceUpdateQueue::ReleaseShmems(mShmAllocator, mLargeAllocs);
+  }
+  mCursor = 0;
+}
+
+ShmSegmentsReader::ShmSegmentsReader(
+    const nsTArray<RefCountedShmem>& aSmallShmems,
+    const nsTArray<ipc::Shmem>& aLargeShmems)
+    : mSmallAllocs(aSmallShmems), mLargeAllocs(aLargeShmems), mChunkSize(0) {
+  if (mSmallAllocs.IsEmpty()) {
+    return;
+  }
+
+  mChunkSize = RefCountedShm::GetSize(mSmallAllocs[0]);
+
+  // Check that all shmems are readable and have the same size. If anything
+  // isn't right, set mChunkSize to zero which signifies that the reader is
+  // in an invalid state and Read calls will return false;
+  for (const auto& shm : mSmallAllocs) {
+    if (!RefCountedShm::IsValid(shm) ||
+        RefCountedShm::GetSize(shm) != mChunkSize ||
+        RefCountedShm::GetBytes(shm) == nullptr) {
+      mChunkSize = 0;
+      return;
+    }
+  }
+
+  for (const auto& shm : mLargeAllocs) {
+    if (!shm.IsReadable() || shm.get<uint8_t>() == nullptr) {
+      mChunkSize = 0;
+      return;
+    }
+  }
+}
+
+bool ShmSegmentsReader::ReadLarge(const layers::OffsetRange& aRange,
+                                  wr::Vec<uint8_t>& aInto) {
+  // source = zero is for small allocs.
+  MOZ_RELEASE_ASSERT(aRange.source() != 0);
+  if (aRange.source() > mLargeAllocs.Length()) {
+    return false;
+  }
+  size_t id = aRange.source() - 1;
+  const ipc::Shmem& shm = mLargeAllocs[id];
+  if (shm.Size<uint8_t>() < aRange.length()) {
+    return false;
+  }
+
+  uint8_t* srcPtr = shm.get<uint8_t>();
+  aInto.PushBytes(Range<uint8_t>(srcPtr, aRange.length()));
+
+  return true;
+}
+
+bool ShmSegmentsReader::Read(const layers::OffsetRange& aRange,
+                             wr::Vec<uint8_t>& aInto) {
+  if (aRange.length() == 0) {
+    return true;
+  }
+
+  if (aRange.source() != 0) {
+    return ReadLarge(aRange, aInto);
+  }
+
+  if (mChunkSize == 0) {
+    return false;
+  }
+
+  if (aRange.start() + aRange.length() > mChunkSize * mSmallAllocs.Length()) {
+    return false;
+  }
+
+  size_t initialLength = aInto.Length();
+
+  size_t srcCursor = aRange.start();
+  size_t remainingBytesToCopy = aRange.length();
+  while (remainingBytesToCopy > 0) {
+    const size_t shm_idx = srcCursor / mChunkSize;
+    const size_t ptrOffset = srcCursor % mChunkSize;
+    const size_t copyRange =
+        std::min(remainingBytesToCopy, mChunkSize - ptrOffset);
+    uint8_t* srcPtr =
+        RefCountedShm::GetBytes(mSmallAllocs[shm_idx]) + ptrOffset;
+
+    aInto.PushBytes(Range<uint8_t>(srcPtr, copyRange));
+
+    srcCursor += copyRange;
+    remainingBytesToCopy -= copyRange;
+  }
+
+  return aInto.Length() - initialLength == aRange.length();
+}
+
+Maybe<Range<uint8_t>> ShmSegmentsReader::GetReadPointerLarge(
+    const layers::OffsetRange& aRange) {
+  // source = zero is for small allocs.
+  MOZ_RELEASE_ASSERT(aRange.source() != 0);
+  if (aRange.source() > mLargeAllocs.Length()) {
+    return Nothing();
+  }
+  size_t id = aRange.source() - 1;
+  const ipc::Shmem& shm = mLargeAllocs[id];
+  if (shm.Size<uint8_t>() < aRange.length()) {
+    return Nothing();
+  }
+
+  uint8_t* srcPtr = shm.get<uint8_t>();
+  return Some(Range<uint8_t>(srcPtr, aRange.length()));
+}
+
+Maybe<Range<uint8_t>> ShmSegmentsReader::GetReadPointer(
+    const layers::OffsetRange& aRange) {
+  if (aRange.length() == 0) {
+    return Some(Range<uint8_t>());
+  }
+
+  if (aRange.source() != 0) {
+    return GetReadPointerLarge(aRange);
+  }
+
+  if (mChunkSize == 0 ||
+      aRange.start() + aRange.length() > mChunkSize * mSmallAllocs.Length()) {
+    return Nothing();
+  }
+
+  size_t srcCursor = aRange.start();
+  size_t remainingBytesToCopy = aRange.length();
+  const size_t shm_idx = srcCursor / mChunkSize;
+  const size_t ptrOffset = srcCursor % mChunkSize;
+  // Return nothing if we can't return a pointer to the full range
+  if (mChunkSize - ptrOffset < remainingBytesToCopy) {
+    return Nothing();
+  }
+  uint8_t* srcPtr = RefCountedShm::GetBytes(mSmallAllocs[shm_idx]) + ptrOffset;
+  return Some(Range<uint8_t>(srcPtr, remainingBytesToCopy));
+}
+
+IpcResourceUpdateQueue::IpcResourceUpdateQueue(
+    layers::WebRenderBridgeChild* aAllocator, size_t aChunkSize)
+    : mWriter(aAllocator, aChunkSize) {}
+
+IpcResourceUpdateQueue::IpcResourceUpdateQueue(
+    IpcResourceUpdateQueue&& aOther) noexcept
+    : mWriter(std::move(aOther.mWriter)),
+      mUpdates(std::move(aOther.mUpdates)) {}
+
+IpcResourceUpdateQueue& IpcResourceUpdateQueue::operator=(
+    IpcResourceUpdateQueue&& aOther) noexcept {
+  MOZ_ASSERT(IsEmpty(), "Will forget existing updates!");
+  mWriter = std::move(aOther.mWriter);
+  mUpdates = std::move(aOther.mUpdates);
+  return *this;
+}
+
+void IpcResourceUpdateQueue::ReplaceResources(IpcResourceUpdateQueue&& aOther) {
+  MOZ_ASSERT(IsEmpty(), "Will forget existing updates!");
+  mWriter = std::move(aOther.mWriter);
+  mUpdates = std::move(aOther.mUpdates);
+}
+
+bool IpcResourceUpdateQueue::AddImage(ImageKey key,
+                                      const ImageDescriptor& aDescriptor,
+                                      Range<uint8_t> aBytes) {
+  auto bytes = mWriter.Write(aBytes);
+  if (!bytes.length()) {
+    return false;
+  }
+  mUpdates.AppendElement(layers::OpAddImage(aDescriptor, bytes, 0, key));
+  return true;
+}
+
+bool IpcResourceUpdateQueue::AddBlobImage(BlobImageKey key,
+                                          const ImageDescriptor& aDescriptor,
+                                          Range<uint8_t> aBytes,
+                                          ImageIntRect aVisibleRect) {
+  MOZ_RELEASE_ASSERT(aDescriptor.width > 0 && aDescriptor.height > 0);
+  auto bytes = mWriter.Write(aBytes);
+  if (!bytes.length()) {
+    return false;
+  }
+  mUpdates.AppendElement(
+      layers::OpAddBlobImage(aDescriptor, bytes, aVisibleRect, 0, key));
+  return true;
+}
+
+void IpcResourceUpdateQueue::AddSharedExternalImage(wr::ExternalImageId aExtId,
+                                                    wr::ImageKey aKey) {
+  mUpdates.AppendElement(layers::OpAddSharedExternalImage(aExtId, aKey));
+}
+
+void IpcResourceUpdateQueue::PushExternalImageForTexture(
+    wr::ExternalImageId aExtId, wr::ImageKey aKey,
+    layers::TextureClient* aTexture, bool aIsUpdate) {
+  MOZ_ASSERT(aTexture);
+  MOZ_ASSERT(aTexture->GetIPDLActor());
+  MOZ_RELEASE_ASSERT(aTexture->GetIPDLActor()->GetIPCChannel() ==
+                     mWriter.WrBridge()->GetIPCChannel());
+  mUpdates.AppendElement(layers::OpPushExternalImageForTexture(
+      aExtId, aKey, WrapNotNull(aTexture->GetIPDLActor()), aIsUpdate));
+}
+
+bool IpcResourceUpdateQueue::UpdateImageBuffer(
+    ImageKey aKey, const ImageDescriptor& aDescriptor, Range<uint8_t> aBytes) {
+  auto bytes = mWriter.Write(aBytes);
+  if (!bytes.length()) {
+    return false;
+  }
+  mUpdates.AppendElement(layers::OpUpdateImage(aDescriptor, bytes, aKey));
+  return true;
+}
+
+bool IpcResourceUpdateQueue::UpdateBlobImage(BlobImageKey aKey,
+                                             const ImageDescriptor& aDescriptor,
+                                             Range<uint8_t> aBytes,
+                                             ImageIntRect aVisibleRect,
+                                             ImageIntRect aDirtyRect) {
+  MOZ_ASSERT(aVisibleRect.width > 0 && aVisibleRect.height > 0);
+
+  auto bytes = mWriter.Write(aBytes);
+  if (!bytes.length()) {
+    return false;
+  }
+  mUpdates.AppendElement(layers::OpUpdateBlobImage(aDescriptor, bytes, aKey,
+                                                   aVisibleRect, aDirtyRect));
+  return true;
+}
+
+void IpcResourceUpdateQueue::UpdateSharedExternalImage(
+    wr::ExternalImageId aExtId, wr::ImageKey aKey, ImageIntRect aDirtyRect) {
+  mUpdates.AppendElement(
+      layers::OpUpdateSharedExternalImage(aExtId, aKey, aDirtyRect));
+}
+
+void IpcResourceUpdateQueue::SetBlobImageVisibleArea(
+    wr::BlobImageKey aKey, const ImageIntRect& aArea) {
+  mUpdates.AppendElement(layers::OpSetBlobImageVisibleArea(aArea, aKey));
+}
+
+void IpcResourceUpdateQueue::DeleteImage(ImageKey aKey) {
+  mUpdates.AppendElement(layers::OpDeleteImage(aKey));
+}
+
+void IpcResourceUpdateQueue::DeleteBlobImage(BlobImageKey aKey) {
+  mUpdates.AppendElement(layers::OpDeleteBlobImage(aKey));
+}
+
+bool IpcResourceUpdateQueue::AddRawFont(wr::FontKey aKey, Range<uint8_t> aBytes,
+                                        uint32_t aIndex) {
+  auto bytes = mWriter.Write(aBytes);
+  if (!bytes.length()) {
+    return false;
+  }
+  mUpdates.AppendElement(layers::OpAddRawFont(bytes, aIndex, aKey));
+  return true;
+}
+
+bool IpcResourceUpdateQueue::AddFontDescriptor(wr::FontKey aKey,
+                                               Range<uint8_t> aBytes,
+                                               uint32_t aIndex) {
+  auto bytes = mWriter.Write(aBytes);
+  if (!bytes.length()) {
+    return false;
+  }
+  mUpdates.AppendElement(layers::OpAddFontDescriptor(bytes, aIndex, aKey));
+  return true;
+}
+
+void IpcResourceUpdateQueue::DeleteFont(wr::FontKey aKey) {
+  mUpdates.AppendElement(layers::OpDeleteFont(aKey));
+}
+
+void IpcResourceUpdateQueue::AddFontInstance(
+    wr::FontInstanceKey aKey, wr::FontKey aFontKey, float aGlyphSize,
+    const wr::FontInstanceOptions* aOptions,
+    const wr::FontInstancePlatformOptions* aPlatformOptions,
+    Range<const gfx::FontVariation> aVariations) {
+  auto bytes = mWriter.WriteAsBytes(aVariations);
+  mUpdates.AppendElement(layers::OpAddFontInstance(
+      aOptions ? Some(*aOptions) : Nothing(),
+      aPlatformOptions ? Some(*aPlatformOptions) : Nothing(), bytes, aKey,
+      aFontKey, aGlyphSize));
+}
+
+void IpcResourceUpdateQueue::DeleteFontInstance(wr::FontInstanceKey aKey) {
+  mUpdates.AppendElement(layers::OpDeleteFontInstance(aKey));
+}
+
+void IpcResourceUpdateQueue::Flush(
+    nsTArray<layers::OpUpdateResource>& aUpdates,
+    nsTArray<layers::RefCountedShmem>& aSmallAllocs,
+    nsTArray<ipc::Shmem>& aLargeAllocs) {
+  aUpdates = std::move(mUpdates);
+  mWriter.Flush(aSmallAllocs, aLargeAllocs);
+}
+
+bool IpcResourceUpdateQueue::IsEmpty() const {
+  if (mUpdates.Length() == 0) {
+    MOZ_ASSERT(mWriter.IsEmpty());
+    return true;
+  }
+  return false;
+}
+
+void IpcResourceUpdateQueue::Clear() {
+  mWriter.Clear();
+  mUpdates.Clear();
+}
+
+// static
+void IpcResourceUpdateQueue::ReleaseShmems(
+    ipc::IProtocol* aShmAllocator, nsTArray<layers::RefCountedShmem>& aShms) {
+  for (auto& shm : aShms) {
+    if (RefCountedShm::IsValid(shm) && RefCountedShm::Release(shm) == 0) {
+      RefCountedShm::Dealloc(aShmAllocator, shm);
+    }
+  }
+  aShms.Clear();
+}
+
+// static
+void IpcResourceUpdateQueue::ReleaseShmems(ipc::IProtocol* aShmAllocator,
+                                           nsTArray<ipc::Shmem>& aShms) {
+  for (auto& shm : aShms) {
+    aShmAllocator->DeallocShmem(shm);
+  }
+  aShms.Clear();
+}
+
+}  // namespace wr
+}  // namespace mozilla
diff --git a/gfx/layers/wr/IpcResourceUpdateQueue.h b/gfx/layers/wr/IpcResourceUpdateQueue.h
new file mode 100644
index 0000000000..6096ddbddb
--- /dev/null
+++ b/gfx/layers/wr/IpcResourceUpdateQueue.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 GFX_WR_IPCRESOURCEUPDATEQUEUE_H
+#define GFX_WR_IPCRESOURCEUPDATEQUEUE_H
+
+#include "mozilla/layers/WebRenderMessages.h"
+#include "mozilla/layers/RefCountedShmem.h"
+#include "mozilla/layers/TextureClient.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+
+namespace mozilla {
+namespace ipc {
+class IShmemAllocator;
+}
+namespace layers {
+class TextureClient;
+class WebRenderBridgeChild;
+}  // namespace layers
+
+namespace wr {
+
+/// ShmSegmentsWriter pushes bytes in a sequence of fixed size shmems for small
+/// allocations and creates dedicated shmems for large allocations.
+class ShmSegmentsWriter {
+ public:
+  ShmSegmentsWriter(layers::WebRenderBridgeChild* aAllocator,
+                    size_t aChunkSize);
+  ~ShmSegmentsWriter();
+
+  ShmSegmentsWriter(ShmSegmentsWriter&& aOther) noexcept;
+  ShmSegmentsWriter& operator=(ShmSegmentsWriter&& aOther) noexcept;
+
+  ShmSegmentsWriter(const ShmSegmentsWriter& aOther) = delete;
+  ShmSegmentsWriter& operator=(const ShmSegmentsWriter& aOther) = delete;
+
+  layers::OffsetRange Write(Range<uint8_t> aBytes);
+
+  template <typename T>
+  layers::OffsetRange WriteAsBytes(Range<T> aValues) {
+    return Write(Range<uint8_t>((uint8_t*)aValues.begin().get(),
+                                aValues.length() * sizeof(T)));
+  }
+
+  void Flush(nsTArray<layers::RefCountedShmem>& aSmallAllocs,
+             nsTArray<mozilla::ipc::Shmem>& aLargeAllocs);
+
+  void Clear();
+  bool IsEmpty() const;
+
+  layers::WebRenderBridgeChild* WrBridge() const { return mShmAllocator; }
+  size_t ChunkSize() const { return mChunkSize; }
+
+ protected:
+  bool AllocChunk();
+  layers::OffsetRange AllocLargeChunk(size_t aSize);
+
+  nsTArray<layers::RefCountedShmem> mSmallAllocs;
+  nsTArray<mozilla::ipc::Shmem> mLargeAllocs;
+  layers::WebRenderBridgeChild* mShmAllocator;
+  size_t mCursor;
+  size_t mChunkSize;
+};
+
+class ShmSegmentsReader {
+ public:
+  ShmSegmentsReader(const nsTArray<layers::RefCountedShmem>& aSmallShmems,
+                    const nsTArray<mozilla::ipc::Shmem>& aLargeShmems);
+
+  bool Read(const layers::OffsetRange& aRange, wr::Vec<uint8_t>& aInto);
+
+  // Get a read pointer, if possible, directly into the shm. If the range has
+  // been broken up into multiple chunks that can't be represented by a single
+  // range, nothing will be returned to indicate failure.
+  Maybe<Range<uint8_t>> GetReadPointer(const layers::OffsetRange& aRange);
+
+  // Get a read pointer, if possible, directly into the shm. Otherwise, copy
+  // it into the Vec and return a pointer to that contiguous memory instead.
+  // If all fails, return nothing.
+  Maybe<Range<uint8_t>> GetReadPointerOrCopy(const layers::OffsetRange& aRange,
+                                             wr::Vec<uint8_t>& aInto) {
+    if (Maybe<Range<uint8_t>> ptr = GetReadPointer(aRange)) {
+      return ptr;
+    } else {
+      size_t initialLength = aInto.Length();
+      if (Read(aRange, aInto)) {
+        return Some(Range<uint8_t>(aInto.Data() + initialLength,
+                                   aInto.Length() - initialLength));
+      } else {
+        return Nothing();
+      }
+    }
+  }
+
+ protected:
+  bool ReadLarge(const layers::OffsetRange& aRange, wr::Vec<uint8_t>& aInto);
+
+  Maybe<Range<uint8_t>> GetReadPointerLarge(const layers::OffsetRange& aRange);
+
+  const nsTArray<layers::RefCountedShmem>& mSmallAllocs;
+  const nsTArray<mozilla::ipc::Shmem>& mLargeAllocs;
+  size_t mChunkSize;
+};
+
+class IpcResourceUpdateQueue {
+ public:
+  // Because we are using shmems, the size should be a multiple of the page
+  // size. Each shmem has two guard pages, and the minimum shmem size (at least
+  // one Windows) is 64k which is already quite large for a lot of the resources
+  // we use here. The RefCountedShmem type used to allocate the chunks keeps a
+  // 16 bytes header in the buffer which we account for here as well. So we pick
+  // 64k - 2 * 4k - 16 = 57328 bytes as the default alloc size.
+  explicit IpcResourceUpdateQueue(layers::WebRenderBridgeChild* aAllocator,
+                                  size_t aChunkSize = 57328);
+
+  IpcResourceUpdateQueue(IpcResourceUpdateQueue&& aOther) noexcept;
+  IpcResourceUpdateQueue& operator=(IpcResourceUpdateQueue&& aOther) noexcept;
+
+  IpcResourceUpdateQueue(const IpcResourceUpdateQueue& aOther) = delete;
+  IpcResourceUpdateQueue& operator=(const IpcResourceUpdateQueue& aOther) =
+      delete;
+
+  // Moves over everything but the subqueues
+  void ReplaceResources(IpcResourceUpdateQueue&& aOther);
+
+  bool AddImage(wr::ImageKey aKey, const ImageDescriptor& aDescriptor,
+                Range<uint8_t> aBytes);
+
+  bool AddBlobImage(wr::BlobImageKey aKey, const ImageDescriptor& aDescriptor,
+                    Range<uint8_t> aBytes, ImageIntRect aVisibleRect);
+
+  void AddSharedExternalImage(wr::ExternalImageId aExtId, wr::ImageKey aKey);
+
+  void PushExternalImageForTexture(wr::ExternalImageId aExtId,
+                                   wr::ImageKey aKey,
+                                   layers::TextureClient* aTexture,
+                                   bool aIsUpdate);
+
+  bool UpdateImageBuffer(wr::ImageKey aKey, const ImageDescriptor& aDescriptor,
+                         Range<uint8_t> aBytes);
+
+  bool UpdateBlobImage(wr::BlobImageKey aKey,
+                       const ImageDescriptor& aDescriptor,
+                       Range<uint8_t> aBytes, ImageIntRect aVisibleRect,
+                       ImageIntRect aDirtyRect);
+
+  void UpdateSharedExternalImage(ExternalImageId aExtID, ImageKey aKey,
+                                 ImageIntRect aDirtyRect);
+
+  void SetBlobImageVisibleArea(BlobImageKey aKey, const ImageIntRect& aArea);
+
+  void DeleteImage(wr::ImageKey aKey);
+
+  void DeleteBlobImage(wr::BlobImageKey aKey);
+
+  bool AddRawFont(wr::FontKey aKey, Range<uint8_t> aBytes, uint32_t aIndex);
+
+  bool AddFontDescriptor(wr::FontKey aKey, Range<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,
+                       Range<const gfx::FontVariation> aVariations);
+
+  void DeleteFontInstance(wr::FontInstanceKey aKey);
+
+  void Clear();
+
+  void Flush(nsTArray<layers::OpUpdateResource>& aUpdates,
+             nsTArray<layers::RefCountedShmem>& aSmallAllocs,
+             nsTArray<mozilla::ipc::Shmem>& aLargeAllocs);
+
+  bool IsEmpty() const;
+
+  static void ReleaseShmems(mozilla::ipc::IProtocol*,
+                            nsTArray<layers::RefCountedShmem>& aShms);
+  static void ReleaseShmems(mozilla::ipc::IProtocol*,
+                            nsTArray<mozilla::ipc::Shmem>& aShms);
+
+ protected:
+  ShmSegmentsWriter mWriter;
+  nsTArray<layers::OpUpdateResource> mUpdates;
+};
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/layers/wr/OMTAController.cpp b/gfx/layers/wr/OMTAController.cpp
new file mode 100644
index 0000000000..527ec881f6
--- /dev/null
+++ b/gfx/layers/wr/OMTAController.cpp
@@ -0,0 +1,41 @@
+/* -*- 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/layers/OMTAController.h"
+
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/StaticPrefs_layout.h"
+
+namespace mozilla {
+namespace layers {
+
+void OMTAController::NotifyJankedAnimations(
+    JankedAnimations&& aJankedAnimations) const {
+  if (StaticPrefs::layout_animation_prerender_partial_jank()) {
+    return;
+  }
+
+  if (!CompositorThread()) {
+    return;
+  }
+
+  if (!CompositorThread()->IsOnCurrentThread()) {
+    CompositorThread()->Dispatch(NewRunnableMethod<JankedAnimations&&>(
+        "layers::OMTAController::NotifyJankedAnimations", this,
+        &OMTAController::NotifyJankedAnimations, std::move(aJankedAnimations)));
+    return;
+  }
+
+  if (CompositorBridgeParent* bridge =
+          CompositorBridgeParent::GetCompositorBridgeParentFromLayersId(
+              mRootLayersId)) {
+    bridge->NotifyJankedAnimations(aJankedAnimations);
+  }
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/OMTAController.h b/gfx/layers/wr/OMTAController.h
new file mode 100644
index 0000000000..3119650267
--- /dev/null
+++ b/gfx/layers/wr/OMTAController.h
@@ -0,0 +1,44 @@
+/* -*- 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_OMTAController_h
+#define mozilla_layers_OMTAController_h
+
+#include <unordered_map>
+
+#include "mozilla/layers/LayersTypes.h"  // for LayersId
+#include "nsISerialEventTarget.h"
+#include "nsISupportsImpl.h"
+#include "nsTArrayForwardDeclare.h"
+
+namespace mozilla {
+namespace layers {
+
+/**
+ * This class just delegates the jank animations notification to the compositor
+ * thread from the sampler thread.
+ */
+class OMTAController final {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(OMTAController)
+
+ public:
+  explicit OMTAController(LayersId aRootLayersId)
+      : mRootLayersId(aRootLayersId) {}
+
+  using JankedAnimations =
+      std::unordered_map<LayersId, nsTArray<uint64_t>, LayersId::HashFn>;
+  void NotifyJankedAnimations(JankedAnimations&& aJankedAnimations) const;
+
+ private:
+  ~OMTAController() = default;
+
+  LayersId mRootLayersId;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif  // mozilla_layers_OMTAController_h
diff --git a/gfx/layers/wr/OMTASampler.cpp b/gfx/layers/wr/OMTASampler.cpp
new file mode 100644
index 0000000000..c9616e87e1
--- /dev/null
+++ b/gfx/layers/wr/OMTASampler.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 "mozilla/layers/OMTASampler.h"
+
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/layers/CompositorAnimationStorage.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/OMTAController.h"
+#include "mozilla/layers/SynchronousTask.h"
+#include "mozilla/layers/WebRenderBridgeParent.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+
+namespace mozilla {
+namespace layers {
+
+StaticMutex OMTASampler::sWindowIdLock;
+StaticAutoPtr<std::unordered_map<uint64_t, RefPtr<OMTASampler>>>
+    OMTASampler::sWindowIdMap;
+
+OMTASampler::OMTASampler(const RefPtr<CompositorAnimationStorage>& aAnimStorage,
+                         LayersId aRootLayersId)
+    : mAnimStorage(aAnimStorage),
+      mStorageLock("OMTASampler::mStorageLock"),
+      mThreadIdLock("OMTASampler::mThreadIdLock"),
+      mSampleTimeLock("OMTASampler::mSampleTimeLock"),
+      mIsInTestMode(false) {
+  mController = new OMTAController(aRootLayersId);
+}
+
+void OMTASampler::Destroy() {
+  StaticMutexAutoLock lock(sWindowIdLock);
+  if (mWindowId) {
+    MOZ_ASSERT(sWindowIdMap);
+    sWindowIdMap->erase(wr::AsUint64(*mWindowId));
+  }
+}
+
+void OMTASampler::SetWebRenderWindowId(const wr::WrWindowId& aWindowId) {
+  StaticMutexAutoLock lock(sWindowIdLock);
+  MOZ_ASSERT(!mWindowId);
+  mWindowId = Some(aWindowId);
+  if (!sWindowIdMap) {
+    sWindowIdMap = new std::unordered_map<uint64_t, RefPtr<OMTASampler>>();
+    NS_DispatchToMainThread(
+        NS_NewRunnableFunction("OMTASampler::ClearOnShutdown",
+                               [] { ClearOnShutdown(&sWindowIdMap); }));
+  }
+  (*sWindowIdMap)[wr::AsUint64(aWindowId)] = this;
+}
+
+/*static*/
+void OMTASampler::SetSamplerThread(const wr::WrWindowId& aWindowId) {
+  if (RefPtr<OMTASampler> sampler = GetSampler(aWindowId)) {
+    MutexAutoLock lock(sampler->mThreadIdLock);
+    sampler->mSamplerThreadId = Some(PlatformThread::CurrentId());
+  }
+}
+
+/*static*/
+void OMTASampler::Sample(const wr::WrWindowId& aWindowId,
+                         wr::Transaction* aTransaction) {
+  if (RefPtr<OMTASampler> sampler = GetSampler(aWindowId)) {
+    wr::TransactionWrapper txn(aTransaction);
+    sampler->Sample(txn);
+  }
+}
+
+void OMTASampler::SetSampleTime(const TimeStamp& aSampleTime) {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+  const bool hasAnimations = HasAnimations();
+
+  MutexAutoLock lock(mSampleTimeLock);
+
+  // Reset the previous time stamp if we don't already have any running
+  // animations to avoid using the time which is far behind for newly
+  // started animations.
+  mPreviousSampleTime = hasAnimations ? std::move(mSampleTime) : TimeStamp();
+  mSampleTime = aSampleTime;
+}
+
+void OMTASampler::ResetPreviousSampleTime() {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MutexAutoLock lock(mSampleTimeLock);
+
+  mPreviousSampleTime = TimeStamp();
+}
+
+void OMTASampler::Sample(wr::TransactionWrapper& aTxn) {
+  MOZ_ASSERT(IsSamplerThread());
+
+  // If we are in test mode, don't sample with the current time stamp, it will
+  // skew cached animation values.
+  if (mIsInTestMode) {
+    return;
+  }
+
+  TimeStamp sampleTime;
+  TimeStamp previousSampleTime;
+  {  // scope lock
+    MutexAutoLock lock(mSampleTimeLock);
+
+    // If mSampleTime is null we're in a startup phase where the
+    // WebRenderBridgeParent hasn't yet provided us with a sample time.
+    // If we're that early there probably aren't any OMTA animations happening
+    // anyway, so using Timestamp::Now() should be fine.
+    sampleTime = mSampleTime.IsNull() ? TimeStamp::Now() : mSampleTime;
+    previousSampleTime = mPreviousSampleTime;
+  }
+
+  WrAnimations animations = SampleAnimations(previousSampleTime, sampleTime);
+
+  aTxn.AppendDynamicProperties(animations.mOpacityArrays,
+                               animations.mTransformArrays,
+                               animations.mColorArrays);
+}
+
+WrAnimations OMTASampler::SampleAnimations(const TimeStamp& aPreviousSampleTime,
+                                           const TimeStamp& aSampleTime) {
+  MOZ_ASSERT(IsSamplerThread());
+
+  MutexAutoLock lock(mStorageLock);
+
+  mAnimStorage->SampleAnimations(mController, aPreviousSampleTime, aSampleTime);
+
+  return mAnimStorage->CollectWebRenderAnimations();
+}
+
+OMTAValue OMTASampler::GetOMTAValue(const uint64_t& aId) const {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MutexAutoLock lock(mStorageLock);
+
+  return mAnimStorage->GetOMTAValue(aId);
+}
+
+void OMTASampler::SampleForTesting(const Maybe<TimeStamp>& aTestingSampleTime) {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+  TimeStamp sampleTime;
+  TimeStamp previousSampleTime;
+  {  // scope lock
+    MutexAutoLock timeLock(mSampleTimeLock);
+    if (aTestingSampleTime) {
+      // If we are on testing refresh mode, use the testing time stamp for both
+      // of the previous sample time and the current sample time since unlike
+      // normal refresh mode, the testing mode animations on the compositor are
+      // synchronously composed, so we don't need to worry about the time gap
+      // between the main thread and compositor thread.
+      sampleTime = *aTestingSampleTime;
+      previousSampleTime = *aTestingSampleTime;
+    } else {
+      sampleTime = mSampleTime;
+      previousSampleTime = mPreviousSampleTime;
+    }
+  }
+
+  MutexAutoLock storageLock(mStorageLock);
+  mAnimStorage->SampleAnimations(mController, previousSampleTime, sampleTime);
+}
+
+void OMTASampler::SetAnimations(
+    uint64_t aId, const LayersId& aLayersId,
+    const nsTArray<layers::Animation>& aAnimations) {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MutexAutoLock lock(mStorageLock);
+
+  mAnimStorage->SetAnimations(aId, aLayersId, aAnimations);
+}
+
+bool OMTASampler::HasAnimations() const {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MutexAutoLock lock(mStorageLock);
+
+  return mAnimStorage->HasAnimations();
+}
+
+void OMTASampler::ClearActiveAnimations(
+    std::unordered_map<uint64_t, wr::WrEpoch>& aActiveAnimations) {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MutexAutoLock lock(mStorageLock);
+  for (const auto& id : aActiveAnimations) {
+    mAnimStorage->ClearById(id.first);
+  }
+}
+
+void OMTASampler::RemoveEpochDataPriorTo(
+    std::queue<CompositorAnimationIdsForEpoch>& aCompositorAnimationsToDelete,
+    std::unordered_map<uint64_t, wr::WrEpoch>& aActiveAnimations,
+    const wr::WrEpoch& aRenderedEpoch) {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MutexAutoLock lock(mStorageLock);
+
+  while (!aCompositorAnimationsToDelete.empty()) {
+    if (aRenderedEpoch < aCompositorAnimationsToDelete.front().mEpoch) {
+      break;
+    }
+    for (uint64_t id : aCompositorAnimationsToDelete.front().mIds) {
+      const auto activeAnim = aActiveAnimations.find(id);
+      if (activeAnim == aActiveAnimations.end()) {
+        NS_ERROR("Tried to delete invalid animation");
+        continue;
+      }
+      // Check if animation delete request is still valid.
+      if (activeAnim->second <= aCompositorAnimationsToDelete.front().mEpoch) {
+        mAnimStorage->ClearById(id);
+        aActiveAnimations.erase(activeAnim);
+      }
+    }
+    aCompositorAnimationsToDelete.pop();
+  }
+}
+
+bool OMTASampler::IsSamplerThread() const {
+  MutexAutoLock lock(mThreadIdLock);
+  return mSamplerThreadId && PlatformThread::CurrentId() == *mSamplerThreadId;
+}
+
+/*static*/
+already_AddRefed<OMTASampler> OMTASampler::GetSampler(
+    const wr::WrWindowId& aWindowId) {
+  RefPtr<OMTASampler> sampler;
+  StaticMutexAutoLock lock(sWindowIdLock);
+  if (sWindowIdMap) {
+    auto it = sWindowIdMap->find(wr::AsUint64(aWindowId));
+    if (it != sWindowIdMap->end()) {
+      sampler = it->second;
+    }
+  }
+  return sampler.forget();
+}
+
+}  // namespace layers
+}  // namespace mozilla
+
+void omta_register_sampler(mozilla::wr::WrWindowId aWindowId) {
+  mozilla::layers::OMTASampler::SetSamplerThread(aWindowId);
+}
+
+void omta_sample(mozilla::wr::WrWindowId aWindowId,
+                 mozilla::wr::Transaction* aTransaction) {
+  mozilla::layers::OMTASampler::Sample(aWindowId, aTransaction);
+}
+
+void omta_deregister_sampler(mozilla::wr::WrWindowId aWindowId) {}
diff --git a/gfx/layers/wr/OMTASampler.h b/gfx/layers/wr/OMTASampler.h
new file mode 100644
index 0000000000..513c905fa1
--- /dev/null
+++ b/gfx/layers/wr/OMTASampler.h
@@ -0,0 +1,156 @@
+/* -*- 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_OMTASampler_h
+#define mozilla_layers_OMTASampler_h
+
+#include <unordered_map>
+#include <queue>
+
+#include "base/platform_thread.h"           // for PlatformThreadId
+#include "mozilla/layers/OMTAController.h"  // for OMTAController
+#include "mozilla/Atomics.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/StaticMutex.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/webrender/WebRenderTypes.h"  // For WrWindowId, WrEpoch, etc.
+
+namespace mozilla {
+
+class TimeStamp;
+
+namespace wr {
+struct Transaction;
+class TransactionWrapper;
+}  // namespace wr
+
+namespace layers {
+class Animation;
+class CompositorAnimationStorage;
+class OMTAValue;
+struct CompositorAnimationIdsForEpoch;
+struct LayersId;
+struct WrAnimations;
+
+/**
+ * This interface exposes OMTA methods related to "sampling" (i.e. calculating
+ * animating values) and "". All sampling methods should be called on the
+ * sampler thread, all some of them should be called on the compositor thread.
+ */
+class OMTASampler final {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(OMTASampler)
+
+ public:
+  OMTASampler(const RefPtr<CompositorAnimationStorage>& aAnimStorage,
+              LayersId aRootLayersId);
+
+  // Whoever creates this sampler is responsible for calling Destroy() on it
+  // before releasing the owning refptr.
+  void Destroy();
+
+  void SetWebRenderWindowId(const wr::WrWindowId& aWindowId);
+
+  /**
+   * This function is invoked from rust on the render backend thread when it
+   * is created. It effectively tells the OMTASampler "the current thread is
+   * the sampler thread for this window id" and allows OMTASampler to remember
+   * which thread it is.
+   */
+  static void SetSamplerThread(const wr::WrWindowId& aWindowId);
+
+  static void Sample(const wr::WrWindowId& aWindowId, wr::Transaction* aTxn);
+
+  /**
+   * Sample all animations, called on the sampler thread.
+   */
+  void Sample(wr::TransactionWrapper& aTxn);
+
+  /**
+   * These funtions get called on the the compositor thread.
+   */
+  void SetSampleTime(const TimeStamp& aSampleTime);
+  void ResetPreviousSampleTime();
+  void SetAnimations(uint64_t aId, const LayersId& aLayersId,
+                     const nsTArray<layers::Animation>& aAnimations);
+  bool HasAnimations() const;
+
+  /**
+   * Clear AnimatedValues and Animations data, called on the compositor
+   * thread.
+   */
+  void ClearActiveAnimations(
+      std::unordered_map<uint64_t, wr::Epoch>& aActiveAnimations);
+  void RemoveEpochDataPriorTo(
+      std::queue<CompositorAnimationIdsForEpoch>& aCompositorAnimationsToDelete,
+      std::unordered_map<uint64_t, wr::Epoch>& aActiveAnimations,
+      const wr::Epoch& aRenderedEpoch);
+
+  // Those two methods are for testing called on the compositor thread.
+  OMTAValue GetOMTAValue(const uint64_t& aId) const;
+  /**
+   * There are two possibilities when this function gets called, either 1) in
+   * testing refesh driver mode or 2) in normal refresh driver mode. In the case
+   * of 2) |aTestingSampleTime| should be Nothing() so that we can use
+   * |mPreviousSampleTime| and |mSampleTime| for sampling animations.
+   */
+  void SampleForTesting(const Maybe<TimeStamp>& aTestingSampleTime);
+
+  /**
+   * Returns true if currently on the "sampler thread".
+   */
+  bool IsSamplerThread() const;
+
+  void EnterTestMode() { mIsInTestMode = true; }
+  void LeaveTestMode() { mIsInTestMode = false; }
+
+ protected:
+  ~OMTASampler() = default;
+
+  static already_AddRefed<OMTASampler> GetSampler(
+      const wr::WrWindowId& aWindowId);
+
+ private:
+  WrAnimations SampleAnimations(const TimeStamp& aPreviousSampleTime,
+                                const TimeStamp& aSampleTime);
+
+  RefPtr<OMTAController> mController;
+  // Can only be accessed or modified while holding mStorageLock.
+  RefPtr<CompositorAnimationStorage> mAnimStorage;
+  mutable Mutex mStorageLock MOZ_UNANNOTATED;
+
+  // Used to manage the mapping from a WR window id to OMTASampler. These are
+  // only used if WebRender is enabled. Both sWindowIdMap and mWindowId should
+  // only be used while holding the sWindowIdLock. Note that we use a
+  // StaticAutoPtr wrapper on sWindowIdMap to avoid a static initializer for the
+  // unordered_map. This also avoids the initializer/memory allocation in cases
+  // where we're not using WebRender.
+  static StaticMutex sWindowIdLock MOZ_UNANNOTATED;
+  static StaticAutoPtr<std::unordered_map<uint64_t, RefPtr<OMTASampler>>>
+      sWindowIdMap;
+  Maybe<wr::WrWindowId> mWindowId;
+
+  // Lock used to protected mSamplerThreadId
+  mutable Mutex mThreadIdLock MOZ_UNANNOTATED;
+  // If WebRender is enabled, this holds the thread id of the render backend
+  // thread (which is the sampler thread) for the compositor associated with
+  // this OMTASampler instance.
+  Maybe<PlatformThreadId> mSamplerThreadId;
+
+  Mutex mSampleTimeLock MOZ_UNANNOTATED;
+  // Can only be accessed or modified while holding mSampleTimeLock.
+  TimeStamp mSampleTime;
+  // Same as |mSampleTime|, can only be accessed or modified while holding
+  // mSampleTimeLock.
+  // We basically use this time stamp instead of |mSampleTime| to make
+  // animations more in sync with other animations on the main thread.
+  TimeStamp mPreviousSampleTime;
+  Atomic<bool> mIsInTestMode;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif  // mozilla_layers_OMTASampler_h
diff --git a/gfx/layers/wr/RenderRootStateManager.cpp b/gfx/layers/wr/RenderRootStateManager.cpp
new file mode 100644
index 0000000000..8ddaa601a9
--- /dev/null
+++ b/gfx/layers/wr/RenderRootStateManager.cpp
@@ -0,0 +1,210 @@
+/* -*- 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/layers/RenderRootStateManager.h"
+
+#include "mozilla/layers/WebRenderBridgeChild.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+
+namespace mozilla {
+namespace layers {
+
+// RenderRootStateManager shares its ref count with the WebRenderLayerManager
+// that created it. You can think of the two classes as being one unit, except
+// there are multiple RenderRootStateManagers per WebRenderLayerManager. Since
+// we need to reference the WebRenderLayerManager and it needs to reference us,
+// this avoids us needing to involve the cycle collector.
+void RenderRootStateManager::AddRef() { mLayerManager->AddRef(); }
+
+void RenderRootStateManager::Release() { mLayerManager->Release(); }
+
+WebRenderBridgeChild* RenderRootStateManager::WrBridge() const {
+  return mLayerManager->WrBridge();
+}
+
+WebRenderCommandBuilder& RenderRootStateManager::CommandBuilder() {
+  return mLayerManager->CommandBuilder();
+}
+
+RenderRootStateManager::WebRenderUserDataRefTable*
+RenderRootStateManager::GetWebRenderUserDataTable() {
+  return mLayerManager->GetWebRenderUserDataTable();
+}
+
+wr::IpcResourceUpdateQueue& RenderRootStateManager::AsyncResourceUpdates() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mAsyncResourceUpdates) {
+    mAsyncResourceUpdates.emplace(WrBridge());
+
+    RefPtr<Runnable> task = NewRunnableMethod(
+        "RenderRootStateManager::FlushAsyncResourceUpdates", this,
+        &RenderRootStateManager::FlushAsyncResourceUpdates);
+    NS_DispatchToMainThread(task.forget());
+  }
+
+  return mAsyncResourceUpdates.ref();
+}
+
+void RenderRootStateManager::Destroy() {
+  ClearAsyncAnimations();
+
+  if (WrBridge()) {
+    // Just clear ImageKeys, they are deleted during WebRenderAPI destruction.
+    DiscardLocalImages();
+    // CompositorAnimations are cleared by WebRenderBridgeParent.
+    mDiscardedCompositorAnimationsIds.Clear();
+  }
+
+  mActiveCompositorAnimationIds.clear();
+
+  mDestroyed = true;
+}
+
+void RenderRootStateManager::FlushAsyncResourceUpdates() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mAsyncResourceUpdates) {
+    return;
+  }
+
+  if (!IsDestroyed() && WrBridge()) {
+    WrBridge()->UpdateResources(mAsyncResourceUpdates.ref());
+  }
+
+  mAsyncResourceUpdates.reset();
+}
+
+void RenderRootStateManager::AddImageKeyForDiscard(wr::ImageKey key) {
+  mImageKeysToDelete.AppendElement(key);
+}
+
+void RenderRootStateManager::AddBlobImageKeyForDiscard(wr::BlobImageKey key) {
+  mBlobImageKeysToDelete.AppendElement(key);
+}
+
+void RenderRootStateManager::DiscardImagesInTransaction(
+    wr::IpcResourceUpdateQueue& aResources) {
+  for (const auto& key : mImageKeysToDelete) {
+    aResources.DeleteImage(key);
+  }
+  for (const auto& key : mBlobImageKeysToDelete) {
+    aResources.DeleteBlobImage(key);
+  }
+  mImageKeysToDelete.Clear();
+  mBlobImageKeysToDelete.Clear();
+}
+
+void RenderRootStateManager::DiscardLocalImages() {
+  // Removes images but doesn't tell the parent side about them
+  // This is useful in empty / failed transactions where we created
+  // image keys but didn't tell the parent about them yet.
+  mImageKeysToDelete.Clear();
+  mBlobImageKeysToDelete.Clear();
+}
+
+void RenderRootStateManager::ClearCachedResources() {
+  mActiveCompositorAnimationIds.clear();
+  mDiscardedCompositorAnimationsIds.Clear();
+}
+
+void RenderRootStateManager::AddActiveCompositorAnimationId(uint64_t aId) {
+  // In layers-free mode we track the active compositor animation ids on the
+  // client side so that we don't try to discard the same animation id multiple
+  // times. We could just ignore the multiple-discard on the parent side, but
+  // checking on the content side reduces IPC traffic.
+  mActiveCompositorAnimationIds.insert(aId);
+}
+
+void RenderRootStateManager::AddCompositorAnimationsIdForDiscard(uint64_t aId) {
+  if (mActiveCompositorAnimationIds.erase(aId)) {
+    // For layers-free ensure we don't try to discard an animation id that
+    // wasn't active. We also remove it from mActiveCompositorAnimationIds so we
+    // don't discard it again unless it gets re-activated.
+    mDiscardedCompositorAnimationsIds.AppendElement(aId);
+  }
+}
+
+void RenderRootStateManager::DiscardCompositorAnimations() {
+  if (WrBridge()->IPCOpen() && !mDiscardedCompositorAnimationsIds.IsEmpty()) {
+    WrBridge()->SendDeleteCompositorAnimations(
+        mDiscardedCompositorAnimationsIds);
+  }
+  mDiscardedCompositorAnimationsIds.Clear();
+}
+
+void RenderRootStateManager::RegisterAsyncAnimation(
+    const wr::ImageKey& aKey, SharedSurfacesAnimation* aAnimation) {
+  mAsyncAnimations.insert(std::make_pair(wr::AsUint64(aKey), aAnimation));
+}
+
+void RenderRootStateManager::DeregisterAsyncAnimation(
+    const wr::ImageKey& aKey) {
+  mAsyncAnimations.erase(wr::AsUint64(aKey));
+}
+
+void RenderRootStateManager::ClearAsyncAnimations() {
+  for (const auto& i : mAsyncAnimations) {
+    i.second->Invalidate(this);
+  }
+  mAsyncAnimations.clear();
+}
+
+void RenderRootStateManager::WrReleasedImages(
+    const nsTArray<wr::ExternalImageKeyPair>& aPairs) {
+  // A SharedSurfaceAnimation object's lifetime is tied to its owning
+  // ImageContainer. When the ImageContainer is released,
+  // SharedSurfaceAnimation::Destroy is called which should ensure it is removed
+  // from the layer manager. Whenever the namespace for the
+  // WebRenderLayerManager itself is invalidated (e.g. we changed windows, or
+  // were destroyed ourselves), we callback into the SharedSurfaceAnimation
+  // object to remove its image key for us and any bound surfaces. If, for any
+  // reason, we somehow missed an WrReleasedImages call before the animation
+  // was bound to the layer manager, it will free those associated surfaces on
+  // the next ReleasePreviousFrame call.
+  for (const auto& pair : aPairs) {
+    auto i = mAsyncAnimations.find(wr::AsUint64(pair.key));
+    if (i != mAsyncAnimations.end()) {
+      i->second->ReleasePreviousFrame(this, pair.id);
+    }
+  }
+}
+
+void RenderRootStateManager::AddWebRenderParentCommand(
+    const WebRenderParentCommand& aCmd) {
+  WrBridge()->AddWebRenderParentCommand(aCmd);
+}
+void RenderRootStateManager::UpdateResources(
+    wr::IpcResourceUpdateQueue& aResources) {
+  WrBridge()->UpdateResources(aResources);
+}
+void RenderRootStateManager::AddPipelineIdForCompositable(
+    const wr::PipelineId& aPipelineId, const CompositableHandle& aHandle,
+    CompositableHandleOwner aOwner) {
+  WrBridge()->AddPipelineIdForCompositable(aPipelineId, aHandle, aOwner);
+}
+void RenderRootStateManager::RemovePipelineIdForCompositable(
+    const wr::PipelineId& aPipelineId) {
+  WrBridge()->RemovePipelineIdForCompositable(aPipelineId);
+}
+/// Release TextureClient that is bounded to ImageKey.
+/// It is used for recycling TextureClient.
+void RenderRootStateManager::ReleaseTextureOfImage(const wr::ImageKey& aKey) {
+  WrBridge()->ReleaseTextureOfImage(aKey);
+}
+
+Maybe<wr::FontInstanceKey> RenderRootStateManager::GetFontKeyForScaledFont(
+    gfx::ScaledFont* aScaledFont, wr::IpcResourceUpdateQueue& aResources) {
+  return WrBridge()->GetFontKeyForScaledFont(aScaledFont, aResources);
+}
+
+Maybe<wr::FontKey> RenderRootStateManager::GetFontKeyForUnscaledFont(
+    gfx::UnscaledFont* aUnscaledFont, wr::IpcResourceUpdateQueue& aResources) {
+  return WrBridge()->GetFontKeyForUnscaledFont(aUnscaledFont, aResources);
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/RenderRootStateManager.h b/gfx/layers/wr/RenderRootStateManager.h
new file mode 100644
index 0000000000..6c0221776e
--- /dev/null
+++ b/gfx/layers/wr/RenderRootStateManager.h
@@ -0,0 +1,97 @@
+/* -*- 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_RENDERROOTSTATEMANAGER_H
+#define GFX_RENDERROOTSTATEMANAGER_H
+
+#include "mozilla/webrender/WebRenderAPI.h"
+
+#include "mozilla/layers/IpcResourceUpdateQueue.h"
+#include "mozilla/layers/SharedSurfacesChild.h"
+#include "mozilla/layers/WebRenderCommandBuilder.h"
+#include "nsTHashSet.h"
+
+namespace mozilla {
+
+namespace layers {
+
+class RenderRootStateManager {
+  typedef nsTHashSet<RefPtr<WebRenderUserData>> WebRenderUserDataRefTable;
+
+ public:
+  void AddRef();
+  void Release();
+
+  RenderRootStateManager() : mLayerManager(nullptr), mDestroyed(false) {}
+
+  void Destroy();
+  bool IsDestroyed() { return mDestroyed; }
+  wr::IpcResourceUpdateQueue& AsyncResourceUpdates();
+  WebRenderBridgeChild* WrBridge() const;
+  WebRenderCommandBuilder& CommandBuilder();
+  WebRenderUserDataRefTable* GetWebRenderUserDataTable();
+  WebRenderLayerManager* LayerManager() { return mLayerManager; }
+
+  void AddImageKeyForDiscard(wr::ImageKey key);
+  void AddBlobImageKeyForDiscard(wr::BlobImageKey key);
+  void DiscardImagesInTransaction(wr::IpcResourceUpdateQueue& aResources);
+  void DiscardLocalImages();
+
+  void ClearCachedResources();
+
+  // Methods to manage the compositor animation ids. Active animations are still
+  // going, and when they end we discard them and remove them from the active
+  // list.
+  void AddActiveCompositorAnimationId(uint64_t aId);
+  void AddCompositorAnimationsIdForDiscard(uint64_t aId);
+  void DiscardCompositorAnimations();
+
+  void RegisterAsyncAnimation(const wr::ImageKey& aKey,
+                              SharedSurfacesAnimation* aAnimation);
+  void DeregisterAsyncAnimation(const wr::ImageKey& aKey);
+  void ClearAsyncAnimations();
+  void WrReleasedImages(const nsTArray<wr::ExternalImageKeyPair>& aPairs);
+
+  void AddWebRenderParentCommand(const WebRenderParentCommand& aCmd);
+  void UpdateResources(wr::IpcResourceUpdateQueue& aResources);
+  void AddPipelineIdForCompositable(const wr::PipelineId& aPipelineId,
+                                    const CompositableHandle& aHandle,
+                                    CompositableHandleOwner aOwner);
+  void RemovePipelineIdForCompositable(const wr::PipelineId& aPipelineId);
+  /// Release TextureClient that is bounded to ImageKey.
+  /// It is used for recycling TextureClient.
+  void ReleaseTextureOfImage(const wr::ImageKey& aKey);
+  Maybe<wr::FontInstanceKey> GetFontKeyForScaledFont(
+      gfx::ScaledFont* aScaledFont, wr::IpcResourceUpdateQueue& aResources);
+  Maybe<wr::FontKey> GetFontKeyForUnscaledFont(
+      gfx::UnscaledFont* aUnscaledFont, wr::IpcResourceUpdateQueue& aResources);
+
+  void FlushAsyncResourceUpdates();
+
+ private:
+  WebRenderLayerManager* mLayerManager;
+  Maybe<wr::IpcResourceUpdateQueue> mAsyncResourceUpdates;
+  nsTArray<wr::ImageKey> mImageKeysToDelete;
+  nsTArray<wr::BlobImageKey> mBlobImageKeysToDelete;
+  std::unordered_map<uint64_t, RefPtr<SharedSurfacesAnimation>>
+      mAsyncAnimations;
+
+  // Set of compositor animation ids for which there are active animations (as
+  // of the last transaction) on the compositor side.
+  std::unordered_set<uint64_t> mActiveCompositorAnimationIds;
+  // Compositor animation ids for animations that are done now and that we want
+  // the compositor to discard information for.
+  nsTArray<uint64_t> mDiscardedCompositorAnimationsIds;
+
+  bool mDestroyed;
+
+  friend class WebRenderLayerManager;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif /* GFX_RENDERROOTSTATEMANAGER_H */
diff --git a/gfx/layers/wr/RenderRootTypes.cpp b/gfx/layers/wr/RenderRootTypes.cpp
new file mode 100644
index 0000000000..18385fa85e
--- /dev/null
+++ b/gfx/layers/wr/RenderRootTypes.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 "RenderRootTypes.h"
+#include "mozilla/layers/WebRenderMessageUtils.h"
+#include "mozilla/layers/WebRenderBridgeChild.h"
+
+namespace mozilla {
+namespace ipc {
+
+void IPDLParamTraits<mozilla::layers::DisplayListData>::Write(
+    IPC::MessageWriter* aWriter, IProtocol* aActor, paramType&& aParam) {
+  WriteIPDLParam(aWriter, aActor, aParam.mIdNamespace);
+  WriteIPDLParam(aWriter, aActor, aParam.mRect);
+  WriteIPDLParam(aWriter, aActor, aParam.mCommands);
+  WriteIPDLParam(aWriter, aActor, std::move(aParam.mDLItems));
+  WriteIPDLParam(aWriter, aActor, std::move(aParam.mDLCache));
+  WriteIPDLParam(aWriter, aActor, std::move(aParam.mDLSpatialTree));
+  WriteIPDLParam(aWriter, aActor, aParam.mDLDesc);
+  WriteIPDLParam(aWriter, aActor, aParam.mRemotePipelineIds);
+  WriteIPDLParam(aWriter, aActor, aParam.mResourceUpdates);
+  WriteIPDLParam(aWriter, aActor, aParam.mSmallShmems);
+  WriteIPDLParam(aWriter, aActor, std::move(aParam.mLargeShmems));
+  WriteIPDLParam(aWriter, aActor, aParam.mScrollData);
+}
+
+bool IPDLParamTraits<mozilla::layers::DisplayListData>::Read(
+    IPC::MessageReader* aReader, IProtocol* aActor, paramType* aResult) {
+  if (ReadIPDLParam(aReader, aActor, &aResult->mIdNamespace) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mRect) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mCommands) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mDLItems) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mDLCache) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mDLSpatialTree) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mDLDesc) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mRemotePipelineIds) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mResourceUpdates) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mSmallShmems) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mLargeShmems) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mScrollData)) {
+    return true;
+  }
+  return false;
+}
+
+void WriteScrollUpdates(IPC::MessageWriter* aWriter, IProtocol* aActor,
+                        layers::ScrollUpdatesMap& aParam) {
+  // ICK: we need to manually serialize this map because
+  // nsDataHashTable doesn't support it (and other maps cause other issues)
+  WriteIPDLParam(aWriter, aActor, aParam.Count());
+  for (auto it = aParam.ConstIter(); !it.Done(); it.Next()) {
+    WriteIPDLParam(aWriter, aActor, it.Key());
+    WriteIPDLParam(aWriter, aActor, it.Data());
+  }
+}
+
+bool ReadScrollUpdates(IPC::MessageReader* aReader, IProtocol* aActor,
+                       layers::ScrollUpdatesMap* aResult) {
+  // Manually deserialize mScrollUpdates as a stream of K,V pairs
+  uint32_t count;
+  if (!ReadIPDLParam(aReader, aActor, &count)) {
+    return false;
+  }
+
+  layers::ScrollUpdatesMap map(count);
+  for (size_t i = 0; i < count; ++i) {
+    layers::ScrollableLayerGuid::ViewID key;
+    nsTArray<mozilla::ScrollPositionUpdate> data;
+    if (!ReadIPDLParam(aReader, aActor, &key) ||
+        !ReadIPDLParam(aReader, aActor, &data)) {
+      return false;
+    }
+    map.InsertOrUpdate(key, std::move(data));
+  }
+
+  MOZ_RELEASE_ASSERT(map.Count() == count);
+  *aResult = std::move(map);
+  return true;
+}
+
+void IPDLParamTraits<mozilla::layers::TransactionData>::Write(
+    IPC::MessageWriter* aWriter, IProtocol* aActor, paramType&& aParam) {
+  WriteIPDLParam(aWriter, aActor, aParam.mIdNamespace);
+  WriteIPDLParam(aWriter, aActor, aParam.mCommands);
+  WriteIPDLParam(aWriter, aActor, aParam.mResourceUpdates);
+  WriteIPDLParam(aWriter, aActor, aParam.mSmallShmems);
+  WriteIPDLParam(aWriter, aActor, std::move(aParam.mLargeShmems));
+  WriteScrollUpdates(aWriter, aActor, aParam.mScrollUpdates);
+  WriteIPDLParam(aWriter, aActor, aParam.mPaintSequenceNumber);
+}
+
+bool IPDLParamTraits<mozilla::layers::TransactionData>::Read(
+    IPC::MessageReader* aReader, IProtocol* aActor, paramType* aResult) {
+  if (ReadIPDLParam(aReader, aActor, &aResult->mIdNamespace) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mCommands) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mResourceUpdates) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mSmallShmems) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mLargeShmems) &&
+      ReadScrollUpdates(aReader, aActor, &aResult->mScrollUpdates) &&
+      ReadIPDLParam(aReader, aActor, &aResult->mPaintSequenceNumber)) {
+    return true;
+  }
+  return false;
+}
+
+}  // namespace ipc
+}  // namespace mozilla
diff --git a/gfx/layers/wr/RenderRootTypes.h b/gfx/layers/wr/RenderRootTypes.h
new file mode 100644
index 0000000000..9921a98f0e
--- /dev/null
+++ b/gfx/layers/wr/RenderRootTypes.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 GFX_RENDERROOTTYPES_H
+#define GFX_RENDERROOTTYPES_H
+
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "mozilla/layers/WebRenderMessages.h"
+#include "mozilla/layers/WebRenderScrollData.h"
+
+namespace mozilla {
+
+namespace layers {
+
+struct DisplayListData {
+  wr::IdNamespace mIdNamespace;
+  LayoutDeviceRect mRect;
+  nsTArray<WebRenderParentCommand> mCommands;
+  Maybe<mozilla::ipc::ByteBuf> mDLItems;
+  Maybe<mozilla::ipc::ByteBuf> mDLCache;
+  Maybe<mozilla::ipc::ByteBuf> mDLSpatialTree;
+  wr::BuiltDisplayListDescriptor mDLDesc;
+  nsTArray<wr::PipelineId> mRemotePipelineIds;
+  nsTArray<OpUpdateResource> mResourceUpdates;
+  nsTArray<RefCountedShmem> mSmallShmems;
+  nsTArray<mozilla::ipc::Shmem> mLargeShmems;
+  Maybe<WebRenderScrollData> mScrollData;
+};
+
+struct TransactionData {
+  wr::IdNamespace mIdNamespace;
+  nsTArray<WebRenderParentCommand> mCommands;
+  nsTArray<OpUpdateResource> mResourceUpdates;
+  nsTArray<RefCountedShmem> mSmallShmems;
+  nsTArray<mozilla::ipc::Shmem> mLargeShmems;
+  ScrollUpdatesMap mScrollUpdates;
+  uint32_t mPaintSequenceNumber;
+};
+
+typedef Maybe<TransactionData> MaybeTransactionData;
+
+}  // namespace layers
+
+namespace ipc {
+
+template <>
+struct IPDLParamTraits<mozilla::layers::DisplayListData> {
+  typedef mozilla::layers::DisplayListData paramType;
+
+  static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+                    paramType&& aParam);
+
+  static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+                   paramType* aResult);
+};
+
+template <>
+struct IPDLParamTraits<mozilla::layers::TransactionData> {
+  typedef mozilla::layers::TransactionData paramType;
+
+  static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+                    paramType&& aParam);
+
+  static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+                   paramType* aResult);
+};
+
+}  // namespace ipc
+}  // namespace mozilla
+
+#endif /* GFX_RENDERROOTTYPES_H */
diff --git a/gfx/layers/wr/StackingContextHelper.cpp b/gfx/layers/wr/StackingContextHelper.cpp
new file mode 100644
index 0000000000..2e0ff1e0c1
--- /dev/null
+++ b/gfx/layers/wr/StackingContextHelper.cpp
@@ -0,0 +1,275 @@
+/* -*- 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/layers/StackingContextHelper.h"
+
+#include "mozilla/PresShell.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/gfx/Matrix.h"
+#include "UnitTransforms.h"
+#include "nsDisplayList.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "nsLayoutUtils.h"
+#include "ActiveLayerTracker.h"
+
+namespace mozilla {
+namespace layers {
+using namespace gfx;
+
+StackingContextHelper::StackingContextHelper()
+    : mBuilder(nullptr),
+      mScale(1.0f, 1.0f),
+      mAffectsClipPositioning(false),
+      mDeferredTransformItem(nullptr),
+      mRasterizeLocally(false) {
+  // mOrigin remains at 0,0
+}
+
+static nsSize ComputeDesiredDisplaySizeForAnimation(nsIFrame* aContainerFrame) {
+  // Use the size of the nearest widget as the maximum size.  This
+  // is important since it might be a popup that is bigger than the
+  // pres context's size.
+  nsPresContext* presContext = aContainerFrame->PresContext();
+  nsIWidget* widget = aContainerFrame->GetNearestWidget();
+  if (widget) {
+    return LayoutDevicePixel::ToAppUnits(widget->GetClientSize(),
+                                         presContext->AppUnitsPerDevPixel());
+  }
+
+  return presContext->GetVisibleArea().Size();
+}
+
+/* static */
+MatrixScales ChooseScale(nsIFrame* aContainerFrame,
+                         nsDisplayItem* aContainerItem,
+                         const nsRect& aVisibleRect, float aXScale,
+                         float aYScale, const Matrix& aTransform2d,
+                         bool aCanDraw2D) {
+  MatrixScales scale;
+  // XXX Should we do something for 3D transforms?
+  if (aCanDraw2D && !aContainerFrame->Combines3DTransformWithAncestors() &&
+      !aContainerFrame->HasPerspective()) {
+    // If the container's transform is animated off main thread, fix a suitable
+    // scale size for animation
+    if (aContainerItem &&
+        aContainerItem->GetType() == DisplayItemType::TYPE_TRANSFORM &&
+        // FIXME: What we need is only transform, rotate, and scale, not
+        // translate, so it's be better to use a property set, instead of
+        // display item type here.
+        EffectCompositor::HasAnimationsForCompositor(
+            aContainerFrame, DisplayItemType::TYPE_TRANSFORM)) {
+      nsSize displaySize =
+          ComputeDesiredDisplaySizeForAnimation(aContainerFrame);
+      // compute scale using the animation on the container, taking ancestors in
+      // to account
+      nsSize scaledVisibleSize = nsSize(aVisibleRect.Width() * aXScale,
+                                        aVisibleRect.Height() * aYScale);
+      scale = nsLayoutUtils::ComputeSuitableScaleForAnimation(
+          aContainerFrame, scaledVisibleSize, displaySize);
+      // multiply by the scale inherited from ancestors--we use a uniform
+      // scale factor to prevent blurring when the layer is rotated.
+      float incomingScale = std::max(aXScale, aYScale);
+      scale = scale * ScaleFactor<UnknownUnits, UnknownUnits>(incomingScale);
+    } else {
+      // Scale factors are normalized to a power of 2 to reduce the number of
+      // resolution changes
+      scale = aTransform2d.ScaleFactors();
+      // For frames with a changing scale transform round scale factors up to
+      // nearest power-of-2 boundary so that we don't keep having to redraw
+      // the content as it scales up and down. Rounding up to nearest
+      // power-of-2 boundary ensures we never scale up, only down --- avoiding
+      // jaggies. It also ensures we never scale down by more than a factor of
+      // 2, avoiding bad downscaling quality.
+      Matrix frameTransform;
+      if (ActiveLayerTracker::IsScaleSubjectToAnimation(aContainerFrame)) {
+        scale.xScale = gfxUtils::ClampToScaleFactor(scale.xScale);
+        scale.yScale = gfxUtils::ClampToScaleFactor(scale.yScale);
+
+        // Limit animated scale factors to not grow excessively beyond the
+        // display size.
+        nsSize maxScale(4, 4);
+        if (!aVisibleRect.IsEmpty()) {
+          nsSize displaySize =
+              ComputeDesiredDisplaySizeForAnimation(aContainerFrame);
+          maxScale = Max(maxScale, displaySize / aVisibleRect.Size());
+        }
+        if (scale.xScale > maxScale.width) {
+          scale.xScale = gfxUtils::ClampToScaleFactor(maxScale.width, true);
+        }
+        if (scale.yScale > maxScale.height) {
+          scale.yScale = gfxUtils::ClampToScaleFactor(maxScale.height, true);
+        }
+      } else {
+        // XXX Do we need to move nearly-integer values to integers here?
+      }
+    }
+    // If the scale factors are too small, just use 1.0. The content is being
+    // scaled out of sight anyway.
+    if (fabs(scale.xScale) < 1e-8 || fabs(scale.yScale) < 1e-8) {
+      scale = MatrixScales(1.0, 1.0);
+    }
+  } else {
+    scale = MatrixScales(1.0, 1.0);
+  }
+
+  // Prevent the scale from getting too large, to avoid excessive memory
+  // allocation. Usually memory allocation is limited by the visible region,
+  // which should be restricted to the display port. But at very large scales
+  // the visible region itself can become excessive due to rounding errors.
+  // Clamping the scale here prevents that.
+  return MatrixScales(std::min(scale.xScale, 32768.0f),
+                      std::min(scale.yScale, 32768.0f));
+}
+
+StackingContextHelper::StackingContextHelper(
+    const StackingContextHelper& aParentSC, const ActiveScrolledRoot* aAsr,
+    nsIFrame* aContainerFrame, nsDisplayItem* aContainerItem,
+    wr::DisplayListBuilder& aBuilder, const wr::StackingContextParams& aParams,
+    const LayoutDeviceRect& aBounds)
+    : mBuilder(&aBuilder),
+      mScale(1.0f, 1.0f),
+      mDeferredTransformItem(aParams.mDeferredTransformItem),
+      mRasterizeLocally(aParams.mRasterizeLocally ||
+                        aParentSC.mRasterizeLocally) {
+  MOZ_ASSERT(!aContainerItem || aContainerItem->CreatesStackingContextHelper());
+
+  mOrigin = aParentSC.mOrigin + aBounds.TopLeft();
+  // Compute scale for fallback rendering. We don't try to guess a scale for 3d
+  // transformed items
+
+  if (aParams.mBoundTransform) {
+    gfx::Matrix transform2d;
+    bool canDraw2D = aParams.mBoundTransform->CanDraw2D(&transform2d);
+    if (canDraw2D &&
+        aParams.reference_frame_kind != wr::WrReferenceFrameKind::Perspective &&
+        !aContainerFrame->Combines3DTransformWithAncestors()) {
+      mInheritedTransform = transform2d * aParentSC.mInheritedTransform;
+
+      int32_t apd = aContainerFrame->PresContext()->AppUnitsPerDevPixel();
+      nsRect r = LayoutDevicePixel::ToAppUnits(aBounds, apd);
+      mScale = ChooseScale(aContainerFrame, aContainerItem, r,
+                           aParentSC.mScale.xScale, aParentSC.mScale.yScale,
+                           mInheritedTransform,
+                           /* aCanDraw2D = */ true);
+    } else {
+      mScale = gfx::MatrixScales(1.0f, 1.0f);
+      mInheritedTransform = gfx::Matrix::Scaling(1.f, 1.f);
+    }
+
+    if (aParams.mAnimated) {
+      mSnappingSurfaceTransform = gfx::Matrix::Scaling(mScale);
+    } else {
+      mSnappingSurfaceTransform =
+          transform2d * aParentSC.mSnappingSurfaceTransform;
+    }
+
+  } else if (aParams.reference_frame_kind ==
+                 wr::WrReferenceFrameKind::Transform &&
+             aContainerItem &&
+             aContainerItem->GetType() == DisplayItemType::TYPE_ASYNC_ZOOM &&
+             aContainerItem->Frame()) {
+    float resolution = aContainerItem->Frame()->PresShell()->GetResolution();
+    gfx::Matrix transform = gfx::Matrix::Scaling(resolution, resolution);
+
+    mInheritedTransform = transform * aParentSC.mInheritedTransform;
+    mScale =
+        ScaleFactor<UnknownUnits, UnknownUnits>(resolution) * aParentSC.mScale;
+
+    MOZ_ASSERT(!aParams.mAnimated);
+    mSnappingSurfaceTransform = transform * aParentSC.mSnappingSurfaceTransform;
+
+  } else if (!aAsr && !aContainerFrame && !aContainerItem &&
+             aParams.mRootReferenceFrame) {
+    // this is the root stacking context helper
+    Scale2D resolution;
+
+    // If we are in a remote browser, then apply scaling from ancestor browsers
+    if (mozilla::dom::BrowserChild* browserChild =
+            mozilla::dom::BrowserChild::GetFrom(
+                aParams.mRootReferenceFrame->PresShell())) {
+      resolution = browserChild->GetEffectsInfo().mRasterScale;
+    }
+
+    gfx::Matrix transform =
+        gfx::Matrix::Scaling(resolution.xScale, resolution.yScale);
+
+    mInheritedTransform = transform * aParentSC.mInheritedTransform;
+    mScale = aParentSC.mScale * resolution;
+
+    MOZ_ASSERT(!aParams.mAnimated);
+    mSnappingSurfaceTransform = transform * aParentSC.mSnappingSurfaceTransform;
+
+  } else {
+    mInheritedTransform = aParentSC.mInheritedTransform;
+    mScale = aParentSC.mScale;
+  }
+
+  auto rasterSpace =
+      mRasterizeLocally
+          ? wr::RasterSpace::Local(std::max(mScale.xScale, mScale.yScale))
+          : wr::RasterSpace::Screen();
+
+  MOZ_ASSERT(!aParams.clip.IsNone());
+  mReferenceFrameId = mBuilder->PushStackingContext(
+      aParams, wr::ToLayoutRect(aBounds), rasterSpace);
+
+  if (mReferenceFrameId) {
+    mSpaceAndClipChainHelper.emplace(aBuilder, mReferenceFrameId.ref());
+  }
+
+  mAffectsClipPositioning =
+      mReferenceFrameId.isSome() || (aBounds.TopLeft() != LayoutDevicePoint());
+
+  // If the parent stacking context has a deferred transform item, inherit it
+  // into this stacking context, as long as the ASR hasn't changed. Refer to
+  // the comments on StackingContextHelper::mDeferredTransformItem for an
+  // explanation of what goes in these fields.
+  if (aParentSC.mDeferredTransformItem &&
+      aAsr == aParentSC.mDeferredTransformItem->GetActiveScrolledRoot()) {
+    if (mDeferredTransformItem) {
+      // If we are deferring another transform, put the combined transform from
+      // all the ancestor deferred items into mDeferredAncestorTransform
+      mDeferredAncestorTransform = aParentSC.GetDeferredTransformMatrix();
+    } else {
+      // We are not deferring another transform, so we can just inherit the
+      // parent stacking context's deferred data without any modification.
+      mDeferredTransformItem = aParentSC.mDeferredTransformItem;
+      mDeferredAncestorTransform = aParentSC.mDeferredAncestorTransform;
+    }
+  }
+}
+
+StackingContextHelper::~StackingContextHelper() {
+  if (mBuilder) {
+    mSpaceAndClipChainHelper.reset();
+    mBuilder->PopStackingContext(mReferenceFrameId.isSome());
+  }
+}
+
+nsDisplayTransform* StackingContextHelper::GetDeferredTransformItem() const {
+  return mDeferredTransformItem;
+}
+
+Maybe<gfx::Matrix4x4> StackingContextHelper::GetDeferredTransformMatrix()
+    const {
+  if (mDeferredTransformItem) {
+    // See the comments on StackingContextHelper::mDeferredTransformItem for
+    // an explanation of what's stored in mDeferredTransformItem and
+    // mDeferredAncestorTransform. Here we need to return the combined transform
+    // transform from all the deferred ancestors, including
+    // mDeferredTransformItem.
+    gfx::Matrix4x4 result = mDeferredTransformItem->GetTransform().GetMatrix();
+    if (mDeferredAncestorTransform) {
+      result = result * *mDeferredAncestorTransform;
+    }
+    return Some(result);
+  } else {
+    return Nothing();
+  }
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/StackingContextHelper.h b/gfx/layers/wr/StackingContextHelper.h
new file mode 100644
index 0000000000..368449a2fd
--- /dev/null
+++ b/gfx/layers/wr/StackingContextHelper.h
@@ -0,0 +1,129 @@
+/* -*- 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_STACKINGCONTEXTHELPER_H
+#define GFX_STACKINGCONTEXTHELPER_H
+
+#include "mozilla/Attributes.h"
+#include "mozilla/gfx/MatrixFwd.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "Units.h"
+
+namespace mozilla {
+
+class nsDisplayTransform;
+struct ActiveScrolledRoot;
+
+namespace layers {
+
+/**
+ * This is a helper class that pushes/pops a stacking context, and manages
+ * some of the coordinate space transformations needed.
+ */
+class MOZ_RAII StackingContextHelper {
+ public:
+  StackingContextHelper(const StackingContextHelper& aParentSC,
+                        const ActiveScrolledRoot* aAsr,
+                        nsIFrame* aContainerFrame,
+                        nsDisplayItem* aContainerItem,
+                        wr::DisplayListBuilder& aBuilder,
+                        const wr::StackingContextParams& aParams,
+                        const LayoutDeviceRect& aBounds = LayoutDeviceRect());
+
+  // This version of the constructor should only be used at the root level
+  // of the tree, so that we have a StackingContextHelper to pass down into
+  // the RenderLayer traversal, but don't actually want it to push a stacking
+  // context on the display list builder.
+  StackingContextHelper();
+
+  // Pops the stacking context, if one was pushed during the constructor.
+  ~StackingContextHelper();
+
+  // Export the inherited scale
+  gfx::MatrixScales GetInheritedScale() const { return mScale; }
+
+  const gfx::Matrix& GetInheritedTransform() const {
+    return mInheritedTransform;
+  }
+
+  const gfx::Matrix& GetSnappingSurfaceTransform() const {
+    return mSnappingSurfaceTransform;
+  }
+
+  nsDisplayTransform* GetDeferredTransformItem() const;
+  Maybe<gfx::Matrix4x4> GetDeferredTransformMatrix() const;
+
+  bool AffectsClipPositioning() const { return mAffectsClipPositioning; }
+  Maybe<wr::WrSpatialId> ReferenceFrameId() const { return mReferenceFrameId; }
+
+  const LayoutDevicePoint& GetOrigin() const { return mOrigin; }
+
+ private:
+  wr::DisplayListBuilder* mBuilder;
+  gfx::MatrixScales mScale;
+  gfx::Matrix mInheritedTransform;
+  LayoutDevicePoint mOrigin;
+
+  // The "snapping surface" defines the space that we want to snap in.
+  // You can think of it as the nearest physical surface.
+  // Animated transforms create a new snapping surface, so that changes to their
+  // transform don't affect the snapping of their contents. Non-animated
+  // transforms do *not* create a new snapping surface, so that for example the
+  // existence of a non-animated identity transform does not affect snapping.
+  gfx::Matrix mSnappingSurfaceTransform;
+  bool mAffectsClipPositioning;
+  Maybe<wr::WrSpatialId> mReferenceFrameId;
+  Maybe<wr::SpaceAndClipChainHelper> mSpaceAndClipChainHelper;
+
+  // The deferred transform item is used when building the WebRenderScrollData
+  // structure. The backstory is that APZ needs to know about transforms that
+  // apply to the different APZC instances. Prior to bug 1423370, we would do
+  // this by creating a new WebRenderLayerScrollData for each nsDisplayTransform
+  // item we encountered. However, this was unnecessarily expensive because it
+  // turned out a lot of nsDisplayTransform items didn't have new ASRs defined
+  // as descendants, so we'd create the WebRenderLayerScrollData and send it
+  // over to APZ even though the transform information was not needed in that
+  // case.
+  //
+  // In bug 1423370 and friends, this was optimized by "deferring" a
+  // nsDisplayTransform item when we encountered it during display list
+  // traversal. If we found a descendant of that transform item that had a
+  // new ASR or otherwise was "relevant to APZ", we would then pluck the
+  // transform matrix off the deferred item and put it on the
+  // WebRenderLayerScrollData instance created for that APZ-relevant descendant.
+  //
+  // One complication with this is if there are multiple nsDisplayTransform
+  // items in the ancestor chain for the APZ-relevant item. As we traverse the
+  // display list, we will defer the outermost nsDisplayTransform item, and when
+  // we encounter the next one we will need to merge it with the already-
+  // deferred one somehow. What we do in this case is have
+  // mDeferredTransformItem always point to the "innermost" deferred transform
+  // item (i.e. the closest ancestor nsDisplayTransform item of the item that
+  // created this StackingContextHelper). And then we use
+  // mDeferredAncestorTransform to store the product of all the other transforms
+  // that were deferred. As a result, there is an invariant here that if
+  // mDeferredTransformItem is nullptr, mDeferredAncestorTransform will also
+  // be Nothing(). Note that we can only do this if the nsDisplayTransform items
+  // share the same ASR. If we are processing an nsDisplayTransform item with a
+  // different ASR than the previously-deferred item, we assume that the
+  // previously-deferred transform will get sent to APZ as part of a separate
+  // WebRenderLayerScrollData item, and so we don't need to bother with any
+  // merging. (The merging probably wouldn't even make sense because the
+  // coordinate spaces might be different in the face of async scrolling). This
+  // behaviour of forcing a WebRenderLayerScrollData item to be generated when
+  // the ASR changes is implemented in
+  // WebRenderCommandBuilder::CreateWebRenderCommandsFromDisplayList.
+  nsDisplayTransform* mDeferredTransformItem;
+  Maybe<gfx::Matrix4x4> mDeferredAncestorTransform;
+
+  bool mRasterizeLocally;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif /* GFX_STACKINGCONTEXTHELPER_H */
diff --git a/gfx/layers/wr/WebRenderBridgeChild.cpp b/gfx/layers/wr/WebRenderBridgeChild.cpp
new file mode 100644
index 0000000000..ff6ec72231
--- /dev/null
+++ b/gfx/layers/wr/WebRenderBridgeChild.cpp
@@ -0,0 +1,602 @@
+/* -*- 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/layers/WebRenderBridgeChild.h"
+
+#include "gfxPlatform.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/layers/CompositableClient.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/ImageDataSerializer.h"
+#include "mozilla/layers/IpcResourceUpdateQueue.h"
+#include "mozilla/layers/StackingContextHelper.h"
+#include "mozilla/layers/PTextureChild.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "PDMFactory.h"
+
+namespace mozilla {
+namespace layers {
+
+using namespace mozilla::gfx;
+
+WebRenderBridgeChild::WebRenderBridgeChild(const wr::PipelineId& aPipelineId)
+    : mIsInTransaction(false),
+      mIsInClearCachedResources(false),
+      mIdNamespace{0},
+      mResourceId(0),
+      mPipelineId(aPipelineId),
+      mManager(nullptr),
+      mIPCOpen(false),
+      mDestroyed(false),
+      mSentDisplayList(false),
+      mFontKeysDeleted(0),
+      mFontInstanceKeysDeleted(0) {}
+
+WebRenderBridgeChild::~WebRenderBridgeChild() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mDestroyed);
+}
+
+void WebRenderBridgeChild::Destroy(bool aIsSync) {
+  if (!IPCOpen()) {
+    return;
+  }
+
+  DoDestroy();
+
+  if (aIsSync) {
+    SendShutdownSync();
+  } else {
+    SendShutdown();
+  }
+}
+
+void WebRenderBridgeChild::ActorDestroy(ActorDestroyReason why) { DoDestroy(); }
+
+void WebRenderBridgeChild::DoDestroy() {
+  if (RefCountedShm::IsValid(mResourceShm) &&
+      RefCountedShm::Release(mResourceShm) == 0) {
+    RefCountedShm::Dealloc(this, mResourceShm);
+    mResourceShm = RefCountedShmem();
+  }
+
+  // mDestroyed is used to prevent calling Send__delete__() twice.
+  // When this function is called from CompositorBridgeChild::Destroy().
+  // mActiveResourceTracker is not cleared here, since it is
+  // used by PersistentBufferProviderShared.
+  mDestroyed = true;
+  mManager = nullptr;
+}
+
+void WebRenderBridgeChild::AddWebRenderParentCommand(
+    const WebRenderParentCommand& aCmd) {
+  mParentCommands.AppendElement(aCmd);
+}
+
+void WebRenderBridgeChild::BeginTransaction() {
+  MOZ_ASSERT(!mDestroyed);
+
+  UpdateFwdTransactionId();
+  mIsInTransaction = true;
+}
+
+void WebRenderBridgeChild::UpdateResources(
+    wr::IpcResourceUpdateQueue& aResources) {
+  if (!IPCOpen()) {
+    aResources.Clear();
+    return;
+  }
+
+  if (aResources.IsEmpty()) {
+    return;
+  }
+
+  nsTArray<OpUpdateResource> resourceUpdates;
+  nsTArray<RefCountedShmem> smallShmems;
+  nsTArray<ipc::Shmem> largeShmems;
+  aResources.Flush(resourceUpdates, smallShmems, largeShmems);
+
+  this->SendUpdateResources(mIdNamespace, resourceUpdates, smallShmems,
+                            std::move(largeShmems));
+}
+
+bool WebRenderBridgeChild::EndTransaction(
+    DisplayListData&& aDisplayListData, TransactionId aTransactionId,
+    bool aContainsSVGGroup, const mozilla::VsyncId& aVsyncId,
+    const mozilla::TimeStamp& aVsyncStartTime,
+    const mozilla::TimeStamp& aRefreshStartTime,
+    const mozilla::TimeStamp& aTxnStartTime, const nsCString& aTxnURL) {
+  MOZ_ASSERT(!mDestroyed);
+  MOZ_ASSERT(mIsInTransaction);
+
+  TimeStamp fwdTime = TimeStamp::Now();
+
+  aDisplayListData.mCommands = std::move(mParentCommands);
+  aDisplayListData.mIdNamespace = mIdNamespace;
+
+  nsTArray<CompositionPayload> payloads;
+  if (mManager) {
+    mManager->TakeCompositionPayloads(payloads);
+  }
+
+  mSentDisplayList = true;
+  bool ret = this->SendSetDisplayList(
+      std::move(aDisplayListData), mDestroyedActors, GetFwdTransactionId(),
+      aTransactionId, aContainsSVGGroup, aVsyncId, aVsyncStartTime,
+      aRefreshStartTime, aTxnStartTime, aTxnURL, fwdTime, payloads);
+
+  // With multiple render roots, we may not have sent all of our
+  // mParentCommands, so go ahead and go through our mParentCommands and ensure
+  // they get sent.
+  ProcessWebRenderParentCommands();
+  mDestroyedActors.Clear();
+  mIsInTransaction = false;
+
+  return ret;
+}
+
+void WebRenderBridgeChild::EndEmptyTransaction(
+    const FocusTarget& aFocusTarget, Maybe<TransactionData>&& aTransactionData,
+    TransactionId aTransactionId, const mozilla::VsyncId& aVsyncId,
+    const mozilla::TimeStamp& aVsyncStartTime,
+    const mozilla::TimeStamp& aRefreshStartTime,
+    const mozilla::TimeStamp& aTxnStartTime, const nsCString& aTxnURL) {
+  MOZ_ASSERT(!mDestroyed);
+  MOZ_ASSERT(mIsInTransaction);
+
+  TimeStamp fwdTime = TimeStamp::Now();
+
+  if (aTransactionData) {
+    aTransactionData->mCommands = std::move(mParentCommands);
+  }
+
+  nsTArray<CompositionPayload> payloads;
+  if (mManager) {
+    mManager->TakeCompositionPayloads(payloads);
+  }
+
+  this->SendEmptyTransaction(
+      aFocusTarget, std::move(aTransactionData), mDestroyedActors,
+      GetFwdTransactionId(), aTransactionId, aVsyncId, aVsyncStartTime,
+      aRefreshStartTime, aTxnStartTime, aTxnURL, fwdTime, payloads);
+
+  // With multiple render roots, we may not have sent all of our
+  // mParentCommands, so go ahead and go through our mParentCommands and ensure
+  // they get sent.
+  ProcessWebRenderParentCommands();
+  mDestroyedActors.Clear();
+  mIsInTransaction = false;
+}
+
+void WebRenderBridgeChild::ProcessWebRenderParentCommands() {
+  MOZ_ASSERT(!mDestroyed);
+
+  if (!mParentCommands.IsEmpty()) {
+    this->SendParentCommands(mIdNamespace, mParentCommands);
+    mParentCommands.Clear();
+  }
+}
+
+void WebRenderBridgeChild::AddPipelineIdForCompositable(
+    const wr::PipelineId& aPipelineId, const CompositableHandle& aHandle,
+    CompositableHandleOwner aOwner) {
+  AddWebRenderParentCommand(
+      OpAddPipelineIdForCompositable(aPipelineId, aHandle, aOwner));
+}
+
+void WebRenderBridgeChild::RemovePipelineIdForCompositable(
+    const wr::PipelineId& aPipelineId) {
+  AddWebRenderParentCommand(OpRemovePipelineIdForCompositable(aPipelineId));
+}
+
+wr::ExternalImageId WebRenderBridgeChild::GetNextExternalImageId() {
+  wr::MaybeExternalImageId id =
+      GetCompositorBridgeChild()->GetNextExternalImageId();
+  MOZ_RELEASE_ASSERT(id.isSome());
+  return id.value();
+}
+
+void WebRenderBridgeChild::ReleaseTextureOfImage(const wr::ImageKey& aKey) {
+  AddWebRenderParentCommand(OpReleaseTextureOfImage(aKey));
+}
+
+struct FontFileDataSink {
+  wr::FontKey* mFontKey;
+  WebRenderBridgeChild* mWrBridge;
+  wr::IpcResourceUpdateQueue* mResources;
+};
+
+static void WriteFontFileData(const uint8_t* aData, uint32_t aLength,
+                              uint32_t aIndex, void* aBaton) {
+  FontFileDataSink* sink = static_cast<FontFileDataSink*>(aBaton);
+
+  *sink->mFontKey = sink->mWrBridge->GetNextFontKey();
+
+  sink->mResources->AddRawFont(
+      *sink->mFontKey, Range<uint8_t>(const_cast<uint8_t*>(aData), aLength),
+      aIndex);
+}
+
+static void WriteFontDescriptor(const uint8_t* aData, uint32_t aLength,
+                                uint32_t aIndex, void* aBaton) {
+  FontFileDataSink* sink = static_cast<FontFileDataSink*>(aBaton);
+
+  *sink->mFontKey = sink->mWrBridge->GetNextFontKey();
+
+  sink->mResources->AddFontDescriptor(
+      *sink->mFontKey, Range<uint8_t>(const_cast<uint8_t*>(aData), aLength),
+      aIndex);
+}
+
+void WebRenderBridgeChild::PushGlyphs(
+    wr::DisplayListBuilder& aBuilder, wr::IpcResourceUpdateQueue& aResources,
+    Range<const wr::GlyphInstance> aGlyphs, gfx::ScaledFont* aFont,
+    const wr::ColorF& aColor, const StackingContextHelper& aSc,
+    const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+    bool aBackfaceVisible, const wr::GlyphOptions* aGlyphOptions) {
+  MOZ_ASSERT(aFont);
+
+  Maybe<wr::WrFontInstanceKey> key = GetFontKeyForScaledFont(aFont, aResources);
+  MOZ_ASSERT(key.isSome());
+
+  if (key.isSome()) {
+    aBuilder.PushText(aBounds, aClip, aBackfaceVisible, aColor, key.value(),
+                      aGlyphs, aGlyphOptions);
+  }
+}
+
+Maybe<wr::FontInstanceKey> WebRenderBridgeChild::GetFontKeyForScaledFont(
+    gfx::ScaledFont* aScaledFont, wr::IpcResourceUpdateQueue& aResources) {
+  MOZ_ASSERT(!mDestroyed);
+  MOZ_ASSERT(aScaledFont);
+  MOZ_ASSERT(aScaledFont->CanSerialize());
+
+  return mFontInstanceKeys.WithEntryHandle(
+      aScaledFont, [&](auto&& entry) -> Maybe<wr::FontInstanceKey> {
+        if (!entry) {
+          Maybe<wr::FontKey> fontKey = GetFontKeyForUnscaledFont(
+              aScaledFont->GetUnscaledFont(), aResources);
+          if (fontKey.isNothing()) {
+            return Nothing();
+          }
+
+          wr::FontInstanceKey instanceKey = GetNextFontInstanceKey();
+
+          Maybe<wr::FontInstanceOptions> options;
+          Maybe<wr::FontInstancePlatformOptions> platformOptions;
+          std::vector<FontVariation> variations;
+          aScaledFont->GetWRFontInstanceOptions(&options, &platformOptions,
+                                                &variations);
+
+          aResources.AddFontInstance(
+              instanceKey, fontKey.value(), aScaledFont->GetSize(),
+              options.ptrOr(nullptr), platformOptions.ptrOr(nullptr),
+              Range<const FontVariation>(variations.data(), variations.size()));
+
+          entry.Insert(instanceKey);
+        }
+
+        return Some(*entry);
+      });
+}
+
+Maybe<wr::FontKey> WebRenderBridgeChild::GetFontKeyForUnscaledFont(
+    gfx::UnscaledFont* aUnscaled, wr::IpcResourceUpdateQueue& aResources) {
+  MOZ_ASSERT(!mDestroyed);
+
+  return mFontKeys.WithEntryHandle(
+      aUnscaled, [&](auto&& entry) -> Maybe<wr::FontKey> {
+        if (!entry) {
+          wr::FontKey fontKey = {wr::IdNamespace{0}, 0};
+          FontFileDataSink sink = {&fontKey, this, &aResources};
+          // First try to retrieve a descriptor for the font, as this is much
+          // cheaper to send over IPC than the full raw font data. If this is
+          // not possible, then and only then fall back to getting the raw font
+          // file data. If that fails, then the only thing left to do is signal
+          // failure by returning a null font key.
+          if (!aUnscaled->GetFontDescriptor(WriteFontDescriptor, &sink) &&
+              !aUnscaled->GetFontFileData(WriteFontFileData, &sink)) {
+            return Nothing();
+          }
+
+          entry.Insert(fontKey);
+        }
+
+        return Some(*entry);
+      });
+}
+
+void WebRenderBridgeChild::RemoveExpiredFontKeys(
+    wr::IpcResourceUpdateQueue& aResourceUpdates) {
+  uint32_t counter = gfx::ScaledFont::DeletionCounter();
+  if (mFontInstanceKeysDeleted != counter) {
+    mFontInstanceKeysDeleted = counter;
+    for (auto iter = mFontInstanceKeys.Iter(); !iter.Done(); iter.Next()) {
+      if (!iter.Key()) {
+        aResourceUpdates.DeleteFontInstance(iter.Data());
+        iter.Remove();
+      }
+    }
+  }
+  counter = gfx::UnscaledFont::DeletionCounter();
+  if (mFontKeysDeleted != counter) {
+    mFontKeysDeleted = counter;
+    for (auto iter = mFontKeys.Iter(); !iter.Done(); iter.Next()) {
+      if (!iter.Key()) {
+        aResourceUpdates.DeleteFont(iter.Data());
+        iter.Remove();
+      }
+    }
+  }
+}
+
+CompositorBridgeChild* WebRenderBridgeChild::GetCompositorBridgeChild() {
+  if (!IPCOpen()) {
+    return nullptr;
+  }
+  return static_cast<CompositorBridgeChild*>(Manager());
+}
+
+TextureForwarder* WebRenderBridgeChild::GetTextureForwarder() {
+  return static_cast<TextureForwarder*>(GetCompositorBridgeChild());
+}
+
+LayersIPCActor* WebRenderBridgeChild::GetLayersIPCActor() {
+  return static_cast<LayersIPCActor*>(GetCompositorBridgeChild());
+}
+
+void WebRenderBridgeChild::SyncWithCompositor() {
+  if (!IPCOpen()) {
+    return;
+  }
+  SendSyncWithCompositor();
+}
+
+void WebRenderBridgeChild::Connect(CompositableClient* aCompositable,
+                                   ImageContainer* aImageContainer) {
+  MOZ_ASSERT(!mDestroyed);
+  MOZ_ASSERT(aCompositable);
+
+  CompositableHandle handle = CompositableHandle::GetNext();
+  mCompositables.InsertOrUpdate(uint64_t(handle), aCompositable);
+
+  aCompositable->InitIPDL(handle);
+  SendNewCompositable(handle, aCompositable->GetTextureInfo());
+}
+
+bool WebRenderBridgeChild::AddOpDestroy(const OpDestroy& aOp) {
+  if (!mIsInTransaction) {
+    return false;
+  }
+
+  mDestroyedActors.AppendElement(aOp);
+  return true;
+}
+
+void WebRenderBridgeChild::ReleaseCompositable(
+    const CompositableHandle& aHandle) {
+  if (!IPCOpen()) {
+    // This can happen if the IPC connection was torn down, because, e.g.
+    // the GPU process died.
+    return;
+  }
+  if (!DestroyInTransaction(aHandle)) {
+    SendReleaseCompositable(aHandle);
+  }
+  mCompositables.Remove(aHandle.Value());
+}
+
+bool WebRenderBridgeChild::DestroyInTransaction(PTextureChild* aTexture) {
+  return AddOpDestroy(OpDestroy(WrapNotNull(aTexture)));
+}
+
+bool WebRenderBridgeChild::DestroyInTransaction(
+    const CompositableHandle& aHandle) {
+  return AddOpDestroy(OpDestroy(aHandle));
+}
+
+void WebRenderBridgeChild::RemoveTextureFromCompositable(
+    CompositableClient* aCompositable, TextureClient* aTexture) {
+  MOZ_ASSERT(aCompositable);
+  MOZ_ASSERT(aTexture);
+  MOZ_ASSERT(aTexture->GetIPDLActor());
+  MOZ_RELEASE_ASSERT(aTexture->GetIPDLActor()->GetIPCChannel() ==
+                     GetIPCChannel());
+  if (!aCompositable->IsConnected() || !aTexture->GetIPDLActor()) {
+    // We don't have an actor anymore, don't try to use it!
+    return;
+  }
+
+  AddWebRenderParentCommand(CompositableOperation(
+      aCompositable->GetIPCHandle(),
+      OpRemoveTexture(WrapNotNull(aTexture->GetIPDLActor()))));
+}
+
+void WebRenderBridgeChild::UseTextures(
+    CompositableClient* aCompositable,
+    const nsTArray<TimedTextureClient>& aTextures) {
+  MOZ_ASSERT(aCompositable);
+
+  if (!aCompositable->IsConnected()) {
+    return;
+  }
+
+  AutoTArray<TimedTexture, 4> textures;
+
+  for (auto& t : aTextures) {
+    MOZ_ASSERT(t.mTextureClient);
+    MOZ_ASSERT(t.mTextureClient->GetIPDLActor());
+    MOZ_RELEASE_ASSERT(t.mTextureClient->GetIPDLActor()->GetIPCChannel() ==
+                       GetIPCChannel());
+    bool readLocked = t.mTextureClient->OnForwardedToHost();
+
+    textures.AppendElement(TimedTexture(
+        WrapNotNull(t.mTextureClient->GetIPDLActor()), t.mTimeStamp,
+        t.mPictureRect, t.mFrameID, t.mProducerID, readLocked));
+    GetCompositorBridgeChild()->HoldUntilCompositableRefReleasedIfNecessary(
+        t.mTextureClient);
+  }
+  AddWebRenderParentCommand(CompositableOperation(aCompositable->GetIPCHandle(),
+                                                  OpUseTexture(textures)));
+}
+
+void WebRenderBridgeChild::UseRemoteTexture(CompositableClient* aCompositable,
+                                            const RemoteTextureId aTextureId,
+                                            const RemoteTextureOwnerId aOwnerId,
+                                            const gfx::IntSize aSize,
+                                            const TextureFlags aFlags) {
+  AddWebRenderParentCommand(CompositableOperation(
+      aCompositable->GetIPCHandle(),
+      OpUseRemoteTexture(aTextureId, aOwnerId, aSize, aFlags)));
+}
+
+void WebRenderBridgeChild::EnableRemoteTexturePushCallback(
+    CompositableClient* aCompositable, const RemoteTextureOwnerId aOwnerId,
+    const gfx::IntSize aSize, const TextureFlags aFlags) {
+  AddWebRenderParentCommand(CompositableOperation(
+      aCompositable->GetIPCHandle(),
+      OpEnableRemoteTexturePushCallback(aOwnerId, aSize, aFlags)));
+}
+
+void WebRenderBridgeChild::UpdateFwdTransactionId() {
+  GetCompositorBridgeChild()->UpdateFwdTransactionId();
+}
+
+uint64_t WebRenderBridgeChild::GetFwdTransactionId() {
+  return GetCompositorBridgeChild()->GetFwdTransactionId();
+}
+
+bool WebRenderBridgeChild::InForwarderThread() { return NS_IsMainThread(); }
+
+mozilla::ipc::IPCResult WebRenderBridgeChild::RecvWrUpdated(
+    const wr::IdNamespace& aNewIdNamespace,
+    const TextureFactoryIdentifier& textureFactoryIdentifier) {
+  if (mManager) {
+    mManager->WrUpdated();
+  }
+  IdentifyTextureHost(textureFactoryIdentifier);
+  // Update mIdNamespace to identify obsolete keys and messages by
+  // WebRenderBridgeParent. Since usage of invalid keys could cause crash in
+  // webrender.
+  mIdNamespace = aNewIdNamespace;
+  // Just clear FontInstaceKeys/FontKeys, they are removed during WebRenderAPI
+  // destruction.
+  mFontInstanceKeys.Clear();
+  mFontKeys.Clear();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeChild::RecvWrReleasedImages(
+    nsTArray<wr::ExternalImageKeyPair>&& aPairs) {
+  if (mManager) {
+    mManager->WrReleasedImages(aPairs);
+  }
+  return IPC_OK();
+}
+
+void WebRenderBridgeChild::BeginClearCachedResources() {
+  mSentDisplayList = false;
+  mIsInClearCachedResources = true;
+  // Clear display list and animtaions at parent side before clearing cached
+  // resources on client side. It prevents to clear resources before clearing
+  // display list at parent side.
+  SendClearCachedResources();
+}
+
+void WebRenderBridgeChild::EndClearCachedResources() {
+  if (!IPCOpen()) {
+    mIsInClearCachedResources = false;
+    return;
+  }
+  ProcessWebRenderParentCommands();
+  mIsInClearCachedResources = false;
+}
+
+void WebRenderBridgeChild::SetWebRenderLayerManager(
+    WebRenderLayerManager* aManager) {
+  MOZ_ASSERT(aManager && !mManager);
+  mManager = aManager;
+
+  MOZ_ASSERT(NS_IsMainThread() || !XRE_IsContentProcess());
+  mActiveResourceTracker =
+      MakeUnique<ActiveResourceTracker>(1000, "CompositableForwarder", nullptr);
+}
+
+ipc::IShmemAllocator* WebRenderBridgeChild::GetShmemAllocator() {
+  if (!IPCOpen()) {
+    return nullptr;
+  }
+  return static_cast<CompositorBridgeChild*>(Manager());
+}
+
+RefPtr<KnowsCompositor> WebRenderBridgeChild::GetForMedia() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Ensure device initialization for video playback unless they are all remote.
+  // The devices are lazily initialized with WebRender to reduce memory usage.
+  if (!PDMFactory::AllDecodersAreRemote()) {
+    gfxPlatform::GetPlatform()->EnsureDevicesInitialized();
+  }
+
+  return MakeAndAddRef<KnowsCompositorMediaProxy>(
+      GetTextureFactoryIdentifier());
+}
+
+bool WebRenderBridgeChild::AllocResourceShmem(size_t aSize,
+                                              RefCountedShmem& aShm) {
+  // We keep a single shmem around to reuse later if it is reference count has
+  // dropped back to 1 (the reference held by the WebRenderBridgeChild).
+
+  // If the cached shmem exists, has the correct size and isn't held by anything
+  // other than us, recycle it.
+  bool alreadyAllocated = RefCountedShm::IsValid(mResourceShm);
+  if (alreadyAllocated) {
+    if (RefCountedShm::GetSize(mResourceShm) == aSize &&
+        RefCountedShm::GetReferenceCount(mResourceShm) <= 1) {
+      MOZ_ASSERT(RefCountedShm::GetReferenceCount(mResourceShm) == 1);
+      aShm = mResourceShm;
+      return true;
+    }
+  }
+
+  // If there was no cached shmem or we couldn't recycle it, alloc a new one.
+  if (!RefCountedShm::Alloc(this, aSize, aShm)) {
+    return false;
+  }
+
+  // Now that we have a valid shmem, put it in the cache if we don't have one
+  // yet.
+  if (!alreadyAllocated) {
+    mResourceShm = aShm;
+    RefCountedShm::AddRef(aShm);
+  }
+
+  return true;
+}
+
+void WebRenderBridgeChild::DeallocResourceShmem(RefCountedShmem& aShm) {
+  if (!RefCountedShm::IsValid(aShm)) {
+    return;
+  }
+  MOZ_ASSERT(RefCountedShm::GetReferenceCount(aShm) == 0);
+
+  RefCountedShm::Dealloc(this, aShm);
+}
+
+void WebRenderBridgeChild::Capture() { this->SendCapture(); }
+
+void WebRenderBridgeChild::StartCaptureSequence(const nsCString& aPath,
+                                                uint32_t aFlags) {
+  this->SendStartCaptureSequence(aPath, aFlags);
+}
+
+void WebRenderBridgeChild::StopCaptureSequence() {
+  this->SendStopCaptureSequence();
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/WebRenderBridgeChild.h b/gfx/layers/wr/WebRenderBridgeChild.h
new file mode 100644
index 0000000000..2bd8dc8570
--- /dev/null
+++ b/gfx/layers/wr/WebRenderBridgeChild.h
@@ -0,0 +1,269 @@
+/* -*- 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_WebRenderBridgeChild_h
+#define mozilla_layers_WebRenderBridgeChild_h
+
+#include "mozilla/layers/CompositableForwarder.h"
+#include "mozilla/layers/PWebRenderBridgeChild.h"
+
+namespace mozilla {
+
+namespace widget {
+class CompositorWidget;
+}
+
+namespace wr {
+class DisplayListBuilder;
+class ResourceUpdateQueue;
+class IpcResourceUpdateQueue;
+}  // namespace wr
+
+namespace layers {
+
+class CompositableClient;
+class CompositorBridgeChild;
+class StackingContextHelper;
+class TextureForwarder;
+class WebRenderLayerManager;
+
+template <class T>
+class ThreadSafeWeakPtrHashKey : public PLDHashEntryHdr {
+ public:
+  typedef RefPtr<T> KeyType;
+  typedef const T* KeyTypePointer;
+
+  explicit ThreadSafeWeakPtrHashKey(KeyTypePointer aKey)
+      : mKey(do_AddRef(const_cast<T*>(aKey))) {}
+
+  KeyType GetKey() const { return do_AddRef(mKey); }
+  bool KeyEquals(KeyTypePointer aKey) const { return mKey == aKey; }
+
+  static KeyTypePointer KeyToPointer(const KeyType& aKey) { return aKey.get(); }
+  static PLDHashNumber HashKey(KeyTypePointer aKey) {
+    return NS_PTR_TO_UINT32(aKey) >> 2;
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+ private:
+  ThreadSafeWeakPtr<T> mKey;
+};
+
+typedef ThreadSafeWeakPtrHashKey<gfx::UnscaledFont> UnscaledFontHashKey;
+typedef ThreadSafeWeakPtrHashKey<gfx::ScaledFont> ScaledFontHashKey;
+
+class WebRenderBridgeChild final : public PWebRenderBridgeChild,
+                                   public CompositableForwarder {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderBridgeChild, override)
+
+  friend class PWebRenderBridgeChild;
+
+ public:
+  explicit WebRenderBridgeChild(const wr::PipelineId& aPipelineId);
+
+  void AddWebRenderParentCommand(const WebRenderParentCommand& aCmd);
+  bool HasWebRenderParentCommands() { return !mParentCommands.IsEmpty(); }
+
+  void UpdateResources(wr::IpcResourceUpdateQueue& aResources);
+  void BeginTransaction();
+  bool EndTransaction(DisplayListData&& aDisplayListData,
+                      TransactionId aTransactionId, bool aContainsSVGroup,
+                      const mozilla::VsyncId& aVsyncId,
+                      const mozilla::TimeStamp& aVsyncStartTime,
+                      const mozilla::TimeStamp& aRefreshStartTime,
+                      const mozilla::TimeStamp& aTxnStartTime,
+                      const nsCString& aTxtURL);
+  void EndEmptyTransaction(const FocusTarget& aFocusTarget,
+                           Maybe<TransactionData>&& aTransactionData,
+                           TransactionId aTransactionId,
+                           const mozilla::VsyncId& aVsyncId,
+                           const mozilla::TimeStamp& aVsyncStartTime,
+                           const mozilla::TimeStamp& aRefreshStartTime,
+                           const mozilla::TimeStamp& aTxnStartTime,
+                           const nsCString& aTxtURL);
+  void ProcessWebRenderParentCommands();
+
+  CompositorBridgeChild* GetCompositorBridgeChild();
+
+  wr::PipelineId GetPipeline() { return mPipelineId; }
+
+  // KnowsCompositor
+  TextureForwarder* GetTextureForwarder() override;
+  LayersIPCActor* GetLayersIPCActor() override;
+  void SyncWithCompositor() override;
+  ActiveResourceTracker* GetActiveResourceTracker() override {
+    return mActiveResourceTracker.get();
+  }
+
+  void AddPipelineIdForCompositable(const wr::PipelineId& aPipelineId,
+                                    const CompositableHandle& aHandle,
+                                    CompositableHandleOwner aOwner);
+  void RemovePipelineIdForCompositable(const wr::PipelineId& aPipelineId);
+
+  /// Release TextureClient that is bounded to ImageKey.
+  /// It is used for recycling TextureClient.
+  void ReleaseTextureOfImage(const wr::ImageKey& aKey);
+
+  /**
+   * Clean this up, finishing with SendShutDown() which will cause __delete__
+   * to be sent from the parent side.
+   */
+  void Destroy(bool aIsSync);
+  bool IPCOpen() const { return mIPCOpen && !mDestroyed; }
+  bool GetSentDisplayList() const { return mSentDisplayList; }
+  bool IsDestroyed() const { return mDestroyed; }
+
+  uint32_t GetNextResourceId() { return ++mResourceId; }
+  wr::IdNamespace GetNamespace() { return mIdNamespace; }
+  void SetNamespace(wr::IdNamespace aIdNamespace) {
+    mIdNamespace = aIdNamespace;
+  }
+
+  bool MatchesNamespace(const wr::ImageKey& aImageKey) const {
+    return aImageKey.mNamespace == mIdNamespace;
+  }
+
+  bool MatchesNamespace(const wr::BlobImageKey& aBlobKey) const {
+    return MatchesNamespace(aBlobKey._0);
+  }
+
+  wr::FontKey GetNextFontKey() {
+    return wr::FontKey{GetNamespace(), GetNextResourceId()};
+  }
+
+  wr::FontInstanceKey GetNextFontInstanceKey() {
+    return wr::FontInstanceKey{GetNamespace(), GetNextResourceId()};
+  }
+
+  wr::WrImageKey GetNextImageKey() {
+    return wr::WrImageKey{GetNamespace(), GetNextResourceId()};
+  }
+
+  void PushGlyphs(wr::DisplayListBuilder& aBuilder,
+                  wr::IpcResourceUpdateQueue& aResources,
+                  Range<const wr::GlyphInstance> aGlyphs,
+                  gfx::ScaledFont* aFont, const wr::ColorF& aColor,
+                  const StackingContextHelper& aSc,
+                  const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+                  bool aBackfaceVisible,
+                  const wr::GlyphOptions* aGlyphOptions = nullptr);
+
+  Maybe<wr::FontInstanceKey> GetFontKeyForScaledFont(
+      gfx::ScaledFont* aScaledFont, wr::IpcResourceUpdateQueue& aResources);
+  Maybe<wr::FontKey> GetFontKeyForUnscaledFont(
+      gfx::UnscaledFont* aUnscaledFont, wr::IpcResourceUpdateQueue& aResources);
+  void RemoveExpiredFontKeys(wr::IpcResourceUpdateQueue& aResources);
+
+  void BeginClearCachedResources();
+  void EndClearCachedResources();
+
+  void SetWebRenderLayerManager(WebRenderLayerManager* aManager);
+
+  mozilla::ipc::IShmemAllocator* GetShmemAllocator();
+
+  bool IsThreadSafe() const override { return false; }
+
+  RefPtr<KnowsCompositor> GetForMedia() override;
+
+  /// Alloc a specific type of shmem that is intended for use in
+  /// IpcResourceUpdateQueue only, and cache at most one of them,
+  /// when called multiple times.
+  ///
+  /// Do not use this for anything else.
+  bool AllocResourceShmem(size_t aSize, RefCountedShmem& aShm);
+  /// Dealloc shared memory that was allocated with AllocResourceShmem.
+  ///
+  /// Do not use this for anything else.
+  void DeallocResourceShmem(RefCountedShmem& aShm);
+
+  void Capture();
+  void StartCaptureSequence(const nsCString& path, uint32_t aFlags);
+  void StopCaptureSequence();
+
+ private:
+  friend class CompositorBridgeChild;
+
+  ~WebRenderBridgeChild();
+
+  wr::ExternalImageId GetNextExternalImageId();
+
+  // CompositableForwarder
+  void Connect(CompositableClient* aCompositable,
+               ImageContainer* aImageContainer = nullptr) override;
+  void ReleaseCompositable(const CompositableHandle& aHandle) override;
+  bool DestroyInTransaction(PTextureChild* aTexture) override;
+  bool DestroyInTransaction(const CompositableHandle& aHandle);
+  void RemoveTextureFromCompositable(CompositableClient* aCompositable,
+                                     TextureClient* aTexture) override;
+  void UseTextures(CompositableClient* aCompositable,
+                   const nsTArray<TimedTextureClient>& aTextures) override;
+  void UseRemoteTexture(CompositableClient* aCompositable,
+                        const RemoteTextureId aTextureId,
+                        const RemoteTextureOwnerId aOwnerId,
+                        const gfx::IntSize aSize,
+                        const TextureFlags aFlags) override;
+  void EnableRemoteTexturePushCallback(CompositableClient* aCompositable,
+                                       const RemoteTextureOwnerId aOwnerId,
+                                       const gfx::IntSize aSize,
+                                       const TextureFlags aFlags) override;
+  void UpdateFwdTransactionId() override;
+  uint64_t GetFwdTransactionId() override;
+  bool InForwarderThread() override;
+
+  void ActorDestroy(ActorDestroyReason why) override;
+
+  void DoDestroy();
+
+  mozilla::ipc::IPCResult RecvWrUpdated(
+      const wr::IdNamespace& aNewIdNamespace,
+      const TextureFactoryIdentifier& textureFactoryIdentifier);
+  mozilla::ipc::IPCResult RecvWrReleasedImages(
+      nsTArray<wr::ExternalImageKeyPair>&& aPairs);
+
+  void AddIPDLReference() {
+    MOZ_ASSERT(mIPCOpen == false);
+    mIPCOpen = true;
+    AddRef();
+  }
+  void ReleaseIPDLReference() {
+    MOZ_ASSERT(mIPCOpen == true);
+    mIPCOpen = false;
+    Release();
+  }
+
+  bool AddOpDestroy(const OpDestroy& aOp);
+
+  nsTArray<OpDestroy> mDestroyedActors;
+  nsTArray<WebRenderParentCommand> mParentCommands;
+  nsTHashMap<nsUint64HashKey, CompositableClient*> mCompositables;
+  bool mIsInTransaction;
+  bool mIsInClearCachedResources;
+  wr::IdNamespace mIdNamespace;
+  uint32_t mResourceId;
+  wr::PipelineId mPipelineId;
+  WebRenderLayerManager* mManager;
+
+  bool mIPCOpen;
+  bool mDestroyed;
+  // True iff we have called SendSetDisplayList and haven't called
+  // SendClearCachedResources since that call.
+  bool mSentDisplayList;
+
+  uint32_t mFontKeysDeleted;
+  nsTHashMap<UnscaledFontHashKey, wr::FontKey> mFontKeys;
+
+  uint32_t mFontInstanceKeysDeleted;
+  nsTHashMap<ScaledFontHashKey, wr::FontInstanceKey> mFontInstanceKeys;
+
+  UniquePtr<ActiveResourceTracker> mActiveResourceTracker;
+
+  RefCountedShmem mResourceShm;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif  // mozilla_layers_WebRenderBridgeChild_h
diff --git a/gfx/layers/wr/WebRenderBridgeParent.cpp b/gfx/layers/wr/WebRenderBridgeParent.cpp
new file mode 100644
index 0000000000..b8a262e577
--- /dev/null
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -0,0 +1,2909 @@
+/* -*- 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/layers/WebRenderBridgeParent.h"
+
+#include "CompositableHost.h"
+#include "gfxEnv.h"
+#include "gfxPlatform.h"
+#include "gfxOTSUtils.h"
+#include "GeckoProfiler.h"
+#include "GLContext.h"
+#include "GLContextProvider.h"
+#include "GLLibraryLoader.h"
+#include "nsExceptionHandler.h"
+#include "mozilla/Range.h"
+#include "mozilla/EnumeratedRange.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/StaticPrefs_webgl.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/GPUParent.h"
+#include "mozilla/layers/AnimationHelper.h"
+#include "mozilla/layers/APZSampler.h"
+#include "mozilla/layers/APZUpdater.h"
+#include "mozilla/layers/Compositor.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/CompositorAnimationStorage.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/CompositorVsyncScheduler.h"
+#include "mozilla/layers/ImageBridgeParent.h"
+#include "mozilla/layers/ImageDataSerializer.h"
+#include "mozilla/layers/IpcResourceUpdateQueue.h"
+#include "mozilla/layers/OMTASampler.h"
+#include "mozilla/layers/SharedSurfacesParent.h"
+#include "mozilla/layers/TextureHost.h"
+#include "mozilla/layers/AsyncImagePipelineManager.h"
+#include "mozilla/layers/UiCompositorControllerParent.h"
+#include "mozilla/layers/WebRenderImageHost.h"
+#include "mozilla/layers/WebRenderTextureHost.h"
+#include "mozilla/ProfilerMarkerTypes.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Unused.h"
+#include "mozilla/webrender/RenderTextureHostSWGL.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/widget/CompositorWidget.h"
+
+#ifdef XP_WIN
+#  include "mozilla/gfx/DeviceManagerDx.h"
+#  include "mozilla/widget/WinCompositorWidget.h"
+#endif
+#if defined(MOZ_WIDGET_GTK)
+#  include "mozilla/widget/GtkCompositorWidget.h"
+#endif
+
+bool is_in_main_thread() { return NS_IsMainThread(); }
+
+bool is_in_compositor_thread() {
+  return mozilla::layers::CompositorThreadHolder::IsInCompositorThread();
+}
+
+bool is_in_render_thread() {
+  return mozilla::wr::RenderThread::IsInRenderThread();
+}
+
+bool gecko_profiler_thread_is_being_profiled() {
+  return profiler_thread_is_being_profiled(ThreadProfilingFeatures::Any);
+}
+
+bool is_glcontext_gles(void* const glcontext_ptr) {
+  MOZ_RELEASE_ASSERT(glcontext_ptr);
+  return reinterpret_cast<mozilla::gl::GLContext*>(glcontext_ptr)->IsGLES();
+}
+
+bool is_glcontext_angle(void* glcontext_ptr) {
+  MOZ_ASSERT(glcontext_ptr);
+
+  mozilla::gl::GLContext* glcontext =
+      reinterpret_cast<mozilla::gl::GLContext*>(glcontext_ptr);
+  if (!glcontext) {
+    return false;
+  }
+  return glcontext->IsANGLE();
+}
+
+const char* gfx_wr_resource_path_override() {
+  return gfxPlatform::WebRenderResourcePathOverride();
+}
+
+bool gfx_wr_use_optimized_shaders() {
+  return mozilla::gfx::gfxVars::UseWebRenderOptimizedShaders();
+}
+
+void gfx_critical_note(const char* msg) { gfxCriticalNote << msg; }
+
+void gfx_critical_error(const char* msg) { gfxCriticalError() << msg; }
+
+void gecko_printf_stderr_output(const char* msg) { printf_stderr("%s\n", msg); }
+
+void* get_proc_address_from_glcontext(void* glcontext_ptr,
+                                      const char* procname) {
+  mozilla::gl::GLContext* glcontext =
+      reinterpret_cast<mozilla::gl::GLContext*>(glcontext_ptr);
+  MOZ_ASSERT(glcontext);
+  if (!glcontext) {
+    return nullptr;
+  }
+  const auto& loader = glcontext->GetSymbolLoader();
+  MOZ_ASSERT(loader);
+
+  const auto ret = loader->GetProcAddress(procname);
+  return reinterpret_cast<void*>(ret);
+}
+
+static CrashReporter::Annotation FromWrCrashAnnotation(
+    mozilla::wr::CrashAnnotation aAnnotation) {
+  switch (aAnnotation) {
+    case mozilla::wr::CrashAnnotation::CompileShader:
+      return CrashReporter::Annotation::GraphicsCompileShader;
+    case mozilla::wr::CrashAnnotation::DrawShader:
+      return CrashReporter::Annotation::GraphicsDrawShader;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unhandled annotation!");
+      return CrashReporter::Annotation::Count;
+  }
+}
+
+extern "C" {
+
+void gfx_wr_set_crash_annotation(mozilla::wr::CrashAnnotation aAnnotation,
+                                 const char* aValue) {
+  MOZ_ASSERT(aValue);
+
+  auto annotation = FromWrCrashAnnotation(aAnnotation);
+  if (annotation == CrashReporter::Annotation::Count) {
+    return;
+  }
+
+  CrashReporter::AnnotateCrashReport(annotation, nsDependentCString(aValue));
+}
+
+void gfx_wr_clear_crash_annotation(mozilla::wr::CrashAnnotation aAnnotation) {
+  auto annotation = FromWrCrashAnnotation(aAnnotation);
+  if (annotation == CrashReporter::Annotation::Count) {
+    return;
+  }
+
+  CrashReporter::RemoveCrashReportAnnotation(annotation);
+}
+}
+
+namespace mozilla {
+
+namespace layers {
+
+using namespace mozilla::gfx;
+
+LazyLogModule gWebRenderBridgeParentLog("WebRenderBridgeParent");
+#define LOG(...) \
+  MOZ_LOG(gWebRenderBridgeParentLog, LogLevel::Debug, (__VA_ARGS__))
+
+class ScheduleObserveLayersUpdate : public wr::NotificationHandler {
+ public:
+  ScheduleObserveLayersUpdate(RefPtr<CompositorBridgeParentBase> aBridge,
+                              LayersId aLayersId, LayersObserverEpoch aEpoch,
+                              bool aIsActive)
+      : mBridge(aBridge),
+        mLayersId(aLayersId),
+        mObserverEpoch(aEpoch),
+        mIsActive(aIsActive) {}
+
+  void Notify(wr::Checkpoint) override {
+    CompositorThread()->Dispatch(
+        NewRunnableMethod<LayersId, LayersObserverEpoch, int>(
+            "ObserveLayersUpdate", mBridge,
+            &CompositorBridgeParentBase::ObserveLayersUpdate, mLayersId,
+            mObserverEpoch, mIsActive));
+  }
+
+ protected:
+  RefPtr<CompositorBridgeParentBase> mBridge;
+  LayersId mLayersId;
+  LayersObserverEpoch mObserverEpoch;
+  bool mIsActive;
+};
+
+class SceneBuiltNotification : public wr::NotificationHandler {
+ public:
+  SceneBuiltNotification(WebRenderBridgeParent* aParent, wr::Epoch aEpoch,
+                         TimeStamp aTxnStartTime)
+      : mParent(aParent), mEpoch(aEpoch), mTxnStartTime(aTxnStartTime) {}
+
+  void Notify(wr::Checkpoint) override {
+    auto startTime = this->mTxnStartTime;
+    RefPtr<WebRenderBridgeParent> parent = mParent;
+    wr::Epoch epoch = mEpoch;
+    CompositorThread()->Dispatch(NS_NewRunnableFunction(
+        "SceneBuiltNotificationRunnable", [parent, epoch, startTime]() {
+          auto endTime = TimeStamp::Now();
+          if (profiler_thread_is_being_profiled_for_markers()) {
+            PROFILER_MARKER("CONTENT_FULL_PAINT_TIME", GRAPHICS,
+                            MarkerTiming::Interval(startTime, endTime),
+                            ContentBuildMarker);
+          }
+          Telemetry::Accumulate(
+              Telemetry::CONTENT_FULL_PAINT_TIME,
+              static_cast<uint32_t>((endTime - startTime).ToMilliseconds()));
+          parent->NotifySceneBuiltForEpoch(epoch, endTime);
+        }));
+  }
+
+ protected:
+  RefPtr<WebRenderBridgeParent> mParent;
+  wr::Epoch mEpoch;
+  TimeStamp mTxnStartTime;
+};
+
+class WebRenderBridgeParent::ScheduleSharedSurfaceRelease final
+    : public wr::NotificationHandler {
+ public:
+  explicit ScheduleSharedSurfaceRelease(WebRenderBridgeParent* aWrBridge)
+      : mWrBridge(aWrBridge), mSurfaces(20) {}
+
+  ~ScheduleSharedSurfaceRelease() override {
+    if (!mSurfaces.IsEmpty()) {
+      MOZ_ASSERT_UNREACHABLE("Unreleased surfaces!");
+      gfxCriticalNote << "ScheduleSharedSurfaceRelease destroyed non-empty";
+      NotifyInternal(/* aFromCheckpoint */ false);
+    }
+  }
+
+  void Add(const wr::ImageKey& aKey, const wr::ExternalImageId& aId) {
+    mSurfaces.AppendElement(wr::ExternalImageKeyPair{aKey, aId});
+  }
+
+  void Notify(wr::Checkpoint) override {
+    NotifyInternal(/* aFromCheckpoint */ true);
+  }
+
+ private:
+  void NotifyInternal(bool aFromCheckpoint) {
+    CompositorThread()->Dispatch(
+        NewRunnableMethod<nsTArray<wr::ExternalImageKeyPair>, bool>(
+            "ObserveSharedSurfaceRelease", mWrBridge,
+            &WebRenderBridgeParent::ObserveSharedSurfaceRelease,
+            std::move(mSurfaces), aFromCheckpoint));
+  }
+
+  RefPtr<WebRenderBridgeParent> mWrBridge;
+  nsTArray<wr::ExternalImageKeyPair> mSurfaces;
+};
+
+class MOZ_STACK_CLASS AutoWebRenderBridgeParentAsyncMessageSender final {
+ public:
+  explicit AutoWebRenderBridgeParentAsyncMessageSender(
+      WebRenderBridgeParent* aWebRenderBridgeParent,
+      nsTArray<OpDestroy>* aDestroyActors = nullptr)
+      : mWebRenderBridgeParent(aWebRenderBridgeParent),
+        mActorsToDestroy(aDestroyActors) {
+    mWebRenderBridgeParent->SetAboutToSendAsyncMessages();
+  }
+
+  ~AutoWebRenderBridgeParentAsyncMessageSender() {
+    mWebRenderBridgeParent->SendPendingAsyncMessages();
+    if (mActorsToDestroy) {
+      // Destroy the actors after sending the async messages because the latter
+      // may contain references to some actors.
+      for (const auto& op : *mActorsToDestroy) {
+        mWebRenderBridgeParent->DestroyActor(op);
+      }
+    }
+  }
+
+ private:
+  WebRenderBridgeParent* mWebRenderBridgeParent;
+  nsTArray<OpDestroy>* mActorsToDestroy;
+};
+
+WebRenderBridgeParent::WebRenderBridgeParent(
+    CompositorBridgeParentBase* aCompositorBridge,
+    const wr::PipelineId& aPipelineId, widget::CompositorWidget* aWidget,
+    CompositorVsyncScheduler* aScheduler, RefPtr<wr::WebRenderAPI>&& aApi,
+    RefPtr<AsyncImagePipelineManager>&& aImageMgr, TimeDuration aVsyncRate)
+    : mCompositorBridge(aCompositorBridge),
+      mPipelineId(aPipelineId),
+      mWidget(aWidget),
+      mApi(aApi),
+      mAsyncImageManager(aImageMgr),
+      mCompositorScheduler(aScheduler),
+      mVsyncRate(aVsyncRate),
+      mChildLayersObserverEpoch{0},
+      mParentLayersObserverEpoch{0},
+      mWrEpoch{0},
+      mIdNamespace(aApi->GetNamespace()),
+#if defined(MOZ_WIDGET_ANDROID)
+      mScreenPixelsTarget(nullptr),
+#endif
+      mBlobTileSize(256),
+      mSkippedCompositeReasons(wr::RenderReasons::NONE),
+      mDestroyed(false),
+      mReceivedDisplayList(false),
+      mIsFirstPaint(true),
+      mSkippedComposite(false),
+      mDisablingNativeCompositor(false),
+      mPendingScrollPayloads("WebRenderBridgeParent::mPendingScrollPayloads") {
+  MOZ_ASSERT(mAsyncImageManager);
+  LOG("WebRenderBridgeParent::WebRenderBridgeParent() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  mAsyncImageManager->AddPipeline(mPipelineId, this);
+  if (IsRootWebRenderBridgeParent()) {
+    MOZ_ASSERT(!mCompositorScheduler);
+    mCompositorScheduler = new CompositorVsyncScheduler(this, mWidget);
+    UpdateDebugFlags();
+    UpdateQualitySettings();
+    UpdateProfilerUI();
+    UpdateParameters();
+    // Start with the cached bool parameter bits inverted so that we update them
+    // all.
+    mBoolParameterBits = ~gfxVars::WebRenderBoolParameters();
+    UpdateBoolParameters();
+  }
+}
+
+WebRenderBridgeParent::WebRenderBridgeParent(const wr::PipelineId& aPipelineId,
+                                             nsCString&& aError)
+    : mCompositorBridge(nullptr),
+      mPipelineId(aPipelineId),
+      mChildLayersObserverEpoch{0},
+      mParentLayersObserverEpoch{0},
+      mWrEpoch{0},
+      mIdNamespace{0},
+      mInitError(aError),
+      mDestroyed(true),
+      mReceivedDisplayList(false),
+      mIsFirstPaint(false),
+      mSkippedComposite(false),
+      mDisablingNativeCompositor(false),
+      mPendingScrollPayloads("WebRenderBridgeParent::mPendingScrollPayloads") {
+  LOG("WebRenderBridgeParent::WebRenderBridgeParent() PipelineId %" PRIx64 "",
+      wr::AsUint64(mPipelineId));
+}
+
+WebRenderBridgeParent::~WebRenderBridgeParent() {
+  LOG("WebRenderBridgeParent::WebRenderBridgeParent() PipelineId %" PRIx64 "",
+      wr::AsUint64(mPipelineId));
+}
+
+/* static */
+WebRenderBridgeParent* WebRenderBridgeParent::CreateDestroyed(
+    const wr::PipelineId& aPipelineId, nsCString&& aError) {
+  return new WebRenderBridgeParent(aPipelineId, std::move(aError));
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvEnsureConnected(
+    TextureFactoryIdentifier* aTextureFactoryIdentifier,
+    MaybeIdNamespace* aMaybeIdNamespace, nsCString* aError) {
+  if (mDestroyed) {
+    *aTextureFactoryIdentifier =
+        TextureFactoryIdentifier(LayersBackend::LAYERS_NONE);
+    *aMaybeIdNamespace = Nothing();
+    if (mInitError.IsEmpty()) {
+      // Got destroyed after we initialized but before the handshake finished?
+      aError->AssignLiteral("FEATURE_FAILURE_WEBRENDER_INITIALIZE_RACE");
+    } else {
+      *aError = std::move(mInitError);
+    }
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(mIdNamespace.mHandle != 0);
+  *aTextureFactoryIdentifier = GetTextureFactoryIdentifier();
+  *aMaybeIdNamespace = Some(mIdNamespace);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvShutdown() {
+  return HandleShutdown();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvShutdownSync() {
+  return HandleShutdown();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::HandleShutdown() {
+  Destroy();
+  IProtocol* mgr = Manager();
+  if (!Send__delete__(this)) {
+    return IPC_FAIL_NO_REASON(mgr);
+  }
+  return IPC_OK();
+}
+
+void WebRenderBridgeParent::Destroy() {
+  if (mDestroyed) {
+    return;
+  }
+  LOG("WebRenderBridgeParent::Destroy() PipelineId %" PRIx64 " Id %" PRIx64
+      " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  mDestroyed = true;
+  if (mWebRenderBridgeRef) {
+    // Break mutual reference
+    mWebRenderBridgeRef->Clear();
+    mWebRenderBridgeRef = nullptr;
+  }
+  for (const auto& entry : mCompositables) {
+    entry.second->OnReleased();
+  }
+  mCompositables.clear();
+  ClearResources();
+}
+
+struct WROTSAlloc {
+  wr::Vec<uint8_t> mVec;
+
+  void* Grow(void* aPtr, size_t aLength) {
+    if (aLength > mVec.Capacity()) {
+      mVec.Reserve(aLength - mVec.Capacity());
+    }
+    return mVec.inner.data;
+  }
+  wr::Vec<uint8_t> ShrinkToFit(void* aPtr, size_t aLength) {
+    wr::Vec<uint8_t> result(std::move(mVec));
+    result.inner.length = aLength;
+    return result;
+  }
+  void Free(void* aPtr) {}
+};
+
+static bool ReadRawFont(const OpAddRawFont& aOp, wr::ShmSegmentsReader& aReader,
+                        wr::TransactionBuilder& aUpdates) {
+  wr::Vec<uint8_t> sourceBytes;
+  Maybe<Range<uint8_t>> ptr =
+      aReader.GetReadPointerOrCopy(aOp.bytes(), sourceBytes);
+  if (ptr.isNothing()) {
+    gfxCriticalNote << "No read pointer from reader for sanitizing font "
+                    << aOp.key().mHandle;
+    return false;
+  }
+  Range<uint8_t>& source = ptr.ref();
+  // Attempt to sanitize the font before passing it along for updating.
+  // Ensure that we're not strict here about font types, since any font that
+  // failed generating a descriptor might end up here as raw font data.
+  size_t lengthHint = gfxOTSContext::GuessSanitizedFontSize(
+      source.begin().get(), source.length(), false);
+  if (!lengthHint) {
+    gfxCriticalNote << "Could not determine font type for sanitizing font "
+                    << aOp.key().mHandle;
+    return false;
+  }
+  gfxOTSExpandingMemoryStream<WROTSAlloc> output(lengthHint);
+  gfxOTSContext otsContext;
+  if (!otsContext.Process(&output, source.begin().get(), source.length())) {
+    gfxCriticalNote << "Failed sanitizing font " << aOp.key().mHandle;
+    return false;
+  }
+  wr::Vec<uint8_t> bytes = output.forget();
+
+  aUpdates.AddRawFont(aOp.key(), bytes, aOp.fontIndex());
+  return true;
+}
+
+bool WebRenderBridgeParent::UpdateResources(
+    const nsTArray<OpUpdateResource>& aResourceUpdates,
+    const nsTArray<RefCountedShmem>& aSmallShmems,
+    const nsTArray<ipc::Shmem>& aLargeShmems,
+    wr::TransactionBuilder& aUpdates) {
+  wr::ShmSegmentsReader reader(aSmallShmems, aLargeShmems);
+  UniquePtr<ScheduleSharedSurfaceRelease> scheduleRelease;
+
+  while (GPUParent::MaybeFlushMemory()) {
+    // If the GPU process has memory pressure, preemptively unmap some of our
+    // shared memory images. If we are in the parent process, the expiration
+    // tracker itself will listen for the memory pressure event.
+    if (!SharedSurfacesParent::AgeAndExpireOneGeneration()) {
+      break;
+    }
+  }
+
+  bool success = true;
+  for (const auto& cmd : aResourceUpdates) {
+    switch (cmd.type()) {
+      case OpUpdateResource::TOpAddImage: {
+        const auto& op = cmd.get_OpAddImage();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale image key (add)!");
+          break;
+        }
+
+        wr::Vec<uint8_t> bytes;
+        if (reader.Read(op.bytes(), bytes)) {
+          aUpdates.AddImage(op.key(), op.descriptor(), bytes);
+        } else {
+          gfxCriticalNote << "TOpAddImage failed";
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpUpdateImage: {
+        const auto& op = cmd.get_OpUpdateImage();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale image key (update)!");
+          break;
+        }
+
+        wr::Vec<uint8_t> bytes;
+        if (reader.Read(op.bytes(), bytes)) {
+          aUpdates.UpdateImageBuffer(op.key(), op.descriptor(), bytes);
+        } else {
+          gfxCriticalNote << "TOpUpdateImage failed";
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpAddBlobImage: {
+        const auto& op = cmd.get_OpAddBlobImage();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale blob image key (add)!");
+          break;
+        }
+
+        wr::Vec<uint8_t> bytes;
+        if (reader.Read(op.bytes(), bytes)) {
+          aUpdates.AddBlobImage(op.key(), op.descriptor(), mBlobTileSize, bytes,
+                                wr::ToDeviceIntRect(op.visibleRect()));
+        } else {
+          gfxCriticalNote << "TOpAddBlobImage failed";
+          success = false;
+        }
+
+        break;
+      }
+      case OpUpdateResource::TOpUpdateBlobImage: {
+        const auto& op = cmd.get_OpUpdateBlobImage();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale blob image key (update)!");
+          break;
+        }
+
+        wr::Vec<uint8_t> bytes;
+        if (reader.Read(op.bytes(), bytes)) {
+          aUpdates.UpdateBlobImage(op.key(), op.descriptor(), bytes,
+                                   wr::ToDeviceIntRect(op.visibleRect()),
+                                   wr::ToLayoutIntRect(op.dirtyRect()));
+        } else {
+          gfxCriticalNote << "TOpUpdateBlobImage failed";
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpSetBlobImageVisibleArea: {
+        const auto& op = cmd.get_OpSetBlobImageVisibleArea();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale blob image key (visible)!");
+          break;
+        }
+        aUpdates.SetBlobImageVisibleArea(op.key(),
+                                         wr::ToDeviceIntRect(op.area()));
+        break;
+      }
+      case OpUpdateResource::TOpAddSharedExternalImage: {
+        const auto& op = cmd.get_OpAddSharedExternalImage();
+        // gfxCriticalNote is called on error
+        if (!AddSharedExternalImage(op.externalImageId(), op.key(), aUpdates)) {
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpPushExternalImageForTexture: {
+        const auto& op = cmd.get_OpPushExternalImageForTexture();
+        CompositableTextureHostRef texture;
+        texture = TextureHost::AsTextureHost(op.texture().AsParent());
+        // gfxCriticalNote is called on error
+        if (!PushExternalImageForTexture(op.externalImageId(), op.key(),
+                                         texture, op.isUpdate(), aUpdates)) {
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpUpdateSharedExternalImage: {
+        const auto& op = cmd.get_OpUpdateSharedExternalImage();
+        // gfxCriticalNote is called on error
+        if (!UpdateSharedExternalImage(op.externalImageId(), op.key(),
+                                       op.dirtyRect(), aUpdates,
+                                       scheduleRelease)) {
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpAddRawFont: {
+        if (!ReadRawFont(cmd.get_OpAddRawFont(), reader, aUpdates)) {
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpAddFontDescriptor: {
+        const auto& op = cmd.get_OpAddFontDescriptor();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale font key (add descriptor)!");
+          break;
+        }
+
+        wr::Vec<uint8_t> bytes;
+        if (reader.Read(op.bytes(), bytes)) {
+          aUpdates.AddFontDescriptor(op.key(), bytes, op.fontIndex());
+        } else {
+          gfxCriticalNote << "TOpAddFontDescriptor failed";
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpAddFontInstance: {
+        const auto& op = cmd.get_OpAddFontInstance();
+        if (!MatchesNamespace(op.instanceKey()) ||
+            !MatchesNamespace(op.fontKey())) {
+          MOZ_ASSERT_UNREACHABLE("Stale font key (add instance)!");
+          break;
+        }
+
+        wr::Vec<uint8_t> variations;
+        if (reader.Read(op.variations(), variations)) {
+          aUpdates.AddFontInstance(op.instanceKey(), op.fontKey(),
+                                   op.glyphSize(), op.options().ptrOr(nullptr),
+                                   op.platformOptions().ptrOr(nullptr),
+                                   variations);
+        } else {
+          gfxCriticalNote << "TOpAddFontInstance failed";
+          success = false;
+        }
+        break;
+      }
+      case OpUpdateResource::TOpDeleteImage: {
+        const auto& op = cmd.get_OpDeleteImage();
+        if (!MatchesNamespace(op.key())) {
+          // TODO(aosmond): We should also assert here, but the callers are less
+          // careful about checking when cleaning up their old keys. We should
+          // perform an audit on image key usage.
+          break;
+        }
+
+        DeleteImage(op.key(), aUpdates);
+        break;
+      }
+      case OpUpdateResource::TOpDeleteBlobImage: {
+        const auto& op = cmd.get_OpDeleteBlobImage();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale blob image key (delete)!");
+          break;
+        }
+
+        aUpdates.DeleteBlobImage(op.key());
+        break;
+      }
+      case OpUpdateResource::TOpDeleteFont: {
+        const auto& op = cmd.get_OpDeleteFont();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale font key (delete)!");
+          break;
+        }
+
+        aUpdates.DeleteFont(op.key());
+        break;
+      }
+      case OpUpdateResource::TOpDeleteFontInstance: {
+        const auto& op = cmd.get_OpDeleteFontInstance();
+        if (!MatchesNamespace(op.key())) {
+          MOZ_ASSERT_UNREACHABLE("Stale font instance key (delete)!");
+          break;
+        }
+
+        aUpdates.DeleteFontInstance(op.key());
+        break;
+      }
+      case OpUpdateResource::T__None:
+        break;
+    }
+  }
+
+  if (scheduleRelease) {
+    // When software WR is enabled, shared surfaces are read during rendering
+    // rather than copied to the texture cache.
+    wr::Checkpoint when = mApi->GetBackendType() == WebRenderBackend::SOFTWARE
+                              ? wr::Checkpoint::FrameRendered
+                              : wr::Checkpoint::FrameTexturesUpdated;
+    aUpdates.Notify(when, std::move(scheduleRelease));
+  }
+
+  MOZ_ASSERT(success);
+  return success;
+}
+
+bool WebRenderBridgeParent::AddSharedExternalImage(
+    wr::ExternalImageId aExtId, wr::ImageKey aKey,
+    wr::TransactionBuilder& aResources) {
+  if (!MatchesNamespace(aKey)) {
+    MOZ_ASSERT_UNREACHABLE("Stale shared external image key (add)!");
+    return true;
+  }
+
+  auto key = wr::AsUint64(aKey);
+  auto it = mSharedSurfaceIds.find(key);
+  if (it != mSharedSurfaceIds.end()) {
+    gfxCriticalNote << "Readding known shared surface: " << key;
+    return false;
+  }
+
+  RefPtr<DataSourceSurface> dSurf = SharedSurfacesParent::Acquire(aExtId);
+  if (!dSurf) {
+    gfxCriticalNote
+        << "DataSourceSurface of SharedSurfaces does not exist for extId:"
+        << wr::AsUint64(aExtId);
+    return false;
+  }
+
+  mSharedSurfaceIds.insert(std::make_pair(key, aExtId));
+
+  // Prefer raw buffers, unless our backend requires native textures.
+  IntSize surfaceSize = dSurf->GetSize();
+  TextureHost::NativeTexturePolicy policy =
+      TextureHost::BackendNativeTexturePolicy(mApi->GetBackendType(),
+                                              surfaceSize);
+  auto imageType =
+      policy == TextureHost::NativeTexturePolicy::REQUIRE
+          ? wr::ExternalImageType::TextureHandle(wr::ImageBufferKind::Texture2D)
+          : wr::ExternalImageType::Buffer();
+  wr::ImageDescriptor descriptor(surfaceSize, dSurf->Stride(),
+                                 dSurf->GetFormat());
+  aResources.AddExternalImage(aKey, descriptor, aExtId, imageType, 0);
+  return true;
+}
+
+bool WebRenderBridgeParent::PushExternalImageForTexture(
+    wr::ExternalImageId aExtId, wr::ImageKey aKey, TextureHost* aTexture,
+    bool aIsUpdate, wr::TransactionBuilder& aResources) {
+  if (!MatchesNamespace(aKey)) {
+    MOZ_ASSERT_UNREACHABLE("Stale texture external image key!");
+    return true;
+  }
+
+  if (!aTexture) {
+    gfxCriticalNote << "TextureHost does not exist for extId:"
+                    << wr::AsUint64(aExtId);
+    return false;
+  }
+
+  auto op = aIsUpdate ? TextureHost::UPDATE_IMAGE : TextureHost::ADD_IMAGE;
+  WebRenderTextureHost* wrTexture = aTexture->AsWebRenderTextureHost();
+  if (wrTexture) {
+    Range<wr::ImageKey> keys(&aKey, 1);
+    wrTexture->PushResourceUpdates(aResources, op, keys,
+                                   wrTexture->GetExternalImageKey());
+    auto it = mTextureHosts.find(wr::AsUint64(aKey));
+    MOZ_ASSERT((it == mTextureHosts.end() && !aIsUpdate) ||
+               (it != mTextureHosts.end() && aIsUpdate));
+    if (it != mTextureHosts.end()) {
+      // Release Texture if it exists.
+      ReleaseTextureOfImage(aKey);
+    }
+    mTextureHosts.emplace(wr::AsUint64(aKey),
+                          CompositableTextureHostRef(aTexture));
+    return true;
+  }
+
+  RefPtr<DataSourceSurface> dSurf = aTexture->GetAsSurface();
+  if (!dSurf) {
+    gfxCriticalNote
+        << "TextureHost does not return DataSourceSurface for extId:"
+        << wr::AsUint64(aExtId);
+    return false;
+  }
+
+  DataSourceSurface::MappedSurface map;
+  if (!dSurf->Map(gfx::DataSourceSurface::MapType::READ, &map)) {
+    gfxCriticalNote << "DataSourceSurface failed to map for Image for extId:"
+                    << wr::AsUint64(aExtId);
+    return false;
+  }
+
+  IntSize size = dSurf->GetSize();
+  wr::ImageDescriptor descriptor(size, map.mStride, dSurf->GetFormat());
+  wr::Vec<uint8_t> data;
+  data.PushBytes(Range<uint8_t>(map.mData, size.height * map.mStride));
+
+  if (op == TextureHost::UPDATE_IMAGE) {
+    aResources.UpdateImageBuffer(aKey, descriptor, data);
+  } else {
+    aResources.AddImage(aKey, descriptor, data);
+  }
+
+  dSurf->Unmap();
+
+  return true;
+}
+
+bool WebRenderBridgeParent::UpdateSharedExternalImage(
+    wr::ExternalImageId aExtId, wr::ImageKey aKey,
+    const ImageIntRect& aDirtyRect, wr::TransactionBuilder& aResources,
+    UniquePtr<ScheduleSharedSurfaceRelease>& aScheduleRelease) {
+  if (!MatchesNamespace(aKey)) {
+    MOZ_ASSERT_UNREACHABLE("Stale shared external image key (update)!");
+    return true;
+  }
+
+  auto key = wr::AsUint64(aKey);
+  auto it = mSharedSurfaceIds.find(key);
+  if (it == mSharedSurfaceIds.end()) {
+    gfxCriticalNote << "Updating unknown shared surface: " << key;
+    return false;
+  }
+
+  RefPtr<DataSourceSurface> dSurf;
+  if (it->second == aExtId) {
+    dSurf = SharedSurfacesParent::Get(aExtId);
+  } else {
+    dSurf = SharedSurfacesParent::Acquire(aExtId);
+  }
+
+  if (!dSurf) {
+    gfxCriticalNote << "Shared surface does not exist for extId:"
+                    << wr::AsUint64(aExtId);
+    return false;
+  }
+
+  if (!(it->second == aExtId)) {
+    // We already have a mapping for this image key, so ensure we release the
+    // previous external image ID. This can happen when an image is animated,
+    // and it is changing the external image that the animation points to.
+    if (!aScheduleRelease) {
+      aScheduleRelease = MakeUnique<ScheduleSharedSurfaceRelease>(this);
+    }
+    aScheduleRelease->Add(aKey, it->second);
+    it->second = aExtId;
+  }
+
+  // Prefer raw buffers, unless our backend requires native textures.
+  IntSize surfaceSize = dSurf->GetSize();
+  TextureHost::NativeTexturePolicy policy =
+      TextureHost::BackendNativeTexturePolicy(mApi->GetBackendType(),
+                                              surfaceSize);
+  auto imageType =
+      policy == TextureHost::NativeTexturePolicy::REQUIRE
+          ? wr::ExternalImageType::TextureHandle(wr::ImageBufferKind::Texture2D)
+          : wr::ExternalImageType::Buffer();
+  wr::ImageDescriptor descriptor(surfaceSize, dSurf->Stride(),
+                                 dSurf->GetFormat());
+  aResources.UpdateExternalImageWithDirtyRect(
+      aKey, descriptor, aExtId, imageType, wr::ToDeviceIntRect(aDirtyRect), 0);
+
+  return true;
+}
+
+void WebRenderBridgeParent::ObserveSharedSurfaceRelease(
+    const nsTArray<wr::ExternalImageKeyPair>& aPairs,
+    const bool& aFromCheckpoint) {
+  if (!mDestroyed) {
+    Unused << SendWrReleasedImages(aPairs);
+  }
+
+  if (!aFromCheckpoint && mAsyncImageManager) {
+    // We failed to receive a checkpoint notification, so we are releasing these
+    // surfaces blind. Let's wait until the next epoch to complete releasing.
+    for (const auto& pair : aPairs) {
+      mAsyncImageManager->HoldExternalImage(mPipelineId, mWrEpoch, pair.id);
+    }
+    return;
+  }
+
+  // We hit the checkpoint, so we know we can safely release the surfaces now.
+  for (const auto& pair : aPairs) {
+    SharedSurfacesParent::Release(pair.id);
+  }
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvUpdateResources(
+    const wr::IdNamespace& aIdNamespace,
+    nsTArray<OpUpdateResource>&& aResourceUpdates,
+    nsTArray<RefCountedShmem>&& aSmallShmems,
+    nsTArray<ipc::Shmem>&& aLargeShmems) {
+  const bool isValidMessage = aIdNamespace == mIdNamespace;
+
+  if (mDestroyed || !isValidMessage) {
+    wr::IpcResourceUpdateQueue::ReleaseShmems(this, aSmallShmems);
+    wr::IpcResourceUpdateQueue::ReleaseShmems(this, aLargeShmems);
+    return IPC_OK();
+  }
+
+  LOG("WebRenderBridgeParent::RecvUpdateResources() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  wr::TransactionBuilder txn(mApi);
+  txn.SetLowPriority(!IsRootWebRenderBridgeParent());
+
+  Unused << GetNextWrEpoch();
+
+  bool success =
+      UpdateResources(aResourceUpdates, aSmallShmems, aLargeShmems, txn);
+  wr::IpcResourceUpdateQueue::ReleaseShmems(this, aSmallShmems);
+  wr::IpcResourceUpdateQueue::ReleaseShmems(this, aLargeShmems);
+
+  // Even when txn.IsResourceUpdatesEmpty() is true, there could be resource
+  // updates. It is handled by WebRenderTextureHostWrapper. In this case
+  // txn.IsRenderedFrameInvalidated() becomes true.
+  if (!txn.IsResourceUpdatesEmpty() || txn.IsRenderedFrameInvalidated()) {
+    // There are resource updates, then we update Epoch of transaction.
+    txn.UpdateEpoch(mPipelineId, mWrEpoch);
+    mAsyncImageManager->SetWillGenerateFrame();
+    ScheduleGenerateFrame(wr::RenderReasons::RESOURCE_UPDATE);
+  } else {
+    // If TransactionBuilder does not have resource updates nor display list,
+    // ScheduleGenerateFrame is not triggered via SceneBuilder and there is no
+    // need to update WrEpoch.
+    // Then we want to rollback WrEpoch. See Bug 1490117.
+    RollbackWrEpoch();
+  }
+
+  mApi->SendTransaction(txn);
+
+  if (!success) {
+    return IPC_FAIL(this, "Invalid WebRender resource data shmem or address.");
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvDeleteCompositorAnimations(
+    nsTArray<uint64_t>&& aIds) {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+
+  LOG("WebRenderBridgeParent::RecvDeleteCompositorAnimations() PipelineId "
+      "%" PRIx64 " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  // Once mWrEpoch has been rendered, we can delete these compositor animations
+  mCompositorAnimationsToDelete.push(
+      CompositorAnimationIdsForEpoch(mWrEpoch, std::move(aIds)));
+  return IPC_OK();
+}
+
+void WebRenderBridgeParent::RemoveEpochDataPriorTo(
+    const wr::Epoch& aRenderedEpoch) {
+  if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+    sampler->RemoveEpochDataPriorTo(mCompositorAnimationsToDelete,
+                                    mActiveAnimations, aRenderedEpoch);
+  }
+}
+
+bool WebRenderBridgeParent::IsRootWebRenderBridgeParent() const {
+  return !!mWidget;
+}
+
+void WebRenderBridgeParent::BeginRecording(const TimeStamp& aRecordingStart) {
+  mApi->BeginRecording(aRecordingStart, mPipelineId);
+}
+
+RefPtr<wr::WebRenderAPI::EndRecordingPromise>
+WebRenderBridgeParent::EndRecording() {
+  return mApi->EndRecording();
+}
+
+void WebRenderBridgeParent::AddPendingScrollPayload(
+    CompositionPayload& aPayload, const VsyncId& aCompositeStartId) {
+  auto pendingScrollPayloads = mPendingScrollPayloads.Lock();
+  nsTArray<CompositionPayload>* payloads =
+      pendingScrollPayloads->GetOrInsertNew(aCompositeStartId.mId);
+
+  payloads->AppendElement(aPayload);
+}
+
+nsTArray<CompositionPayload> WebRenderBridgeParent::TakePendingScrollPayload(
+    const VsyncId& aCompositeStartId) {
+  auto pendingScrollPayloads = mPendingScrollPayloads.Lock();
+  nsTArray<CompositionPayload> payload;
+  if (nsTArray<CompositionPayload>* storedPayload =
+          pendingScrollPayloads->Get(aCompositeStartId.mId)) {
+    payload.AppendElements(std::move(*storedPayload));
+    pendingScrollPayloads->Remove(aCompositeStartId.mId);
+  }
+  return payload;
+}
+
+CompositorBridgeParent* WebRenderBridgeParent::GetRootCompositorBridgeParent()
+    const {
+  if (!mCompositorBridge) {
+    return nullptr;
+  }
+
+  if (IsRootWebRenderBridgeParent()) {
+    // This WebRenderBridgeParent is attached to the root
+    // CompositorBridgeParent.
+    return static_cast<CompositorBridgeParent*>(mCompositorBridge);
+  }
+
+  // Otherwise, this WebRenderBridgeParent is attached to a
+  // ContentCompositorBridgeParent so we have an extra level of
+  // indirection to unravel.
+  CompositorBridgeParent::LayerTreeState* lts =
+      CompositorBridgeParent::GetIndirectShadowTree(GetLayersId());
+  if (!lts) {
+    return nullptr;
+  }
+  return lts->mParent;
+}
+
+RefPtr<WebRenderBridgeParent>
+WebRenderBridgeParent::GetRootWebRenderBridgeParent() const {
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  if (!cbp) {
+    return nullptr;
+  }
+
+  return cbp->GetWebRenderBridgeParent();
+}
+
+void WebRenderBridgeParent::UpdateAPZFocusState(const FocusTarget& aFocus) {
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  if (!cbp) {
+    return;
+  }
+  LayersId rootLayersId = cbp->RootLayerTreeId();
+  if (RefPtr<APZUpdater> apz = cbp->GetAPZUpdater()) {
+    apz->UpdateFocusState(rootLayersId, GetLayersId(), aFocus);
+  }
+}
+
+void WebRenderBridgeParent::UpdateAPZScrollData(const wr::Epoch& aEpoch,
+                                                WebRenderScrollData&& aData) {
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  if (!cbp) {
+    return;
+  }
+  LayersId rootLayersId = cbp->RootLayerTreeId();
+  if (RefPtr<APZUpdater> apz = cbp->GetAPZUpdater()) {
+    apz->UpdateScrollDataAndTreeState(rootLayersId, GetLayersId(), aEpoch,
+                                      std::move(aData));
+  }
+}
+
+void WebRenderBridgeParent::UpdateAPZScrollOffsets(
+    ScrollUpdatesMap&& aUpdates, uint32_t aPaintSequenceNumber) {
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  if (!cbp) {
+    return;
+  }
+  LayersId rootLayersId = cbp->RootLayerTreeId();
+  if (RefPtr<APZUpdater> apz = cbp->GetAPZUpdater()) {
+    apz->UpdateScrollOffsets(rootLayersId, GetLayersId(), std::move(aUpdates),
+                             aPaintSequenceNumber);
+  }
+}
+
+void WebRenderBridgeParent::SetAPZSampleTime() {
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  if (!cbp) {
+    return;
+  }
+  if (RefPtr<APZSampler> apz = cbp->GetAPZSampler()) {
+    SampleTime animationTime;
+    if (Maybe<TimeStamp> testTime = cbp->GetTestingTimeStamp()) {
+      animationTime = SampleTime::FromTest(*testTime);
+    } else {
+      animationTime = mCompositorScheduler->GetLastComposeTime();
+    }
+    TimeDuration frameInterval = cbp->GetVsyncInterval();
+    // As with the non-webrender codepath in AsyncCompositionManager, we want to
+    // use the timestamp for the next vsync when advancing animations.
+    if (frameInterval != TimeDuration::Forever()) {
+      animationTime = animationTime + frameInterval;
+    }
+    apz->SetSampleTime(animationTime);
+  }
+}
+
+bool WebRenderBridgeParent::SetDisplayList(
+    const LayoutDeviceRect& aRect, ipc::ByteBuf&& aDLItems,
+    ipc::ByteBuf&& aDLCache, ipc::ByteBuf&& aSpatialTreeDL,
+    const wr::BuiltDisplayListDescriptor& aDLDesc,
+    const nsTArray<OpUpdateResource>& aResourceUpdates,
+    const nsTArray<RefCountedShmem>& aSmallShmems,
+    const nsTArray<ipc::Shmem>& aLargeShmems, const TimeStamp& aTxnStartTime,
+    wr::TransactionBuilder& aTxn, wr::Epoch aWrEpoch,
+    bool aObserveLayersUpdate) {
+  bool success =
+      UpdateResources(aResourceUpdates, aSmallShmems, aLargeShmems, aTxn);
+
+  wr::Vec<uint8_t> dlItems(std::move(aDLItems));
+  wr::Vec<uint8_t> dlCache(std::move(aDLCache));
+  wr::Vec<uint8_t> dlSpatialTreeData(std::move(aSpatialTreeDL));
+
+  if (IsRootWebRenderBridgeParent()) {
+#ifdef MOZ_WIDGET_GTK
+    if (mWidget->AsGTK()) {
+      mWidget->AsGTK()->RemoteLayoutSizeUpdated(aRect);
+    }
+#endif
+    LayoutDeviceIntSize widgetSize = mWidget->GetClientSize();
+    LayoutDeviceIntRect rect =
+        LayoutDeviceIntRect(LayoutDeviceIntPoint(), widgetSize);
+    aTxn.SetDocumentView(rect);
+  }
+  aTxn.SetDisplayList(aWrEpoch, mPipelineId, aDLDesc, dlItems, dlCache,
+                      dlSpatialTreeData);
+
+  if (aObserveLayersUpdate) {
+    aTxn.Notify(
+        wr::Checkpoint::SceneBuilt,
+        MakeUnique<ScheduleObserveLayersUpdate>(
+            mCompositorBridge, GetLayersId(), mChildLayersObserverEpoch, true));
+  }
+
+  if (!IsRootWebRenderBridgeParent()) {
+    aTxn.Notify(wr::Checkpoint::SceneBuilt, MakeUnique<SceneBuiltNotification>(
+                                                this, aWrEpoch, aTxnStartTime));
+  }
+
+  mApi->SendTransaction(aTxn);
+
+  // We will schedule generating a frame after the scene
+  // build is done, so we don't need to do it here.
+  return success;
+}
+
+bool WebRenderBridgeParent::ProcessDisplayListData(
+    DisplayListData& aDisplayList, wr::Epoch aWrEpoch,
+    const TimeStamp& aTxnStartTime, bool aValidTransaction,
+    bool aObserveLayersUpdate) {
+  wr::TransactionBuilder txn(mApi);
+  Maybe<wr::AutoTransactionSender> sender;
+
+  if (aDisplayList.mScrollData && !aDisplayList.mScrollData->Validate()) {
+    // If the scroll data is invalid, the entire transaction needs to be dropped
+    // because the scroll data and the display list cross-reference each other.
+    MOZ_ASSERT(
+        false,
+        "Content sent malformed scroll data (or validation check has a bug)");
+    aValidTransaction = false;
+  }
+
+  if (!aValidTransaction) {
+    return true;
+  }
+
+  MOZ_ASSERT(aDisplayList.mIdNamespace == mIdNamespace);
+
+  // Note that this needs to happen before the display list transaction is
+  // sent to WebRender, so that the UpdateHitTestingTree call is guaranteed to
+  // be in the updater queue at the time that the scene swap completes.
+  if (aDisplayList.mScrollData) {
+    UpdateAPZScrollData(aWrEpoch, std::move(aDisplayList.mScrollData.ref()));
+  }
+
+  txn.SetLowPriority(!IsRootWebRenderBridgeParent());
+  sender.emplace(mApi, &txn);
+  bool success = true;
+
+  success =
+      ProcessWebRenderParentCommands(aDisplayList.mCommands, txn) && success;
+
+  if (aDisplayList.mDLItems && aDisplayList.mDLCache &&
+      aDisplayList.mDLSpatialTree) {
+    success = SetDisplayList(
+                  aDisplayList.mRect, std::move(aDisplayList.mDLItems.ref()),
+                  std::move(aDisplayList.mDLCache.ref()),
+                  std::move(aDisplayList.mDLSpatialTree.ref()),
+                  aDisplayList.mDLDesc, aDisplayList.mResourceUpdates,
+                  aDisplayList.mSmallShmems, aDisplayList.mLargeShmems,
+                  aTxnStartTime, txn, aWrEpoch, aObserveLayersUpdate) &&
+              success;
+  }
+  return success;
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSetDisplayList(
+    DisplayListData&& aDisplayList, nsTArray<OpDestroy>&& aToDestroy,
+    const uint64_t& aFwdTransactionId, const TransactionId& aTransactionId,
+    const bool& aContainsSVGGroup, const VsyncId& aVsyncId,
+    const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+    const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+    const TimeStamp& aFwdTime, nsTArray<CompositionPayload>&& aPayloads) {
+  if (mDestroyed) {
+    for (const auto& op : aToDestroy) {
+      DestroyActor(op);
+    }
+    wr::IpcResourceUpdateQueue::ReleaseShmems(this, aDisplayList.mSmallShmems);
+    wr::IpcResourceUpdateQueue::ReleaseShmems(this, aDisplayList.mLargeShmems);
+    return IPC_OK();
+  }
+
+  LOG("WebRenderBridgeParent::RecvSetDisplayList() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  if (!IsRootWebRenderBridgeParent()) {
+    CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::URL, aTxnURL);
+  }
+
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  uint64_t innerWindowId = cbp ? cbp->GetInnerWindowId() : 0;
+  AUTO_PROFILER_TRACING_MARKER_INNERWINDOWID("Paint", "SetDisplayList",
+                                             GRAPHICS, innerWindowId);
+  UpdateFwdTransactionId(aFwdTransactionId);
+
+  // This ensures that destroy operations are always processed. It is not safe
+  // to early-return from RecvDPEnd without doing so.
+  AutoWebRenderBridgeParentAsyncMessageSender autoAsyncMessageSender(
+      this, &aToDestroy);
+
+  wr::Epoch wrEpoch = GetNextWrEpoch();
+
+  mReceivedDisplayList = true;
+
+  if (aDisplayList.mScrollData && aDisplayList.mScrollData->IsFirstPaint()) {
+    mIsFirstPaint = true;
+  }
+
+  bool validTransaction = aDisplayList.mIdNamespace == mIdNamespace;
+  bool observeLayersUpdate = ShouldParentObserveEpoch();
+
+  bool success = ProcessDisplayListData(aDisplayList, wrEpoch, aTxnStartTime,
+                                        validTransaction, observeLayersUpdate);
+
+  if (!validTransaction && observeLayersUpdate) {
+    mCompositorBridge->ObserveLayersUpdate(GetLayersId(),
+                                           mChildLayersObserverEpoch, true);
+  }
+
+  if (!IsRootWebRenderBridgeParent()) {
+    aPayloads.AppendElement(
+        CompositionPayload{CompositionPayloadType::eContentPaint, aFwdTime});
+  }
+
+  HoldPendingTransactionId(wrEpoch, aTransactionId, aContainsSVGGroup, aVsyncId,
+                           aVsyncStartTime, aRefreshStartTime, aTxnStartTime,
+                           aTxnURL, aFwdTime, mIsFirstPaint,
+                           std::move(aPayloads));
+  mIsFirstPaint = false;
+
+  if (!validTransaction) {
+    // Pretend we composited since someone is wating for this event,
+    // though DisplayList was not pushed to webrender.
+    if (CompositorBridgeParent* cbp = GetRootCompositorBridgeParent()) {
+      TimeStamp now = TimeStamp::Now();
+      cbp->NotifyPipelineRendered(mPipelineId, wrEpoch, VsyncId(), now, now,
+                                  now);
+    }
+  }
+
+  wr::IpcResourceUpdateQueue::ReleaseShmems(this, aDisplayList.mSmallShmems);
+  wr::IpcResourceUpdateQueue::ReleaseShmems(this, aDisplayList.mLargeShmems);
+
+  if (!success) {
+    return IPC_FAIL(this, "Failed to process DisplayListData.");
+  }
+
+  return IPC_OK();
+}
+
+bool WebRenderBridgeParent::ProcessEmptyTransactionUpdates(
+    TransactionData& aData, bool* aScheduleComposite) {
+  *aScheduleComposite = false;
+  wr::TransactionBuilder txn(mApi);
+  txn.SetLowPriority(!IsRootWebRenderBridgeParent());
+
+  if (!aData.mScrollUpdates.IsEmpty()) {
+    UpdateAPZScrollOffsets(std::move(aData.mScrollUpdates),
+                           aData.mPaintSequenceNumber);
+  }
+
+  // Update WrEpoch for UpdateResources() and ProcessWebRenderParentCommands().
+  // WrEpoch is used to manage ExternalImages lifetimes in
+  // AsyncImagePipelineManager.
+  Unused << GetNextWrEpoch();
+
+  const bool validTransaction = aData.mIdNamespace == mIdNamespace;
+  bool success = true;
+
+  if (validTransaction) {
+    success = UpdateResources(aData.mResourceUpdates, aData.mSmallShmems,
+                              aData.mLargeShmems, txn);
+    if (!aData.mCommands.IsEmpty()) {
+      success = ProcessWebRenderParentCommands(aData.mCommands, txn) && success;
+    }
+  }
+
+  if (ShouldParentObserveEpoch()) {
+    txn.Notify(
+        wr::Checkpoint::SceneBuilt,
+        MakeUnique<ScheduleObserveLayersUpdate>(
+            mCompositorBridge, GetLayersId(), mChildLayersObserverEpoch, true));
+  }
+
+  // Even when txn.IsResourceUpdatesEmpty() is true, there could be resource
+  // updates. It is handled by WebRenderTextureHostWrapper. In this case
+  // txn.IsRenderedFrameInvalidated() becomes true.
+  if (!txn.IsResourceUpdatesEmpty() || txn.IsRenderedFrameInvalidated()) {
+    // There are resource updates, then we update Epoch of transaction.
+    txn.UpdateEpoch(mPipelineId, mWrEpoch);
+    *aScheduleComposite = true;
+  } else {
+    // If TransactionBuilder does not have resource updates nor display list,
+    // ScheduleGenerateFrame is not triggered via SceneBuilder and there is no
+    // need to update WrEpoch.
+    // Then we want to rollback WrEpoch. See Bug 1490117.
+    RollbackWrEpoch();
+  }
+
+  if (!txn.IsEmpty()) {
+    mApi->SendTransaction(txn);
+  }
+
+  if (*aScheduleComposite) {
+    mAsyncImageManager->SetWillGenerateFrame();
+  }
+
+  return success;
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvEmptyTransaction(
+    const FocusTarget& aFocusTarget, Maybe<TransactionData>&& aTransactionData,
+    nsTArray<OpDestroy>&& aToDestroy, const uint64_t& aFwdTransactionId,
+    const TransactionId& aTransactionId, const VsyncId& aVsyncId,
+    const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+    const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+    const TimeStamp& aFwdTime, nsTArray<CompositionPayload>&& aPayloads) {
+  if (mDestroyed) {
+    for (const auto& op : aToDestroy) {
+      DestroyActor(op);
+    }
+    if (aTransactionData) {
+      wr::IpcResourceUpdateQueue::ReleaseShmems(this,
+                                                aTransactionData->mSmallShmems);
+      wr::IpcResourceUpdateQueue::ReleaseShmems(this,
+                                                aTransactionData->mLargeShmems);
+    }
+    return IPC_OK();
+  }
+
+  LOG("WebRenderBridgeParent::RecvEmptyTransaction() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  if (!IsRootWebRenderBridgeParent()) {
+    CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::URL, aTxnURL);
+  }
+
+  AUTO_PROFILER_TRACING_MARKER("Paint", "EmptyTransaction", GRAPHICS);
+  UpdateFwdTransactionId(aFwdTransactionId);
+
+  // This ensures that destroy operations are always processed. It is not safe
+  // to early-return without doing so.
+  AutoWebRenderBridgeParentAsyncMessageSender autoAsyncMessageSender(
+      this, &aToDestroy);
+
+  UpdateAPZFocusState(aFocusTarget);
+
+  bool scheduleAnyComposite = false;
+  wr::RenderReasons renderReasons = wr::RenderReasons::NONE;
+
+  bool success = true;
+  if (aTransactionData) {
+    bool scheduleComposite = false;
+    success =
+        ProcessEmptyTransactionUpdates(*aTransactionData, &scheduleComposite);
+    scheduleAnyComposite = scheduleAnyComposite || scheduleComposite;
+    renderReasons |= wr::RenderReasons::RESOURCE_UPDATE;
+  }
+
+  // If we are going to kick off a new composite as a result of this
+  // transaction, or if there are already composite-triggering pending
+  // transactions inflight, then set sendDidComposite to false because we will
+  // send the DidComposite message after the composite occurs.
+  // If there are no pending transactions and we're not going to do a
+  // composite, then we leave sendDidComposite as true so we just send
+  // the DidComposite notification now.
+  bool sendDidComposite =
+      !scheduleAnyComposite && mPendingTransactionIds.empty();
+
+  // Only register a value for CONTENT_FRAME_TIME telemetry if we actually drew
+  // something. It is for consistency with disabling WebRender.
+  HoldPendingTransactionId(mWrEpoch, aTransactionId, false, aVsyncId,
+                           aVsyncStartTime, aRefreshStartTime, aTxnStartTime,
+                           aTxnURL, aFwdTime,
+                           /* aIsFirstPaint */ false, std::move(aPayloads),
+                           /* aUseForTelemetry */ scheduleAnyComposite);
+
+  if (scheduleAnyComposite) {
+    ScheduleGenerateFrame(renderReasons);
+  } else if (sendDidComposite) {
+    // The only thing in the pending transaction id queue should be the entry
+    // we just added, and now we're going to pretend we rendered it
+    MOZ_ASSERT(mPendingTransactionIds.size() == 1);
+    if (CompositorBridgeParent* cbp = GetRootCompositorBridgeParent()) {
+      TimeStamp now = TimeStamp::Now();
+      cbp->NotifyPipelineRendered(mPipelineId, mWrEpoch, VsyncId(), now, now,
+                                  now);
+    }
+  }
+
+  if (aTransactionData) {
+    wr::IpcResourceUpdateQueue::ReleaseShmems(this,
+                                              aTransactionData->mSmallShmems);
+    wr::IpcResourceUpdateQueue::ReleaseShmems(this,
+                                              aTransactionData->mLargeShmems);
+  }
+
+  if (!success) {
+    return IPC_FAIL(this, "Failed to process empty transaction update.");
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSetFocusTarget(
+    const FocusTarget& aFocusTarget) {
+  UpdateAPZFocusState(aFocusTarget);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvParentCommands(
+    const wr::IdNamespace& aIdNamespace,
+    nsTArray<WebRenderParentCommand>&& aCommands) {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+
+  const bool isValidMessage = aIdNamespace == mIdNamespace;
+  if (!isValidMessage) {
+    return IPC_OK();
+  }
+
+  LOG("WebRenderBridgeParent::RecvParentCommands() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  wr::TransactionBuilder txn(mApi);
+  txn.SetLowPriority(!IsRootWebRenderBridgeParent());
+  bool success = ProcessWebRenderParentCommands(aCommands, txn);
+  mApi->SendTransaction(txn);
+
+  if (!success) {
+    return IPC_FAIL(this, "Invalid parent command found");
+  }
+
+  return IPC_OK();
+}
+
+bool WebRenderBridgeParent::ProcessWebRenderParentCommands(
+    const nsTArray<WebRenderParentCommand>& aCommands,
+    wr::TransactionBuilder& aTxn) {
+  // Transaction for async image pipeline that uses ImageBridge always need to
+  // be non low priority.
+  wr::TransactionBuilder txnForImageBridge(mApi);
+  wr::AutoTransactionSender sender(mApi, &txnForImageBridge);
+
+  bool success = true;
+  for (nsTArray<WebRenderParentCommand>::index_type i = 0;
+       i < aCommands.Length(); ++i) {
+    const WebRenderParentCommand& cmd = aCommands[i];
+    switch (cmd.type()) {
+      case WebRenderParentCommand::TOpAddPipelineIdForCompositable: {
+        const OpAddPipelineIdForCompositable& op =
+            cmd.get_OpAddPipelineIdForCompositable();
+        AddPipelineIdForCompositable(op.pipelineId(), op.handle(), op.owner(),
+                                     aTxn, txnForImageBridge);
+        break;
+      }
+      case WebRenderParentCommand::TOpRemovePipelineIdForCompositable: {
+        const OpRemovePipelineIdForCompositable& op =
+            cmd.get_OpRemovePipelineIdForCompositable();
+        RemovePipelineIdForCompositable(op.pipelineId(), aTxn);
+        break;
+      }
+      case WebRenderParentCommand::TOpReleaseTextureOfImage: {
+        const OpReleaseTextureOfImage& op = cmd.get_OpReleaseTextureOfImage();
+        ReleaseTextureOfImage(op.key());
+        break;
+      }
+      case WebRenderParentCommand::TOpUpdateAsyncImagePipeline: {
+        const OpUpdateAsyncImagePipeline& op =
+            cmd.get_OpUpdateAsyncImagePipeline();
+        mAsyncImageManager->UpdateAsyncImagePipeline(
+            op.pipelineId(), op.scBounds(), op.rotation(), op.filter(),
+            op.mixBlendMode());
+        auto* list = mApi->GetPendingRemoteTextureInfoList();
+        MOZ_ASSERT_IF(IsRootWebRenderBridgeParent(), !list);
+        mAsyncImageManager->ApplyAsyncImageForPipeline(op.pipelineId(), aTxn,
+                                                       txnForImageBridge, list);
+        break;
+      }
+      case WebRenderParentCommand::TOpUpdatedAsyncImagePipeline: {
+        const OpUpdatedAsyncImagePipeline& op =
+            cmd.get_OpUpdatedAsyncImagePipeline();
+        aTxn.InvalidateRenderedFrame(wr::RenderReasons::ASYNC_IMAGE);
+        auto* list = mApi->GetPendingRemoteTextureInfoList();
+        MOZ_ASSERT_IF(IsRootWebRenderBridgeParent(), !list);
+        mAsyncImageManager->ApplyAsyncImageForPipeline(op.pipelineId(), aTxn,
+                                                       txnForImageBridge, list);
+        break;
+      }
+      case WebRenderParentCommand::TCompositableOperation: {
+        if (!ReceiveCompositableUpdate(cmd.get_CompositableOperation())) {
+          NS_ERROR("ReceiveCompositableUpdate failed");
+        }
+        break;
+      }
+      case WebRenderParentCommand::TOpAddCompositorAnimations: {
+        const OpAddCompositorAnimations& op =
+            cmd.get_OpAddCompositorAnimations();
+        CompositorAnimations data(std::move(op.data()));
+        // AnimationHelper::GetNextCompositorAnimationsId() encodes the child
+        // process PID in the upper 32 bits of the id, verify that this is as
+        // expected.
+        if ((data.id() >> 32) != (uint64_t)OtherPid()) {
+          gfxCriticalNote << "TOpAddCompositorAnimations bad id";
+          success = false;
+          continue;
+        }
+        if (data.animations().Length()) {
+          if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+            sampler->SetAnimations(data.id(), GetLayersId(), data.animations());
+            const auto activeAnim = mActiveAnimations.find(data.id());
+            if (activeAnim == mActiveAnimations.end()) {
+              mActiveAnimations.emplace(data.id(), mWrEpoch);
+            } else {
+              // Update wr::Epoch if the animation already exists.
+              activeAnim->second = mWrEpoch;
+            }
+          }
+        }
+        break;
+      }
+      default: {
+        // other commands are handle on the child
+        break;
+      }
+    }
+  }
+
+  MOZ_ASSERT(success);
+  return success;
+}
+
+void WebRenderBridgeParent::FlushSceneBuilds() {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+  // Since we are sending transactions through the scene builder thread, we need
+  // to block until all the inflight transactions have been processed. This
+  // flush message blocks until all previously sent scenes have been built
+  // and received by the render backend thread.
+  mApi->FlushSceneBuilder();
+  // The post-swap hook for async-scene-building calls the
+  // ScheduleRenderOnCompositorThread function from the scene builder thread,
+  // which then triggers a call to ScheduleGenerateFrame() on the compositor
+  // thread. But since *this* function is running on the compositor thread,
+  // that scheduling will not happen until this call stack unwinds (or we
+  // could spin a nested event loop, but that's more messy). Instead, we
+  // simulate it ourselves by calling ScheduleGenerateFrame() directly.
+  // Note also that the post-swap hook will run and do another
+  // ScheduleGenerateFrame() after we unwind here, so we will end up with an
+  // extra render/composite that is probably avoidable, but in practice we
+  // shouldn't be calling this function all that much in production so this
+  // is probably fine. If it becomes an issue we can add more state tracking
+  // machinery to optimize it away.
+  ScheduleGenerateFrame(wr::RenderReasons::FLUSH);
+}
+
+void WebRenderBridgeParent::FlushFrameGeneration(wr::RenderReasons aReasons) {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());  // This function is only useful on
+                                              // the root WRBP
+
+  // This forces a new GenerateFrame transaction to be sent to the render
+  // backend thread, if one is pending. This doesn't block on any other threads.
+  if (mCompositorScheduler->NeedsComposite()) {
+    mCompositorScheduler->CancelCurrentCompositeTask();
+    // Update timestamp of scheduler for APZ and animation.
+    mCompositorScheduler->UpdateLastComposeTime();
+    MaybeGenerateFrame(VsyncId(), /* aForceGenerateFrame */ true,
+                       aReasons | wr::RenderReasons::FLUSH);
+  }
+}
+
+void WebRenderBridgeParent::FlushFramePresentation() {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+  // This sends a message to the render backend thread to send a message
+  // to the renderer thread, and waits for that message to be processed. So
+  // this effectively blocks on the render backend and renderer threads,
+  // following the same codepath that WebRender takes to render and composite
+  // a frame.
+  mApi->WaitFlushed();
+}
+
+void WebRenderBridgeParent::DisableNativeCompositor() {
+  // Make sure that SceneBuilder thread does not have a task.
+  mApi->FlushSceneBuilder();
+  // Disable WebRender's native compositor usage
+  mApi->EnableNativeCompositor(false);
+  // Ensure we generate and render a frame immediately.
+  ScheduleForcedGenerateFrame(wr::RenderReasons::CONFIG_CHANGE);
+
+  mDisablingNativeCompositor = true;
+}
+
+void WebRenderBridgeParent::UpdateQualitySettings() {
+  if (!IsRootWebRenderBridgeParent()) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return;
+  }
+  wr::TransactionBuilder txn(mApi);
+  txn.UpdateQualitySettings(gfxVars::ForceSubpixelAAWherePossible());
+  mApi->SendTransaction(txn);
+}
+
+void WebRenderBridgeParent::UpdateDebugFlags() {
+  if (!IsRootWebRenderBridgeParent()) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return;
+  }
+
+  mApi->UpdateDebugFlags(gfxVars::WebRenderDebugFlags());
+}
+
+void WebRenderBridgeParent::UpdateProfilerUI() {
+  if (!IsRootWebRenderBridgeParent()) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return;
+  }
+
+  nsCString uiString = gfxVars::GetWebRenderProfilerUIOrDefault();
+  mApi->SetProfilerUI(uiString);
+}
+
+void WebRenderBridgeParent::UpdateParameters() {
+  if (!IsRootWebRenderBridgeParent()) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return;
+  }
+
+  uint32_t count = gfxVars::WebRenderBatchingLookback();
+  mApi->SetBatchingLookback(count);
+  mApi->SetInt(wr::IntParameter::BatchedUploadThreshold,
+               gfxVars::WebRenderBatchedUploadThreshold());
+
+  mBlobTileSize = gfxVars::WebRenderBlobTileSize();
+}
+
+void WebRenderBridgeParent::UpdateBoolParameters() {
+  if (!IsRootWebRenderBridgeParent()) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return;
+  }
+
+  uint32_t bits = gfxVars::WebRenderBoolParameters();
+  uint32_t changedBits = mBoolParameterBits ^ bits;
+
+  for (auto paramName : MakeEnumeratedRange(wr::BoolParameter::Sentinel)) {
+    uint32_t i = (uint32_t)paramName;
+    if (changedBits & (1 << i)) {
+      bool value = (bits & (1 << i)) != 0;
+      mApi->SetBool(paramName, value);
+    }
+  }
+  mBoolParameterBits = bits;
+}
+
+#if defined(MOZ_WIDGET_ANDROID)
+void WebRenderBridgeParent::RequestScreenPixels(
+    UiCompositorControllerParent* aController) {
+  mScreenPixelsTarget = aController;
+}
+
+void WebRenderBridgeParent::MaybeCaptureScreenPixels() {
+  if (!mScreenPixelsTarget) {
+    return;
+  }
+
+  if (mDestroyed) {
+    return;
+  }
+
+  if (auto* cbp = GetRootCompositorBridgeParent()) {
+    cbp->FlushPendingWrTransactionEventsWithWait();
+  }
+
+  // This function should only get called in the root WRBP.
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+#  ifdef DEBUG
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  MOZ_ASSERT(cbp && !cbp->IsPaused());
+#  endif
+
+  SurfaceFormat format = SurfaceFormat::R8G8B8A8;  // On android we use RGBA8
+  auto client_size = mWidget->GetClientSize();
+  size_t buffer_size =
+      client_size.width * client_size.height * BytesPerPixel(format);
+
+  ipc::Shmem mem;
+  if (!mScreenPixelsTarget->AllocPixelBuffer(buffer_size, &mem)) {
+    // Failed to alloc shmem, Just bail out.
+    return;
+  }
+
+  IntSize size(client_size.width, client_size.height);
+
+  bool needsYFlip = false;
+  mApi->Readback(TimeStamp::Now(), size, format,
+                 Range<uint8_t>(mem.get<uint8_t>(), buffer_size), &needsYFlip);
+
+  Unused << mScreenPixelsTarget->SendScreenPixels(
+      std::move(mem), ScreenIntSize(client_size.width, client_size.height),
+      needsYFlip);
+
+  mScreenPixelsTarget = nullptr;
+}
+#endif
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvGetSnapshot(
+    NotNull<PTextureParent*> aTexture, bool* aNeedsYFlip) {
+  *aNeedsYFlip = false;
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  if (mDestroyed || !cbp || cbp->IsPaused()) {
+    return IPC_OK();
+  }
+
+  if (auto* cbp = GetRootCompositorBridgeParent()) {
+    cbp->FlushPendingWrTransactionEventsWithWait();
+  }
+
+  LOG("WebRenderBridgeParent::RecvGetSnapshot() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  // This function should only get called in the root WRBP. If this function
+  // gets called in a non-root WRBP, we will set mForceRendering in this WRBP
+  // but it will have no effect because CompositeToTarget (which reads the
+  // flag) only gets invoked in the root WRBP. So we assert that this is the
+  // root WRBP (i.e. has a non-null mWidget) to catch violations of this rule.
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+
+  RefPtr<TextureHost> texture = TextureHost::AsTextureHost(aTexture);
+  if (!texture) {
+    // We kill the content process rather than have it continue with an invalid
+    // snapshot, that may be too harsh and we could decide to return some sort
+    // of error to the child process and let it deal with it...
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  // XXX Add other TextureHost supports.
+  // Only BufferTextureHost is supported now.
+  BufferTextureHost* bufferTexture = texture->AsBufferTextureHost();
+  if (!bufferTexture) {
+    // We kill the content process rather than have it continue with an invalid
+    // snapshot, that may be too harsh and we could decide to return some sort
+    // of error to the child process and let it deal with it...
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  TimeStamp start = TimeStamp::Now();
+  MOZ_ASSERT(bufferTexture->GetBufferDescriptor().type() ==
+             BufferDescriptor::TRGBDescriptor);
+  DebugOnly<uint32_t> stride = ImageDataSerializer::GetRGBStride(
+      bufferTexture->GetBufferDescriptor().get_RGBDescriptor());
+  uint8_t* buffer = bufferTexture->GetBuffer();
+  IntSize size = bufferTexture->GetSize();
+
+  MOZ_ASSERT(buffer);
+  // For now the only formats we get here are RGBA and BGRA, and code below is
+  // assuming a bpp of 4. If we allow other formats, the code needs adjusting
+  // accordingly.
+  MOZ_ASSERT(BytesPerPixel(bufferTexture->GetFormat()) == 4);
+  uint32_t buffer_size = size.width * size.height * 4;
+
+  // Assert the stride of the buffer is what webrender expects
+  MOZ_ASSERT((uint32_t)(size.width * 4) == stride);
+
+  FlushSceneBuilds();
+  FlushFrameGeneration(wr::RenderReasons::SNAPSHOT);
+  mApi->Readback(start, size, bufferTexture->GetFormat(),
+                 Range<uint8_t>(buffer, buffer_size), aNeedsYFlip);
+
+  return IPC_OK();
+}
+
+void WebRenderBridgeParent::AddPipelineIdForCompositable(
+    const wr::PipelineId& aPipelineId, const CompositableHandle& aHandle,
+    const CompositableHandleOwner& aOwner, wr::TransactionBuilder& aTxn,
+    wr::TransactionBuilder& aTxnForImageBridge) {
+  if (mDestroyed) {
+    return;
+  }
+
+  MOZ_ASSERT(mAsyncCompositables.find(wr::AsUint64(aPipelineId)) ==
+             mAsyncCompositables.end());
+
+  RefPtr<CompositableHost> host;
+  switch (aOwner) {
+    case CompositableHandleOwner::WebRenderBridge:
+      host = FindCompositable(aHandle);
+      break;
+    case CompositableHandleOwner::ImageBridge: {
+      RefPtr<ImageBridgeParent> imageBridge =
+          ImageBridgeParent::GetInstance(OtherPid());
+      if (!imageBridge) {
+        return;
+      }
+      host = imageBridge->FindCompositable(aHandle);
+      break;
+    }
+  }
+
+  if (!host) {
+    return;
+  }
+
+  WebRenderImageHost* wrHost = host->AsWebRenderImageHost();
+  MOZ_ASSERT(wrHost);
+  if (!wrHost) {
+    gfxCriticalNote
+        << "Incompatible CompositableHost at WebRenderBridgeParent.";
+  }
+
+  if (!wrHost) {
+    return;
+  }
+
+  wrHost->SetWrBridge(aPipelineId, this);
+  mAsyncCompositables.emplace(wr::AsUint64(aPipelineId), wrHost);
+  mAsyncImageManager->AddAsyncImagePipeline(aPipelineId, wrHost);
+
+  // If this is being called from WebRenderBridgeParent::RecvSetDisplayList,
+  // then aTxn might contain a display list that references pipelines that
+  // we just added to the async image manager.
+  // If we send the display list alone then WR will not yet have the content for
+  // the pipelines and so it will emit errors; the SetEmptyDisplayList call
+  // below ensure that we provide its content to WR as part of the same
+  // transaction.
+  mAsyncImageManager->SetEmptyDisplayList(aPipelineId, aTxn,
+                                          aTxnForImageBridge);
+}
+
+void WebRenderBridgeParent::RemovePipelineIdForCompositable(
+    const wr::PipelineId& aPipelineId, wr::TransactionBuilder& aTxn) {
+  if (mDestroyed) {
+    return;
+  }
+
+  auto it = mAsyncCompositables.find(wr::AsUint64(aPipelineId));
+  if (it == mAsyncCompositables.end()) {
+    return;
+  }
+  RefPtr<WebRenderImageHost>& wrHost = it->second;
+
+  wrHost->ClearWrBridge(aPipelineId, this);
+  mAsyncImageManager->RemoveAsyncImagePipeline(aPipelineId, aTxn);
+  aTxn.RemovePipeline(aPipelineId);
+  mAsyncCompositables.erase(wr::AsUint64(aPipelineId));
+}
+
+void WebRenderBridgeParent::DeleteImage(const ImageKey& aKey,
+                                        wr::TransactionBuilder& aUpdates) {
+  if (mDestroyed) {
+    return;
+  }
+
+  auto it = mSharedSurfaceIds.find(wr::AsUint64(aKey));
+  if (it != mSharedSurfaceIds.end()) {
+    mAsyncImageManager->HoldExternalImage(mPipelineId, mWrEpoch, it->second);
+    mSharedSurfaceIds.erase(it);
+  }
+
+  aUpdates.DeleteImage(aKey);
+}
+
+void WebRenderBridgeParent::ReleaseTextureOfImage(const wr::ImageKey& aKey) {
+  if (mDestroyed) {
+    return;
+  }
+
+  uint64_t id = wr::AsUint64(aKey);
+  CompositableTextureHostRef texture;
+  WebRenderTextureHost* wrTexture = nullptr;
+
+  auto it = mTextureHosts.find(id);
+  if (it != mTextureHosts.end()) {
+    wrTexture = (*it).second->AsWebRenderTextureHost();
+  }
+  if (wrTexture) {
+    mAsyncImageManager->HoldExternalImage(mPipelineId, mWrEpoch, wrTexture);
+  }
+  mTextureHosts.erase(id);
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSetLayersObserverEpoch(
+    const LayersObserverEpoch& aChildEpoch) {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+  mChildLayersObserverEpoch = aChildEpoch;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvClearCachedResources() {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+
+  LOG("WebRenderBridgeParent::RecvClearCachedResources() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  // Clear resources
+  wr::TransactionBuilder txn(mApi);
+  txn.SetLowPriority(true);
+  txn.ClearDisplayList(GetNextWrEpoch(), mPipelineId);
+  txn.Notify(
+      wr::Checkpoint::SceneBuilt,
+      MakeUnique<ScheduleObserveLayersUpdate>(
+          mCompositorBridge, GetLayersId(), mChildLayersObserverEpoch, false));
+  mApi->SendTransaction(txn);
+
+  // Schedule generate frame to clean up Pipeline
+  ScheduleGenerateFrame(wr::RenderReasons::CLEAR_RESOURCES);
+
+  ClearAnimationResources();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvClearAnimationResources() {
+  if (!mDestroyed) {
+    ClearAnimationResources();
+  }
+
+  return IPC_OK();
+}
+
+wr::Epoch WebRenderBridgeParent::UpdateWebRender(
+    CompositorVsyncScheduler* aScheduler, RefPtr<wr::WebRenderAPI>&& aApi,
+    AsyncImagePipelineManager* aImageMgr,
+    const TextureFactoryIdentifier& aTextureFactoryIdentifier) {
+  MOZ_ASSERT(!IsRootWebRenderBridgeParent());
+  MOZ_ASSERT(aScheduler);
+  MOZ_ASSERT(aApi);
+  MOZ_ASSERT(aImageMgr);
+
+  if (mDestroyed) {
+    return mWrEpoch;
+  }
+
+  // Update id name space to identify obsoleted keys.
+  // Since usage of invalid keys could cause crash in webrender.
+  mIdNamespace = aApi->GetNamespace();
+  // XXX Remove it when webrender supports sharing/moving Keys between different
+  // webrender instances.
+  // XXX It requests client to update/reallocate webrender related resources,
+  // but parent side does not wait end of the update.
+  // The code could become simpler if we could serialise old keys deallocation
+  // and new keys allocation. But we do not do it, it is because client side
+  // deallocate old layers/webrender keys after new layers/webrender keys
+  // allocation. Without client side's layout refactoring, we could not finish
+  // all old layers/webrender keys removals before new layer/webrender keys
+  // allocation. In future, we could address the problem.
+  Unused << SendWrUpdated(mIdNamespace, aTextureFactoryIdentifier);
+  CompositorBridgeParentBase* cBridge = mCompositorBridge;
+  // XXX Stop to clear resources if webreder supports resources sharing between
+  // different webrender instances.
+  ClearResources();
+  mCompositorBridge = cBridge;
+  mCompositorScheduler = aScheduler;
+  mApi = aApi;
+  mAsyncImageManager = aImageMgr;
+
+  // Register pipeline to updated AsyncImageManager.
+  mAsyncImageManager->AddPipeline(mPipelineId, this);
+
+  LOG("WebRenderBridgeParent::UpdateWebRender() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  return GetNextWrEpoch();  // Update webrender epoch
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvInvalidateRenderedFrame() {
+  // This function should only get called in the root WRBP
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+  LOG("WebRenderBridgeParent::RecvInvalidateRenderedFrame() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  InvalidateRenderedFrame(wr::RenderReasons::WIDGET);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvScheduleComposite(
+    const wr::RenderReasons& aReasons) {
+  LOG("WebRenderBridgeParent::RecvScheduleComposite() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  // Caller of LayerManager::ScheduleComposite() expects that it trigger
+  // composite. Then we do not want to skip generate frame.
+  ScheduleForcedGenerateFrame(aReasons);
+  return IPC_OK();
+}
+
+void WebRenderBridgeParent::InvalidateRenderedFrame(
+    wr::RenderReasons aReasons) {
+  if (mDestroyed) {
+    return;
+  }
+
+  wr::TransactionBuilder fastTxn(mApi, /* aUseSceneBuilderThread */ false);
+  fastTxn.InvalidateRenderedFrame(aReasons);
+  mApi->SendTransaction(fastTxn);
+}
+
+void WebRenderBridgeParent::ScheduleForcedGenerateFrame(
+    wr::RenderReasons aReasons) {
+  if (mDestroyed) {
+    return;
+  }
+
+  InvalidateRenderedFrame(aReasons);
+  ScheduleGenerateFrame(aReasons);
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvCapture() {
+  if (!mDestroyed) {
+    mApi->Capture();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvStartCaptureSequence(
+    const nsACString& aPath, const uint32_t& aFlags) {
+  if (!mDestroyed) {
+    mApi->StartCaptureSequence(aPath, aFlags);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvStopCaptureSequence() {
+  if (!mDestroyed) {
+    mApi->StopCaptureSequence();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSyncWithCompositor() {
+  LOG("WebRenderBridgeParent::RecvSyncWithCompositor() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+
+  FlushSceneBuilds();
+  if (RefPtr<WebRenderBridgeParent> root = GetRootWebRenderBridgeParent()) {
+    root->FlushFrameGeneration(wr::RenderReasons::CONTENT_SYNC);
+  }
+  FlushFramePresentation();
+  // Finally, we force the AsyncImagePipelineManager to handle all the
+  // pipeline updates produced in the last step, so that it frees any
+  // unneeded textures. Then we can return from this sync IPC call knowing
+  // that we've done everything we can to flush stuff on the compositor.
+  mAsyncImageManager->ProcessPipelineUpdates();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSetConfirmedTargetAPZC(
+    const uint64_t& aBlockId, nsTArray<ScrollableLayerGuid>&& aTargets) {
+  for (size_t i = 0; i < aTargets.Length(); i++) {
+    // Guard against bad data from hijacked child processes
+    if (aTargets[i].mLayersId != GetLayersId()) {
+      NS_ERROR(
+          "Unexpected layers id in RecvSetConfirmedTargetAPZC; dropping "
+          "message...");
+      return IPC_FAIL(this, "Bad layers id");
+    }
+  }
+
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+  mCompositorBridge->SetConfirmedTargetAPZC(GetLayersId(), aBlockId,
+                                            std::move(aTargets));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSetTestSampleTime(
+    const TimeStamp& aTime) {
+  if (mDestroyed) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  if (!mCompositorBridge->SetTestSampleTime(GetLayersId(), aTime)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+    sampler->EnterTestMode();
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvLeaveTestMode() {
+  if (mDestroyed) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  mCompositorBridge->LeaveTestMode(GetLayersId());
+  if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+    sampler->LeaveTestMode();
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvGetAnimationValue(
+    const uint64_t& aCompositorAnimationsId, OMTAValue* aValue) {
+  if (mDestroyed) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+    Maybe<TimeStamp> testingTimeStamp;
+    if (CompositorBridgeParent* cbp = GetRootCompositorBridgeParent()) {
+      testingTimeStamp = cbp->GetTestingTimeStamp();
+    }
+
+    sampler->SampleForTesting(testingTimeStamp);
+    *aValue = sampler->GetOMTAValue(aCompositorAnimationsId);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSetAsyncScrollOffset(
+    const ScrollableLayerGuid::ViewID& aScrollId, const float& aX,
+    const float& aY) {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+  mCompositorBridge->SetTestAsyncScrollOffset(GetLayersId(), aScrollId,
+                                              CSSPoint(aX, aY));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvSetAsyncZoom(
+    const ScrollableLayerGuid::ViewID& aScrollId, const float& aZoom) {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+  mCompositorBridge->SetTestAsyncZoom(GetLayersId(), aScrollId,
+                                      LayerToParentLayerScale(aZoom));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvFlushApzRepaints() {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+  mCompositorBridge->FlushApzRepaints(GetLayersId());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvGetAPZTestData(
+    APZTestData* aOutData) {
+  if (mDestroyed) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  mCompositorBridge->GetAPZTestData(GetLayersId(), aOutData);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvGetFrameUniformity(
+    FrameUniformityData* aOutData) {
+  if (mDestroyed) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  mCompositorBridge->GetFrameUniformity(GetLayersId(), aOutData);
+  return IPC_OK();
+}
+
+void WebRenderBridgeParent::ActorDestroy(ActorDestroyReason aWhy) { Destroy(); }
+
+void WebRenderBridgeParent::ResetPreviousSampleTime() {
+  if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+    sampler->ResetPreviousSampleTime();
+  }
+}
+
+RefPtr<OMTASampler> WebRenderBridgeParent::GetOMTASampler() const {
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  if (!cbp) {
+    return nullptr;
+  }
+  return cbp->GetOMTASampler();
+}
+
+void WebRenderBridgeParent::SetOMTASampleTime() {
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+  if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+    sampler->SetSampleTime(mCompositorScheduler->GetLastComposeTime().Time());
+  }
+}
+
+void WebRenderBridgeParent::RetrySkippedComposite() {
+  if (!mSkippedComposite) {
+    return;
+  }
+
+  mSkippedComposite = false;
+  if (mCompositorScheduler) {
+    mCompositorScheduler->ScheduleComposition(mSkippedCompositeReasons |
+                                              RenderReasons::SKIPPED_COMPOSITE);
+  }
+  mSkippedCompositeReasons = wr::RenderReasons::NONE;
+}
+
+void WebRenderBridgeParent::CompositeToTarget(VsyncId aId,
+                                              wr::RenderReasons aReasons,
+                                              gfx::DrawTarget* aTarget,
+                                              const gfx::IntRect* aRect) {
+  // This function should only get called in the root WRBP
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+
+  // The two arguments are part of the CompositorVsyncSchedulerOwner API but in
+  // this implementation they should never be non-null.
+  MOZ_ASSERT(aTarget == nullptr);
+  MOZ_ASSERT(aRect == nullptr);
+
+  LOG("WebRenderBridgeParent::CompositeToTarget() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
+  uint64_t innerWindowId = cbp ? cbp->GetInnerWindowId() : 0;
+  AUTO_PROFILER_TRACING_MARKER_INNERWINDOWID("Paint", "CompositeToTarget",
+                                             GRAPHICS, innerWindowId);
+
+  bool paused = true;
+  if (cbp) {
+    paused = cbp->IsPaused();
+  }
+
+  if (paused || !mReceivedDisplayList) {
+    ResetPreviousSampleTime();
+    mCompositionOpportunityId = mCompositionOpportunityId.Next();
+    PROFILER_MARKER_TEXT("Discarded composite", GRAPHICS,
+                         MarkerInnerWindowId(innerWindowId),
+                         paused ? "Paused"_ns : "No display list"_ns);
+    return;
+  }
+
+  mSkippedComposite =
+      wr::RenderThread::Get()->TooManyPendingFrames(mApi->GetId());
+
+  if (mSkippedComposite) {
+    // Render thread is busy, try next time.
+    mSkippedComposite = true;
+    mSkippedCompositeReasons = mSkippedCompositeReasons | aReasons;
+    ResetPreviousSampleTime();
+
+    // Record that we skipped presenting a frame for
+    // all pending transactions that have finished scene building.
+    for (auto& id : mPendingTransactionIds) {
+      if (id.mSceneBuiltTime) {
+        id.mSkippedComposites++;
+      }
+    }
+
+    PROFILER_MARKER_TEXT("SkippedComposite", GRAPHICS,
+                         MarkerInnerWindowId(innerWindowId),
+                         "Too many pending frames");
+
+    Telemetry::ScalarAdd(Telemetry::ScalarID::GFX_SKIPPED_COMPOSITES, 1);
+
+    return;
+  }
+
+  mCompositionOpportunityId = mCompositionOpportunityId.Next();
+  MaybeGenerateFrame(aId, /* aForceGenerateFrame */ false, aReasons);
+}
+
+TimeDuration WebRenderBridgeParent::GetVsyncInterval() const {
+  // This function should only get called in the root WRBP
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+  if (CompositorBridgeParent* cbp = GetRootCompositorBridgeParent()) {
+    return cbp->GetVsyncInterval();
+  }
+  return TimeDuration();
+}
+
+void WebRenderBridgeParent::MaybeGenerateFrame(VsyncId aId,
+                                               bool aForceGenerateFrame,
+                                               wr::RenderReasons aReasons) {
+  // This function should only get called in the root WRBP
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+  LOG("WebRenderBridgeParent::MaybeGenerateFrame() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  if (CompositorBridgeParent* cbp = GetRootCompositorBridgeParent()) {
+    // Skip WR render during paused state.
+    if (cbp->IsPaused()) {
+      TimeStamp now = TimeStamp::Now();
+      PROFILER_MARKER_TEXT(
+          "SkippedComposite", GRAPHICS,
+          MarkerOptions(MarkerInnerWindowId(cbp->GetInnerWindowId()),
+                        MarkerTiming::InstantAt(now)),
+          "CompositorBridgeParent is paused");
+      cbp->NotifyPipelineRendered(mPipelineId, mWrEpoch, VsyncId(), now, now,
+                                  now);
+      return;
+    }
+  }
+
+  TimeStamp start = TimeStamp::Now();
+
+  // Ensure GenerateFrame is handled on the render backend thread rather
+  // than going through the scene builder thread. That way we continue
+  // generating frames with the old scene even during slow scene builds.
+  wr::TransactionBuilder fastTxn(mApi, false /* useSceneBuilderThread */);
+  // Handle transaction that is related to DisplayList.
+  wr::TransactionBuilder sceneBuilderTxn(mApi);
+  wr::AutoTransactionSender sender(mApi, &sceneBuilderTxn);
+
+  mAsyncImageManager->SetCompositionInfo(start, mCompositionOpportunityId);
+  mAsyncImageManager->ApplyAsyncImagesOfImageBridge(sceneBuilderTxn, fastTxn);
+  mAsyncImageManager->SetCompositionInfo(TimeStamp(),
+                                         CompositionOpportunityId{});
+
+  if (!mAsyncImageManager->GetCompositeUntilTime().IsNull()) {
+    // Trigger another CompositeToTarget() call because there might be another
+    // frame that we want to generate after this one.
+    // It will check if we actually want to generate the frame or not.
+    mCompositorScheduler->ScheduleComposition(
+        wr::RenderReasons::ASYNC_IMAGE_COMPOSITE_UNTIL);
+  }
+
+  bool generateFrame = !fastTxn.IsEmpty() || aForceGenerateFrame;
+
+  if (mAsyncImageManager->GetAndResetWillGenerateFrame()) {
+    aReasons |= wr::RenderReasons::ASYNC_IMAGE;
+    generateFrame = true;
+  }
+
+  if (!generateFrame) {
+    // Could skip generating frame now.
+    PROFILER_MARKER_TEXT("SkippedComposite", GRAPHICS,
+                         MarkerTiming::InstantAt(start),
+                         "No reason to generate frame");
+    ResetPreviousSampleTime();
+    return;
+  }
+
+  if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+    if (sampler->HasAnimations()) {
+      ScheduleGenerateFrame(wr::RenderReasons::ANIMATED_PROPERTY);
+    }
+  }
+
+  SetOMTASampleTime();
+  SetAPZSampleTime();
+
+#if defined(ENABLE_FRAME_LATENCY_LOG)
+  auto startTime = TimeStamp::Now();
+  mApi->SetFrameStartTime(startTime);
+#endif
+
+  fastTxn.GenerateFrame(aId, aReasons);
+  wr::RenderThread::Get()->IncPendingFrameCount(mApi->GetId(), aId, start);
+
+  mApi->SendTransaction(fastTxn);
+
+#if defined(MOZ_WIDGET_ANDROID)
+  MaybeCaptureScreenPixels();
+#endif
+
+  mMostRecentComposite = TimeStamp::Now();
+
+  // During disabling native compositor, webrender needs to render twice.
+  // Otherwise, browser flashes black.
+  // XXX better fix?
+  if (mDisablingNativeCompositor) {
+    mDisablingNativeCompositor = false;
+
+    // Ensure we generate and render a frame immediately.
+    ScheduleForcedGenerateFrame(aReasons);
+  }
+}
+
+void WebRenderBridgeParent::HoldPendingTransactionId(
+    const wr::Epoch& aWrEpoch, TransactionId aTransactionId,
+    bool aContainsSVGGroup, const VsyncId& aVsyncId,
+    const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+    const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+    const TimeStamp& aFwdTime, const bool aIsFirstPaint,
+    nsTArray<CompositionPayload>&& aPayloads, const bool aUseForTelemetry) {
+  MOZ_ASSERT(aTransactionId > LastPendingTransactionId());
+  mPendingTransactionIds.push_back(PendingTransactionId(
+      aWrEpoch, aTransactionId, aContainsSVGGroup, aVsyncId, aVsyncStartTime,
+      aRefreshStartTime, aTxnStartTime, aTxnURL, aFwdTime, aIsFirstPaint,
+      aUseForTelemetry, std::move(aPayloads)));
+}
+
+TransactionId WebRenderBridgeParent::LastPendingTransactionId() {
+  TransactionId id{0};
+  if (!mPendingTransactionIds.empty()) {
+    id = mPendingTransactionIds.back().mId;
+  }
+  return id;
+}
+
+void WebRenderBridgeParent::NotifySceneBuiltForEpoch(
+    const wr::Epoch& aEpoch, const TimeStamp& aEndTime) {
+  for (auto& id : mPendingTransactionIds) {
+    if (id.mEpoch.mHandle == aEpoch.mHandle) {
+      id.mSceneBuiltTime = aEndTime;
+      break;
+    }
+  }
+}
+
+void WebRenderBridgeParent::NotifyDidSceneBuild(
+    RefPtr<const wr::WebRenderPipelineInfo> aInfo) {
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+  if (!mCompositorScheduler) {
+    return;
+  }
+
+  mAsyncImageManager->SetWillGenerateFrame();
+
+  // If the scheduler has a composite more recent than our last composite (which
+  // we missed), and we're within the threshold ms of the last vsync, then
+  // kick of a late composite.
+  TimeStamp lastVsync = mCompositorScheduler->GetLastVsyncTime();
+  VsyncId lastVsyncId = mCompositorScheduler->GetLastVsyncId();
+  if (lastVsyncId == VsyncId() || !mMostRecentComposite ||
+      mMostRecentComposite >= lastVsync ||
+      ((TimeStamp::Now() - lastVsync).ToMilliseconds() >
+       StaticPrefs::gfx_webrender_late_scenebuild_threshold())) {
+    mCompositorScheduler->ScheduleComposition(wr::RenderReasons::SCENE);
+    return;
+  }
+
+  // Look through all the pipelines contained within the built scene
+  // and check which vsync they initiated from.
+  const auto& info = aInfo->Raw();
+  for (const auto& epoch : info.epochs) {
+    WebRenderBridgeParent* wrBridge = this;
+    if (!(epoch.pipeline_id == PipelineId())) {
+      wrBridge = mAsyncImageManager->GetWrBridge(epoch.pipeline_id);
+    }
+
+    if (wrBridge) {
+      VsyncId startId = wrBridge->GetVsyncIdForEpoch(epoch.epoch);
+      // If any of the pipelines started building on the current vsync (i.e
+      // we did all of display list building and scene building within the
+      // threshold), then don't do an early composite.
+      if (startId == lastVsyncId) {
+        mCompositorScheduler->ScheduleComposition(wr::RenderReasons::SCENE);
+        return;
+      }
+    }
+  }
+
+  CompositeToTarget(mCompositorScheduler->GetLastVsyncId(),
+                    wr::RenderReasons::SCENE, nullptr, nullptr);
+}
+
+static Telemetry::HistogramID GetHistogramId(const bool aIsLargePaint,
+                                             const bool aIsFullDisplayList) {
+  const Telemetry::HistogramID histogramIds[] = {
+      Telemetry::CONTENT_SMALL_PAINT_PHASE_WEIGHT_PARTIAL,
+      Telemetry::CONTENT_LARGE_PAINT_PHASE_WEIGHT_PARTIAL,
+      Telemetry::CONTENT_SMALL_PAINT_PHASE_WEIGHT_FULL,
+      Telemetry::CONTENT_LARGE_PAINT_PHASE_WEIGHT_FULL,
+  };
+
+  return histogramIds[(aIsFullDisplayList * 2) + aIsLargePaint];
+}
+
+static void RecordPaintPhaseTelemetry(wr::RendererStats* aStats) {
+  if (!aStats || !aStats->full_paint) {
+    return;
+  }
+
+  const double geckoDL = aStats->gecko_display_list_time;
+  const double wrDL = aStats->wr_display_list_time;
+  const double sceneBuild = aStats->scene_build_time;
+  const double frameBuild = aStats->frame_build_time;
+  const double totalMs = geckoDL + wrDL + sceneBuild + frameBuild;
+
+  // If the total time was >= 16ms, then it's likely we missed a frame due to
+  // painting. We bucket these metrics separately.
+  const bool isLargePaint = totalMs >= 16.0;
+
+  // Split the results based on display list build type, partial or full.
+  const bool isFullDisplayList = aStats->full_display_list;
+
+  auto AsPercentage = [&](const double aTimeMs) -> double {
+    MOZ_ASSERT(aTimeMs <= totalMs);
+    return (aTimeMs / totalMs) * 100.0;
+  };
+
+  auto RecordKey = [&](const nsCString& aKey, const double aTimeMs) -> void {
+    const auto val = static_cast<uint32_t>(AsPercentage(aTimeMs));
+    const auto histogramId = GetHistogramId(isLargePaint, isFullDisplayList);
+    Telemetry::Accumulate(histogramId, aKey, val);
+  };
+
+  RecordKey("dl"_ns, geckoDL);
+  RecordKey("wrdl"_ns, wrDL);
+  RecordKey("sb"_ns, sceneBuild);
+  RecordKey("fb"_ns, frameBuild);
+}
+
+void WebRenderBridgeParent::FlushTransactionIdsForEpoch(
+    const wr::Epoch& aEpoch, const VsyncId& aCompositeStartId,
+    const TimeStamp& aCompositeStartTime, const TimeStamp& aRenderStartTime,
+    const TimeStamp& aEndTime, UiCompositorControllerParent* aUiController,
+    wr::RendererStats* aStats, nsTArray<FrameStats>& aOutputStats,
+    nsTArray<TransactionId>& aOutputTransactions) {
+  while (!mPendingTransactionIds.empty()) {
+    const auto& transactionId = mPendingTransactionIds.front();
+
+    if (aEpoch.mHandle < transactionId.mEpoch.mHandle) {
+      break;
+    }
+
+    if (!IsRootWebRenderBridgeParent() && !mVsyncRate.IsZero() &&
+        transactionId.mUseForTelemetry) {
+      auto fullPaintTime =
+          transactionId.mSceneBuiltTime
+              ? transactionId.mSceneBuiltTime - transactionId.mTxnStartTime
+              : TimeDuration::FromMilliseconds(0);
+
+      int32_t contentFrameTime = RecordContentFrameTime(
+          transactionId.mVsyncId, transactionId.mVsyncStartTime,
+          transactionId.mTxnStartTime, aCompositeStartId, aEndTime,
+          fullPaintTime, mVsyncRate, transactionId.mContainsSVGGroup, true,
+          aStats);
+
+      RecordPaintPhaseTelemetry(aStats);
+
+      if (StaticPrefs::gfx_logging_slow_frames_enabled_AtStartup() &&
+          contentFrameTime > 200) {
+        aOutputStats.AppendElement(FrameStats(
+            transactionId.mId, aCompositeStartTime, aRenderStartTime, aEndTime,
+            contentFrameTime,
+            aStats ? (double(aStats->resource_upload_time) / 1000000.0) : 0.0,
+            aStats ? (double(aStats->gpu_cache_upload_time) / 1000000.0) : 0.0,
+            transactionId.mTxnStartTime, transactionId.mRefreshStartTime,
+            transactionId.mFwdTime, transactionId.mSceneBuiltTime,
+            transactionId.mSkippedComposites, transactionId.mTxnURL));
+      }
+    }
+
+#if defined(ENABLE_FRAME_LATENCY_LOG)
+    if (transactionId.mRefreshStartTime) {
+      int32_t latencyMs =
+          lround((aEndTime - transactionId.mRefreshStartTime).ToMilliseconds());
+      printf_stderr(
+          "From transaction start to end of generate frame latencyMs %d this "
+          "%p\n",
+          latencyMs, this);
+    }
+    if (transactionId.mFwdTime) {
+      int32_t latencyMs =
+          lround((aEndTime - transactionId.mFwdTime).ToMilliseconds());
+      printf_stderr(
+          "From forwarding transaction to end of generate frame latencyMs %d "
+          "this %p\n",
+          latencyMs, this);
+    }
+#endif
+
+    if (aUiController && transactionId.mIsFirstPaint) {
+      aUiController->NotifyFirstPaint();
+    }
+
+    RecordCompositionPayloadsPresented(aEndTime, transactionId.mPayloads);
+
+    aOutputTransactions.AppendElement(transactionId.mId);
+    mPendingTransactionIds.pop_front();
+  }
+}
+
+LayersId WebRenderBridgeParent::GetLayersId() const {
+  return wr::AsLayersId(mPipelineId);
+}
+
+void WebRenderBridgeParent::ScheduleGenerateFrame(wr::RenderReasons aReasons) {
+  if (mCompositorScheduler) {
+    mAsyncImageManager->SetWillGenerateFrame();
+    mCompositorScheduler->ScheduleComposition(aReasons);
+  }
+}
+
+void WebRenderBridgeParent::FlushRendering(wr::RenderReasons aReasons,
+                                           bool aWaitForPresent) {
+  if (mDestroyed) {
+    return;
+  }
+
+  // This gets called during e.g. window resizes, so we need to flush the
+  // scene (which has the display list at the new window size).
+  FlushSceneBuilds();
+  FlushFrameGeneration(aReasons);
+  if (aWaitForPresent) {
+    FlushFramePresentation();
+  }
+}
+
+ipc::IPCResult WebRenderBridgeParent::RecvSetDefaultClearColor(
+    const uint32_t& aColor) {
+  SetClearColor(gfx::DeviceColor::FromABGR(aColor));
+  return IPC_OK();
+}
+
+void WebRenderBridgeParent::SetClearColor(const gfx::DeviceColor& aColor) {
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+
+  if (!IsRootWebRenderBridgeParent() || mDestroyed) {
+    return;
+  }
+
+  mApi->SetClearColor(aColor);
+}
+
+void WebRenderBridgeParent::Pause() {
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+  LOG("WebRenderBridgeParent::Pause() PipelineId %" PRIx64 " Id %" PRIx64
+      " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  if (!IsRootWebRenderBridgeParent() || mDestroyed) {
+    return;
+  }
+
+  mApi->Pause();
+}
+
+bool WebRenderBridgeParent::Resume() {
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+  LOG("WebRenderBridgeParent::Resume() PipelineId %" PRIx64 " Id %" PRIx64
+      " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  if (!IsRootWebRenderBridgeParent() || mDestroyed) {
+    return false;
+  }
+
+  if (!mApi->Resume()) {
+    return false;
+  }
+
+  // Ensure we generate and render a frame immediately.
+  ScheduleForcedGenerateFrame(wr::RenderReasons::WIDGET);
+  return true;
+}
+
+void WebRenderBridgeParent::ClearResources() {
+  if (!mApi) {
+    return;
+  }
+
+  if (!IsRootWebRenderBridgeParent()) {
+    mApi->FlushPendingWrTransactionEventsWithoutWait();
+  }
+
+  LOG("WebRenderBridgeParent::ClearResources() PipelineId %" PRIx64
+      " Id %" PRIx64 " root %d",
+      wr::AsUint64(mPipelineId), wr::AsUint64(mApi->GetId()),
+      IsRootWebRenderBridgeParent());
+
+  wr::Epoch wrEpoch = GetNextWrEpoch();
+  mReceivedDisplayList = false;
+  // Schedule generate frame to clean up Pipeline
+  ScheduleGenerateFrame(wr::RenderReasons::CLEAR_RESOURCES);
+
+  // WrFontKeys and WrImageKeys are deleted during WebRenderAPI destruction.
+  for (const auto& entry : mTextureHosts) {
+    WebRenderTextureHost* wrTexture = entry.second->AsWebRenderTextureHost();
+    MOZ_ASSERT(wrTexture);
+    if (wrTexture) {
+      mAsyncImageManager->HoldExternalImage(mPipelineId, wrEpoch, wrTexture);
+    }
+  }
+  mTextureHosts.clear();
+
+  for (const auto& entry : mSharedSurfaceIds) {
+    mAsyncImageManager->HoldExternalImage(mPipelineId, mWrEpoch, entry.second);
+  }
+  mSharedSurfaceIds.clear();
+
+  mAsyncImageManager->RemovePipeline(mPipelineId, wrEpoch);
+
+  wr::TransactionBuilder txn(mApi);
+  txn.SetLowPriority(true);
+  txn.ClearDisplayList(wrEpoch, mPipelineId);
+
+  for (const auto& entry : mAsyncCompositables) {
+    wr::PipelineId pipelineId = wr::AsPipelineId(entry.first);
+    RefPtr<WebRenderImageHost> host = entry.second;
+    host->ClearWrBridge(pipelineId, this);
+    mAsyncImageManager->RemoveAsyncImagePipeline(pipelineId, txn);
+    txn.RemovePipeline(pipelineId);
+  }
+  mAsyncCompositables.clear();
+  txn.RemovePipeline(mPipelineId);
+  mApi->SendTransaction(txn);
+
+  ClearAnimationResources();
+
+  if (IsRootWebRenderBridgeParent()) {
+    mCompositorScheduler->Destroy();
+    mApi->DestroyRenderer();
+  }
+
+  mCompositorScheduler = nullptr;
+  mAsyncImageManager = nullptr;
+  mApi = nullptr;
+  mCompositorBridge = nullptr;
+}
+
+void WebRenderBridgeParent::ClearAnimationResources() {
+  if (RefPtr<OMTASampler> sampler = GetOMTASampler()) {
+    sampler->ClearActiveAnimations(mActiveAnimations);
+  }
+  mActiveAnimations.clear();
+  std::queue<CompositorAnimationIdsForEpoch>().swap(
+      mCompositorAnimationsToDelete);  // clear queue
+}
+
+bool WebRenderBridgeParent::ShouldParentObserveEpoch() {
+  if (mParentLayersObserverEpoch == mChildLayersObserverEpoch) {
+    return false;
+  }
+
+  mParentLayersObserverEpoch = mChildLayersObserverEpoch;
+  return true;
+}
+
+void WebRenderBridgeParent::SendAsyncMessage(
+    const nsTArray<AsyncParentMessageData>& aMessage) {
+  MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+}
+
+void WebRenderBridgeParent::SendPendingAsyncMessages() {
+  MOZ_ASSERT(mCompositorBridge);
+  mCompositorBridge->SendPendingAsyncMessages();
+}
+
+void WebRenderBridgeParent::SetAboutToSendAsyncMessages() {
+  MOZ_ASSERT(mCompositorBridge);
+  mCompositorBridge->SetAboutToSendAsyncMessages();
+}
+
+void WebRenderBridgeParent::NotifyNotUsed(PTextureParent* aTexture,
+                                          uint64_t aTransactionId) {
+  MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+}
+
+base::ProcessId WebRenderBridgeParent::GetChildProcessId() {
+  return OtherPid();
+}
+
+dom::ContentParentId WebRenderBridgeParent::GetContentId() {
+  MOZ_ASSERT(mCompositorBridge);
+  return mCompositorBridge->GetContentId();
+}
+
+bool WebRenderBridgeParent::IsSameProcess() const {
+  return OtherPid() == base::GetCurrentProcId();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvNewCompositable(
+    const CompositableHandle& aHandle, const TextureInfo& aInfo) {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+  if (!AddCompositable(aHandle, aInfo)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WebRenderBridgeParent::RecvReleaseCompositable(
+    const CompositableHandle& aHandle) {
+  if (mDestroyed) {
+    return IPC_OK();
+  }
+  ReleaseCompositable(aHandle);
+  return IPC_OK();
+}
+
+TextureFactoryIdentifier WebRenderBridgeParent::GetTextureFactoryIdentifier() {
+  MOZ_ASSERT(mApi);
+
+#ifdef XP_WIN
+  const bool supportsD3D11NV12 = gfx::DeviceManagerDx::Get()->CanUseNV12();
+#else
+  const bool supportsD3D11NV12 = false;
+#endif
+
+  TextureFactoryIdentifier ident(
+      mApi->GetBackendType(), mApi->GetCompositorType(), XRE_GetProcessType(),
+      mApi->GetMaxTextureSize(), mApi->GetUseANGLE(), mApi->GetUseDComp(),
+      mAsyncImageManager->UseCompositorWnd(), false, false, false,
+      supportsD3D11NV12, mApi->GetSyncHandle());
+  return ident;
+}
+
+wr::Epoch WebRenderBridgeParent::GetNextWrEpoch() {
+  MOZ_RELEASE_ASSERT(mWrEpoch.mHandle != UINT32_MAX);
+  mWrEpoch.mHandle++;
+  return mWrEpoch;
+}
+
+void WebRenderBridgeParent::RollbackWrEpoch() {
+  MOZ_RELEASE_ASSERT(mWrEpoch.mHandle != 0);
+  mWrEpoch.mHandle--;
+}
+
+void WebRenderBridgeParent::ExtractImageCompositeNotifications(
+    nsTArray<ImageCompositeNotificationInfo>* aNotifications) {
+  MOZ_ASSERT(IsRootWebRenderBridgeParent());
+  if (mDestroyed) {
+    return;
+  }
+  mAsyncImageManager->FlushImageNotifications(aNotifications);
+}
+
+void WebRenderBridgeParent::FlushPendingWrTransactionEventsWithWait() {
+  if (mDestroyed || IsRootWebRenderBridgeParent()) {
+    return;
+  }
+  mApi->FlushPendingWrTransactionEventsWithWait();
+}
+
+RefPtr<WebRenderBridgeParentRef>
+WebRenderBridgeParent::GetWebRenderBridgeParentRef() {
+  if (mDestroyed) {
+    return nullptr;
+  }
+
+  if (!mWebRenderBridgeRef) {
+    mWebRenderBridgeRef = new WebRenderBridgeParentRef(this);
+  }
+  return mWebRenderBridgeRef;
+}
+
+WebRenderBridgeParentRef::WebRenderBridgeParentRef(
+    WebRenderBridgeParent* aWebRenderBridge)
+    : mWebRenderBridge(aWebRenderBridge) {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MOZ_ASSERT(mWebRenderBridge);
+}
+
+RefPtr<WebRenderBridgeParent> WebRenderBridgeParentRef::WrBridge() {
+  return mWebRenderBridge;
+}
+
+void WebRenderBridgeParentRef::Clear() {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  mWebRenderBridge = nullptr;
+}
+
+WebRenderBridgeParentRef::~WebRenderBridgeParentRef() {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+  MOZ_ASSERT(!mWebRenderBridge);
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/WebRenderBridgeParent.h b/gfx/layers/wr/WebRenderBridgeParent.h
new file mode 100644
index 0000000000..c96713e752
--- /dev/null
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -0,0 +1,533 @@
+/* -*- 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_WebRenderBridgeParent_h
+#define mozilla_layers_WebRenderBridgeParent_h
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "CompositableHost.h"  // for CompositableHost, ImageCompositeNotificationInfo
+#include "GLContextProvider.h"
+#include "mozilla/DataMutex.h"
+#include "mozilla/layers/CompositableTransactionParent.h"
+#include "mozilla/layers/CompositorVsyncSchedulerOwner.h"
+#include "mozilla/layers/PWebRenderBridgeParent.h"
+#include "mozilla/HashTable.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Result.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "nsTArrayForwardDeclare.h"
+#include "WindowRenderer.h"
+
+namespace mozilla {
+
+namespace gl {
+class GLContext;
+}
+
+namespace widget {
+class CompositorWidget;
+}
+
+namespace wr {
+class WebRenderAPI;
+class WebRenderPipelineInfo;
+}  // namespace wr
+
+namespace layers {
+
+class AsyncImagePipelineManager;
+class Compositor;
+class CompositorBridgeParentBase;
+class CompositorVsyncScheduler;
+class OMTASampler;
+class UiCompositorControllerParent;
+class WebRenderBridgeParentRef;
+class WebRenderImageHost;
+struct WrAnimations;
+
+struct CompositorAnimationIdsForEpoch {
+  CompositorAnimationIdsForEpoch(const wr::Epoch& aEpoch,
+                                 nsTArray<uint64_t>&& aIds)
+      : mEpoch(aEpoch), mIds(std::move(aIds)) {}
+
+  wr::Epoch mEpoch;
+  nsTArray<uint64_t> mIds;
+};
+
+class WebRenderBridgeParent final : public PWebRenderBridgeParent,
+                                    public CompositorVsyncSchedulerOwner,
+                                    public CompositableParentManager,
+                                    public FrameRecorder {
+ public:
+  WebRenderBridgeParent(CompositorBridgeParentBase* aCompositorBridge,
+                        const wr::PipelineId& aPipelineId,
+                        widget::CompositorWidget* aWidget,
+                        CompositorVsyncScheduler* aScheduler,
+                        RefPtr<wr::WebRenderAPI>&& aApi,
+                        RefPtr<AsyncImagePipelineManager>&& aImageMgr,
+                        TimeDuration aVsyncRate);
+
+  static WebRenderBridgeParent* CreateDestroyed(
+      const wr::PipelineId& aPipelineId, nsCString&& aError);
+
+  wr::PipelineId PipelineId() { return mPipelineId; }
+  already_AddRefed<wr::WebRenderAPI> GetWebRenderAPI() {
+    return do_AddRef(mApi);
+  }
+  AsyncImagePipelineManager* AsyncImageManager() { return mAsyncImageManager; }
+  CompositorVsyncScheduler* CompositorScheduler() {
+    return mCompositorScheduler.get();
+  }
+  CompositorBridgeParentBase* GetCompositorBridge() {
+    return mCompositorBridge;
+  }
+
+  void UpdateQualitySettings();
+  void UpdateDebugFlags();
+  void UpdateParameters();
+  void UpdateBoolParameters();
+  void UpdateProfilerUI();
+
+  mozilla::ipc::IPCResult RecvEnsureConnected(
+      TextureFactoryIdentifier* aTextureFactoryIdentifier,
+      MaybeIdNamespace* aMaybeIdNamespace, nsCString* aError) override;
+
+  mozilla::ipc::IPCResult RecvNewCompositable(
+      const CompositableHandle& aHandle, const TextureInfo& aInfo) override;
+  mozilla::ipc::IPCResult RecvReleaseCompositable(
+      const CompositableHandle& aHandle) override;
+
+  mozilla::ipc::IPCResult RecvShutdown() override;
+  mozilla::ipc::IPCResult RecvShutdownSync() override;
+  mozilla::ipc::IPCResult RecvDeleteCompositorAnimations(
+      nsTArray<uint64_t>&& aIds) override;
+  mozilla::ipc::IPCResult RecvUpdateResources(
+      const wr::IdNamespace& aIdNamespace,
+      nsTArray<OpUpdateResource>&& aUpdates,
+      nsTArray<RefCountedShmem>&& aSmallShmems,
+      nsTArray<ipc::Shmem>&& aLargeShmems) override;
+  mozilla::ipc::IPCResult RecvSetDisplayList(
+      DisplayListData&& aDisplayList, nsTArray<OpDestroy>&& aToDestroy,
+      const uint64_t& aFwdTransactionId, const TransactionId& aTransactionId,
+      const bool& aContainsSVGGroup, const VsyncId& aVsyncId,
+      const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+      const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+      const TimeStamp& aFwdTime,
+      nsTArray<CompositionPayload>&& aPayloads) override;
+  mozilla::ipc::IPCResult RecvEmptyTransaction(
+      const FocusTarget& aFocusTarget,
+      Maybe<TransactionData>&& aTransactionData,
+      nsTArray<OpDestroy>&& aToDestroy, const uint64_t& aFwdTransactionId,
+      const TransactionId& aTransactionId, const VsyncId& aVsyncId,
+      const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+      const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+      const TimeStamp& aFwdTime,
+      nsTArray<CompositionPayload>&& aPayloads) override;
+  mozilla::ipc::IPCResult RecvSetFocusTarget(
+      const FocusTarget& aFocusTarget) override;
+  mozilla::ipc::IPCResult RecvParentCommands(
+      const wr::IdNamespace& aIdNamespace,
+      nsTArray<WebRenderParentCommand>&& commands) override;
+  mozilla::ipc::IPCResult RecvGetSnapshot(NotNull<PTextureParent*> aTexture,
+                                          bool* aNeedsYFlip) override;
+
+  mozilla::ipc::IPCResult RecvSetLayersObserverEpoch(
+      const LayersObserverEpoch& aChildEpoch) override;
+
+  mozilla::ipc::IPCResult RecvClearCachedResources() override;
+  mozilla::ipc::IPCResult RecvClearAnimationResources() override;
+  mozilla::ipc::IPCResult RecvInvalidateRenderedFrame() override;
+  mozilla::ipc::IPCResult RecvScheduleComposite(
+      const wr::RenderReasons& aReasons) override;
+  mozilla::ipc::IPCResult RecvCapture() override;
+  mozilla::ipc::IPCResult RecvStartCaptureSequence(
+      const nsACString& path, const uint32_t& aFlags) override;
+  mozilla::ipc::IPCResult RecvStopCaptureSequence() override;
+  mozilla::ipc::IPCResult RecvSyncWithCompositor() override;
+
+  mozilla::ipc::IPCResult RecvSetConfirmedTargetAPZC(
+      const uint64_t& aBlockId,
+      nsTArray<ScrollableLayerGuid>&& aTargets) override;
+
+  mozilla::ipc::IPCResult RecvSetTestSampleTime(
+      const TimeStamp& aTime) override;
+  mozilla::ipc::IPCResult RecvLeaveTestMode() override;
+  mozilla::ipc::IPCResult RecvGetAnimationValue(
+      const uint64_t& aCompositorAnimationsId, OMTAValue* aValue) override;
+  mozilla::ipc::IPCResult RecvSetAsyncScrollOffset(
+      const ScrollableLayerGuid::ViewID& aScrollId, const float& aX,
+      const float& aY) override;
+  mozilla::ipc::IPCResult RecvSetAsyncZoom(
+      const ScrollableLayerGuid::ViewID& aScrollId,
+      const float& aZoom) override;
+  mozilla::ipc::IPCResult RecvFlushApzRepaints() override;
+  mozilla::ipc::IPCResult RecvGetAPZTestData(APZTestData* data) override;
+  mozilla::ipc::IPCResult RecvGetFrameUniformity(
+      FrameUniformityData* aOutData) override;
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  mozilla::ipc::IPCResult RecvSetDefaultClearColor(
+      const uint32_t& aColor) override;
+  void SetClearColor(const gfx::DeviceColor& aColor);
+
+  void Pause();
+  bool Resume();
+
+  void Destroy();
+
+  // CompositorVsyncSchedulerOwner
+  bool IsPendingComposite() override { return false; }
+  void FinishPendingComposite() override {}
+  void CompositeToTarget(VsyncId aId, wr::RenderReasons aReasons,
+                         gfx::DrawTarget* aTarget,
+                         const gfx::IntRect* aRect = nullptr) override;
+  TimeDuration GetVsyncInterval() const override;
+
+  // CompositableParentManager
+  bool IsSameProcess() const override;
+  base::ProcessId GetChildProcessId() override;
+  dom::ContentParentId GetContentId() override;
+  void NotifyNotUsed(PTextureParent* aTexture,
+                     uint64_t aTransactionId) override;
+  void SendAsyncMessage(
+      const nsTArray<AsyncParentMessageData>& aMessage) override;
+  void SendPendingAsyncMessages() override;
+  void SetAboutToSendAsyncMessages() override;
+
+  void HoldPendingTransactionId(
+      const wr::Epoch& aWrEpoch, TransactionId aTransactionId,
+      bool aContainsSVGGroup, const VsyncId& aVsyncId,
+      const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+      const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+      const TimeStamp& aFwdTime, const bool aIsFirstPaint,
+      nsTArray<CompositionPayload>&& aPayloads,
+      const bool aUseForTelemetry = true);
+  TransactionId LastPendingTransactionId();
+  void FlushTransactionIdsForEpoch(
+      const wr::Epoch& aEpoch, const VsyncId& aCompositeStartId,
+      const TimeStamp& aCompositeStartTime, const TimeStamp& aRenderStartTime,
+      const TimeStamp& aEndTime, UiCompositorControllerParent* aUiController,
+      wr::RendererStats* aStats, nsTArray<FrameStats>& aOutputStats,
+      nsTArray<TransactionId>& aOutputTransactions);
+  void NotifySceneBuiltForEpoch(const wr::Epoch& aEpoch,
+                                const TimeStamp& aEndTime);
+
+  void RetrySkippedComposite();
+
+  TextureFactoryIdentifier GetTextureFactoryIdentifier();
+
+  void ExtractImageCompositeNotifications(
+      nsTArray<ImageCompositeNotificationInfo>* aNotifications);
+
+  wr::Epoch GetCurrentEpoch() const { return mWrEpoch; }
+  wr::IdNamespace GetIdNamespace() { return mIdNamespace; }
+
+  bool MatchesNamespace(const wr::ImageKey& aImageKey) const {
+    return aImageKey.mNamespace == mIdNamespace;
+  }
+
+  bool MatchesNamespace(const wr::BlobImageKey& aBlobKey) const {
+    return MatchesNamespace(wr::AsImageKey(aBlobKey));
+  }
+
+  bool MatchesNamespace(const wr::FontKey& aFontKey) const {
+    return aFontKey.mNamespace == mIdNamespace;
+  }
+
+  bool MatchesNamespace(const wr::FontInstanceKey& aFontKey) const {
+    return aFontKey.mNamespace == mIdNamespace;
+  }
+
+  void FlushRendering(wr::RenderReasons aReasons, bool aWaitForPresent = true);
+
+  /**
+   * Schedule generating WebRender frame definitely at next composite timing.
+   *
+   * WebRenderBridgeParent uses composite timing to check if there is an update
+   * to AsyncImagePipelines. If there is no update, WebRenderBridgeParent skips
+   * to generate frame. If we need to generate new frame at next composite
+   * timing, call this method.
+   *
+   * Call CompositorVsyncScheduler::ScheduleComposition() directly, if we just
+   * want to trigger AsyncImagePipelines update checks.
+   */
+  void ScheduleGenerateFrame(wr::RenderReasons aReason);
+
+  /**
+   * Invalidate rendered frame.
+   *
+   * WebRender could skip frame rendering if there is no update.
+   * This function is used to force invalidating even when there is no update.
+   */
+  void InvalidateRenderedFrame(wr::RenderReasons aReasons);
+
+  /**
+   * Schedule forced frame rendering at next composite timing.
+   *
+   * WebRender could skip frame rendering if there is no update.
+   * This function is used to force rendering even when there is no update.
+   */
+  void ScheduleForcedGenerateFrame(wr::RenderReasons aReasons);
+
+  void NotifyDidSceneBuild(RefPtr<const wr::WebRenderPipelineInfo> aInfo);
+
+  wr::Epoch UpdateWebRender(
+      CompositorVsyncScheduler* aScheduler, RefPtr<wr::WebRenderAPI>&& aApi,
+      AsyncImagePipelineManager* aImageMgr,
+      const TextureFactoryIdentifier& aTextureFactoryIdentifier);
+
+  void RemoveEpochDataPriorTo(const wr::Epoch& aRenderedEpoch);
+
+  bool IsRootWebRenderBridgeParent() const;
+  LayersId GetLayersId() const;
+
+  void BeginRecording(const TimeStamp& aRecordingStart);
+
+#if defined(MOZ_WIDGET_ANDROID)
+  /**
+   * Request a screengrab for android
+   */
+  void RequestScreenPixels(UiCompositorControllerParent* aController);
+  void MaybeCaptureScreenPixels();
+#endif
+  /**
+   * Stop recording and the frames collected since the call to BeginRecording
+   */
+  RefPtr<wr::WebRenderAPI::EndRecordingPromise> EndRecording();
+
+  void DisableNativeCompositor();
+  void AddPendingScrollPayload(CompositionPayload& aPayload,
+                               const VsyncId& aCompositeStartId);
+
+  nsTArray<CompositionPayload> TakePendingScrollPayload(
+      const VsyncId& aCompositeStartId);
+
+  RefPtr<WebRenderBridgeParentRef> GetWebRenderBridgeParentRef();
+
+  void FlushPendingWrTransactionEventsWithWait();
+
+ private:
+  class ScheduleSharedSurfaceRelease;
+
+  WebRenderBridgeParent(const wr::PipelineId& aPipelineId, nsCString&& aError);
+  virtual ~WebRenderBridgeParent();
+
+  bool ProcessEmptyTransactionUpdates(TransactionData& aData,
+                                      bool* aScheduleComposite);
+
+  bool ProcessDisplayListData(DisplayListData& aDisplayList, wr::Epoch aWrEpoch,
+                              const TimeStamp& aTxnStartTime,
+                              bool aValidTransaction,
+                              bool aObserveLayersUpdate);
+
+  bool SetDisplayList(const LayoutDeviceRect& aRect, ipc::ByteBuf&& aDLItems,
+                      ipc::ByteBuf&& aDLCache, ipc::ByteBuf&& aSpatialTreeDL,
+                      const wr::BuiltDisplayListDescriptor& aDLDesc,
+                      const nsTArray<OpUpdateResource>& aResourceUpdates,
+                      const nsTArray<RefCountedShmem>& aSmallShmems,
+                      const nsTArray<ipc::Shmem>& aLargeShmems,
+                      const TimeStamp& aTxnStartTime,
+                      wr::TransactionBuilder& aTxn, wr::Epoch aWrEpoch,
+                      bool aObserveLayersUpdate);
+
+  void UpdateAPZFocusState(const FocusTarget& aFocus);
+  void UpdateAPZScrollData(const wr::Epoch& aEpoch,
+                           WebRenderScrollData&& aData);
+  void UpdateAPZScrollOffsets(ScrollUpdatesMap&& aUpdates,
+                              uint32_t aPaintSequenceNumber);
+
+  bool UpdateResources(const nsTArray<OpUpdateResource>& aResourceUpdates,
+                       const nsTArray<RefCountedShmem>& aSmallShmems,
+                       const nsTArray<ipc::Shmem>& aLargeShmems,
+                       wr::TransactionBuilder& aUpdates);
+  bool AddSharedExternalImage(wr::ExternalImageId aExtId, wr::ImageKey aKey,
+                              wr::TransactionBuilder& aResources);
+  bool UpdateSharedExternalImage(
+      wr::ExternalImageId aExtId, wr::ImageKey aKey,
+      const ImageIntRect& aDirtyRect, wr::TransactionBuilder& aResources,
+      UniquePtr<ScheduleSharedSurfaceRelease>& aScheduleRelease);
+  void ObserveSharedSurfaceRelease(
+      const nsTArray<wr::ExternalImageKeyPair>& aPairs,
+      const bool& aFromCheckpoint);
+
+  bool PushExternalImageForTexture(wr::ExternalImageId aExtId,
+                                   wr::ImageKey aKey, TextureHost* aTexture,
+                                   bool aIsUpdate,
+                                   wr::TransactionBuilder& aResources);
+
+  void AddPipelineIdForCompositable(const wr::PipelineId& aPipelineIds,
+                                    const CompositableHandle& aHandle,
+                                    const CompositableHandleOwner& aOwner,
+                                    wr::TransactionBuilder& aTxn,
+                                    wr::TransactionBuilder& aTxnForImageBridge);
+  void RemovePipelineIdForCompositable(const wr::PipelineId& aPipelineId,
+                                       wr::TransactionBuilder& aTxn);
+
+  void DeleteImage(const wr::ImageKey& aKey, wr::TransactionBuilder& aUpdates);
+  void ReleaseTextureOfImage(const wr::ImageKey& aKey);
+
+  bool ProcessWebRenderParentCommands(
+      const nsTArray<WebRenderParentCommand>& aCommands,
+      wr::TransactionBuilder& aTxn);
+
+  void ClearResources();
+  void ClearAnimationResources();
+  bool ShouldParentObserveEpoch();
+  mozilla::ipc::IPCResult HandleShutdown();
+
+  void ResetPreviousSampleTime();
+
+  void SetOMTASampleTime();
+  RefPtr<OMTASampler> GetOMTASampler() const;
+
+  CompositorBridgeParent* GetRootCompositorBridgeParent() const;
+
+  RefPtr<WebRenderBridgeParent> GetRootWebRenderBridgeParent() const;
+
+  // Tell APZ what the subsequent sampling's timestamp should be.
+  void SetAPZSampleTime();
+
+  wr::Epoch GetNextWrEpoch();
+  // This function is expected to be used when GetNextWrEpoch() is called,
+  // but TransactionBuilder does not have resource updates nor display list.
+  // In this case, ScheduleGenerateFrame is not triggered via SceneBuilder.
+  // Then we want to rollback WrEpoch. See Bug 1490117.
+  void RollbackWrEpoch();
+
+  void FlushSceneBuilds();
+  void FlushFrameGeneration(wr::RenderReasons aReasons);
+  void FlushFramePresentation();
+
+  void MaybeGenerateFrame(VsyncId aId, bool aForceGenerateFrame,
+                          wr::RenderReasons aReasons);
+
+  VsyncId GetVsyncIdForEpoch(const wr::Epoch& aEpoch) {
+    for (auto& id : mPendingTransactionIds) {
+      if (id.mEpoch.mHandle == aEpoch.mHandle) {
+        return id.mVsyncId;
+      }
+    }
+    return VsyncId();
+  }
+
+ private:
+  struct PendingTransactionId {
+    PendingTransactionId(const wr::Epoch& aEpoch, TransactionId aId,
+                         bool aContainsSVGGroup, const VsyncId& aVsyncId,
+                         const TimeStamp& aVsyncStartTime,
+                         const TimeStamp& aRefreshStartTime,
+                         const TimeStamp& aTxnStartTime,
+                         const nsACString& aTxnURL, const TimeStamp& aFwdTime,
+                         const bool aIsFirstPaint, const bool aUseForTelemetry,
+                         nsTArray<CompositionPayload>&& aPayloads)
+        : mEpoch(aEpoch),
+          mId(aId),
+          mVsyncId(aVsyncId),
+          mVsyncStartTime(aVsyncStartTime),
+          mRefreshStartTime(aRefreshStartTime),
+          mTxnStartTime(aTxnStartTime),
+          mTxnURL(aTxnURL),
+          mFwdTime(aFwdTime),
+          mSkippedComposites(0),
+          mContainsSVGGroup(aContainsSVGGroup),
+          mIsFirstPaint(aIsFirstPaint),
+          mUseForTelemetry(aUseForTelemetry),
+          mPayloads(std::move(aPayloads)) {}
+    wr::Epoch mEpoch;
+    TransactionId mId;
+    VsyncId mVsyncId;
+    TimeStamp mVsyncStartTime;
+    TimeStamp mRefreshStartTime;
+    TimeStamp mTxnStartTime;
+    nsCString mTxnURL;
+    TimeStamp mFwdTime;
+    TimeStamp mSceneBuiltTime;
+    uint32_t mSkippedComposites;
+    bool mContainsSVGGroup;
+    bool mIsFirstPaint;
+    bool mUseForTelemetry;
+    nsTArray<CompositionPayload> mPayloads;
+  };
+
+  CompositorBridgeParentBase* MOZ_NON_OWNING_REF mCompositorBridge;
+  wr::PipelineId mPipelineId;
+  RefPtr<widget::CompositorWidget> mWidget;
+  RefPtr<wr::WebRenderAPI> mApi;
+  RefPtr<AsyncImagePipelineManager> mAsyncImageManager;
+  RefPtr<CompositorVsyncScheduler> mCompositorScheduler;
+  // mActiveAnimations is used to avoid leaking animations when
+  // WebRenderBridgeParent is destroyed abnormally and Tab move between
+  // different windows.
+  std::unordered_map<uint64_t, wr::Epoch> mActiveAnimations;
+  std::unordered_map<uint64_t, RefPtr<WebRenderImageHost>> mAsyncCompositables;
+  std::unordered_map<uint64_t, CompositableTextureHostRef> mTextureHosts;
+  std::unordered_map<uint64_t, wr::ExternalImageId> mSharedSurfaceIds;
+
+  TimeDuration mVsyncRate;
+  TimeStamp mPreviousFrameTimeStamp;
+  // These fields keep track of the latest layer observer epoch values in the
+  // child and the parent. mChildLayersObserverEpoch is the latest epoch value
+  // received from the child. mParentLayersObserverEpoch is the latest epoch
+  // value that we have told BrowserParent about (via ObserveLayerUpdate).
+  LayersObserverEpoch mChildLayersObserverEpoch;
+  LayersObserverEpoch mParentLayersObserverEpoch;
+
+  std::deque<PendingTransactionId> mPendingTransactionIds;
+  std::queue<CompositorAnimationIdsForEpoch> mCompositorAnimationsToDelete;
+  wr::Epoch mWrEpoch;
+  wr::IdNamespace mIdNamespace;
+  CompositionOpportunityId mCompositionOpportunityId;
+  nsCString mInitError;
+
+  TimeStamp mMostRecentComposite;
+
+  RefPtr<WebRenderBridgeParentRef> mWebRenderBridgeRef;
+
+#if defined(MOZ_WIDGET_ANDROID)
+  UiCompositorControllerParent* mScreenPixelsTarget;
+#endif
+  uint32_t mBoolParameterBits;
+  uint16_t mBlobTileSize;
+  wr::RenderReasons mSkippedCompositeReasons;
+  bool mDestroyed;
+  bool mReceivedDisplayList;
+  bool mIsFirstPaint;
+  bool mSkippedComposite;
+  bool mDisablingNativeCompositor;
+  // These payloads are being used for SCROLL_PRESENT_LATENCY telemetry
+  DataMutex<nsClassHashtable<nsUint64HashKey, nsTArray<CompositionPayload>>>
+      mPendingScrollPayloads;
+};
+
+// Use this class, since WebRenderBridgeParent could not supports
+// ThreadSafeWeakPtr.
+// This class provides a ref of WebRenderBridgeParent when
+// the WebRenderBridgeParent is not destroyed. Then it works similar to
+// weak pointer.
+class WebRenderBridgeParentRef final {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderBridgeParentRef)
+
+  explicit WebRenderBridgeParentRef(WebRenderBridgeParent* aWebRenderBridge);
+
+  RefPtr<WebRenderBridgeParent> WrBridge();
+  void Clear();
+
+ protected:
+  ~WebRenderBridgeParentRef();
+
+  RefPtr<WebRenderBridgeParent> mWebRenderBridge;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif  // mozilla_layers_WebRenderBridgeParent_h
diff --git a/gfx/layers/wr/WebRenderCanvasRenderer.cpp b/gfx/layers/wr/WebRenderCanvasRenderer.cpp
new file mode 100644
index 0000000000..21c13221ac
--- /dev/null
+++ b/gfx/layers/wr/WebRenderCanvasRenderer.cpp
@@ -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/. */
+
+#include "WebRenderCanvasRenderer.h"
+
+#include "GLContext.h"
+#include "GLScreenBuffer.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/StaticPrefs_webgl.h"
+#include "SharedSurfaceGL.h"
+#include "WebRenderBridgeChild.h"
+
+namespace mozilla {
+namespace layers {
+
+CompositableForwarder* WebRenderCanvasRenderer::GetForwarder() {
+  return mManager->WrBridge();
+}
+
+WebRenderCanvasRendererAsync::~WebRenderCanvasRendererAsync() {
+  if (mPipelineId.isSome()) {
+    mManager->RemovePipelineIdForCompositable(mPipelineId.ref());
+    mPipelineId.reset();
+  }
+}
+
+void WebRenderCanvasRendererAsync::Initialize(const CanvasRendererData& aData) {
+  WebRenderCanvasRenderer::Initialize(aData);
+
+  ClearCachedResources();
+}
+
+bool WebRenderCanvasRendererAsync::CreateCompositable() {
+  if (!mCanvasClient) {
+    auto compositableFlags = TextureFlags::NO_FLAGS;
+    if (!mData.mIsAlphaPremult) {
+      // WR needs this flag marked on the compositable, not just the texture.
+      compositableFlags |= TextureFlags::NON_PREMULTIPLIED;
+    }
+    mCanvasClient = new CanvasClient(GetForwarder(), compositableFlags);
+    mCanvasClient->Connect();
+  }
+  return true;
+}
+
+void WebRenderCanvasRendererAsync::EnsurePipeline() {
+  MOZ_ASSERT(mCanvasClient);
+  if (!mCanvasClient) {
+    return;
+  }
+
+  if (mPipelineId) {
+    return;
+  }
+
+  // Alloc async image pipeline id.
+  mPipelineId = Some(
+      mManager->WrBridge()->GetCompositorBridgeChild()->GetNextPipelineId());
+  mManager->AddPipelineIdForCompositable(
+      mPipelineId.ref(), mCanvasClient->GetIPCHandle(),
+      CompositableHandleOwner::WebRenderBridge);
+}
+
+void WebRenderCanvasRendererAsync::ClearCachedResources() {
+  if (mPipelineId.isSome()) {
+    mManager->RemovePipelineIdForCompositable(mPipelineId.ref());
+    mPipelineId.reset();
+  }
+}
+
+void WebRenderCanvasRendererAsync::
+    UpdateCompositableClientForEmptyTransaction() {
+  bool wasDirty = IsDirty();
+  UpdateCompositableClient();
+  if (wasDirty && mPipelineId.isSome()) {
+    // Notify an update of async image pipeline during empty transaction.
+    // During non empty transaction, WebRenderBridgeParent receives
+    // OpUpdateAsyncImagePipeline message, but during empty transaction, the
+    // message is not sent to WebRenderBridgeParent. Then
+    // OpUpdatedAsyncImagePipeline is used to notify the update.
+    mManager->AddWebRenderParentCommand(
+        OpUpdatedAsyncImagePipeline(mPipelineId.ref()));
+  }
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/WebRenderCanvasRenderer.h b/gfx/layers/wr/WebRenderCanvasRenderer.h
new file mode 100644
index 0000000000..de4a1b4fa0
--- /dev/null
+++ b/gfx/layers/wr/WebRenderCanvasRenderer.h
@@ -0,0 +1,56 @@
+/* -*- 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_WEBRENDERCANVASRENDERER_H
+#define GFX_WEBRENDERCANVASRENDERER_H
+
+#include "mozilla/layers/RenderRootStateManager.h"
+#include "ShareableCanvasRenderer.h"
+
+namespace mozilla {
+namespace layers {
+
+class WebRenderCanvasRenderer : public ShareableCanvasRenderer {
+ public:
+  explicit WebRenderCanvasRenderer(RenderRootStateManager* aManager)
+      : mManager(aManager) {}
+
+  CompositableForwarder* GetForwarder() override;
+  RenderRootStateManager* GetRenderRootStateManager() { return mManager; }
+
+ protected:
+  RefPtr<RenderRootStateManager> mManager;
+};
+
+class WebRenderCanvasRendererAsync final : public WebRenderCanvasRenderer {
+ public:
+  explicit WebRenderCanvasRendererAsync(RenderRootStateManager* aManager)
+      : WebRenderCanvasRenderer(aManager) {}
+  virtual ~WebRenderCanvasRendererAsync();
+
+  WebRenderCanvasRendererAsync* AsWebRenderCanvasRendererAsync() override {
+    return this;
+  }
+
+  void Initialize(const CanvasRendererData& aData) override;
+  bool CreateCompositable() override;
+  void EnsurePipeline() override;
+
+  void ClearCachedResources() override;
+
+  void UpdateCompositableClientForEmptyTransaction();
+
+  Maybe<wr::PipelineId> GetPipelineId() { return mPipelineId; }
+
+ protected:
+  Maybe<wr::PipelineId> mPipelineId;
+  bool mIsAsync = false;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/layers/wr/WebRenderCommandBuilder.cpp b/gfx/layers/wr/WebRenderCommandBuilder.cpp
new file mode 100644
index 0000000000..f280bb8a0c
--- /dev/null
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -0,0 +1,2959 @@
+/* -*- 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 "WebRenderCommandBuilder.h"
+
+#include "mozilla/AutoRestore.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/EffectCompositor.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/SVGGeometryFrame.h"
+#include "mozilla/SVGImageFrame.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/image/WebRenderImageProvider.h"
+#include "mozilla/layers/AnimationHelper.h"
+#include "mozilla/layers/ClipManager.h"
+#include "mozilla/layers/ImageClient.h"
+#include "mozilla/layers/RenderRootStateManager.h"
+#include "mozilla/layers/WebRenderBridgeChild.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/layers/IpcResourceUpdateQueue.h"
+#include "mozilla/layers/SharedSurfacesChild.h"
+#include "mozilla/layers/SourceSurfaceSharedData.h"
+#include "mozilla/layers/StackingContextHelper.h"
+#include "mozilla/layers/UpdateImageHelper.h"
+#include "mozilla/layers/WebRenderDrawEventRecorder.h"
+#include "UnitTransforms.h"
+#include "gfxEnv.h"
+#include "nsDisplayListInvalidation.h"
+#include "nsLayoutUtils.h"
+#include "nsTHashSet.h"
+#include "WebRenderCanvasRenderer.h"
+
+#include <cstdint>
+
+namespace mozilla {
+namespace layers {
+
+using namespace gfx;
+using namespace image;
+static int sIndent;
+#include <stdarg.h>
+#include <stdio.h>
+
+static void GP(const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+#if 0
+    for (int i = 0; i < sIndent; i++) { printf(" "); }
+    vprintf(fmt, args);
+#endif
+  va_end(args);
+}
+
+bool FitsInt32(const float aVal) {
+  // Although int32_t min and max can't be represented exactly with floats, the
+  // cast truncates towards zero which is what we want here.
+  const float min = static_cast<float>(std::numeric_limits<int32_t>::min());
+  const float max = static_cast<float>(std::numeric_limits<int32_t>::max());
+  return aVal > min && aVal < max;
+}
+
+// XXX: problems:
+// - How do we deal with scrolling while having only a single invalidation rect?
+// We can have a valid rect and an invalid rect. As we scroll the valid rect
+// will move and the invalid rect will be the new area
+
+struct BlobItemData;
+static void DestroyBlobGroupDataProperty(nsTArray<BlobItemData*>* aArray);
+NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(BlobGroupDataProperty,
+                                    nsTArray<BlobItemData*>,
+                                    DestroyBlobGroupDataProperty);
+
+// These are currently manually allocated and ownership is help by the
+// mDisplayItems hash table in DIGroup
+struct BlobItemData {
+  // a weak pointer to the frame for this item.
+  // DisplayItemData has a mFrameList to deal with merged frames. Hopefully we
+  // don't need to worry about that.
+  nsIFrame* mFrame;
+
+  uint32_t mDisplayItemKey;
+  nsTArray<BlobItemData*>*
+      mArray;  // a weak pointer to the array that's owned by the frame property
+
+  LayerIntRect mRect;
+  // It would be nice to not need this. We need to be able to call
+  // ComputeInvalidationRegion. ComputeInvalidationRegion will sometimes reach
+  // into parent style structs to get information that can change the
+  // invalidation region
+  UniquePtr<nsDisplayItemGeometry> mGeometry;
+  DisplayItemClip mClip;
+  bool mInvisible;
+  bool mUsed;  // initialized near construction
+  // XXX: only used for debugging
+  bool mInvalid;
+
+  // a weak pointer to the group that owns this item
+  // we use this to track whether group for a particular item has changed
+  struct DIGroup* mGroup;
+
+  // We need to keep a list of all the external surfaces used by the blob image.
+  // We do this on a per-display item basis so that the lists remains correct
+  // during invalidations.
+  std::vector<RefPtr<SourceSurface>> mExternalSurfaces;
+
+  BlobItemData(DIGroup* aGroup, nsDisplayItem* aItem)
+      : mInvisible(false), mUsed(false), mGroup(aGroup) {
+    mInvalid = false;
+    mDisplayItemKey = aItem->GetPerFrameKey();
+    AddFrame(aItem->Frame());
+  }
+
+ private:
+  void AddFrame(nsIFrame* aFrame) {
+    mFrame = aFrame;
+
+    nsTArray<BlobItemData*>* array =
+        aFrame->GetProperty(BlobGroupDataProperty());
+    if (!array) {
+      array = new nsTArray<BlobItemData*>();
+      aFrame->SetProperty(BlobGroupDataProperty(), array);
+    }
+    array->AppendElement(this);
+    mArray = array;
+  }
+
+ public:
+  void ClearFrame() {
+    // Delete the weak pointer to this BlobItemData on the frame
+    MOZ_RELEASE_ASSERT(mFrame);
+    // the property may already be removed if WebRenderUserData got deleted
+    // first so we use our own mArray pointer.
+    mArray->RemoveElement(this);
+
+    // drop the entire property if nothing's left in the array
+    if (mArray->IsEmpty()) {
+      // If the frame is in the process of being destroyed this will fail
+      // but that's ok, because the the property will be removed then anyways
+      mFrame->RemoveProperty(BlobGroupDataProperty());
+    }
+    mFrame = nullptr;
+  }
+
+  ~BlobItemData() {
+    if (mFrame) {
+      ClearFrame();
+    }
+  }
+};
+
+static BlobItemData* GetBlobItemData(nsDisplayItem* aItem) {
+  nsIFrame* frame = aItem->Frame();
+  uint32_t key = aItem->GetPerFrameKey();
+  const nsTArray<BlobItemData*>* array =
+      frame->GetProperty(BlobGroupDataProperty());
+  if (array) {
+    for (BlobItemData* item : *array) {
+      if (item->mDisplayItemKey == key) {
+        return item;
+      }
+    }
+  }
+  return nullptr;
+}
+
+// We keep around the BlobItemData so that when we invalidate it get properly
+// included in the rect
+static void DestroyBlobGroupDataProperty(nsTArray<BlobItemData*>* aArray) {
+  for (BlobItemData* item : *aArray) {
+    GP("DestroyBlobGroupDataProperty: %p-%d\n", item->mFrame,
+       item->mDisplayItemKey);
+    item->mFrame = nullptr;
+  }
+  delete aArray;
+}
+
+static void TakeExternalSurfaces(
+    WebRenderDrawEventRecorder* aRecorder,
+    std::vector<RefPtr<SourceSurface>>& aExternalSurfaces,
+    RenderRootStateManager* aManager, wr::IpcResourceUpdateQueue& aResources) {
+  aRecorder->TakeExternalSurfaces(aExternalSurfaces);
+
+  for (auto& surface : aExternalSurfaces) {
+    // While we don't use the image key with the surface, because the blob image
+    // renderer doesn't have easy access to the resource set, we still want to
+    // ensure one is generated. That will ensure the surface remains alive until
+    // at least the last epoch which the blob image could be used in.
+    wr::ImageKey key;
+    DebugOnly<nsresult> rv =
+        SharedSurfacesChild::Share(surface, aManager, aResources, key);
+    MOZ_ASSERT(rv.value != NS_ERROR_NOT_IMPLEMENTED);
+  }
+}
+
+struct DIGroup;
+struct Grouper {
+  explicit Grouper(ClipManager& aClipManager)
+      : mAppUnitsPerDevPixel(0),
+        mDisplayListBuilder(nullptr),
+        mClipManager(aClipManager) {}
+
+  int32_t mAppUnitsPerDevPixel;
+  nsDisplayListBuilder* mDisplayListBuilder;
+  ClipManager& mClipManager;
+  HitTestInfoManager mHitTestInfoManager;
+  Matrix mTransform;
+
+  // Paint the list of aChildren display items.
+  void PaintContainerItem(DIGroup* aGroup, nsDisplayItem* aItem,
+                          BlobItemData* aData, const IntRect& aItemBounds,
+                          bool aDirty, nsDisplayList* aChildren,
+                          gfxContext* aContext,
+                          WebRenderDrawEventRecorder* aRecorder,
+                          RenderRootStateManager* aRootManager,
+                          wr::IpcResourceUpdateQueue& aResources);
+
+  // Builds groups of display items split based on 'layer activity'
+  void ConstructGroups(nsDisplayListBuilder* aDisplayListBuilder,
+                       WebRenderCommandBuilder* aCommandBuilder,
+                       wr::DisplayListBuilder& aBuilder,
+                       wr::IpcResourceUpdateQueue& aResources, DIGroup* aGroup,
+                       nsDisplayList* aList, nsDisplayItem* aWrappingItem,
+                       const StackingContextHelper& aSc);
+  // Builds a group of display items without promoting anything to active.
+  bool ConstructGroupInsideInactive(WebRenderCommandBuilder* aCommandBuilder,
+                                    wr::DisplayListBuilder& aBuilder,
+                                    wr::IpcResourceUpdateQueue& aResources,
+                                    DIGroup* aGroup, nsDisplayList* aList,
+                                    const StackingContextHelper& aSc);
+  // Helper method for processing a single inactive item
+  bool ConstructItemInsideInactive(WebRenderCommandBuilder* aCommandBuilder,
+                                   wr::DisplayListBuilder& aBuilder,
+                                   wr::IpcResourceUpdateQueue& aResources,
+                                   DIGroup* aGroup, nsDisplayItem* aItem,
+                                   const StackingContextHelper& aSc,
+                                   bool* aOutIsInvisible);
+  ~Grouper() = default;
+};
+
+// Returns whether this is an item for which complete invalidation was
+// reliant on LayerTreeInvalidation in the pre-webrender world.
+static bool IsContainerLayerItem(nsDisplayItem* aItem) {
+  switch (aItem->GetType()) {
+    case DisplayItemType::TYPE_WRAP_LIST:
+    case DisplayItemType::TYPE_CONTAINER:
+    case DisplayItemType::TYPE_TRANSFORM:
+    case DisplayItemType::TYPE_OPACITY:
+    case DisplayItemType::TYPE_FILTER:
+    case DisplayItemType::TYPE_BLEND_CONTAINER:
+    case DisplayItemType::TYPE_BLEND_MODE:
+    case DisplayItemType::TYPE_MASK:
+    case DisplayItemType::TYPE_PERSPECTIVE: {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+#include <sstream>
+
+static bool DetectContainerLayerPropertiesBoundsChange(
+    nsDisplayItem* aItem, BlobItemData* aData,
+    nsDisplayItemGeometry& aGeometry) {
+  if (aItem->GetType() == DisplayItemType::TYPE_FILTER) {
+    // Filters get clipped to the BuildingRect since they can
+    // have huge bounds outside of the visible area.
+    aGeometry.mBounds = aGeometry.mBounds.Intersect(aItem->GetBuildingRect());
+  }
+
+  return !aGeometry.mBounds.IsEqualEdges(aData->mGeometry->mBounds);
+}
+
+/* A Display Item Group. This represents a set of diplay items that
+ * have been grouped together for rasterization and can be partially
+ * invalidated. It also tracks a number of properties from the environment
+ * that when changed would cause us to repaint like mScale. */
+struct DIGroup {
+  // XXX: Storing owning pointers to the BlobItemData in a hash table is not
+  // a good choice. There are two better options:
+  //
+  // 1. We should just be using a linked list for this stuff.
+  //    That we can iterate over only the used items.
+  //    We remove from the unused list and add to the used list
+  //    when we see an item.
+  //
+  //    we allocate using a free list.
+  //
+  // 2. We can use a Vec and use SwapRemove().
+  //    We'll just need to be careful when iterating.
+  //    The advantage of a Vec is that everything stays compact
+  //    and we don't need to heap allocate the BlobItemData's
+  nsTHashSet<BlobItemData*> mDisplayItems;
+
+  LayerIntRect mInvalidRect;
+  LayerIntRect mVisibleRect;
+  // This is the last visible rect sent to WebRender. It's used
+  // to compute the invalid rect and ensure that we send
+  // the appropriate data to WebRender for merging.
+  LayerIntRect mLastVisibleRect;
+
+  // This is the intersection of mVisibleRect and mLastVisibleRect
+  // we ensure that mInvalidRect is contained in mPreservedRect
+  LayerIntRect mPreservedRect;
+  // mHitTestBounds is the same as mActualBounds except for the bounds
+  // of invisible items which are accounted for in the former but not
+  // in the latter.
+  LayerIntRect mHitTestBounds;
+  LayerIntRect mActualBounds;
+  int32_t mAppUnitsPerDevPixel;
+  gfx::MatrixScales mScale;
+  ScrollableLayerGuid::ViewID mScrollId;
+  CompositorHitTestInfo mHitInfo;
+  LayerPoint mResidualOffset;
+  LayerIntRect mLayerBounds;  // mGroupBounds converted to Layer space
+  // mLayerBounds clipped to the container/parent of the
+  // current item being processed.
+  LayerIntRect mClippedImageBounds;  // mLayerBounds with the clipping of any
+                                     // containers applied
+  Maybe<wr::BlobImageKey> mKey;
+  std::vector<RefPtr<ScaledFont>> mFonts;
+
+  DIGroup()
+      : mAppUnitsPerDevPixel(0),
+        mScrollId(ScrollableLayerGuid::NULL_SCROLL_ID),
+        mHitInfo(CompositorHitTestInvisibleToHit) {}
+
+  void InvalidateRect(const LayerIntRect& aRect) {
+    auto r = aRect.Intersect(mPreservedRect);
+    // Empty rects get dropped
+    if (!r.IsEmpty()) {
+      mInvalidRect = mInvalidRect.Union(r);
+    }
+  }
+
+  LayerIntRect ItemBounds(nsDisplayItem* aItem) {
+    BlobItemData* data = GetBlobItemData(aItem);
+    return data->mRect;
+  }
+
+  void ClearItems() {
+    GP("items: %d\n", mDisplayItems.Count());
+    for (BlobItemData* data : mDisplayItems) {
+      GP("Deleting %p-%d\n", data->mFrame, data->mDisplayItemKey);
+      delete data;
+    }
+    mDisplayItems.Clear();
+  }
+
+  void ClearImageKey(RenderRootStateManager* aManager, bool aForce = false) {
+    if (mKey) {
+      MOZ_RELEASE_ASSERT(aForce || mInvalidRect.IsEmpty());
+      aManager->AddBlobImageKeyForDiscard(*mKey);
+      mKey = Nothing();
+    }
+    mFonts.clear();
+  }
+
+  static LayerIntRect ToDeviceSpace(nsRect aBounds, Matrix& aMatrix,
+                                    int32_t aAppUnitsPerDevPixel) {
+    // RoundedOut can convert empty rectangles to non-empty ones
+    // so special case them here
+    if (aBounds.IsEmpty()) {
+      return LayerIntRect();
+    }
+    return LayerIntRect::FromUnknownRect(RoundedOut(aMatrix.TransformBounds(
+        ToRect(nsLayoutUtils::RectToGfxRect(aBounds, aAppUnitsPerDevPixel)))));
+  }
+
+  bool ComputeGeometryChange(nsDisplayItem* aItem, BlobItemData* aData,
+                             Matrix& aMatrix, nsDisplayListBuilder* aBuilder) {
+    // If the frame is marked as invalidated, and didn't specify a rect to
+    // invalidate then we want to invalidate both the old and new bounds,
+    // otherwise we only want to invalidate the changed areas. If we do get an
+    // invalid rect, then we want to add this on top of the change areas.
+    nsRect invalid;
+    bool invalidated = false;
+    const DisplayItemClip& clip = aItem->GetClip();
+
+    int32_t appUnitsPerDevPixel =
+        aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+    MOZ_RELEASE_ASSERT(mAppUnitsPerDevPixel == appUnitsPerDevPixel);
+    GP("\n");
+    GP("clippedImageRect %d %d %d %d\n", mClippedImageBounds.x,
+       mClippedImageBounds.y, mClippedImageBounds.width,
+       mClippedImageBounds.height);
+    LayerIntSize size = mVisibleRect.Size();
+    GP("imageSize: %d %d\n", size.width, size.height);
+    /*if (aItem->IsReused() && aData->mGeometry) {
+      return;
+    }*/
+
+    GP("pre mInvalidRect: %s %p-%d - inv: %d %d %d %d\n", aItem->Name(),
+       aItem->Frame(), aItem->GetPerFrameKey(), mInvalidRect.x, mInvalidRect.y,
+       mInvalidRect.width, mInvalidRect.height);
+    if (!aData->mGeometry) {
+      // This item is being added for the first time, invalidate its entire
+      // area.
+      UniquePtr<nsDisplayItemGeometry> geometry(
+          aItem->AllocateGeometry(aBuilder));
+      nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
+          geometry->ComputeInvalidationRegion());
+      aData->mGeometry = std::move(geometry);
+
+      LayerIntRect transformedRect =
+          ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel);
+      aData->mRect = transformedRect.Intersect(mClippedImageBounds);
+      GP("CGC %s %d %d %d %d\n", aItem->Name(), clippedBounds.x,
+         clippedBounds.y, clippedBounds.width, clippedBounds.height);
+      GP("%d %d,  %f %f\n", mVisibleRect.TopLeft().x.value,
+         mVisibleRect.TopLeft().y.value, aMatrix._11, aMatrix._22);
+      GP("mRect %d %d %d %d\n", aData->mRect.x, aData->mRect.y,
+         aData->mRect.width, aData->mRect.height);
+      InvalidateRect(aData->mRect);
+      aData->mInvalid = true;
+      invalidated = true;
+    } else if (aItem->IsInvalid(invalid) && invalid.IsEmpty()) {
+      UniquePtr<nsDisplayItemGeometry> geometry(
+          aItem->AllocateGeometry(aBuilder));
+      nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
+          geometry->ComputeInvalidationRegion());
+      aData->mGeometry = std::move(geometry);
+
+      GP("matrix: %f %f\n", aMatrix._31, aMatrix._32);
+      GP("frame invalid invalidate: %s\n", aItem->Name());
+      GP("old rect: %d %d %d %d\n", aData->mRect.x, aData->mRect.y,
+         aData->mRect.width, aData->mRect.height);
+      InvalidateRect(aData->mRect);
+      // We want to snap to outside pixels. When should we multiply by the
+      // matrix?
+      // XXX: TransformBounds is expensive. We should avoid doing it if we have
+      // no transform
+      LayerIntRect transformedRect =
+          ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel);
+      aData->mRect = transformedRect.Intersect(mClippedImageBounds);
+      InvalidateRect(aData->mRect);
+      GP("new rect: %d %d %d %d\n", aData->mRect.x, aData->mRect.y,
+         aData->mRect.width, aData->mRect.height);
+      aData->mInvalid = true;
+      invalidated = true;
+    } else {
+      GP("else invalidate: %s\n", aItem->Name());
+      nsRegion combined;
+      // this includes situations like reflow changing the position
+      aItem->ComputeInvalidationRegion(aBuilder, aData->mGeometry.get(),
+                                       &combined);
+      if (!combined.IsEmpty()) {
+        // There might be no point in doing this elaborate tracking here to get
+        // smaller areas
+        InvalidateRect(aData->mRect);  // invalidate the old area -- in theory
+                                       // combined should take care of this
+        UniquePtr<nsDisplayItemGeometry> geometry(
+            aItem->AllocateGeometry(aBuilder));
+        // invalidate the invalidated area.
+
+        aData->mGeometry = std::move(geometry);
+
+        nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
+            aData->mGeometry->ComputeInvalidationRegion());
+        LayerIntRect transformedRect =
+            ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel);
+        aData->mRect = transformedRect.Intersect(mClippedImageBounds);
+        InvalidateRect(aData->mRect);
+
+        aData->mInvalid = true;
+        invalidated = true;
+      } else {
+        if (aData->mClip != clip) {
+          UniquePtr<nsDisplayItemGeometry> geometry(
+              aItem->AllocateGeometry(aBuilder));
+          if (!IsContainerLayerItem(aItem)) {
+            // the bounds of layer items can change on us without
+            // ComputeInvalidationRegion returning any change. Other items
+            // shouldn't have any hidden geometry change.
+            MOZ_RELEASE_ASSERT(
+                geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds));
+          } else {
+            aData->mGeometry = std::move(geometry);
+          }
+          nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
+              aData->mGeometry->ComputeInvalidationRegion());
+          LayerIntRect transformedRect =
+              ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel);
+          InvalidateRect(aData->mRect);
+          aData->mRect = transformedRect.Intersect(mClippedImageBounds);
+          InvalidateRect(aData->mRect);
+          invalidated = true;
+
+          GP("ClipChange: %s %d %d %d %d\n", aItem->Name(), aData->mRect.x,
+             aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());
+
+        } else if (IsContainerLayerItem(aItem)) {
+          UniquePtr<nsDisplayItemGeometry> geometry(
+              aItem->AllocateGeometry(aBuilder));
+          // we need to catch bounds changes of containers so that we continue
+          // to have the correct bounds rects in the recording
+          if (DetectContainerLayerPropertiesBoundsChange(aItem, aData,
+                                                         *geometry)) {
+            nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
+                geometry->ComputeInvalidationRegion());
+            aData->mGeometry = std::move(geometry);
+            LayerIntRect transformedRect =
+                ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel);
+            InvalidateRect(aData->mRect);
+            aData->mRect = transformedRect.Intersect(mClippedImageBounds);
+            InvalidateRect(aData->mRect);
+            invalidated = true;
+            GP("DetectContainerLayerPropertiesBoundsChange change\n");
+          } else {
+            // Handle changes in mClippedImageBounds
+            nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
+                geometry->ComputeInvalidationRegion());
+            LayerIntRect transformedRect =
+                ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel);
+            auto rect = transformedRect.Intersect(mClippedImageBounds);
+            if (!rect.IsEqualEdges(aData->mRect)) {
+              GP("ContainerLayer image rect bounds change\n");
+              InvalidateRect(aData->mRect);
+              aData->mRect = rect;
+              InvalidateRect(aData->mRect);
+              invalidated = true;
+            } else {
+              GP("Layer NoChange: %s %d %d %d %d\n", aItem->Name(),
+                 aData->mRect.x, aData->mRect.y, aData->mRect.XMost(),
+                 aData->mRect.YMost());
+            }
+          }
+        } else {
+          UniquePtr<nsDisplayItemGeometry> geometry(
+              aItem->AllocateGeometry(aBuilder));
+          nsRect clippedBounds = clip.ApplyNonRoundedIntersection(
+              geometry->ComputeInvalidationRegion());
+          LayerIntRect transformedRect =
+              ToDeviceSpace(clippedBounds, aMatrix, appUnitsPerDevPixel);
+          auto rect = transformedRect.Intersect(mClippedImageBounds);
+          // Make sure we update mRect for mClippedImageBounds changes
+          if (!rect.IsEqualEdges(aData->mRect)) {
+            GP("ContainerLayer image rect bounds change\n");
+            InvalidateRect(aData->mRect);
+            aData->mRect = rect;
+            InvalidateRect(aData->mRect);
+            invalidated = true;
+          } else {
+            GP("NoChange: %s %d %d %d %d\n", aItem->Name(), aData->mRect.x,
+               aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());
+          }
+        }
+      }
+    }
+
+    mHitTestBounds.OrWith(aData->mRect);
+    if (!aData->mInvisible) {
+      mActualBounds.OrWith(aData->mRect);
+    }
+    aData->mClip = clip;
+    GP("post mInvalidRect: %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y,
+       mInvalidRect.width, mInvalidRect.height);
+    return invalidated;
+  }
+
+  void EndGroup(WebRenderLayerManager* aWrManager,
+                nsDisplayListBuilder* aDisplayListBuilder,
+                wr::DisplayListBuilder& aBuilder,
+                wr::IpcResourceUpdateQueue& aResources, Grouper* aGrouper,
+                nsDisplayList::iterator aStartItem,
+                nsDisplayList::iterator aEndItem) {
+    GP("\n\n");
+    GP("Begin EndGroup\n");
+
+    auto scale = LayoutDeviceToLayerScale2D::FromUnknownScale(mScale);
+
+    auto hitTestRect = mVisibleRect.Intersect(ViewAs<LayerPixel>(
+        mHitTestBounds, PixelCastJustification::LayerIsImage));
+    if (!hitTestRect.IsEmpty()) {
+      auto deviceHitTestRect =
+          (LayerRect(hitTestRect) - mResidualOffset) / scale;
+      PushHitTest(aBuilder, deviceHitTestRect);
+    }
+
+    mVisibleRect = mVisibleRect.Intersect(ViewAs<LayerPixel>(
+        mActualBounds, PixelCastJustification::LayerIsImage));
+
+    if (mVisibleRect.IsEmpty()) {
+      return;
+    }
+
+    // Invalidate any unused items
+    GP("mDisplayItems\n");
+    mDisplayItems.RemoveIf([&](BlobItemData* data) {
+      GP("  : %p-%d\n", data->mFrame, data->mDisplayItemKey);
+      if (!data->mUsed) {
+        GP("Invalidate unused: %p-%d\n", data->mFrame, data->mDisplayItemKey);
+        InvalidateRect(data->mRect);
+        delete data;
+        return true;
+      }
+
+      data->mUsed = false;
+      return false;
+    });
+
+    IntSize dtSize = mVisibleRect.Size().ToUnknownSize();
+    // The actual display item's size shouldn't have the scale factored in
+    // Round the bounds out to leave space for unsnapped content
+    LayoutDeviceRect itemBounds =
+        (LayerRect(mVisibleRect) - mResidualOffset) / scale;
+
+    if (mInvalidRect.IsEmpty() && mVisibleRect.IsEqualEdges(mLastVisibleRect)) {
+      GP("Not repainting group because it's empty\n");
+      GP("End EndGroup\n");
+      if (mKey) {
+        // Although the contents haven't changed, the visible area *may* have,
+        // so request it be updated unconditionally (wr should be able to easily
+        // detect if this is a no-op on its side, if that matters)
+        aResources.SetBlobImageVisibleArea(
+            *mKey, ViewAs<ImagePixel>(mVisibleRect,
+                                      PixelCastJustification::LayerIsImage));
+        mLastVisibleRect = mVisibleRect;
+        PushImage(aBuilder, itemBounds);
+      }
+      return;
+    }
+
+    std::vector<RefPtr<ScaledFont>> fonts;
+    bool validFonts = true;
+    RefPtr<WebRenderDrawEventRecorder> recorder =
+        MakeAndAddRef<WebRenderDrawEventRecorder>(
+            [&](MemStream& aStream,
+                std::vector<RefPtr<ScaledFont>>& aScaledFonts) {
+              size_t count = aScaledFonts.size();
+              aStream.write((const char*)&count, sizeof(count));
+              for (auto& scaled : aScaledFonts) {
+                Maybe<wr::FontInstanceKey> key =
+                    aWrManager->WrBridge()->GetFontKeyForScaledFont(scaled,
+                                                                    aResources);
+                if (key.isNothing()) {
+                  validFonts = false;
+                  break;
+                }
+                BlobFont font = {key.value(), scaled};
+                aStream.write((const char*)&font, sizeof(font));
+              }
+              fonts = std::move(aScaledFonts);
+            });
+
+    RefPtr<gfx::DrawTarget> dummyDt =
+        gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
+
+    RefPtr<gfx::DrawTarget> dt = gfx::Factory::CreateRecordingDrawTarget(
+        recorder, dummyDt, mLayerBounds.ToUnknownRect());
+    if (!dt || !dt->IsValid()) {
+      gfxCriticalNote << "Failed to create drawTarget for blob image";
+      return;
+    }
+
+    gfxContext context(dt);
+    context.SetMatrix(Matrix::Scaling(mScale).PostTranslate(mResidualOffset.x,
+                                                            mResidualOffset.y));
+
+    GP("mInvalidRect: %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y,
+       mInvalidRect.width, mInvalidRect.height);
+
+    RenderRootStateManager* rootManager =
+        aWrManager->GetRenderRootStateManager();
+
+    bool empty = aStartItem == aEndItem;
+    if (empty) {
+      ClearImageKey(rootManager, true);
+      return;
+    }
+
+    PaintItemRange(aGrouper, aStartItem, aEndItem, &context, recorder,
+                   rootManager, aResources);
+
+    // XXX: set this correctly perhaps using
+    // aItem->GetOpaqueRegion(aDisplayListBuilder, &snapped).
+    //   Contains(paintBounds);?
+    wr::OpacityType opacity = wr::OpacityType::HasAlphaChannel;
+
+    bool hasItems = recorder->Finish();
+    GP("%d Finish\n", hasItems);
+    if (!validFonts) {
+      gfxCriticalNote << "Failed serializing fonts for blob image";
+      return;
+    }
+    Range<uint8_t> bytes((uint8_t*)recorder->mOutputStream.mData,
+                         recorder->mOutputStream.mLength);
+    if (!mKey) {
+      // we don't want to send a new image that doesn't have any
+      // items in it
+      if (!hasItems || mVisibleRect.IsEmpty()) {
+        GP("Skipped group with no items\n");
+        return;
+      }
+
+      wr::BlobImageKey key =
+          wr::BlobImageKey{aWrManager->WrBridge()->GetNextImageKey()};
+      GP("No previous key making new one %d\n", key._0.mHandle);
+      wr::ImageDescriptor descriptor(dtSize, 0, dt->GetFormat(), opacity);
+      MOZ_RELEASE_ASSERT(bytes.length() > sizeof(size_t));
+      if (!aResources.AddBlobImage(
+              key, descriptor, bytes,
+              ViewAs<ImagePixel>(mVisibleRect,
+                                 PixelCastJustification::LayerIsImage))) {
+        return;
+      }
+      mKey = Some(key);
+    } else {
+      MOZ_DIAGNOSTIC_ASSERT(
+          aWrManager->WrBridge()->MatchesNamespace(mKey.ref()),
+          "Stale blob key for group!");
+
+      wr::ImageDescriptor descriptor(dtSize, 0, dt->GetFormat(), opacity);
+
+      // Convert mInvalidRect to image space by subtracting the corner of the
+      // image bounds
+      auto dirtyRect = ViewAs<ImagePixel>(mInvalidRect,
+                                          PixelCastJustification::LayerIsImage);
+
+      auto bottomRight = dirtyRect.BottomRight();
+      GP("check invalid %d %d - %d %d\n", bottomRight.x.value,
+         bottomRight.y.value, dtSize.width, dtSize.height);
+      GP("Update Blob %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y,
+         mInvalidRect.width, mInvalidRect.height);
+      if (!aResources.UpdateBlobImage(
+              *mKey, descriptor, bytes,
+              ViewAs<ImagePixel>(mVisibleRect,
+                                 PixelCastJustification::LayerIsImage),
+              dirtyRect)) {
+        return;
+      }
+    }
+    mFonts = std::move(fonts);
+    aResources.SetBlobImageVisibleArea(
+        *mKey,
+        ViewAs<ImagePixel>(mVisibleRect, PixelCastJustification::LayerIsImage));
+    mLastVisibleRect = mVisibleRect;
+    PushImage(aBuilder, itemBounds);
+    GP("End EndGroup\n\n");
+  }
+
+  void PushImage(wr::DisplayListBuilder& aBuilder,
+                 const LayoutDeviceRect& bounds) {
+    wr::LayoutRect dest = wr::ToLayoutRect(bounds);
+    GP("PushImage: %f %f %f %f\n", dest.min.x, dest.min.y, dest.max.x,
+       dest.max.y);
+    // wr::ToImageRendering(aItem->Frame()->UsedImageRendering());
+    auto rendering = wr::ImageRendering::Auto;
+    bool backfaceHidden = false;
+
+    // XXX - clipping the item against the paint rect breaks some content.
+    // cf. Bug 1455422.
+    // wr::LayoutRect clip = wr::ToLayoutRect(bounds.Intersect(mVisibleRect));
+
+    aBuilder.PushImage(dest, dest, !backfaceHidden, false, rendering,
+                       wr::AsImageKey(*mKey));
+  }
+
+  void PushHitTest(wr::DisplayListBuilder& aBuilder,
+                   const LayoutDeviceRect& bounds) {
+    wr::LayoutRect dest = wr::ToLayoutRect(bounds);
+    GP("PushHitTest: %f %f %f %f\n", dest.min.x, dest.min.y, dest.max.x,
+       dest.max.y);
+
+    // We don't really know the exact shape of this blob because it may contain
+    // SVG shapes. Also mHitInfo may be a combination of hit info flags from
+    // different shapes so generate an irregular-area hit-test region for it.
+    CompositorHitTestInfo hitInfo = mHitInfo;
+    if (hitInfo.contains(CompositorHitTestFlags::eVisibleToHitTest)) {
+      hitInfo += CompositorHitTestFlags::eIrregularArea;
+    }
+
+    bool backfaceHidden = false;
+    aBuilder.PushHitTest(dest, dest, !backfaceHidden, mScrollId, hitInfo,
+                         SideBits::eNone);
+  }
+
+  void PaintItemRange(Grouper* aGrouper, nsDisplayList::iterator aStartItem,
+                      nsDisplayList::iterator aEndItem, gfxContext* aContext,
+                      WebRenderDrawEventRecorder* aRecorder,
+                      RenderRootStateManager* aRootManager,
+                      wr::IpcResourceUpdateQueue& aResources) {
+    LayerIntSize size = mVisibleRect.Size();
+    for (auto it = aStartItem; it != aEndItem; ++it) {
+      nsDisplayItem* item = *it;
+      MOZ_ASSERT(item);
+
+      BlobItemData* data = GetBlobItemData(item);
+      if (data->mInvisible) {
+        continue;
+      }
+
+      LayerIntRect bounds = data->mRect;
+      auto bottomRight = bounds.BottomRight();
+
+      GP("Trying %s %p-%d %d %d %d %d\n", item->Name(), item->Frame(),
+         item->GetPerFrameKey(), bounds.x, bounds.y, bounds.XMost(),
+         bounds.YMost());
+
+      if (item->GetType() == DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO) {
+        continue;
+      }
+
+      GP("paint check invalid %d %d - %d %d\n", bottomRight.x.value,
+         bottomRight.y.value, size.width, size.height);
+      // skip empty items
+      if (bounds.IsEmpty()) {
+        continue;
+      }
+
+      bool dirty = true;
+      auto preservedBounds = bounds.Intersect(mPreservedRect);
+      if (!mInvalidRect.Contains(preservedBounds)) {
+        GP("Passing\n");
+        dirty = false;
+        BlobItemData* data = GetBlobItemData(item);
+        if (data->mInvalid) {
+          gfxCriticalError()
+              << "DisplayItem" << item->Name() << "-should be invalid";
+        }
+        // if the item is invalid it needs to be fully contained
+        MOZ_RELEASE_ASSERT(!data->mInvalid);
+      }
+
+      nsDisplayList* children = item->GetChildren();
+      if (children) {
+        // If we aren't dirty, we still need to iterate over the children to
+        // ensure the blob index data is recorded the same as before to allow
+        // the merging of the parts inside in the invalid rect. Any items that
+        // are painted as a single item need to avoid repainting in that case.
+        GP("doing children in EndGroup\n");
+        aGrouper->PaintContainerItem(this, item, data, bounds.ToUnknownRect(),
+                                     dirty, children, aContext, aRecorder,
+                                     aRootManager, aResources);
+        continue;
+      }
+      nsPaintedDisplayItem* paintedItem = item->AsPaintedDisplayItem();
+      if (!paintedItem) {
+        continue;
+      }
+      if (dirty) {
+        // What should the clip settting strategy be? We can set the full
+        // clip everytime. this is probably easiest for now. An alternative
+        // would be to put the push and the pop into separate items and let
+        // invalidation handle it that way.
+        DisplayItemClip currentClip = paintedItem->GetClip();
+
+        if (currentClip.HasClip()) {
+          aContext->Save();
+          currentClip.ApplyTo(aContext, aGrouper->mAppUnitsPerDevPixel);
+        }
+        aContext->NewPath();
+        GP("painting %s %p-%d\n", paintedItem->Name(), paintedItem->Frame(),
+           paintedItem->GetPerFrameKey());
+        if (aGrouper->mDisplayListBuilder->IsPaintingToWindow()) {
+          paintedItem->Frame()->AddStateBits(NS_FRAME_PAINTED_THEBES);
+        }
+
+        paintedItem->Paint(aGrouper->mDisplayListBuilder, aContext);
+        TakeExternalSurfaces(aRecorder, data->mExternalSurfaces, aRootManager,
+                             aResources);
+
+        if (currentClip.HasClip()) {
+          aContext->Restore();
+        }
+      }
+      aContext->GetDrawTarget()->FlushItem(bounds.ToUnknownRect());
+    }
+  }
+
+  ~DIGroup() {
+    GP("Group destruct\n");
+    for (BlobItemData* data : mDisplayItems) {
+      GP("Deleting %p-%d\n", data->mFrame, data->mDisplayItemKey);
+      delete data;
+    }
+  }
+};
+
+// If we have an item we need to make sure it matches the current group
+// otherwise it means the item switched groups and we need to invalidate
+// it and recreate the data.
+static BlobItemData* GetBlobItemDataForGroup(nsDisplayItem* aItem,
+                                             DIGroup* aGroup) {
+  BlobItemData* data = GetBlobItemData(aItem);
+  if (data) {
+    MOZ_RELEASE_ASSERT(data->mGroup->mDisplayItems.Contains(data));
+    if (data->mGroup != aGroup) {
+      GP("group don't match %p %p\n", data->mGroup, aGroup);
+      data->ClearFrame();
+      // the item is for another group
+      // it should be cleared out as being unused at the end of this paint
+      data = nullptr;
+    }
+  }
+  if (!data) {
+    GP("Allocating blob data\n");
+    data = new BlobItemData(aGroup, aItem);
+    aGroup->mDisplayItems.Insert(data);
+  }
+  data->mUsed = true;
+  return data;
+}
+
+void Grouper::PaintContainerItem(DIGroup* aGroup, nsDisplayItem* aItem,
+                                 BlobItemData* aData,
+                                 const IntRect& aItemBounds, bool aDirty,
+                                 nsDisplayList* aChildren, gfxContext* aContext,
+                                 WebRenderDrawEventRecorder* aRecorder,
+                                 RenderRootStateManager* aRootManager,
+                                 wr::IpcResourceUpdateQueue& aResources) {
+  switch (aItem->GetType()) {
+    case DisplayItemType::TYPE_TRANSFORM: {
+      DisplayItemClip currentClip = aItem->GetClip();
+
+      gfxContextMatrixAutoSaveRestore saveMatrix;
+      if (currentClip.HasClip()) {
+        aContext->Save();
+        currentClip.ApplyTo(aContext, this->mAppUnitsPerDevPixel);
+        aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      } else {
+        saveMatrix.SetContext(aContext);
+      }
+
+      auto transformItem = static_cast<nsDisplayTransform*>(aItem);
+      Matrix4x4Flagged trans = transformItem->GetTransform();
+      Matrix trans2d;
+      if (!trans.Is2D(&trans2d)) {
+        // Painting will cause us to include the item's recording in the blob.
+        // We only want to do that if it is dirty, because otherwise the
+        // recording might change (e.g. due to factor of 2 scaling of images
+        // giving different results) and the merging will discard it because it
+        // is outside the invalid rect.
+        if (aDirty) {
+          // We don't currently support doing invalidation inside 3d transforms.
+          // For now just paint it as a single item.
+          aItem->AsPaintedDisplayItem()->Paint(mDisplayListBuilder, aContext);
+          TakeExternalSurfaces(aRecorder, aData->mExternalSurfaces,
+                               aRootManager, aResources);
+        }
+        aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      } else if (!trans2d.IsSingular()) {
+        aContext->Multiply(ThebesMatrix(trans2d));
+        aGroup->PaintItemRange(this, aChildren->begin(), aChildren->end(),
+                               aContext, aRecorder, aRootManager, aResources);
+      }
+
+      if (currentClip.HasClip()) {
+        aContext->Restore();
+        aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      }
+      break;
+    }
+    case DisplayItemType::TYPE_OPACITY: {
+      auto opacityItem = static_cast<nsDisplayOpacity*>(aItem);
+      float opacity = opacityItem->GetOpacity();
+      if (opacity == 0.0f) {
+        return;
+      }
+
+      aContext->GetDrawTarget()->PushLayer(false, opacityItem->GetOpacity(),
+                                           nullptr, mozilla::gfx::Matrix(),
+                                           aItemBounds);
+      GP("beginGroup %s %p-%d\n", aItem->Name(), aItem->Frame(),
+         aItem->GetPerFrameKey());
+      aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      aGroup->PaintItemRange(this, aChildren->begin(), aChildren->end(),
+                             aContext, aRecorder, aRootManager, aResources);
+      aContext->GetDrawTarget()->PopLayer();
+      GP("endGroup %s %p-%d\n", aItem->Name(), aItem->Frame(),
+         aItem->GetPerFrameKey());
+      aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      break;
+    }
+    case DisplayItemType::TYPE_BLEND_MODE: {
+      auto blendItem = static_cast<nsDisplayBlendMode*>(aItem);
+      auto blendMode = blendItem->BlendMode();
+      aContext->GetDrawTarget()->PushLayerWithBlend(
+          false, 1.0, nullptr, mozilla::gfx::Matrix(), aItemBounds, false,
+          blendMode);
+      GP("beginGroup %s %p-%d\n", aItem->Name(), aItem->Frame(),
+         aItem->GetPerFrameKey());
+      aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      aGroup->PaintItemRange(this, aChildren->begin(), aChildren->end(),
+                             aContext, aRecorder, aRootManager, aResources);
+      aContext->GetDrawTarget()->PopLayer();
+      GP("endGroup %s %p-%d\n", aItem->Name(), aItem->Frame(),
+         aItem->GetPerFrameKey());
+      aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      break;
+    }
+    case DisplayItemType::TYPE_BLEND_CONTAINER: {
+      aContext->GetDrawTarget()->PushLayer(false, 1.0, nullptr,
+                                           mozilla::gfx::Matrix(), aItemBounds);
+      GP("beginGroup %s %p-%d\n", aItem->Name(), aItem->Frame(),
+         aItem->GetPerFrameKey());
+      aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      aGroup->PaintItemRange(this, aChildren->begin(), aChildren->end(),
+                             aContext, aRecorder, aRootManager, aResources);
+      aContext->GetDrawTarget()->PopLayer();
+      GP("endGroup %s %p-%d\n", aItem->Name(), aItem->Frame(),
+         aItem->GetPerFrameKey());
+      aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      break;
+    }
+    case DisplayItemType::TYPE_MASK: {
+      GP("Paint Mask\n");
+      auto maskItem = static_cast<nsDisplayMasksAndClipPaths*>(aItem);
+      if (maskItem->IsValidMask()) {
+        maskItem->PaintWithContentsPaintCallback(
+            mDisplayListBuilder, aContext, [&] {
+              GP("beginGroup %s %p-%d\n", aItem->Name(), aItem->Frame(),
+                 aItem->GetPerFrameKey());
+              aContext->GetDrawTarget()->FlushItem(aItemBounds);
+              aGroup->PaintItemRange(this, aChildren->begin(), aChildren->end(),
+                                     aContext, aRecorder, aRootManager,
+                                     aResources);
+              GP("endGroup %s %p-%d\n", aItem->Name(), aItem->Frame(),
+                 aItem->GetPerFrameKey());
+            });
+        TakeExternalSurfaces(aRecorder, aData->mExternalSurfaces, aRootManager,
+                             aResources);
+        aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      }
+      break;
+    }
+    case DisplayItemType::TYPE_FILTER: {
+      GP("Paint Filter\n");
+      // Painting will cause us to include the item's recording in the blob. We
+      // only want to do that if it is dirty, because otherwise the recording
+      // might change (e.g. due to factor of 2 scaling of images giving
+      // different results) and the merging will discard it because it is
+      // outside the invalid rect.
+      if (aDirty) {
+        auto filterItem = static_cast<nsDisplayFilters*>(aItem);
+
+        nsRegion visible(aItem->GetClippedBounds(mDisplayListBuilder));
+        nsRect buildingRect = aItem->GetBuildingRect();
+        visible.And(visible, buildingRect);
+
+        filterItem->Paint(mDisplayListBuilder, aContext);
+        TakeExternalSurfaces(aRecorder, aData->mExternalSurfaces, aRootManager,
+                             aResources);
+      }
+      aContext->GetDrawTarget()->FlushItem(aItemBounds);
+      break;
+    }
+
+    default:
+      aGroup->PaintItemRange(this, aChildren->begin(), aChildren->end(),
+                             aContext, aRecorder, aRootManager, aResources);
+      break;
+  }
+}
+
+class WebRenderGroupData : public WebRenderUserData {
+ public:
+  WebRenderGroupData(RenderRootStateManager* aWRManager, nsDisplayItem* aItem);
+  virtual ~WebRenderGroupData();
+
+  WebRenderGroupData* AsGroupData() override { return this; }
+  UserDataType GetType() override { return UserDataType::eGroup; }
+  static UserDataType Type() { return UserDataType::eGroup; }
+
+  DIGroup mSubGroup;
+  DIGroup mFollowingGroup;
+};
+
+enum class ItemActivity : uint8_t {
+  /// Item must not be active.
+  No = 0,
+  /// Could be active if it has no layerization cost.
+  /// Typically active if first of an item group.
+  Could = 1,
+  /// Should be active unless something external makes that less useful.
+  /// For example if the item is affected by a complex mask, it remains
+  /// inactive.
+  Should = 2,
+  /// Must be active regardless of external factors.
+  Must = 3,
+};
+
+ItemActivity CombineActivity(ItemActivity a, ItemActivity b) {
+  return a > b ? a : b;
+}
+
+bool ActivityAtLeast(ItemActivity rhs, ItemActivity atLeast) {
+  return rhs >= atLeast;
+}
+
+static ItemActivity IsItemProbablyActive(
+    nsDisplayItem* aItem, mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const mozilla::layers::StackingContextHelper& aSc,
+    mozilla::layers::RenderRootStateManager* aManager,
+    nsDisplayListBuilder* aDisplayListBuilder, bool aSiblingActive,
+    bool aUniformlyScaled);
+
+static ItemActivity HasActiveChildren(
+    const nsDisplayList& aList, mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const mozilla::layers::StackingContextHelper& aSc,
+    mozilla::layers::RenderRootStateManager* aManager,
+    nsDisplayListBuilder* aDisplayListBuilder, bool aUniformlyScaled) {
+  ItemActivity activity = ItemActivity::No;
+  for (nsDisplayItem* item : aList) {
+    // Here we only want to know if a child must be active, so we don't specify
+    // when the item is first or last, which can cause an item that could be
+    // either decide to be active. This is a bit conservative and avoids some
+    // extra layers. It's a good tradeoff until we get to the point where most
+    // items could have been active but none *had* to. Right now this is
+    // unlikely but as more svg items get webrenderized it will be better to
+    // make them active more aggressively.
+    auto childActivity =
+        IsItemProbablyActive(item, aBuilder, aResources, aSc, aManager,
+                             aDisplayListBuilder, false, aUniformlyScaled);
+    activity = CombineActivity(activity, childActivity);
+    if (activity == ItemActivity::Must) {
+      return activity;
+    }
+  }
+  return activity;
+}
+
+static ItemActivity AssessBounds(const StackingContextHelper& aSc,
+                                 nsDisplayListBuilder* aDisplayListBuilder,
+                                 nsDisplayItem* aItem,
+                                 bool aHasActivePrecedingSibling) {
+  // Arbitrary threshold up for adjustments. What we want to avoid here
+  // is alternating between active and non active items and create a lot
+  // of overlapping blobs, so we only make images active if they are
+  // costly enough that it's worth the risk of having more layers. As we
+  // move more blob items into wr display items it will become less of a
+  // concern.
+  constexpr float largeish = 512;
+
+  bool snap = false;
+  nsRect bounds = aItem->GetBounds(aDisplayListBuilder, &snap);
+
+  float appUnitsPerDevPixel =
+      static_cast<float>(aItem->Frame()->PresContext()->AppUnitsPerDevPixel());
+
+  float width =
+      static_cast<float>(bounds.width) * aSc.GetInheritedScale().xScale;
+  float height =
+      static_cast<float>(bounds.height) * aSc.GetInheritedScale().yScale;
+
+  // Webrender doesn't handle primitives smaller than a pixel well, so
+  // avoid making them active.
+  if (width >= appUnitsPerDevPixel && height >= appUnitsPerDevPixel) {
+    if (aHasActivePrecedingSibling || width > largeish || height > largeish) {
+      return ItemActivity::Should;
+    }
+
+    return ItemActivity::Could;
+  }
+
+  return ItemActivity::No;
+}
+
+// This function decides whether we want to treat this item as "active", which
+// means that it's a container item which we will turn into a WebRender
+// StackingContext, or whether we treat it as "inactive" and include it inside
+// the parent blob image.
+//
+// We can't easily use GetLayerState because it wants a bunch of layers related
+// information.
+static ItemActivity IsItemProbablyActive(
+    nsDisplayItem* aItem, mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const mozilla::layers::StackingContextHelper& aSc,
+    mozilla::layers::RenderRootStateManager* aManager,
+    nsDisplayListBuilder* aDisplayListBuilder, bool aHasActivePrecedingSibling,
+    bool aUniformlyScaled) {
+  switch (aItem->GetType()) {
+    case DisplayItemType::TYPE_TRANSFORM: {
+      nsDisplayTransform* transformItem =
+          static_cast<nsDisplayTransform*>(aItem);
+      const Matrix4x4Flagged& t = transformItem->GetTransform();
+      Matrix t2d;
+      bool is2D = t.Is2D(&t2d);
+      if (!is2D) {
+        return ItemActivity::Must;
+      }
+
+      auto activity = HasActiveChildren(*transformItem->GetChildren(), aBuilder,
+                                        aResources, aSc, aManager,
+                                        aDisplayListBuilder, aUniformlyScaled);
+
+      if (transformItem->MayBeAnimated(aDisplayListBuilder)) {
+        activity = CombineActivity(activity, ItemActivity::Should);
+      }
+
+      return activity;
+    }
+    case DisplayItemType::TYPE_OPACITY: {
+      nsDisplayOpacity* opacityItem = static_cast<nsDisplayOpacity*>(aItem);
+      if (opacityItem->NeedsActiveLayer(aDisplayListBuilder,
+                                        opacityItem->Frame())) {
+        return ItemActivity::Must;
+      }
+      return HasActiveChildren(*opacityItem->GetChildren(), aBuilder,
+                               aResources, aSc, aManager, aDisplayListBuilder,
+                               aUniformlyScaled);
+    }
+    case DisplayItemType::TYPE_FOREIGN_OBJECT: {
+      return ItemActivity::Must;
+    }
+    case DisplayItemType::TYPE_SVG_GEOMETRY: {
+      auto* svgItem = static_cast<DisplaySVGGeometry*>(aItem);
+      if (StaticPrefs::gfx_webrender_svg_shapes() && aUniformlyScaled &&
+          svgItem->ShouldBeActive(aBuilder, aResources, aSc, aManager,
+                                  aDisplayListBuilder)) {
+        return AssessBounds(aSc, aDisplayListBuilder, aItem,
+                            aHasActivePrecedingSibling);
+      }
+
+      return ItemActivity::No;
+    }
+    case DisplayItemType::TYPE_SVG_IMAGE: {
+      auto* svgItem = static_cast<DisplaySVGImage*>(aItem);
+      if (StaticPrefs::gfx_webrender_svg_images() && aUniformlyScaled &&
+          svgItem->ShouldBeActive(aBuilder, aResources, aSc, aManager,
+                                  aDisplayListBuilder)) {
+        return AssessBounds(aSc, aDisplayListBuilder, aItem,
+                            aHasActivePrecedingSibling);
+      }
+
+      return ItemActivity::No;
+    }
+    case DisplayItemType::TYPE_BLEND_MODE: {
+      /* BLEND_MODE needs to be active if it might have a previous sibling
+       * that is active so that it's able to blend with that content. */
+      if (aHasActivePrecedingSibling) {
+        return ItemActivity::Must;
+      }
+
+      return HasActiveChildren(*aItem->GetChildren(), aBuilder, aResources, aSc,
+                               aManager, aDisplayListBuilder, aUniformlyScaled);
+    }
+    case DisplayItemType::TYPE_MASK: {
+      if (aItem->GetChildren()) {
+        auto activity =
+            HasActiveChildren(*aItem->GetChildren(), aBuilder, aResources, aSc,
+                              aManager, aDisplayListBuilder, aUniformlyScaled);
+        // For masked items, don't bother with making children active since we
+        // are going to have to need to paint and upload a large mask anyway.
+        if (activity < ItemActivity::Must) {
+          return ItemActivity::No;
+        }
+        return activity;
+      }
+      return ItemActivity::No;
+    }
+    case DisplayItemType::TYPE_WRAP_LIST:
+    case DisplayItemType::TYPE_CONTAINER:
+    case DisplayItemType::TYPE_PERSPECTIVE: {
+      if (aItem->GetChildren()) {
+        return HasActiveChildren(*aItem->GetChildren(), aBuilder, aResources,
+                                 aSc, aManager, aDisplayListBuilder,
+                                 aUniformlyScaled);
+      }
+      return ItemActivity::No;
+    }
+    case DisplayItemType::TYPE_FILTER: {
+      nsDisplayFilters* filters = static_cast<nsDisplayFilters*>(aItem);
+      if (filters->CanCreateWebRenderCommands()) {
+        // Items are usually expensive enough on the CPU that we want to
+        // make them active whenever we can.
+        return ItemActivity::Must;
+      }
+      return ItemActivity::No;
+    }
+    default:
+      // TODO: handle other items?
+      return ItemActivity::No;
+  }
+}
+
+// This does a pass over the display lists and will join the display items
+// into groups as well as paint them
+void Grouper::ConstructGroups(nsDisplayListBuilder* aDisplayListBuilder,
+                              WebRenderCommandBuilder* aCommandBuilder,
+                              wr::DisplayListBuilder& aBuilder,
+                              wr::IpcResourceUpdateQueue& aResources,
+                              DIGroup* aGroup, nsDisplayList* aList,
+                              nsDisplayItem* aWrappingItem,
+                              const StackingContextHelper& aSc) {
+  RenderRootStateManager* manager =
+      aCommandBuilder->mManager->GetRenderRootStateManager();
+
+  nsDisplayList::iterator startOfCurrentGroup = aList->end();
+  DIGroup* currentGroup = aGroup;
+
+  // We need to track whether we have active siblings for mixed blend mode.
+  bool encounteredActiveItem = false;
+  bool isFirstGroup = true;
+  // Track whether the item is the first (visible) of its group in which case
+  // making it active won't add extra layers.
+  bool isFirst = true;
+
+  for (auto it = aList->begin(); it != aList->end(); ++it) {
+    nsDisplayItem* item = *it;
+    MOZ_ASSERT(item);
+
+    if (item->HasHitTestInfo()) {
+      // Accumulate the hit-test info flags. In cases where there are multiple
+      // hittest-info display items with different flags, mHitInfo will have
+      // the union of all those flags. If that is the case, we will
+      // additionally set eIrregularArea (at the site that we use mHitInfo)
+      // so that downstream consumers of this (primarily APZ) will know that
+      // the exact shape of what gets hit with what is unknown.
+      currentGroup->mHitInfo += item->GetHitTestInfo().Info();
+    }
+
+    if (startOfCurrentGroup == aList->end()) {
+      startOfCurrentGroup = it;
+      if (!isFirstGroup) {
+        mClipManager.SwitchItem(aDisplayListBuilder, aWrappingItem);
+      }
+    }
+
+    bool isLast = it.HasNext();
+
+    // WebRender's anti-aliasing approximation is not very good under
+    // non-uniform scales.
+    bool uniformlyScaled =
+        fabs(aGroup->mScale.xScale - aGroup->mScale.yScale) < 0.1;
+
+    auto activity = IsItemProbablyActive(
+        item, aBuilder, aResources, aSc, manager, mDisplayListBuilder,
+        encounteredActiveItem, uniformlyScaled);
+    auto threshold =
+        isFirst || isLast ? ItemActivity::Could : ItemActivity::Should;
+
+    if (activity >= threshold) {
+      encounteredActiveItem = true;
+      // We're going to be starting a new group.
+      RefPtr<WebRenderGroupData> groupData =
+          aCommandBuilder->CreateOrRecycleWebRenderUserData<WebRenderGroupData>(
+              item);
+
+      groupData->mFollowingGroup.mInvalidRect.SetEmpty();
+
+      // Initialize groupData->mFollowingGroup with data from currentGroup.
+      // We want to copy out this information before calling EndGroup because
+      // EndGroup will set mLastVisibleRect depending on whether
+      // we send something to WebRender.
+
+      // TODO: compute the group bounds post-grouping, so that they can be
+      // tighter for just the sublist that made it into this group.
+      // We want to ensure the tight bounds are still clipped by area
+      // that we're building the display list for.
+      if (groupData->mFollowingGroup.mScale != currentGroup->mScale ||
+          groupData->mFollowingGroup.mAppUnitsPerDevPixel !=
+              currentGroup->mAppUnitsPerDevPixel ||
+          groupData->mFollowingGroup.mResidualOffset !=
+              currentGroup->mResidualOffset) {
+        if (groupData->mFollowingGroup.mAppUnitsPerDevPixel !=
+            currentGroup->mAppUnitsPerDevPixel) {
+          GP("app unit change following: %d %d\n",
+             groupData->mFollowingGroup.mAppUnitsPerDevPixel,
+             currentGroup->mAppUnitsPerDevPixel);
+        }
+        // The group changed size
+        GP("Inner group size change\n");
+        groupData->mFollowingGroup.ClearItems();
+        groupData->mFollowingGroup.ClearImageKey(
+            aCommandBuilder->mManager->GetRenderRootStateManager());
+      }
+      groupData->mFollowingGroup.mAppUnitsPerDevPixel =
+          currentGroup->mAppUnitsPerDevPixel;
+      groupData->mFollowingGroup.mLayerBounds = currentGroup->mLayerBounds;
+      groupData->mFollowingGroup.mClippedImageBounds =
+          currentGroup->mClippedImageBounds;
+      groupData->mFollowingGroup.mScale = currentGroup->mScale;
+      groupData->mFollowingGroup.mResidualOffset =
+          currentGroup->mResidualOffset;
+      groupData->mFollowingGroup.mVisibleRect = currentGroup->mVisibleRect;
+      groupData->mFollowingGroup.mPreservedRect =
+          groupData->mFollowingGroup.mVisibleRect.Intersect(
+              groupData->mFollowingGroup.mLastVisibleRect);
+      groupData->mFollowingGroup.mActualBounds = LayerIntRect();
+      groupData->mFollowingGroup.mHitTestBounds = LayerIntRect();
+      groupData->mFollowingGroup.mHitInfo = currentGroup->mHitInfo;
+
+      currentGroup->EndGroup(aCommandBuilder->mManager, aDisplayListBuilder,
+                             aBuilder, aResources, this, startOfCurrentGroup,
+                             it);
+
+      {
+        auto spaceAndClipChain =
+            mClipManager.SwitchItem(aDisplayListBuilder, item);
+        wr::SpaceAndClipChainHelper saccHelper(aBuilder, spaceAndClipChain);
+        bool hasHitTest = mHitTestInfoManager.ProcessItem(item, aBuilder,
+                                                          aDisplayListBuilder);
+        // XXX - This is hacky. Some items have hit testing info on them but we
+        // also have dedicated hit testing items, the flags of which apply to
+        // the the group that contains them. We don't want layerization to
+        // affect that so if the item didn't emit any hit testing then we still
+        // push a hit test item if the previous group had some hit test flags
+        // set. This is obviously not great. Hit testing should be independent
+        // from how we layerize.
+        if (!hasHitTest &&
+            currentGroup->mHitInfo != gfx::CompositorHitTestInvisibleToHit) {
+          auto hitTestRect = item->GetBuildingRect();
+          if (!hitTestRect.IsEmpty()) {
+            currentGroup->PushHitTest(
+                aBuilder, LayoutDeviceRect::FromAppUnits(
+                              hitTestRect, currentGroup->mAppUnitsPerDevPixel));
+          }
+        }
+
+        sIndent++;
+        // Note: this call to CreateWebRenderCommands can recurse back into
+        // this function.
+        bool createdWRCommands = item->CreateWebRenderCommands(
+            aBuilder, aResources, aSc, manager, mDisplayListBuilder);
+        MOZ_RELEASE_ASSERT(
+            createdWRCommands,
+            "active transforms should always succeed at creating "
+            "WebRender commands");
+        sIndent--;
+      }
+
+      isFirstGroup = false;
+      startOfCurrentGroup = aList->end();
+      currentGroup = &groupData->mFollowingGroup;
+      isFirst = true;
+    } else {  // inactive item
+      bool isInvisible = false;
+      ConstructItemInsideInactive(aCommandBuilder, aBuilder, aResources,
+                                  currentGroup, item, aSc, &isInvisible);
+      if (!isInvisible) {
+        // Invisible items don't count.
+        isFirst = false;
+      }
+    }
+  }
+
+  currentGroup->EndGroup(aCommandBuilder->mManager, aDisplayListBuilder,
+                         aBuilder, aResources, this, startOfCurrentGroup,
+                         aList->end());
+}
+
+// This does a pass over the display lists and will join the display items
+// into a single group.
+bool Grouper::ConstructGroupInsideInactive(
+    WebRenderCommandBuilder* aCommandBuilder, wr::DisplayListBuilder& aBuilder,
+    wr::IpcResourceUpdateQueue& aResources, DIGroup* aGroup,
+    nsDisplayList* aList, const StackingContextHelper& aSc) {
+  bool invalidated = false;
+  for (nsDisplayItem* item : *aList) {
+    if (item->HasHitTestInfo()) {
+      // Accumulate the hit-test info flags. In cases where there are multiple
+      // hittest-info display items with different flags, mHitInfo will have
+      // the union of all those flags. If that is the case, we will
+      // additionally set eIrregularArea (at the site that we use mHitInfo)
+      // so that downstream consumers of this (primarily APZ) will know that
+      // the exact shape of what gets hit with what is unknown.
+      aGroup->mHitInfo += item->GetHitTestInfo().Info();
+    }
+
+    bool invisible = false;
+    invalidated |= ConstructItemInsideInactive(
+        aCommandBuilder, aBuilder, aResources, aGroup, item, aSc, &invisible);
+  }
+  return invalidated;
+}
+
+bool Grouper::ConstructItemInsideInactive(
+    WebRenderCommandBuilder* aCommandBuilder, wr::DisplayListBuilder& aBuilder,
+    wr::IpcResourceUpdateQueue& aResources, DIGroup* aGroup,
+    nsDisplayItem* aItem, const StackingContextHelper& aSc,
+    bool* aOutIsInvisible) {
+  nsDisplayList* children = aItem->GetChildren();
+  BlobItemData* data = GetBlobItemDataForGroup(aItem, aGroup);
+
+  /* mInvalid unfortunately persists across paints. Clear it so that if we don't
+   * set it to 'true' we ensure that we're not using the value from the last
+   * time that we painted */
+  data->mInvalid = false;
+  data->mInvisible = aItem->IsInvisible();
+  *aOutIsInvisible = data->mInvisible;
+
+  // we compute the geometry change here because we have the transform around
+  // still
+  bool invalidated = aGroup->ComputeGeometryChange(aItem, data, mTransform,
+                                                   mDisplayListBuilder);
+
+  // Temporarily restrict the image bounds to the bounds of the container so
+  // that clipped children within the container know about the clip. This
+  // ensures that the bounds passed to FlushItem are contained in the bounds of
+  // the clip so that we don't include items in the recording without including
+  // their corresponding clipping items.
+  auto oldClippedImageBounds = aGroup->mClippedImageBounds;
+  aGroup->mClippedImageBounds =
+      aGroup->mClippedImageBounds.Intersect(data->mRect);
+
+  if (aItem->GetType() == DisplayItemType::TYPE_FILTER) {
+    // If ConstructGroupInsideInactive finds any change, we invalidate the
+    // entire container item. This is needed because blob merging requires the
+    // entire item to be within the invalid region.
+    Matrix m = mTransform;
+    mTransform = Matrix();
+    sIndent++;
+    if (ConstructGroupInsideInactive(aCommandBuilder, aBuilder, aResources,
+                                     aGroup, children, aSc)) {
+      data->mInvalid = true;
+      aGroup->InvalidateRect(data->mRect);
+      invalidated = true;
+    }
+    sIndent--;
+    mTransform = m;
+  } else if (aItem->GetType() == DisplayItemType::TYPE_TRANSFORM) {
+    Matrix m = mTransform;
+    nsDisplayTransform* transformItem = static_cast<nsDisplayTransform*>(aItem);
+    const Matrix4x4Flagged& t = transformItem->GetTransform();
+    Matrix t2d;
+    bool is2D = t.CanDraw2D(&t2d);
+    if (!is2D) {
+      // If ConstructGroupInsideInactive finds any change, we invalidate the
+      // entire container item. This is needed because blob merging requires the
+      // entire item to be within the invalid region.
+      mTransform = Matrix();
+      sIndent++;
+      if (ConstructGroupInsideInactive(aCommandBuilder, aBuilder, aResources,
+                                       aGroup, children, aSc)) {
+        data->mInvalid = true;
+        aGroup->InvalidateRect(data->mRect);
+        invalidated = true;
+      }
+      sIndent--;
+    } else {
+      GP("t2d: %f %f\n", t2d._31, t2d._32);
+      mTransform.PreMultiply(t2d);
+      GP("mTransform: %f %f\n", mTransform._31, mTransform._32);
+      sIndent++;
+      invalidated |= ConstructGroupInsideInactive(
+          aCommandBuilder, aBuilder, aResources, aGroup, children, aSc);
+      sIndent--;
+    }
+    mTransform = m;
+  } else if (children) {
+    sIndent++;
+    invalidated |= ConstructGroupInsideInactive(
+        aCommandBuilder, aBuilder, aResources, aGroup, children, aSc);
+    sIndent--;
+  }
+
+  GP("Including %s of %d\n", aItem->Name(), aGroup->mDisplayItems.Count());
+  aGroup->mClippedImageBounds = oldClippedImageBounds;
+  return invalidated;
+}
+
+/* This is just a copy of nsRect::ScaleToOutsidePixels with an offset added in.
+ * The offset is applied just before the rounding. It's in the scaled space. */
+static mozilla::LayerIntRect ScaleToOutsidePixelsOffset(
+    nsRect aRect, float aXScale, float aYScale, nscoord aAppUnitsPerPixel,
+    LayerPoint aOffset) {
+  mozilla::LayerIntRect rect;
+  rect.SetNonEmptyBox(
+      NSToIntFloor(NSAppUnitsToFloatPixels(aRect.x, float(aAppUnitsPerPixel)) *
+                       aXScale +
+                   aOffset.x),
+      NSToIntFloor(NSAppUnitsToFloatPixels(aRect.y, float(aAppUnitsPerPixel)) *
+                       aYScale +
+                   aOffset.y),
+      NSToIntCeil(
+          NSAppUnitsToFloatPixels(aRect.XMost(), float(aAppUnitsPerPixel)) *
+              aXScale +
+          aOffset.x),
+      NSToIntCeil(
+          NSAppUnitsToFloatPixels(aRect.YMost(), float(aAppUnitsPerPixel)) *
+              aYScale +
+          aOffset.y));
+  return rect;
+}
+
+/* This function is the same as the above except that it rounds to the
+ * nearest instead of rounding out. We use it for attempting to compute the
+ * actual pixel bounds of opaque items */
+static mozilla::gfx::IntRect ScaleToNearestPixelsOffset(
+    nsRect aRect, float aXScale, float aYScale, nscoord aAppUnitsPerPixel,
+    LayerPoint aOffset) {
+  mozilla::gfx::IntRect rect;
+  rect.SetNonEmptyBox(
+      NSToIntFloor(NSAppUnitsToFloatPixels(aRect.x, float(aAppUnitsPerPixel)) *
+                       aXScale +
+                   aOffset.x + 0.5),
+      NSToIntFloor(NSAppUnitsToFloatPixels(aRect.y, float(aAppUnitsPerPixel)) *
+                       aYScale +
+                   aOffset.y + 0.5),
+      NSToIntFloor(
+          NSAppUnitsToFloatPixels(aRect.XMost(), float(aAppUnitsPerPixel)) *
+              aXScale +
+          aOffset.x + 0.5),
+      NSToIntFloor(
+          NSAppUnitsToFloatPixels(aRect.YMost(), float(aAppUnitsPerPixel)) *
+              aYScale +
+          aOffset.y + 0.5));
+  return rect;
+}
+
+RenderRootStateManager* WebRenderCommandBuilder::GetRenderRootStateManager() {
+  return mManager->GetRenderRootStateManager();
+}
+
+void WebRenderCommandBuilder::DoGroupingForDisplayList(
+    nsDisplayList* aList, nsDisplayItem* aWrappingItem,
+    nsDisplayListBuilder* aDisplayListBuilder, const StackingContextHelper& aSc,
+    wr::DisplayListBuilder& aBuilder, wr::IpcResourceUpdateQueue& aResources) {
+  if (!aList->GetBottom()) {
+    return;
+  }
+
+  GP("DoGroupingForDisplayList\n");
+
+  mClipManager.BeginList(aSc);
+  mHitTestInfoManager.Reset();
+  Grouper g(mClipManager);
+
+  int32_t appUnitsPerDevPixel =
+      aWrappingItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+
+  g.mDisplayListBuilder = aDisplayListBuilder;
+  RefPtr<WebRenderGroupData> groupData =
+      CreateOrRecycleWebRenderUserData<WebRenderGroupData>(aWrappingItem);
+
+  bool snapped;
+  nsRect groupBounds =
+      aWrappingItem->GetUntransformedBounds(aDisplayListBuilder, &snapped);
+  DIGroup& group = groupData->mSubGroup;
+
+  auto scale = aSc.GetInheritedScale();
+  GP("Inherited scale %f %f\n", scale.xScale, scale.yScale);
+
+  auto trans =
+      ViewAs<LayerPixel>(aSc.GetSnappingSurfaceTransform().GetTranslation());
+  auto snappedTrans = LayerIntPoint::Floor(trans);
+  LayerPoint residualOffset = trans - snappedTrans;
+
+  auto layerBounds =
+      ScaleToOutsidePixelsOffset(groupBounds, scale.xScale, scale.yScale,
+                                 appUnitsPerDevPixel, residualOffset);
+
+  const nsRect& untransformedPaintRect =
+      aWrappingItem->GetUntransformedPaintRect();
+
+  auto visibleRect = ScaleToOutsidePixelsOffset(
+                         untransformedPaintRect, scale.xScale, scale.yScale,
+                         appUnitsPerDevPixel, residualOffset)
+                         .Intersect(layerBounds);
+
+  GP("LayerBounds: %d %d %d %d\n", layerBounds.x, layerBounds.y,
+     layerBounds.width, layerBounds.height);
+  GP("VisibleRect: %d %d %d %d\n", visibleRect.x, visibleRect.y,
+     visibleRect.width, visibleRect.height);
+
+  GP("Inherited scale %f %f\n", scale.xScale, scale.yScale);
+
+  group.mInvalidRect.SetEmpty();
+  if (group.mAppUnitsPerDevPixel != appUnitsPerDevPixel ||
+      group.mScale != scale || group.mResidualOffset != residualOffset) {
+    GP("Property change. Deleting blob\n");
+
+    if (group.mAppUnitsPerDevPixel != appUnitsPerDevPixel) {
+      GP(" App unit change %d -> %d\n", group.mAppUnitsPerDevPixel,
+         appUnitsPerDevPixel);
+    }
+
+    if (group.mScale != scale) {
+      GP(" Scale %f %f -> %f %f\n", group.mScale.xScale, group.mScale.yScale,
+         scale.xScale, scale.yScale);
+    }
+
+    if (group.mResidualOffset != residualOffset) {
+      GP(" Residual Offset %f %f -> %f %f\n", group.mResidualOffset.x.value,
+         group.mResidualOffset.y.value, residualOffset.x.value,
+         residualOffset.y.value);
+    }
+
+    group.ClearItems();
+    group.ClearImageKey(mManager->GetRenderRootStateManager());
+  }
+
+  ScrollableLayerGuid::ViewID scrollId = ScrollableLayerGuid::NULL_SCROLL_ID;
+  if (const ActiveScrolledRoot* asr = aWrappingItem->GetActiveScrolledRoot()) {
+    scrollId = asr->GetViewId();
+  }
+
+  g.mAppUnitsPerDevPixel = appUnitsPerDevPixel;
+  group.mResidualOffset = residualOffset;
+  group.mLayerBounds = layerBounds;
+  group.mVisibleRect = visibleRect;
+  group.mActualBounds = LayerIntRect();
+  group.mHitTestBounds = LayerIntRect();
+  group.mPreservedRect = group.mVisibleRect.Intersect(group.mLastVisibleRect);
+  group.mAppUnitsPerDevPixel = appUnitsPerDevPixel;
+  group.mClippedImageBounds = layerBounds;
+
+  g.mTransform =
+      Matrix::Scaling(scale).PostTranslate(residualOffset.x, residualOffset.y);
+  group.mScale = scale;
+  group.mScrollId = scrollId;
+  g.ConstructGroups(aDisplayListBuilder, this, aBuilder, aResources, &group,
+                    aList, aWrappingItem, aSc);
+  mClipManager.EndList(aSc);
+}
+
+WebRenderCommandBuilder::WebRenderCommandBuilder(
+    WebRenderLayerManager* aManager)
+    : mManager(aManager),
+      mLastAsr(nullptr),
+      mBuilderDumpIndex(0),
+      mDumpIndent(0),
+      mDoGrouping(false),
+      mContainsSVGGroup(false) {}
+
+void WebRenderCommandBuilder::Destroy() {
+  mLastCanvasDatas.Clear();
+  ClearCachedResources();
+}
+
+void WebRenderCommandBuilder::EmptyTransaction() {
+  // We need to update canvases that might have changed.
+  for (RefPtr<WebRenderCanvasData> canvasData : mLastCanvasDatas) {
+    WebRenderCanvasRendererAsync* canvas = canvasData->GetCanvasRenderer();
+    if (canvas) {
+      canvas->UpdateCompositableClientForEmptyTransaction();
+    }
+  }
+}
+
+bool WebRenderCommandBuilder::NeedsEmptyTransaction() {
+  return !mLastCanvasDatas.IsEmpty();
+}
+
+void WebRenderCommandBuilder::BuildWebRenderCommands(
+    wr::DisplayListBuilder& aBuilder,
+    wr::IpcResourceUpdateQueue& aResourceUpdates, nsDisplayList* aDisplayList,
+    nsDisplayListBuilder* aDisplayListBuilder, WebRenderScrollData& aScrollData,
+    WrFiltersHolder&& aFilters) {
+  AUTO_PROFILER_LABEL_CATEGORY_PAIR(GRAPHICS_WRDisplayList);
+
+  StackingContextHelper sc;
+  aScrollData = WebRenderScrollData(mManager, aDisplayListBuilder);
+  MOZ_ASSERT(mLayerScrollData.empty());
+  mClipManager.BeginBuild(mManager, aBuilder);
+  mHitTestInfoManager.Reset();
+
+  mBuilderDumpIndex = 0;
+  mLastCanvasDatas.Clear();
+  mLastAsr = nullptr;
+  mContainsSVGGroup = false;
+  MOZ_ASSERT(mDumpIndent == 0);
+
+  {
+    wr::StackingContextParams params;
+    params.mRootReferenceFrame = aDisplayListBuilder->RootReferenceFrame();
+    params.mFilters = std::move(aFilters.filters);
+    params.mFilterDatas = std::move(aFilters.filter_datas);
+    params.clip =
+        wr::WrStackingContextClip::ClipChain(aBuilder.CurrentClipChainId());
+
+    StackingContextHelper pageRootSc(sc, nullptr, nullptr, nullptr, aBuilder,
+                                     params);
+    if (ShouldDumpDisplayList(aDisplayListBuilder)) {
+      mBuilderDumpIndex =
+          aBuilder.Dump(mDumpIndent + 1, Some(mBuilderDumpIndex), Nothing());
+    }
+    CreateWebRenderCommandsFromDisplayList(aDisplayList, nullptr,
+                                           aDisplayListBuilder, pageRootSc,
+                                           aBuilder, aResourceUpdates);
+  }
+
+  // Make a "root" layer data that has everything else as descendants
+  mLayerScrollData.emplace_back();
+  mLayerScrollData.back().InitializeRoot(mLayerScrollData.size() - 1);
+  auto callback =
+      [&aScrollData](ScrollableLayerGuid::ViewID aScrollId) -> bool {
+    return aScrollData.HasMetadataFor(aScrollId).isSome();
+  };
+  Maybe<ScrollMetadata> rootMetadata =
+      nsLayoutUtils::GetRootMetadata(aDisplayListBuilder, mManager, callback);
+  if (rootMetadata) {
+    // Put the fallback root metadata on the rootmost layer that is
+    // a matching async zoom container, or the root layer that we just
+    // created above.
+    size_t rootMetadataTarget = mLayerScrollData.size() - 1;
+    for (size_t i = rootMetadataTarget; i > 0; i--) {
+      if (auto zoomContainerId =
+              mLayerScrollData[i - 1].GetAsyncZoomContainerId()) {
+        if (*zoomContainerId == rootMetadata->GetMetrics().GetScrollId()) {
+          rootMetadataTarget = i - 1;
+          break;
+        }
+      }
+    }
+    mLayerScrollData[rootMetadataTarget].AppendScrollMetadata(
+        aScrollData, rootMetadata.ref());
+  }
+
+  // Append the WebRenderLayerScrollData items into WebRenderScrollData
+  // in reverse order, from topmost to bottommost. This is in keeping with
+  // the semantics of WebRenderScrollData.
+  for (auto it = mLayerScrollData.rbegin(); it != mLayerScrollData.rend();
+       it++) {
+    aScrollData.AddLayerData(std::move(*it));
+  }
+  mLayerScrollData.clear();
+  mClipManager.EndBuild();
+
+  // Remove the user data those are not displayed on the screen and
+  // also reset the data to unused for next transaction.
+  RemoveUnusedAndResetWebRenderUserData();
+}
+
+bool WebRenderCommandBuilder::ShouldDumpDisplayList(
+    nsDisplayListBuilder* aBuilder) {
+  return aBuilder && aBuilder->IsInActiveDocShell() &&
+         ((XRE_IsParentProcess() &&
+           StaticPrefs::gfx_webrender_debug_dl_dump_parent()) ||
+          (XRE_IsContentProcess() &&
+           StaticPrefs::gfx_webrender_debug_dl_dump_content()));
+}
+
+void WebRenderCommandBuilder::CreateWebRenderCommands(
+    nsDisplayItem* aItem, mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const StackingContextHelper& aSc,
+    nsDisplayListBuilder* aDisplayListBuilder) {
+  mHitTestInfoManager.ProcessItem(aItem, aBuilder, aDisplayListBuilder);
+  if (aItem->GetType() == DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO) {
+    // The hit test information was processed above.
+    return;
+  }
+
+  auto* item = aItem->AsPaintedDisplayItem();
+  MOZ_RELEASE_ASSERT(item, "Tried to paint item that cannot be painted");
+
+  if (aBuilder.ReuseItem(item)) {
+    // No further processing should be needed, since the item was reused.
+    return;
+  }
+
+  RenderRootStateManager* manager = mManager->GetRenderRootStateManager();
+
+  // Note: this call to CreateWebRenderCommands can recurse back into
+  // this function if the |item| is a wrapper for a sublist.
+  const bool createdWRCommands = aItem->CreateWebRenderCommands(
+      aBuilder, aResources, aSc, manager, aDisplayListBuilder);
+
+  if (!createdWRCommands) {
+    PushItemAsImage(aItem, aBuilder, aResources, aSc, aDisplayListBuilder);
+  }
+}
+
+// A helper struct to store information needed when creating a new
+// WebRenderLayerScrollData in CreateWebRenderCommandsFromDisplayList().
+// This information is gathered before the recursion, and then used to
+// emit the new layer after the recursion.
+struct NewLayerData {
+  size_t mLayerCountBeforeRecursing = 0;
+  const ActiveScrolledRoot* mStopAtAsr = nullptr;
+
+  // Information pertaining to the deferred transform.
+  nsDisplayTransform* mDeferredItem = nullptr;
+  ScrollableLayerGuid::ViewID mDeferredId = ScrollableLayerGuid::NULL_SCROLL_ID;
+  bool mTransformShouldGetOwnLayer = false;
+
+  void ComputeDeferredTransformInfo(
+      const StackingContextHelper& aSc, nsDisplayItem* aItem,
+      nsDisplayTransform* aLastDeferredTransform) {
+    // See the comments on StackingContextHelper::mDeferredTransformItem
+    // for an overview of what deferred transforms are.
+    // In the case where we deferred a transform, but have a child display
+    // item with a different ASR than the deferred transform item, we cannot
+    // put the transform on the WebRenderLayerScrollData item for the child.
+    // We cannot do this because it will not conform to APZ's expectations
+    // with respect to how the APZ tree ends up structured. In particular,
+    // the GetTransformToThis() for the child APZ (which is created for the
+    // child item's ASR) will not include the transform when we actually do
+    // want it to.
+    // When we run into this scenario, we solve it by creating two
+    // WebRenderLayerScrollData items; one that just holds the transform,
+    // that we deferred, and a child WebRenderLayerScrollData item that
+    // holds the scroll metadata for the child's ASR.
+    mDeferredItem = aSc.GetDeferredTransformItem();
+    // If this deferred transform is already slated to be emitted onto an
+    // ancestor layer, do not emit it on this layer as well. Note that it's
+    // sufficient to check the most recently deferred item here, because
+    // there's only one per stacking context, and we emit it when changing
+    // stacking contexts.
+    if (mDeferredItem == aLastDeferredTransform) {
+      mDeferredItem = nullptr;
+    }
+    if (mDeferredItem) {
+      // It's possible the transform's ASR is not only an ancestor of
+      // the item's ASR, but an ancestor of stopAtAsr. In such cases,
+      // don't use the transform at all at this level (it would be
+      // scrolled by stopAtAsr which is incorrect). The transform will
+      // instead be emitted as part of the ancestor WebRenderLayerScrollData
+      // node (the one with stopAtAsr as its item ASR), or one of its
+      // ancetors in turn.
+      if (ActiveScrolledRoot::IsProperAncestor(
+              mDeferredItem->GetActiveScrolledRoot(), mStopAtAsr)) {
+        mDeferredItem = nullptr;
+      }
+    }
+    if (mDeferredItem) {
+      if (const auto* asr = mDeferredItem->GetActiveScrolledRoot()) {
+        mDeferredId = asr->GetViewId();
+      }
+      if (mDeferredItem->GetActiveScrolledRoot() !=
+          aItem->GetActiveScrolledRoot()) {
+        mTransformShouldGetOwnLayer = true;
+      } else if (aItem->GetType() == DisplayItemType::TYPE_SCROLL_INFO_LAYER) {
+        // A scroll info layer has its own scroll id that's not reflected
+        // in item->GetActiveScrolledRoot(), but will be added to the
+        // WebRenderLayerScrollData node, so it needs to be treated as
+        // having a distinct ASR from the deferred transform item.
+        mTransformShouldGetOwnLayer = true;
+      }
+    }
+  }
+};
+
+void WebRenderCommandBuilder::CreateWebRenderCommandsFromDisplayList(
+    nsDisplayList* aDisplayList, nsDisplayItem* aWrappingItem,
+    nsDisplayListBuilder* aDisplayListBuilder, const StackingContextHelper& aSc,
+    wr::DisplayListBuilder& aBuilder, wr::IpcResourceUpdateQueue& aResources,
+    bool aNewClipList) {
+  if (mDoGrouping) {
+    MOZ_RELEASE_ASSERT(
+        aWrappingItem,
+        "Only the root list should have a null wrapping item, and mDoGrouping "
+        "should never be true for the root list.");
+    GP("actually entering the grouping code\n");
+    DoGroupingForDisplayList(aDisplayList, aWrappingItem, aDisplayListBuilder,
+                             aSc, aBuilder, aResources);
+    return;
+  }
+
+  bool dumpEnabled = ShouldDumpDisplayList(aDisplayListBuilder);
+  if (dumpEnabled) {
+    // If we're inside a nested display list, print the WR DL items from the
+    // wrapper item before we start processing the nested items.
+    mBuilderDumpIndex =
+        aBuilder.Dump(mDumpIndent + 1, Some(mBuilderDumpIndex), Nothing());
+  }
+
+  FlattenedDisplayListIterator iter(aDisplayListBuilder, aDisplayList);
+  if (!iter.HasNext()) {
+    return;
+  }
+
+  mDumpIndent++;
+  if (aNewClipList) {
+    mClipManager.BeginList(aSc);
+  }
+
+  const bool apzEnabled = mManager->AsyncPanZoomEnabled();
+  do {
+    nsDisplayItem* item = iter.GetNextItem();
+
+    DisplayItemType itemType = item->GetType();
+
+    // If this is a new (not retained/reused) item, then we need to disable
+    // the display item cache for descendants, since it's possible that some of
+    // them got cached with a flattened opacity values., which may no longer be
+    // applied.
+    Maybe<AutoDisplayItemCacheSuppressor> cacheSuppressor;
+
+    if (itemType == DisplayItemType::TYPE_OPACITY) {
+      nsDisplayOpacity* opacity = static_cast<nsDisplayOpacity*>(item);
+
+      if (!opacity->IsReused()) {
+        cacheSuppressor.emplace(aBuilder.GetDisplayItemCache());
+      }
+
+      if (opacity->CanApplyOpacityToChildren(
+              mManager->GetRenderRootStateManager()->LayerManager(),
+              aDisplayListBuilder, aBuilder.GetInheritedOpacity())) {
+        // If all our children support handling the opacity directly, then push
+        // the opacity and clip onto the builder and skip creating a stacking
+        // context.
+        float oldOpacity = aBuilder.GetInheritedOpacity();
+        const DisplayItemClipChain* oldClip = aBuilder.GetInheritedClipChain();
+        aBuilder.SetInheritedOpacity(oldOpacity * opacity->GetOpacity());
+        aBuilder.PushInheritedClipChain(aDisplayListBuilder,
+                                        opacity->GetClipChain());
+
+        CreateWebRenderCommandsFromDisplayList(opacity->GetChildren(), item,
+                                               aDisplayListBuilder, aSc,
+                                               aBuilder, aResources, false);
+
+        aBuilder.SetInheritedOpacity(oldOpacity);
+        aBuilder.SetInheritedClipChain(oldClip);
+        continue;
+      }
+    }
+
+    // If this is an unscrolled background color item, in the root display list
+    // for the parent process, consider doing opaque checks.
+    if (XRE_IsParentProcess() && !aWrappingItem &&
+        itemType == DisplayItemType::TYPE_BACKGROUND_COLOR &&
+        !item->GetActiveScrolledRoot() &&
+        item->GetClip().GetRoundedRectCount() == 0) {
+      bool snap;
+      nsRegion opaque = item->GetOpaqueRegion(aDisplayListBuilder, &snap);
+      if (opaque.GetNumRects() == 1) {
+        nsRect clippedOpaque =
+            item->GetClip().ApplyNonRoundedIntersection(opaque.GetBounds());
+        if (!clippedOpaque.IsEmpty()) {
+          aDisplayListBuilder->AddWindowOpaqueRegion(item->Frame(),
+                                                     clippedOpaque);
+        }
+      }
+    }
+
+    Maybe<NewLayerData> newLayerData;
+    if (apzEnabled) {
+      // For some types of display items we want to force a new
+      // WebRenderLayerScrollData object, to ensure we preserve the APZ-relevant
+      // data that is in the display item.
+      if (item->UpdateScrollData(nullptr, nullptr)) {
+        newLayerData = Some(NewLayerData());
+      }
+
+      // Anytime the ASR changes we also want to force a new layer data because
+      // the stack of scroll metadata is going to be different for this
+      // display item than previously, so we can't squash the display items
+      // into the same "layer".
+      const ActiveScrolledRoot* asr = item->GetActiveScrolledRoot();
+      if (asr != mLastAsr) {
+        mLastAsr = asr;
+        newLayerData = Some(NewLayerData());
+      }
+
+      // Refer to the comment on StackingContextHelper::mDeferredTransformItem
+      // for an overview of what this is about. This bit of code applies to the
+      // case where we are deferring a transform item, and we then need to defer
+      // another transform with a different ASR. In such a case we cannot just
+      // merge the deferred transforms, but need to force a new
+      // WebRenderLayerScrollData item to flush the old deferred transform, so
+      // that we can then start deferring the new one.
+      if (!newLayerData && item->CreatesStackingContextHelper() &&
+          aSc.GetDeferredTransformItem() &&
+          aSc.GetDeferredTransformItem()->GetActiveScrolledRoot() != asr) {
+        newLayerData = Some(NewLayerData());
+      }
+
+      // If we're going to create a new layer data for this item, stash the
+      // ASR so that if we recurse into a sublist they will know where to stop
+      // walking up their ASR chain when building scroll metadata.
+      if (newLayerData) {
+        newLayerData->mLayerCountBeforeRecursing = mLayerScrollData.size();
+        newLayerData->mStopAtAsr =
+            mAsrStack.empty() ? nullptr : mAsrStack.back();
+        newLayerData->ComputeDeferredTransformInfo(
+            aSc, item,
+            mDeferredTransformStack.empty() ? nullptr
+                                            : mDeferredTransformStack.back());
+
+        // Ensure our children's |stopAtAsr| is not be an ancestor of our
+        // |stopAtAsr|, otherwise we could get cyclic scroll metadata
+        // annotations.
+        const ActiveScrolledRoot* stopAtAsrForChildren =
+            ActiveScrolledRoot::PickDescendant(asr, newLayerData->mStopAtAsr);
+        // Additionally, while unusual and probably indicative of a poorly
+        // behaved display list, it's possible to have a deferred transform item
+        // which we will emit as its own layer on the way out of the recursion,
+        // whose ASR (let's call it T) is a *descendant* of the current item's
+        // ASR. In such cases, make sure our children have stopAtAsr=T,
+        // otherwise ASRs in the range [T, asr) may be emitted in duplicate,
+        // leading again to cylic scroll metadata annotations.
+        if (newLayerData->mTransformShouldGetOwnLayer) {
+          stopAtAsrForChildren = ActiveScrolledRoot::PickDescendant(
+              stopAtAsrForChildren,
+              newLayerData->mDeferredItem->GetActiveScrolledRoot());
+        }
+        mAsrStack.push_back(stopAtAsrForChildren);
+
+        // If we're going to emit a deferred transform onto this layer,
+        // keep track of that so descendant layers know not to emit the
+        // same deferred transform.
+        if (newLayerData->mDeferredItem) {
+          mDeferredTransformStack.push_back(newLayerData->mDeferredItem);
+        }
+      }
+    }
+
+    // This is where we emulate the clip/scroll stack that was previously
+    // implemented on the WR display list side.
+    auto spaceAndClipChain = mClipManager.SwitchItem(aDisplayListBuilder, item);
+    wr::SpaceAndClipChainHelper saccHelper(aBuilder, spaceAndClipChain);
+
+    {  // scope restoreDoGrouping
+      AutoRestore<bool> restoreDoGrouping(mDoGrouping);
+      if (itemType == DisplayItemType::TYPE_SVG_WRAPPER) {
+        // Inside an <svg>, all display items that are not LAYER_ACTIVE wrapper
+        // display items (like animated transforms / opacity) share the same
+        // animated geometry root, so we can combine subsequent items of that
+        // type into the same image.
+        mContainsSVGGroup = mDoGrouping = true;
+        GP("attempting to enter the grouping code\n");
+      }
+
+      if (dumpEnabled) {
+        std::stringstream ss;
+        nsIFrame::PrintDisplayItem(aDisplayListBuilder, item, ss,
+                                   static_cast<uint32_t>(mDumpIndent));
+        printf_stderr("%s", ss.str().c_str());
+      }
+
+      CreateWebRenderCommands(item, aBuilder, aResources, aSc,
+                              aDisplayListBuilder);
+
+      if (dumpEnabled) {
+        mBuilderDumpIndex =
+            aBuilder.Dump(mDumpIndent + 1, Some(mBuilderDumpIndex), Nothing());
+      }
+    }
+
+    if (apzEnabled) {
+      if (newLayerData) {
+        // Pop the thing we pushed before the recursion, so the topmost item on
+        // the stack is enclosing display item's ASR (or the stack is empty)
+        mAsrStack.pop_back();
+
+        if (newLayerData->mDeferredItem) {
+          MOZ_ASSERT(!mDeferredTransformStack.empty());
+          mDeferredTransformStack.pop_back();
+        }
+
+        const ActiveScrolledRoot* stopAtAsr = newLayerData->mStopAtAsr;
+
+        int32_t descendants =
+            mLayerScrollData.size() - newLayerData->mLayerCountBeforeRecursing;
+
+        nsDisplayTransform* deferred = newLayerData->mDeferredItem;
+        ScrollableLayerGuid::ViewID deferredId = newLayerData->mDeferredId;
+
+        if (newLayerData->mTransformShouldGetOwnLayer) {
+          // This creates the child WebRenderLayerScrollData for |item|, but
+          // omits the transform (hence the Nothing() as the last argument to
+          // Initialize(...)). We also need to make sure that the ASR from
+          // the deferred transform item is not on this node, so we use that
+          // ASR as the "stop at" ASR for this WebRenderLayerScrollData.
+          mLayerScrollData.emplace_back();
+          mLayerScrollData.back().Initialize(
+              mManager->GetScrollData(), item, descendants,
+              deferred->GetActiveScrolledRoot(), Nothing(),
+              ScrollableLayerGuid::NULL_SCROLL_ID);
+
+          // The above WebRenderLayerScrollData will also be a descendant of
+          // the transform-holding WebRenderLayerScrollData we create below.
+          descendants++;
+
+          // This creates the WebRenderLayerScrollData for the deferred
+          // transform item. This holds the transform matrix and the remaining
+          // ASRs needed to complete the ASR chain (i.e. the ones from the
+          // stopAtAsr down to the deferred transform item's ASR, which must be
+          // "between" stopAtAsr and |item|'s ASR in the ASR tree).
+          mLayerScrollData.emplace_back();
+          mLayerScrollData.back().Initialize(
+              mManager->GetScrollData(), deferred, descendants, stopAtAsr,
+              aSc.GetDeferredTransformMatrix(), deferredId);
+        } else {
+          // This is the "simple" case where we don't need to create two
+          // WebRenderLayerScrollData items; we can just create one that also
+          // holds the deferred transform matrix, if any.
+          mLayerScrollData.emplace_back();
+          mLayerScrollData.back().Initialize(
+              mManager->GetScrollData(), item, descendants, stopAtAsr,
+              deferred ? aSc.GetDeferredTransformMatrix() : Nothing(),
+              deferredId);
+        }
+      }
+    }
+  } while (iter.HasNext());
+
+  mDumpIndent--;
+  if (aNewClipList) {
+    mClipManager.EndList(aSc);
+  }
+}
+
+void WebRenderCommandBuilder::PushOverrideForASR(
+    const ActiveScrolledRoot* aASR, const wr::WrSpatialId& aSpatialId) {
+  mClipManager.PushOverrideForASR(aASR, aSpatialId);
+}
+
+void WebRenderCommandBuilder::PopOverrideForASR(
+    const ActiveScrolledRoot* aASR) {
+  mClipManager.PopOverrideForASR(aASR);
+}
+
+Maybe<wr::ImageKey> WebRenderCommandBuilder::CreateImageKey(
+    nsDisplayItem* aItem, ImageContainer* aContainer,
+    mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    mozilla::wr::ImageRendering aRendering, const StackingContextHelper& aSc,
+    gfx::IntSize& aSize, const Maybe<LayoutDeviceRect>& aAsyncImageBounds) {
+  RefPtr<WebRenderImageData> imageData =
+      CreateOrRecycleWebRenderUserData<WebRenderImageData>(aItem);
+  MOZ_ASSERT(imageData);
+
+  if (aContainer->IsAsync()) {
+    MOZ_ASSERT(aAsyncImageBounds);
+
+    LayoutDeviceRect rect = aAsyncImageBounds.value();
+    LayoutDeviceRect scBounds(LayoutDevicePoint(0, 0), rect.Size());
+    // TODO!
+    // We appear to be using the image bridge for a lot (most/all?) of
+    // layers-free image handling and that breaks frame consistency.
+    imageData->CreateAsyncImageWebRenderCommands(
+        aBuilder, aContainer, aSc, rect, scBounds, aContainer->GetRotation(),
+        aRendering, wr::MixBlendMode::Normal, !aItem->BackfaceIsHidden());
+    return Nothing();
+  }
+
+  AutoLockImage autoLock(aContainer);
+  if (!autoLock.HasImage()) {
+    return Nothing();
+  }
+  mozilla::layers::Image* image = autoLock.GetImage();
+  aSize = image->GetSize();
+
+  return imageData->UpdateImageKey(aContainer, aResources);
+}
+
+bool WebRenderCommandBuilder::PushImage(
+    nsDisplayItem* aItem, ImageContainer* aContainer,
+    mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const StackingContextHelper& aSc, const LayoutDeviceRect& aRect,
+    const LayoutDeviceRect& aClip) {
+  auto rendering = wr::ToImageRendering(aItem->Frame()->UsedImageRendering());
+  gfx::IntSize size;
+  Maybe<wr::ImageKey> key =
+      CreateImageKey(aItem, aContainer, aBuilder, aResources, rendering, aSc,
+                     size, Some(aRect));
+  if (aContainer->IsAsync()) {
+    // Async ImageContainer does not create ImageKey, instead it uses Pipeline.
+    MOZ_ASSERT(key.isNothing());
+    return true;
+  }
+  if (!key) {
+    return false;
+  }
+
+  auto r = wr::ToLayoutRect(aRect);
+  auto c = wr::ToLayoutRect(aClip);
+  aBuilder.PushImage(r, c, !aItem->BackfaceIsHidden(), false, rendering,
+                     key.value());
+
+  return true;
+}
+
+Maybe<wr::ImageKey> WebRenderCommandBuilder::CreateImageProviderKey(
+    nsDisplayItem* aItem, image::WebRenderImageProvider* aProvider,
+    image::ImgDrawResult aDrawResult,
+    mozilla::wr::IpcResourceUpdateQueue& aResources) {
+  RefPtr<WebRenderImageProviderData> imageData =
+      CreateOrRecycleWebRenderUserData<WebRenderImageProviderData>(aItem);
+  MOZ_ASSERT(imageData);
+  return imageData->UpdateImageKey(aProvider, aDrawResult, aResources);
+}
+
+bool WebRenderCommandBuilder::PushImageProvider(
+    nsDisplayItem* aItem, image::WebRenderImageProvider* aProvider,
+    image::ImgDrawResult aDrawResult, mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const LayoutDeviceRect& aRect, const LayoutDeviceRect& aClip) {
+  Maybe<wr::ImageKey> key =
+      CreateImageProviderKey(aItem, aProvider, aDrawResult, aResources);
+  if (!key) {
+    return false;
+  }
+
+  bool antialiased = aItem->GetType() == DisplayItemType::TYPE_SVG_GEOMETRY;
+
+  auto rendering = wr::ToImageRendering(aItem->Frame()->UsedImageRendering());
+  auto r = wr::ToLayoutRect(aRect);
+  auto c = wr::ToLayoutRect(aClip);
+  aBuilder.PushImage(r, c, !aItem->BackfaceIsHidden(), antialiased, rendering,
+                     key.value());
+
+  return true;
+}
+
+static void PaintItemByDrawTarget(nsDisplayItem* aItem, gfx::DrawTarget* aDT,
+                                  const LayoutDevicePoint& aOffset,
+                                  const IntRect& visibleRect,
+                                  nsDisplayListBuilder* aDisplayListBuilder,
+                                  const gfx::MatrixScales& aScale,
+                                  Maybe<gfx::DeviceColor>& aHighlight) {
+  MOZ_ASSERT(aDT && aDT->IsValid());
+
+  // XXX Why is this ClearRect() needed?
+  aDT->ClearRect(Rect(visibleRect));
+  gfxContext context(aDT);
+
+  switch (aItem->GetType()) {
+    case DisplayItemType::TYPE_SVG_WRAPPER:
+    case DisplayItemType::TYPE_MASK: {
+      // These items should be handled by other code paths
+      MOZ_RELEASE_ASSERT(0);
+      break;
+    }
+    default:
+      if (!aItem->AsPaintedDisplayItem()) {
+        break;
+      }
+
+      context.SetMatrix(context.CurrentMatrix().PreScale(aScale).PreTranslate(
+          -aOffset.x, -aOffset.y));
+      if (aDisplayListBuilder->IsPaintingToWindow()) {
+        aItem->Frame()->AddStateBits(NS_FRAME_PAINTED_THEBES);
+      }
+      aItem->AsPaintedDisplayItem()->Paint(aDisplayListBuilder, &context);
+      break;
+  }
+
+  if (aHighlight && aItem->GetType() != DisplayItemType::TYPE_MASK) {
+    // Apply highlight fills, if the appropriate prefs are set.
+    // We don't do this for masks because we'd be filling the A8 mask surface,
+    // which isn't very useful.
+    aDT->SetTransform(gfx::Matrix());
+    aDT->FillRect(Rect(visibleRect), gfx::ColorPattern(aHighlight.value()));
+  }
+}
+
+bool WebRenderCommandBuilder::ComputeInvalidationForDisplayItem(
+    nsDisplayListBuilder* aBuilder, const nsPoint& aShift,
+    nsDisplayItem* aItem) {
+  RefPtr<WebRenderFallbackData> fallbackData =
+      CreateOrRecycleWebRenderUserData<WebRenderFallbackData>(aItem);
+
+  nsRect invalid;
+  if (!fallbackData->mGeometry || aItem->IsInvalid(invalid)) {
+    fallbackData->mGeometry = WrapUnique(aItem->AllocateGeometry(aBuilder));
+    return true;
+  }
+
+  fallbackData->mGeometry->MoveBy(aShift);
+  nsRegion combined;
+  aItem->ComputeInvalidationRegion(aBuilder, fallbackData->mGeometry.get(),
+                                   &combined);
+
+  UniquePtr<nsDisplayItemGeometry> geometry;
+  if (!combined.IsEmpty() || aItem->NeedsGeometryUpdates()) {
+    geometry = WrapUnique(aItem->AllocateGeometry(aBuilder));
+  }
+
+  fallbackData->mClip.AddOffsetAndComputeDifference(
+      aShift, fallbackData->mGeometry->ComputeInvalidationRegion(),
+      aItem->GetClip(),
+      geometry ? geometry->ComputeInvalidationRegion()
+               : fallbackData->mGeometry->ComputeInvalidationRegion(),
+      &combined);
+
+  if (geometry) {
+    fallbackData->mGeometry = std::move(geometry);
+  }
+  fallbackData->mClip = aItem->GetClip();
+
+  if (!combined.IsEmpty()) {
+    return true;
+  } else if (aItem->GetChildren()) {
+    return ComputeInvalidationForDisplayList(aBuilder, aShift,
+                                             aItem->GetChildren());
+  }
+  return false;
+}
+
+bool WebRenderCommandBuilder::ComputeInvalidationForDisplayList(
+    nsDisplayListBuilder* aBuilder, const nsPoint& aShift,
+    nsDisplayList* aList) {
+  FlattenedDisplayListIterator iter(aBuilder, aList);
+  while (iter.HasNext()) {
+    if (ComputeInvalidationForDisplayItem(aBuilder, aShift,
+                                          iter.GetNextItem())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// When drawing fallback images we create either
+// a real image or a blob image that will contain the display item.
+// In the case of a blob image we paint the item at 0,0 instead
+// of trying to keep at aItem->GetBounds().TopLeft() like we do
+// with SVG. We do this because there's not necessarily a reference frame
+// between us and the rest of the world so the the coordinates
+// that we get for the bounds are not necessarily stable across scrolling
+// or other movement.
+already_AddRefed<WebRenderFallbackData>
+WebRenderCommandBuilder::GenerateFallbackData(
+    nsDisplayItem* aItem, wr::DisplayListBuilder& aBuilder,
+    wr::IpcResourceUpdateQueue& aResources, const StackingContextHelper& aSc,
+    nsDisplayListBuilder* aDisplayListBuilder, LayoutDeviceRect& aImageRect) {
+  const bool paintOnContentSide = aItem->MustPaintOnContentSide();
+  bool useBlobImage =
+      StaticPrefs::gfx_webrender_blob_images() && !paintOnContentSide;
+  Maybe<gfx::DeviceColor> highlight = Nothing();
+  if (StaticPrefs::gfx_webrender_debug_highlight_painted_layers()) {
+    highlight = Some(useBlobImage ? gfx::DeviceColor(1.0, 0.0, 0.0, 0.5)
+                                  : gfx::DeviceColor(1.0, 1.0, 0.0, 0.5));
+  }
+
+  RefPtr<WebRenderFallbackData> fallbackData =
+      CreateOrRecycleWebRenderUserData<WebRenderFallbackData>(aItem);
+
+  bool snap;
+  nsRect itemBounds = aItem->GetBounds(aDisplayListBuilder, &snap);
+
+  // Blob images will only draw the visible area of the blob so we don't need to
+  // clip them here and can just rely on the webrender clipping.
+  // TODO We also don't clip native themed widget to avoid over-invalidation
+  // during scrolling. It would be better to support a sort of streaming/tiling
+  // scheme for large ones but the hope is that we should not have large native
+  // themed items.
+  nsRect paintBounds = (useBlobImage || paintOnContentSide)
+                           ? itemBounds
+                           : aItem->GetClippedBounds(aDisplayListBuilder);
+
+  nsRect buildingRect = aItem->GetBuildingRect();
+
+  const int32_t appUnitsPerDevPixel =
+      aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+  auto bounds =
+      LayoutDeviceRect::FromAppUnits(paintBounds, appUnitsPerDevPixel);
+  if (bounds.IsEmpty()) {
+    return nullptr;
+  }
+
+  MatrixScales scale = aSc.GetInheritedScale();
+  MatrixScales oldScale = fallbackData->mScale;
+  // We tolerate slight changes in scale so that we don't, for example,
+  // rerasterize on MotionMark
+  bool differentScale = gfx::FuzzyEqual(scale.xScale, oldScale.xScale, 1e-6f) &&
+                        gfx::FuzzyEqual(scale.yScale, oldScale.yScale, 1e-6f);
+
+  auto layerScale = LayoutDeviceToLayerScale2D::FromUnknownScale(scale);
+
+  auto trans =
+      ViewAs<LayerPixel>(aSc.GetSnappingSurfaceTransform().GetTranslation());
+
+  if (!FitsInt32(trans.X()) || !FitsInt32(trans.Y())) {
+    // The translation overflowed int32_t.
+    return nullptr;
+  }
+
+  auto snappedTrans = LayerIntPoint::Floor(trans);
+  LayerPoint residualOffset = trans - snappedTrans;
+
+  nsRegion opaqueRegion = aItem->GetOpaqueRegion(aDisplayListBuilder, &snap);
+  wr::OpacityType opacity = opaqueRegion.Contains(paintBounds)
+                                ? wr::OpacityType::Opaque
+                                : wr::OpacityType::HasAlphaChannel;
+
+  LayerIntRect dtRect, visibleRect;
+  // If we think the item is opaque we round the bounds
+  // to the nearest pixel instead of rounding them out. If we rounded
+  // out we'd potentially introduce transparent pixels.
+  //
+  // Ideally we'd be able to ask an item its bounds in pixels and whether
+  // they're all opaque. Unfortunately no such API exists so we currently
+  // just hope that we get it right.
+  if (aBuilder.GetInheritedOpacity() == 1.0f &&
+      opacity == wr::OpacityType::Opaque && snap) {
+    dtRect = LayerIntRect::FromUnknownRect(
+        ScaleToNearestPixelsOffset(paintBounds, scale.xScale, scale.yScale,
+                                   appUnitsPerDevPixel, residualOffset));
+
+    visibleRect =
+        LayerIntRect::FromUnknownRect(
+            ScaleToNearestPixelsOffset(buildingRect, scale.xScale, scale.yScale,
+                                       appUnitsPerDevPixel, residualOffset))
+            .Intersect(dtRect);
+  } else {
+    dtRect = ScaleToOutsidePixelsOffset(paintBounds, scale.xScale, scale.yScale,
+                                        appUnitsPerDevPixel, residualOffset);
+
+    visibleRect =
+        ScaleToOutsidePixelsOffset(buildingRect, scale.xScale, scale.yScale,
+                                   appUnitsPerDevPixel, residualOffset)
+            .Intersect(dtRect);
+  }
+
+  auto visibleSize = visibleRect.Size();
+  // these rectangles can overflow from scaling so try to
+  // catch that with IsEmpty() checks. See bug 1622126.
+  if (visibleSize.IsEmpty() || dtRect.IsEmpty()) {
+    return nullptr;
+  }
+
+  if (useBlobImage) {
+    // Display item bounds should be unscaled
+    aImageRect = visibleRect / layerScale;
+  } else {
+    // Display item bounds should be unscaled
+    aImageRect = dtRect / layerScale;
+  }
+
+  // We always paint items at 0,0 so the visibleRect that we use inside the blob
+  // is needs to be adjusted by the display item bounds top left.
+  visibleRect -= dtRect.TopLeft();
+
+  nsDisplayItemGeometry* geometry = fallbackData->mGeometry.get();
+
+  bool needPaint = true;
+
+  MOZ_RELEASE_ASSERT(aItem->GetType() != DisplayItemType::TYPE_SVG_WRAPPER);
+  if (geometry && !fallbackData->IsInvalid() &&
+      aItem->GetType() != DisplayItemType::TYPE_SVG_WRAPPER && differentScale) {
+    nsRect invalid;
+    if (!aItem->IsInvalid(invalid)) {
+      nsPoint shift = itemBounds.TopLeft() - geometry->mBounds.TopLeft();
+      geometry->MoveBy(shift);
+
+      nsRegion invalidRegion;
+      aItem->ComputeInvalidationRegion(aDisplayListBuilder, geometry,
+                                       &invalidRegion);
+
+      nsRect lastBounds = fallbackData->mBounds;
+      lastBounds.MoveBy(shift);
+
+      if (lastBounds.IsEqualInterior(paintBounds) && invalidRegion.IsEmpty() &&
+          aBuilder.GetInheritedOpacity() == fallbackData->mOpacity) {
+        if (aItem->GetType() == DisplayItemType::TYPE_FILTER) {
+          needPaint = ComputeInvalidationForDisplayList(
+              aDisplayListBuilder, shift, aItem->GetChildren());
+          if (!buildingRect.IsEqualInterior(fallbackData->mBuildingRect)) {
+            needPaint = true;
+          }
+        } else {
+          needPaint = false;
+        }
+      }
+    }
+  }
+
+  if (needPaint || !fallbackData->GetImageKey()) {
+    fallbackData->mGeometry =
+        WrapUnique(aItem->AllocateGeometry(aDisplayListBuilder));
+
+    gfx::SurfaceFormat format = aItem->GetType() == DisplayItemType::TYPE_MASK
+                                    ? gfx::SurfaceFormat::A8
+                                    : (opacity == wr::OpacityType::Opaque
+                                           ? gfx::SurfaceFormat::B8G8R8X8
+                                           : gfx::SurfaceFormat::B8G8R8A8);
+    if (useBlobImage) {
+      MOZ_ASSERT(!opaqueRegion.IsComplex());
+
+      std::vector<RefPtr<ScaledFont>> fonts;
+      bool validFonts = true;
+      RefPtr<WebRenderDrawEventRecorder> recorder =
+          MakeAndAddRef<WebRenderDrawEventRecorder>(
+              [&](MemStream& aStream,
+                  std::vector<RefPtr<ScaledFont>>& aScaledFonts) {
+                size_t count = aScaledFonts.size();
+                aStream.write((const char*)&count, sizeof(count));
+                for (auto& scaled : aScaledFonts) {
+                  Maybe<wr::FontInstanceKey> key =
+                      mManager->WrBridge()->GetFontKeyForScaledFont(scaled,
+                                                                    aResources);
+                  if (key.isNothing()) {
+                    validFonts = false;
+                    break;
+                  }
+                  BlobFont font = {key.value(), scaled};
+                  aStream.write((const char*)&font, sizeof(font));
+                }
+                fonts = std::move(aScaledFonts);
+              });
+      RefPtr<gfx::DrawTarget> dummyDt = gfx::Factory::CreateDrawTarget(
+          gfx::BackendType::SKIA, gfx::IntSize(1, 1), format);
+      RefPtr<gfx::DrawTarget> dt = gfx::Factory::CreateRecordingDrawTarget(
+          recorder, dummyDt, (dtRect - dtRect.TopLeft()).ToUnknownRect());
+      if (aBuilder.GetInheritedOpacity() != 1.0f) {
+        dt->PushLayer(false, aBuilder.GetInheritedOpacity(), nullptr,
+                      gfx::Matrix());
+      }
+      PaintItemByDrawTarget(aItem, dt, (dtRect / layerScale).TopLeft(),
+                            /*aVisibleRect: */ dt->GetRect(),
+                            aDisplayListBuilder, scale, highlight);
+      if (aBuilder.GetInheritedOpacity() != 1.0f) {
+        dt->PopLayer();
+      }
+
+      // the item bounds are relative to the blob origin which is
+      // dtRect.TopLeft()
+      recorder->FlushItem((dtRect - dtRect.TopLeft()).ToUnknownRect());
+      recorder->Finish();
+
+      if (!validFonts) {
+        gfxCriticalNote << "Failed serializing fonts for blob image";
+        return nullptr;
+      }
+
+      Range<uint8_t> bytes((uint8_t*)recorder->mOutputStream.mData,
+                           recorder->mOutputStream.mLength);
+      wr::BlobImageKey key =
+          wr::BlobImageKey{mManager->WrBridge()->GetNextImageKey()};
+      wr::ImageDescriptor descriptor(visibleSize.ToUnknownSize(), 0,
+                                     dt->GetFormat(), opacity);
+      if (!aResources.AddBlobImage(
+              key, descriptor, bytes,
+              ViewAs<ImagePixel>(visibleRect,
+                                 PixelCastJustification::LayerIsImage))) {
+        return nullptr;
+      }
+      TakeExternalSurfaces(recorder, fallbackData->mExternalSurfaces,
+                           mManager->GetRenderRootStateManager(), aResources);
+      fallbackData->SetBlobImageKey(key);
+      fallbackData->SetFonts(fonts);
+    } else {
+      WebRenderImageData* imageData = fallbackData->PaintIntoImage();
+
+      imageData->CreateImageClientIfNeeded();
+      RefPtr<ImageClient> imageClient = imageData->GetImageClient();
+      RefPtr<ImageContainer> imageContainer = MakeAndAddRef<ImageContainer>();
+
+      {
+        UpdateImageHelper helper(imageContainer, imageClient,
+                                 dtRect.Size().ToUnknownSize(), format);
+        {
+          RefPtr<gfx::DrawTarget> dt = helper.GetDrawTarget();
+          if (!dt) {
+            return nullptr;
+          }
+          if (aBuilder.GetInheritedOpacity() != 1.0f) {
+            dt->PushLayer(false, aBuilder.GetInheritedOpacity(), nullptr,
+                          gfx::Matrix());
+          }
+          PaintItemByDrawTarget(aItem, dt,
+                                /*aOffset: */ aImageRect.TopLeft(),
+                                /*aVisibleRect: */ dt->GetRect(),
+                                aDisplayListBuilder, scale, highlight);
+          if (aBuilder.GetInheritedOpacity() != 1.0f) {
+            dt->PopLayer();
+          }
+        }
+
+        // Update image if there it's invalidated.
+        if (!helper.UpdateImage()) {
+          return nullptr;
+        }
+      }
+
+      // Force update the key in fallback data since we repaint the image in
+      // this path. If not force update, fallbackData may reuse the original key
+      // because it doesn't know UpdateImageHelper already updated the image
+      // container.
+      if (!imageData->UpdateImageKey(imageContainer, aResources, true)) {
+        return nullptr;
+      }
+    }
+
+    fallbackData->mScale = scale;
+    fallbackData->mOpacity = aBuilder.GetInheritedOpacity();
+    fallbackData->SetInvalid(false);
+  }
+
+  if (useBlobImage) {
+    MOZ_DIAGNOSTIC_ASSERT(mManager->WrBridge()->MatchesNamespace(
+                              fallbackData->GetBlobImageKey().ref()),
+                          "Stale blob key for fallback!");
+
+    aResources.SetBlobImageVisibleArea(
+        fallbackData->GetBlobImageKey().value(),
+        ViewAs<ImagePixel>(visibleRect, PixelCastJustification::LayerIsImage));
+  }
+
+  // Update current bounds to fallback data
+  fallbackData->mBounds = paintBounds;
+  fallbackData->mBuildingRect = buildingRect;
+
+  MOZ_ASSERT(fallbackData->GetImageKey());
+
+  return fallbackData.forget();
+}
+
+void WebRenderMaskData::ClearImageKey() {
+  if (mBlobKey) {
+    mManager->AddBlobImageKeyForDiscard(mBlobKey.value());
+  }
+  mBlobKey.reset();
+}
+
+void WebRenderMaskData::Invalidate() {
+  mMaskStyle = nsStyleImageLayers(nsStyleImageLayers::LayerType::Mask);
+}
+
+Maybe<wr::ImageMask> WebRenderCommandBuilder::BuildWrMaskImage(
+    nsDisplayMasksAndClipPaths* aMaskItem, wr::DisplayListBuilder& aBuilder,
+    wr::IpcResourceUpdateQueue& aResources, const StackingContextHelper& aSc,
+    nsDisplayListBuilder* aDisplayListBuilder,
+    const LayoutDeviceRect& aBounds) {
+  RefPtr<WebRenderMaskData> maskData =
+      CreateOrRecycleWebRenderUserData<WebRenderMaskData>(aMaskItem);
+
+  if (!maskData) {
+    return Nothing();
+  }
+
+  bool snap;
+  nsRect bounds = aMaskItem->GetBounds(aDisplayListBuilder, &snap);
+
+  const int32_t appUnitsPerDevPixel =
+      aMaskItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+
+  MatrixScales scale = aSc.GetInheritedScale();
+  MatrixScales oldScale = maskData->mScale;
+  // This scale determination should probably be done using
+  // ChooseScaleAndSetTransform but for now we just fake it.
+  // We tolerate slight changes in scale so that we don't, for example,
+  // rerasterize on MotionMark
+  bool sameScale = FuzzyEqual(scale.xScale, oldScale.xScale, 1e-6f) &&
+                   FuzzyEqual(scale.yScale, oldScale.yScale, 1e-6f);
+
+  LayerIntRect itemRect =
+      LayerIntRect::FromUnknownRect(bounds.ScaleToOutsidePixels(
+          scale.xScale, scale.yScale, appUnitsPerDevPixel));
+
+  LayerIntRect visibleRect =
+      LayerIntRect::FromUnknownRect(
+          aMaskItem->GetBuildingRect().ScaleToOutsidePixels(
+              scale.xScale, scale.yScale, appUnitsPerDevPixel))
+          .SafeIntersect(itemRect);
+
+  if (visibleRect.IsEmpty()) {
+    return Nothing();
+  }
+
+  LayoutDeviceToLayerScale2D layerScale(scale.xScale, scale.yScale);
+  LayoutDeviceRect imageRect = LayerRect(visibleRect) / layerScale;
+
+  nsPoint maskOffset = aMaskItem->ToReferenceFrame() - bounds.TopLeft();
+
+  bool shouldHandleOpacity = aBuilder.GetInheritedOpacity() != 1.0f;
+
+  nsRect dirtyRect;
+  // If this mask item is being painted for the first time, some members of
+  // WebRenderMaskData are still default initialized. This is intentional.
+  if (aMaskItem->IsInvalid(dirtyRect) ||
+      !itemRect.IsEqualInterior(maskData->mItemRect) ||
+      !(aMaskItem->Frame()->StyleSVGReset()->mMask == maskData->mMaskStyle) ||
+      maskOffset != maskData->mMaskOffset || !sameScale ||
+      shouldHandleOpacity != maskData->mShouldHandleOpacity) {
+    IntSize size = itemRect.Size().ToUnknownSize();
+
+    if (!Factory::AllowedSurfaceSize(size)) {
+      return Nothing();
+    }
+
+    std::vector<RefPtr<ScaledFont>> fonts;
+    bool validFonts = true;
+    RefPtr<WebRenderDrawEventRecorder> recorder =
+        MakeAndAddRef<WebRenderDrawEventRecorder>(
+            [&](MemStream& aStream,
+                std::vector<RefPtr<ScaledFont>>& aScaledFonts) {
+              size_t count = aScaledFonts.size();
+              aStream.write((const char*)&count, sizeof(count));
+
+              for (auto& scaled : aScaledFonts) {
+                Maybe<wr::FontInstanceKey> key =
+                    mManager->WrBridge()->GetFontKeyForScaledFont(scaled,
+                                                                  aResources);
+                if (key.isNothing()) {
+                  validFonts = false;
+                  break;
+                }
+                BlobFont font = {key.value(), scaled};
+                aStream.write((const char*)&font, sizeof(font));
+              }
+
+              fonts = std::move(aScaledFonts);
+            });
+
+    RefPtr<DrawTarget> dummyDt = Factory::CreateDrawTarget(
+        BackendType::SKIA, IntSize(1, 1), SurfaceFormat::A8);
+    RefPtr<DrawTarget> dt = Factory::CreateRecordingDrawTarget(
+        recorder, dummyDt, IntRect(IntPoint(0, 0), size));
+    if (!dt || !dt->IsValid()) {
+      gfxCriticalNote << "Failed to create drawTarget for blob mask image";
+      return Nothing();
+    }
+
+    gfxContext context(dt);
+    context.SetMatrix(context.CurrentMatrix()
+                          .PreTranslate(-itemRect.x, -itemRect.y)
+                          .PreScale(scale));
+
+    bool maskPainted = false;
+    bool maskIsComplete = aMaskItem->PaintMask(
+        aDisplayListBuilder, &context, shouldHandleOpacity, &maskPainted);
+    if (!maskPainted) {
+      return Nothing();
+    }
+
+    // If a mask is incomplete or missing (e.g. it's display: none) the proper
+    // behaviour depends on the masked frame being html or svg.
+    //
+    // For an HTML frame:
+    //   According to css-masking spec, always create a mask surface when
+    //   we have any item in maskFrame even if all of those items are
+    //   non-resolvable <mask-sources> or <images> so continue with the
+    //   painting code. Note that in a common case of no layer of the mask being
+    //   complete or even partially complete then the mask surface will be
+    //   transparent black so this results in hiding the frame.
+    // For an SVG frame:
+    //   SVG 1.1 say that if we fail to resolve a mask, we should draw the
+    //   object unmasked so return Nothing().
+    if (!maskIsComplete &&
+        aMaskItem->Frame()->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) {
+      return Nothing();
+    }
+
+    recorder->FlushItem(IntRect(0, 0, size.width, size.height));
+    recorder->Finish();
+
+    if (!validFonts) {
+      gfxCriticalNote << "Failed serializing fonts for blob mask image";
+      return Nothing();
+    }
+
+    Range<uint8_t> bytes((uint8_t*)recorder->mOutputStream.mData,
+                         recorder->mOutputStream.mLength);
+    wr::BlobImageKey key =
+        wr::BlobImageKey{mManager->WrBridge()->GetNextImageKey()};
+    wr::ImageDescriptor descriptor(size, 0, dt->GetFormat(),
+                                   wr::OpacityType::HasAlphaChannel);
+    if (!aResources.AddBlobImage(key, descriptor, bytes,
+                                 ImageIntRect(0, 0, size.width, size.height))) {
+      return Nothing();
+    }
+    maskData->ClearImageKey();
+    maskData->mBlobKey = Some(key);
+    maskData->mFonts = fonts;
+    TakeExternalSurfaces(recorder, maskData->mExternalSurfaces,
+                         mManager->GetRenderRootStateManager(), aResources);
+    if (maskIsComplete) {
+      maskData->mItemRect = itemRect;
+      maskData->mMaskOffset = maskOffset;
+      maskData->mScale = scale;
+      maskData->mMaskStyle = aMaskItem->Frame()->StyleSVGReset()->mMask;
+      maskData->mShouldHandleOpacity = shouldHandleOpacity;
+    }
+  }
+
+  aResources.SetBlobImageVisibleArea(
+      maskData->mBlobKey.value(),
+      ViewAs<ImagePixel>(visibleRect - itemRect.TopLeft(),
+                         PixelCastJustification::LayerIsImage));
+
+  MOZ_DIAGNOSTIC_ASSERT(
+      mManager->WrBridge()->MatchesNamespace(maskData->mBlobKey.ref()),
+      "Stale blob key for mask!");
+
+  wr::ImageMask imageMask;
+  imageMask.image = wr::AsImageKey(maskData->mBlobKey.value());
+  imageMask.rect = wr::ToLayoutRect(imageRect);
+  return Some(imageMask);
+}
+
+bool WebRenderCommandBuilder::PushItemAsImage(
+    nsDisplayItem* aItem, wr::DisplayListBuilder& aBuilder,
+    wr::IpcResourceUpdateQueue& aResources, const StackingContextHelper& aSc,
+    nsDisplayListBuilder* aDisplayListBuilder) {
+  LayoutDeviceRect imageRect;
+  RefPtr<WebRenderFallbackData> fallbackData = GenerateFallbackData(
+      aItem, aBuilder, aResources, aSc, aDisplayListBuilder, imageRect);
+  if (!fallbackData) {
+    return false;
+  }
+
+  wr::LayoutRect dest = wr::ToLayoutRect(imageRect);
+  auto rendering = wr::ToImageRendering(aItem->Frame()->UsedImageRendering());
+  aBuilder.PushImage(dest, dest, !aItem->BackfaceIsHidden(), false, rendering,
+                     fallbackData->GetImageKey().value());
+  return true;
+}
+
+void WebRenderCommandBuilder::RemoveUnusedAndResetWebRenderUserData() {
+  mWebRenderUserDatas.RemoveIf([&](WebRenderUserData* data) {
+    if (!data->IsUsed()) {
+      nsIFrame* frame = data->GetFrame();
+
+      MOZ_ASSERT(frame->HasProperty(WebRenderUserDataProperty::Key()));
+
+      WebRenderUserDataTable* userDataTable =
+          frame->GetProperty(WebRenderUserDataProperty::Key());
+
+      MOZ_ASSERT(userDataTable->Count());
+
+      userDataTable->Remove(
+          WebRenderUserDataKey(data->GetDisplayItemKey(), data->GetType()));
+
+      if (!userDataTable->Count()) {
+        frame->RemoveProperty(WebRenderUserDataProperty::Key());
+        userDataTable = nullptr;
+      }
+
+      switch (data->GetType()) {
+        case WebRenderUserData::UserDataType::eCanvas:
+          mLastCanvasDatas.Remove(data->AsCanvasData());
+          break;
+        case WebRenderUserData::UserDataType::eAnimation:
+          EffectCompositor::ClearIsRunningOnCompositor(
+              frame, GetDisplayItemTypeFromKey(data->GetDisplayItemKey()));
+          break;
+        default:
+          break;
+      }
+
+      return true;
+    }
+
+    data->SetUsed(false);
+    return false;
+  });
+}
+
+void WebRenderCommandBuilder::ClearCachedResources() {
+  RemoveUnusedAndResetWebRenderUserData();
+  // UserDatas should only be in the used state during a call to
+  // WebRenderCommandBuilder::BuildWebRenderCommands The should always be false
+  // upon return from BuildWebRenderCommands().
+  MOZ_RELEASE_ASSERT(mWebRenderUserDatas.Count() == 0);
+}
+
+WebRenderGroupData::WebRenderGroupData(
+    RenderRootStateManager* aRenderRootStateManager, nsDisplayItem* aItem)
+    : WebRenderUserData(aRenderRootStateManager, aItem) {
+  MOZ_COUNT_CTOR(WebRenderGroupData);
+}
+
+WebRenderGroupData::~WebRenderGroupData() {
+  MOZ_COUNT_DTOR(WebRenderGroupData);
+  GP("Group data destruct\n");
+  mSubGroup.ClearImageKey(mManager, true);
+  mFollowingGroup.ClearImageKey(mManager, true);
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/WebRenderCommandBuilder.h b/gfx/layers/wr/WebRenderCommandBuilder.h
new file mode 100644
index 0000000000..68c9a4ce63
--- /dev/null
+++ b/gfx/layers/wr/WebRenderCommandBuilder.h
@@ -0,0 +1,237 @@
+/* -*- 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_WEBRENDERCOMMANDBUILDER_H
+#define GFX_WEBRENDERCOMMANDBUILDER_H
+
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/layers/ClipManager.h"
+#include "mozilla/layers/HitTestInfoManager.h"
+#include "mozilla/layers/WebRenderMessages.h"
+#include "mozilla/layers/WebRenderScrollData.h"
+#include "mozilla/layers/WebRenderUserData.h"
+#include "mozilla/SVGIntegrationUtils.h"  // for WrFiltersHolder
+#include "nsDisplayList.h"
+#include "nsIFrame.h"
+#include "nsTHashSet.h"
+#include "DisplayItemCache.h"
+#include "ImgDrawResult.h"
+
+namespace mozilla {
+
+namespace image {
+class WebRenderImageProvider;
+}
+
+namespace layers {
+
+class ImageClient;
+class ImageContainer;
+class WebRenderBridgeChild;
+class WebRenderCanvasData;
+class WebRenderCanvasRendererAsync;
+class WebRenderImageData;
+class WebRenderFallbackData;
+class WebRenderParentCommand;
+class WebRenderUserData;
+
+class WebRenderCommandBuilder final {
+  typedef nsTHashSet<RefPtr<WebRenderUserData>> WebRenderUserDataRefTable;
+  typedef nsTHashSet<RefPtr<WebRenderCanvasData>> CanvasDataSet;
+
+ public:
+  explicit WebRenderCommandBuilder(WebRenderLayerManager* aManager);
+
+  void Destroy();
+
+  void EmptyTransaction();
+
+  bool NeedsEmptyTransaction();
+
+  void BuildWebRenderCommands(wr::DisplayListBuilder& aBuilder,
+                              wr::IpcResourceUpdateQueue& aResourceUpdates,
+                              nsDisplayList* aDisplayList,
+                              nsDisplayListBuilder* aDisplayListBuilder,
+                              WebRenderScrollData& aScrollData,
+                              WrFiltersHolder&& aFilters);
+
+  void PushOverrideForASR(const ActiveScrolledRoot* aASR,
+                          const wr::WrSpatialId& aSpatialId);
+  void PopOverrideForASR(const ActiveScrolledRoot* aASR);
+
+  Maybe<wr::ImageKey> CreateImageKey(
+      nsDisplayItem* aItem, ImageContainer* aContainer,
+      mozilla::wr::DisplayListBuilder& aBuilder,
+      mozilla::wr::IpcResourceUpdateQueue& aResources,
+      mozilla::wr::ImageRendering aRendering, const StackingContextHelper& aSc,
+      gfx::IntSize& aSize, const Maybe<LayoutDeviceRect>& aAsyncImageBounds);
+
+  Maybe<wr::ImageKey> CreateImageProviderKey(
+      nsDisplayItem* aItem, image::WebRenderImageProvider* aProvider,
+      image::ImgDrawResult aDrawResult,
+      mozilla::wr::IpcResourceUpdateQueue& aResources);
+
+  WebRenderUserDataRefTable* GetWebRenderUserDataTable() {
+    return &mWebRenderUserDatas;
+  }
+
+  bool PushImage(nsDisplayItem* aItem, ImageContainer* aContainer,
+                 mozilla::wr::DisplayListBuilder& aBuilder,
+                 mozilla::wr::IpcResourceUpdateQueue& aResources,
+                 const StackingContextHelper& aSc,
+                 const LayoutDeviceRect& aRect, const LayoutDeviceRect& aClip);
+
+  bool PushImageProvider(nsDisplayItem* aItem,
+                         image::WebRenderImageProvider* aProvider,
+                         image::ImgDrawResult aDrawResult,
+                         mozilla::wr::DisplayListBuilder& aBuilder,
+                         mozilla::wr::IpcResourceUpdateQueue& aResources,
+                         const LayoutDeviceRect& aRect,
+                         const LayoutDeviceRect& aClip);
+
+  Maybe<wr::ImageMask> BuildWrMaskImage(
+      nsDisplayMasksAndClipPaths* aMaskItem, wr::DisplayListBuilder& aBuilder,
+      wr::IpcResourceUpdateQueue& aResources, const StackingContextHelper& aSc,
+      nsDisplayListBuilder* aDisplayListBuilder,
+      const LayoutDeviceRect& aBounds);
+
+  bool PushItemAsImage(nsDisplayItem* aItem, wr::DisplayListBuilder& aBuilder,
+                       wr::IpcResourceUpdateQueue& aResources,
+                       const StackingContextHelper& aSc,
+                       nsDisplayListBuilder* aDisplayListBuilder);
+
+  void CreateWebRenderCommandsFromDisplayList(
+      nsDisplayList* aDisplayList, nsDisplayItem* aWrappingItem,
+      nsDisplayListBuilder* aDisplayListBuilder,
+      const StackingContextHelper& aSc, wr::DisplayListBuilder& aBuilder,
+      wr::IpcResourceUpdateQueue& aResources, bool aNewClipList = true);
+
+  // aWrappingItem has to be non-null.
+  void DoGroupingForDisplayList(nsDisplayList* aDisplayList,
+                                nsDisplayItem* aWrappingItem,
+                                nsDisplayListBuilder* aDisplayListBuilder,
+                                const StackingContextHelper& aSc,
+                                wr::DisplayListBuilder& aBuilder,
+                                wr::IpcResourceUpdateQueue& aResources);
+
+  already_AddRefed<WebRenderFallbackData> GenerateFallbackData(
+      nsDisplayItem* aItem, wr::DisplayListBuilder& aBuilder,
+      wr::IpcResourceUpdateQueue& aResources, const StackingContextHelper& aSc,
+      nsDisplayListBuilder* aDisplayListBuilder, LayoutDeviceRect& aImageRect);
+
+  void RemoveUnusedAndResetWebRenderUserData();
+  void ClearCachedResources();
+
+  bool ShouldDumpDisplayList(nsDisplayListBuilder* aBuilder);
+  wr::usize GetBuilderDumpIndex() const { return mBuilderDumpIndex; }
+
+  bool GetContainsSVGGroup() { return mContainsSVGGroup; }
+
+  // Those are data that we kept between transactions. We used to cache some
+  // data in the layer. But in layers free mode, we don't have layer which
+  // means we need some other place to cached the data between transaction.
+  // We store the data in frame's property.
+  template <class T>
+  already_AddRefed<T> CreateOrRecycleWebRenderUserData(
+      nsDisplayItem* aItem, bool* aOutIsRecycled = nullptr) {
+    MOZ_ASSERT(aItem);
+    nsIFrame* frame = aItem->Frame();
+    if (aOutIsRecycled) {
+      *aOutIsRecycled = true;
+    }
+
+    WebRenderUserDataTable* userDataTable =
+        frame->GetProperty(WebRenderUserDataProperty::Key());
+
+    if (!userDataTable) {
+      userDataTable = new WebRenderUserDataTable();
+      frame->AddProperty(WebRenderUserDataProperty::Key(), userDataTable);
+    }
+
+    RefPtr<WebRenderUserData>& data = userDataTable->LookupOrInsertWith(
+        WebRenderUserDataKey(aItem->GetPerFrameKey(), T::Type()), [&] {
+          auto data = MakeRefPtr<T>(GetRenderRootStateManager(), aItem);
+          mWebRenderUserDatas.Insert(data);
+          if (aOutIsRecycled) {
+            *aOutIsRecycled = false;
+          }
+          return data;
+        });
+
+    MOZ_ASSERT(data);
+    MOZ_ASSERT(data->GetType() == T::Type());
+
+    // Mark the data as being used. We will remove unused user data in the end
+    // of EndTransaction.
+    data->SetUsed(true);
+
+    switch (T::Type()) {
+      case WebRenderUserData::UserDataType::eCanvas:
+        mLastCanvasDatas.Insert(data->AsCanvasData());
+        break;
+      default:
+        break;
+    }
+
+    RefPtr<T> res = static_cast<T*>(data.get());
+    return res.forget();
+  }
+
+  WebRenderLayerManager* mManager;
+
+ private:
+  RenderRootStateManager* GetRenderRootStateManager();
+  void CreateWebRenderCommands(nsDisplayItem* aItem,
+                               mozilla::wr::DisplayListBuilder& aBuilder,
+                               mozilla::wr::IpcResourceUpdateQueue& aResources,
+                               const StackingContextHelper& aSc,
+                               nsDisplayListBuilder* aDisplayListBuilder);
+
+  bool ComputeInvalidationForDisplayItem(nsDisplayListBuilder* aBuilder,
+                                         const nsPoint& aShift,
+                                         nsDisplayItem* aItem);
+  bool ComputeInvalidationForDisplayList(nsDisplayListBuilder* aBuilder,
+                                         const nsPoint& aShift,
+                                         nsDisplayList* aList);
+
+  ClipManager mClipManager;
+  HitTestInfoManager mHitTestInfoManager;
+
+  // We use this as a temporary data structure while building the mScrollData
+  // inside a layers-free transaction.
+  std::vector<WebRenderLayerScrollData> mLayerScrollData;
+  // We use this as a temporary data structure to track the current display
+  // item's ASR as we recurse in CreateWebRenderCommandsFromDisplayList. We
+  // need this so that WebRenderLayerScrollData items that deeper in the
+  // tree don't duplicate scroll metadata that their ancestors already have.
+  std::vector<const ActiveScrolledRoot*> mAsrStack;
+  // A similar stack to track the deferred transform that we decided to emit
+  // most recently.
+  std::vector<nsDisplayTransform*> mDeferredTransformStack;
+  const ActiveScrolledRoot* mLastAsr;
+
+  WebRenderUserDataRefTable mWebRenderUserDatas;
+
+  // Store of WebRenderCanvasData objects for use in empty transactions
+  CanvasDataSet mLastCanvasDatas;
+
+  wr::usize mBuilderDumpIndex;
+  wr::usize mDumpIndent;
+
+ public:
+  // Whether consecutive inactive display items should be grouped into one
+  // blob image.
+  bool mDoGrouping;
+
+  // True if the most recently build display list contained an svg that
+  // we did grouping for.
+  bool mContainsSVGGroup;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif /* GFX_WEBRENDERCOMMANDBUILDER_H */
diff --git a/gfx/layers/wr/WebRenderDrawEventRecorder.cpp b/gfx/layers/wr/WebRenderDrawEventRecorder.cpp
new file mode 100644
index 0000000000..db4345d592
--- /dev/null
+++ b/gfx/layers/wr/WebRenderDrawEventRecorder.cpp
@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 20; 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 "WebRenderDrawEventRecorder.h"
+#include "mozilla/layers/SharedSurfacesChild.h"
+#include "mozilla/layers/SharedSurfacesParent.h"
+
+namespace mozilla {
+using namespace gfx;
+
+namespace layers {
+
+void WebRenderDrawEventRecorder::StoreSourceSurfaceRecording(
+    SourceSurface* aSurface, const char* aReason) {
+  wr::ExternalImageId extId;
+  nsresult rv = layers::SharedSurfacesChild::Share(aSurface, extId);
+  if (NS_FAILED(rv)) {
+    DrawEventRecorderMemory::StoreSourceSurfaceRecording(aSurface, aReason);
+    return;
+  }
+
+  StoreExternalSurfaceRecording(aSurface, wr::AsUint64(extId));
+}
+
+already_AddRefed<SourceSurface> WebRenderTranslator::LookupExternalSurface(
+    uint64_t aKey) {
+  return SharedSurfacesParent::Get(wr::ToExternalImageId(aKey));
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/WebRenderDrawEventRecorder.h b/gfx/layers/wr/WebRenderDrawEventRecorder.h
new file mode 100644
index 0000000000..b08ff5b959
--- /dev/null
+++ b/gfx/layers/wr/WebRenderDrawEventRecorder.h
@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 20; 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_LAYERS_WEBRENDERDRAWTARGETRECORDER_H
+#define MOZILLA_LAYERS_WEBRENDERDRAWTARGETRECORDER_H
+
+#include "mozilla/gfx/DrawEventRecorder.h"
+#include "mozilla/gfx/InlineTranslator.h"
+#include "mozilla/webrender/webrender_ffi.h"
+
+namespace mozilla {
+namespace layers {
+
+struct BlobFont {
+  wr::FontInstanceKey mFontInstanceKey;
+  gfx::ReferencePtr mScaledFontPtr;
+};
+
+class WebRenderDrawEventRecorder final : public gfx::DrawEventRecorderMemory {
+ public:
+  MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(WebRenderDrawEventRecorder, final)
+
+  explicit WebRenderDrawEventRecorder(
+      const gfx::SerializeResourcesFn& aSerialize)
+      : DrawEventRecorderMemory(aSerialize) {}
+
+  void StoreSourceSurfaceRecording(gfx::SourceSurface* aSurface,
+                                   const char* aReason) final;
+
+ private:
+  virtual ~WebRenderDrawEventRecorder() = default;
+};
+
+class WebRenderTranslator final : public gfx::InlineTranslator {
+ public:
+  explicit WebRenderTranslator(gfx::DrawTarget* aDT,
+                               void* aFontContext = nullptr)
+      : InlineTranslator(aDT, aFontContext) {}
+
+  already_AddRefed<gfx::SourceSurface> LookupExternalSurface(
+      uint64_t aKey) final;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif
diff --git a/gfx/layers/wr/WebRenderImageHost.cpp b/gfx/layers/wr/WebRenderImageHost.cpp
new file mode 100644
index 0000000000..361c08f9c2
--- /dev/null
+++ b/gfx/layers/wr/WebRenderImageHost.cpp
@@ -0,0 +1,395 @@
+/* -*- 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 "WebRenderImageHost.h"
+
+#include <utility>
+
+#include "mozilla/ScopeExit.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/AsyncImagePipelineManager.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/CompositorVsyncScheduler.h"  // for CompositorVsyncScheduler
+#include "mozilla/layers/RemoteTextureHostWrapper.h"
+#include "mozilla/layers/RemoteTextureMap.h"
+#include "mozilla/layers/WebRenderBridgeParent.h"
+#include "mozilla/layers/WebRenderTextureHost.h"
+#include "mozilla/StaticPrefs_webgl.h"
+#include "nsAString.h"
+#include "nsDebug.h"          // for NS_WARNING, NS_ASSERTION
+#include "nsPrintfCString.h"  // for nsPrintfCString
+#include "nsString.h"         // for nsAutoCString
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace layers {
+
+class ISurfaceAllocator;
+
+WebRenderImageHost::WebRenderImageHost(const TextureInfo& aTextureInfo)
+    : CompositableHost(aTextureInfo),
+      ImageComposite(),
+      mCurrentAsyncImageManager(nullptr) {}
+
+WebRenderImageHost::~WebRenderImageHost() {
+  MOZ_ASSERT(mPendingRemoteTextureWrappers.empty());
+  MOZ_ASSERT(mWrBridges.empty());
+}
+
+void WebRenderImageHost::OnReleased() {
+  if (mRemoteTextureOwnerIdOfPushCallback) {
+    RemoteTextureMap::Get()->UnregisterRemoteTexturePushListener(
+        *mRemoteTextureOwnerIdOfPushCallback, mForPidOfPushCallback, this);
+    mRemoteTextureOwnerIdOfPushCallback = Nothing();
+    mSizeOfPushCallback = gfx::IntSize();
+    mFlagsOfPushCallback = TextureFlags::NO_FLAGS;
+  }
+  if (!mPendingRemoteTextureWrappers.empty()) {
+    mPendingRemoteTextureWrappers.clear();
+  }
+}
+
+void WebRenderImageHost::UseTextureHost(
+    const nsTArray<TimedTexture>& aTextures) {
+  CompositableHost::UseTextureHost(aTextures);
+  MOZ_ASSERT(aTextures.Length() >= 1);
+
+  if (!mPendingRemoteTextureWrappers.empty()) {
+    mPendingRemoteTextureWrappers.clear();
+  }
+
+  if (mCurrentTextureHost &&
+      mCurrentTextureHost->AsRemoteTextureHostWrapper()) {
+    mCurrentTextureHost = nullptr;
+  }
+
+  nsTArray<TimedImage> newImages;
+
+  for (uint32_t i = 0; i < aTextures.Length(); ++i) {
+    const TimedTexture& t = aTextures[i];
+    MOZ_ASSERT(t.mTexture);
+    if (i + 1 < aTextures.Length() && t.mProducerID == mLastProducerID &&
+        t.mFrameID < mLastFrameID) {
+      // Ignore frames before a frame that we already composited. We don't
+      // ever want to display these frames. This could be important if
+      // the frame producer adjusts timestamps (e.g. to track the audio clock)
+      // and the new frame times are earlier.
+      continue;
+    }
+    TimedImage& img = *newImages.AppendElement();
+    img.mTextureHost = t.mTexture;
+    img.mTimeStamp = t.mTimeStamp;
+    img.mPictureRect = t.mPictureRect;
+    img.mFrameID = t.mFrameID;
+    img.mProducerID = t.mProducerID;
+    img.mTextureHost->SetCropRect(img.mPictureRect);
+  }
+
+  SetImages(std::move(newImages));
+
+  if (GetAsyncRef()) {
+    for (const auto& it : mWrBridges) {
+      RefPtr<WebRenderBridgeParent> wrBridge = it.second->WrBridge();
+      if (wrBridge && wrBridge->CompositorScheduler()) {
+        wrBridge->CompositorScheduler()->ScheduleComposition(
+            wr::RenderReasons::ASYNC_IMAGE);
+      }
+    }
+  }
+
+  // Video producers generally send replacement images with the same frameID but
+  // slightly different timestamps in order to sync with the audio clock. This
+  // means that any CompositeUntil() call we made in Composite() may no longer
+  // guarantee that we'll composite until the next frame is ready. Fix that
+  // here.
+  if (mLastFrameID >= 0 && !mWrBridges.empty()) {
+    for (const auto& img : Images()) {
+      bool frameComesAfter =
+          img.mFrameID > mLastFrameID || img.mProducerID != mLastProducerID;
+      if (frameComesAfter && !img.mTimeStamp.IsNull()) {
+        for (const auto& it : mWrBridges) {
+          RefPtr<WebRenderBridgeParent> wrBridge = it.second->WrBridge();
+          if (wrBridge) {
+            wrBridge->AsyncImageManager()->CompositeUntil(
+                img.mTimeStamp + TimeDuration::FromMilliseconds(BIAS_TIME_MS));
+          }
+        }
+        break;
+      }
+    }
+  }
+}
+
+void WebRenderImageHost::PushPendingRemoteTexture(
+    const RemoteTextureId aTextureId, const RemoteTextureOwnerId aOwnerId,
+    const base::ProcessId aForPid, const gfx::IntSize aSize,
+    const TextureFlags aFlags) {
+  // Ensure aOwnerId is the same as RemoteTextureOwnerId of pending
+  // RemoteTextures.
+  if (!mPendingRemoteTextureWrappers.empty()) {
+    auto* wrapper =
+        mPendingRemoteTextureWrappers.front()->AsRemoteTextureHostWrapper();
+    MOZ_ASSERT(wrapper);
+    if (wrapper->mOwnerId != aOwnerId || wrapper->mForPid != aForPid) {
+      // Clear when RemoteTextureOwner is different.
+      mPendingRemoteTextureWrappers.clear();
+      mWaitingReadyCallback = false;
+    }
+  }
+
+  RefPtr<TextureHost> texture =
+      RemoteTextureMap::Get()->GetOrCreateRemoteTextureHostWrapper(
+          aTextureId, aOwnerId, aForPid, aSize, aFlags);
+  MOZ_ASSERT(texture);
+  mPendingRemoteTextureWrappers.push_back(
+      CompositableTextureHostRef(texture.get()));
+}
+
+void WebRenderImageHost::UseRemoteTexture() {
+  if (mPendingRemoteTextureWrappers.empty()) {
+    return;
+  }
+
+  const bool useAsyncRemoteTexture =
+      gfx::gfxVars::UseCanvasRenderThread() &&
+      StaticPrefs::webgl_out_of_process_async_present() &&
+      !gfx::gfxVars::WebglOopAsyncPresentForceSync();
+  const bool useReadyCallback = GetAsyncRef() && useAsyncRemoteTexture &&
+                                mRemoteTextureOwnerIdOfPushCallback.isNothing();
+  CompositableTextureHostRef texture;
+
+  if (useReadyCallback) {
+    if (mWaitingReadyCallback) {
+      return;
+    }
+    MOZ_ASSERT(!mWaitingReadyCallback);
+
+    auto readyCallback = [self = RefPtr<WebRenderImageHost>(this)](
+                             const RemoteTextureInfo aInfo) {
+      RefPtr<nsIRunnable> runnable = NS_NewRunnableFunction(
+          "WebRenderImageHost::UseRemoteTexture",
+          [self = std::move(self), aInfo]() {
+            MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+            if (self->mPendingRemoteTextureWrappers.empty()) {
+              return;
+            }
+
+            auto* wrapper = self->mPendingRemoteTextureWrappers.front()
+                                ->AsRemoteTextureHostWrapper();
+            MOZ_ASSERT(wrapper);
+            if (wrapper->mOwnerId != aInfo.mOwnerId ||
+                wrapper->mForPid != aInfo.mForPid) {
+              // obsoleted callback
+              return;
+            }
+
+            self->mWaitingReadyCallback = false;
+            self->UseRemoteTexture();
+          });
+
+      CompositorThread()->Dispatch(runnable.forget());
+    };
+
+    // Check which of the pending remote textures is the most recent and ready.
+    while (!mPendingRemoteTextureWrappers.empty()) {
+      auto* wrapper =
+          mPendingRemoteTextureWrappers.front()->AsRemoteTextureHostWrapper();
+      mWaitingReadyCallback =
+          RemoteTextureMap::Get()->GetRemoteTextureForDisplayList(
+              wrapper, readyCallback);
+      MOZ_ASSERT_IF(mWaitingReadyCallback, !wrapper->IsReadyForRendering());
+      if (!wrapper->IsReadyForRendering()) {
+        break;
+      }
+      texture = mPendingRemoteTextureWrappers.front();
+      mPendingRemoteTextureWrappers.pop_front();
+    }
+  } else {
+    texture = mPendingRemoteTextureWrappers.front();
+    auto* wrapper = texture->AsRemoteTextureHostWrapper();
+    mPendingRemoteTextureWrappers.pop_front();
+    MOZ_ASSERT(mPendingRemoteTextureWrappers.empty());
+
+    std::function<void(const RemoteTextureInfo&)> function;
+    RemoteTextureMap::Get()->GetRemoteTextureForDisplayList(
+        wrapper, std::move(function));
+  }
+
+  if (!texture ||
+      !texture->AsRemoteTextureHostWrapper()->IsReadyForRendering()) {
+    return;
+  }
+
+  SetCurrentTextureHost(texture);
+
+  if (GetAsyncRef()) {
+    for (const auto& it : mWrBridges) {
+      RefPtr<WebRenderBridgeParent> wrBridge = it.second->WrBridge();
+      if (wrBridge && wrBridge->CompositorScheduler()) {
+        wrBridge->CompositorScheduler()->ScheduleComposition(
+            wr::RenderReasons::ASYNC_IMAGE);
+      }
+    }
+  }
+}
+
+void WebRenderImageHost::EnableRemoteTexturePushCallback(
+    const RemoteTextureOwnerId aOwnerId, const base::ProcessId aForPid,
+    const gfx::IntSize aSize, const TextureFlags aFlags) {
+  if (!GetAsyncRef()) {
+    MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+    return;
+  }
+
+  if (mRemoteTextureOwnerIdOfPushCallback.isSome()) {
+    RemoteTextureMap::Get()->UnregisterRemoteTexturePushListener(aOwnerId,
+                                                                 aForPid, this);
+  }
+
+  RemoteTextureMap::Get()->RegisterRemoteTexturePushListener(aOwnerId, aForPid,
+                                                             this);
+  mRemoteTextureOwnerIdOfPushCallback = Some(aOwnerId);
+  mForPidOfPushCallback = aForPid;
+  mSizeOfPushCallback = aSize;
+  mFlagsOfPushCallback = aFlags;
+}
+
+void WebRenderImageHost::NotifyPushTexture(const RemoteTextureId aTextureId,
+                                           const RemoteTextureOwnerId aOwnerId,
+                                           const base::ProcessId aForPid) {
+  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
+
+  if (mRemoteTextureOwnerIdOfPushCallback != Some(aOwnerId)) {
+    // RemoteTextureOwnerId is already obsoleted
+    return;
+  }
+  PushPendingRemoteTexture(aTextureId, aOwnerId, aForPid, mSizeOfPushCallback,
+                           mFlagsOfPushCallback);
+  UseRemoteTexture();
+}
+
+void WebRenderImageHost::CleanupResources() {
+  ClearImages();
+  SetCurrentTextureHost(nullptr);
+}
+
+void WebRenderImageHost::RemoveTextureHost(TextureHost* aTexture) {
+  CompositableHost::RemoveTextureHost(aTexture);
+  RemoveImagesWithTextureHost(aTexture);
+}
+
+TimeStamp WebRenderImageHost::GetCompositionTime() const {
+  TimeStamp time;
+
+  MOZ_ASSERT(mCurrentAsyncImageManager);
+  if (mCurrentAsyncImageManager) {
+    time = mCurrentAsyncImageManager->GetCompositionTime();
+  }
+  return time;
+}
+
+CompositionOpportunityId WebRenderImageHost::GetCompositionOpportunityId()
+    const {
+  CompositionOpportunityId id;
+
+  MOZ_ASSERT(mCurrentAsyncImageManager);
+  if (mCurrentAsyncImageManager) {
+    id = mCurrentAsyncImageManager->GetCompositionOpportunityId();
+  }
+  return id;
+}
+
+void WebRenderImageHost::AppendImageCompositeNotification(
+    const ImageCompositeNotificationInfo& aInfo) const {
+  if (mCurrentAsyncImageManager) {
+    mCurrentAsyncImageManager->AppendImageCompositeNotification(aInfo);
+  }
+}
+
+TextureHost* WebRenderImageHost::GetAsTextureHostForComposite(
+    AsyncImagePipelineManager* aAsyncImageManager) {
+  if (mCurrentTextureHost &&
+      mCurrentTextureHost->AsRemoteTextureHostWrapper()) {
+    return mCurrentTextureHost;
+  }
+
+  mCurrentAsyncImageManager = aAsyncImageManager;
+  const auto onExit =
+      mozilla::MakeScopeExit([&]() { mCurrentAsyncImageManager = nullptr; });
+
+  int imageIndex = ChooseImageIndex();
+  if (imageIndex < 0) {
+    SetCurrentTextureHost(nullptr);
+    return nullptr;
+  }
+
+  if (uint32_t(imageIndex) + 1 < ImagesCount()) {
+    mCurrentAsyncImageManager->CompositeUntil(
+        GetImage(imageIndex + 1)->mTimeStamp +
+        TimeDuration::FromMilliseconds(BIAS_TIME_MS));
+  }
+
+  const TimedImage* img = GetImage(imageIndex);
+  SetCurrentTextureHost(img->mTextureHost);
+
+  if (mCurrentAsyncImageManager->GetCompositionTime()) {
+    // We are in a composition. Send ImageCompositeNotifications.
+    OnFinishRendering(imageIndex, img, mAsyncRef.mProcessId, mAsyncRef.mHandle);
+  }
+
+  return mCurrentTextureHost;
+}
+
+void WebRenderImageHost::SetCurrentTextureHost(TextureHost* aTexture) {
+  if (aTexture == mCurrentTextureHost.get()) {
+    return;
+  }
+  mCurrentTextureHost = aTexture;
+}
+
+void WebRenderImageHost::Dump(std::stringstream& aStream, const char* aPrefix,
+                              bool aDumpHtml) {
+  for (const auto& img : Images()) {
+    aStream << aPrefix;
+    aStream << (aDumpHtml ? "<ul><li>TextureHost: " : "TextureHost: ");
+    DumpTextureHost(aStream, img.mTextureHost);
+    aStream << (aDumpHtml ? " </li></ul> " : " ");
+  }
+}
+
+void WebRenderImageHost::SetWrBridge(const wr::PipelineId& aPipelineId,
+                                     WebRenderBridgeParent* aWrBridge) {
+  MOZ_ASSERT(aWrBridge);
+  MOZ_ASSERT(!mCurrentAsyncImageManager);
+#ifdef DEBUG
+  const auto it = mWrBridges.find(wr::AsUint64(aPipelineId));
+  MOZ_ASSERT(it == mWrBridges.end());
+#endif
+  RefPtr<WebRenderBridgeParentRef> ref =
+      aWrBridge->GetWebRenderBridgeParentRef();
+  mWrBridges.emplace(wr::AsUint64(aPipelineId), ref);
+}
+
+void WebRenderImageHost::ClearWrBridge(const wr::PipelineId& aPipelineId,
+                                       WebRenderBridgeParent* aWrBridge) {
+  MOZ_ASSERT(aWrBridge);
+  MOZ_ASSERT(!mCurrentAsyncImageManager);
+
+  const auto it = mWrBridges.find(wr::AsUint64(aPipelineId));
+  MOZ_ASSERT(it != mWrBridges.end());
+  if (it == mWrBridges.end()) {
+    gfxCriticalNote << "WrBridge mismatch happened";
+    return;
+  }
+  mWrBridges.erase(it);
+  SetCurrentTextureHost(nullptr);
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/WebRenderImageHost.h b/gfx/layers/wr/WebRenderImageHost.h
new file mode 100644
index 0000000000..23e0f88f88
--- /dev/null
+++ b/gfx/layers/wr/WebRenderImageHost.h
@@ -0,0 +1,100 @@
+/* -*- 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_WEBRENDERIMAGEHOST_H
+#define MOZILLA_GFX_WEBRENDERIMAGEHOST_H
+
+#include <deque>
+#include <unordered_map>
+
+#include "CompositableHost.h"               // for CompositableHost
+#include "mozilla/layers/ImageComposite.h"  // for ImageComposite
+#include "mozilla/WeakPtr.h"
+
+namespace mozilla {
+namespace layers {
+
+class AsyncImagePipelineManager;
+class WebRenderBridgeParent;
+class WebRenderBridgeParentRef;
+
+/**
+ * ImageHost. Works with ImageClientSingle and ImageClientBuffered
+ */
+class WebRenderImageHost : public CompositableHost, public ImageComposite {
+ public:
+  explicit WebRenderImageHost(const TextureInfo& aTextureInfo);
+  virtual ~WebRenderImageHost();
+
+  void UseTextureHost(const nsTArray<TimedTexture>& aTextures) override;
+  void RemoveTextureHost(TextureHost* aTexture) override;
+
+  void EnableRemoteTexturePushCallback(const RemoteTextureOwnerId aOwnerId,
+                                       const base::ProcessId aForPid,
+                                       const gfx::IntSize aSize,
+                                       const TextureFlags aFlags) override;
+
+  void NotifyPushTexture(const RemoteTextureId aTextureId,
+                         const RemoteTextureOwnerId aOwnerId,
+                         const base::ProcessId aForPid) override;
+
+  void Dump(std::stringstream& aStream, const char* aPrefix = "",
+            bool aDumpHtml = false) override;
+
+  void CleanupResources() override;
+
+  void OnReleased() override;
+
+  uint32_t GetDroppedFrames() override { return GetDroppedFramesAndReset(); }
+
+  WebRenderImageHost* AsWebRenderImageHost() override { return this; }
+
+  void PushPendingRemoteTexture(const RemoteTextureId aTextureId,
+                                const RemoteTextureOwnerId aOwnerId,
+                                const base::ProcessId aForPid,
+                                const gfx::IntSize aSize,
+                                const TextureFlags aFlags);
+  void UseRemoteTexture();
+
+  TextureHost* GetAsTextureHostForComposite(
+      AsyncImagePipelineManager* aAsyncImageManager);
+
+  void SetWrBridge(const wr::PipelineId& aPipelineId,
+                   WebRenderBridgeParent* aWrBridge);
+
+  void ClearWrBridge(const wr::PipelineId& aPipelineId,
+                     WebRenderBridgeParent* aWrBridge);
+
+  TextureHost* GetCurrentTextureHost() { return mCurrentTextureHost; }
+
+ protected:
+  // ImageComposite
+  TimeStamp GetCompositionTime() const override;
+  CompositionOpportunityId GetCompositionOpportunityId() const override;
+  void AppendImageCompositeNotification(
+      const ImageCompositeNotificationInfo& aInfo) const override;
+
+  void SetCurrentTextureHost(TextureHost* aTexture);
+
+  std::unordered_map<uint64_t, RefPtr<WebRenderBridgeParentRef>> mWrBridges;
+
+  AsyncImagePipelineManager* mCurrentAsyncImageManager;
+
+  CompositableTextureHostRef mCurrentTextureHost;
+
+  std::deque<CompositableTextureHostRef> mPendingRemoteTextureWrappers;
+  bool mWaitingReadyCallback = false;
+
+  Maybe<RemoteTextureOwnerId> mRemoteTextureOwnerIdOfPushCallback;
+  base::ProcessId mForPidOfPushCallback;
+  gfx::IntSize mSizeOfPushCallback;
+  TextureFlags mFlagsOfPushCallback = TextureFlags::NO_FLAGS;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_WEBRENDERIMAGEHOST_H
diff --git a/gfx/layers/wr/WebRenderLayerManager.cpp b/gfx/layers/wr/WebRenderLayerManager.cpp
new file mode 100644
index 0000000000..8dc6c13ac1
--- /dev/null
+++ b/gfx/layers/wr/WebRenderLayerManager.cpp
@@ -0,0 +1,821 @@
+/* -*- 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 "WebRenderLayerManager.h"
+
+#include "GeckoProfiler.h"
+#include "mozilla/StaticPrefs_apz.h"
+#include "mozilla/StaticPrefs_layers.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/gfx/DrawEventRecorder.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/StackingContextHelper.h"
+#include "mozilla/layers/TextureClient.h"
+#include "mozilla/layers/TransactionIdAllocator.h"
+#include "mozilla/layers/WebRenderBridgeChild.h"
+#include "mozilla/layers/UpdateImageHelper.h"
+#include "mozilla/PerfStats.h"
+#include "nsDisplayList.h"
+#include "nsLayoutUtils.h"
+#include "WebRenderCanvasRenderer.h"
+#include "LayerUserData.h"
+
+#ifdef XP_WIN
+#  include "gfxDWriteFonts.h"
+#  include "mozilla/WindowsProcessMitigations.h"
+#endif
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace layers {
+
+WebRenderLayerManager::WebRenderLayerManager(nsIWidget* aWidget)
+    : mWidget(aWidget),
+      mLatestTransactionId{0},
+      mNeedsComposite(false),
+      mIsFirstPaint(false),
+      mDestroyed(false),
+      mTarget(nullptr),
+      mPaintSequenceNumber(0),
+      mWebRenderCommandBuilder(this) {
+  MOZ_COUNT_CTOR(WebRenderLayerManager);
+  mStateManager.mLayerManager = this;
+
+  if (XRE_IsContentProcess() &&
+      StaticPrefs::gfx_webrender_enable_item_cache_AtStartup()) {
+    static const size_t kInitialCacheSize = 1024;
+    static const size_t kMaximumCacheSize = 10240;
+
+    mDisplayItemCache.SetCapacity(kInitialCacheSize, kMaximumCacheSize);
+  }
+}
+
+KnowsCompositor* WebRenderLayerManager::AsKnowsCompositor() { return mWrChild; }
+
+bool WebRenderLayerManager::Initialize(
+    PCompositorBridgeChild* aCBChild, wr::PipelineId aLayersId,
+    TextureFactoryIdentifier* aTextureFactoryIdentifier, nsCString& aError) {
+  MOZ_ASSERT(mWrChild == nullptr);
+  MOZ_ASSERT(aTextureFactoryIdentifier);
+
+  // When we fail to initialize WebRender, it is useful to know if it has ever
+  // succeeded, or if this is the first attempt.
+  static bool hasInitialized = false;
+
+  WindowKind windowKind;
+  if (mWidget->GetWindowType() != widget::WindowType::Popup) {
+    windowKind = WindowKind::MAIN;
+  } else {
+    windowKind = WindowKind::SECONDARY;
+  }
+
+  LayoutDeviceIntSize size = mWidget->GetClientSize();
+  // Check widget size
+  if (!wr::WindowSizeSanityCheck(size.width, size.height)) {
+    gfxCriticalNoteOnce << "Widget size is not valid " << size
+                        << " isParent: " << XRE_IsParentProcess();
+  }
+
+  PWebRenderBridgeChild* bridge =
+      aCBChild->SendPWebRenderBridgeConstructor(aLayersId, size, windowKind);
+  if (!bridge) {
+    // This should only fail if we attempt to access a layer we don't have
+    // permission for, or more likely, the GPU process crashed again during
+    // reinitialization. We can expect to be notified again to reinitialize
+    // (which may or may not be using WebRender).
+    gfxCriticalNote << "Failed to create WebRenderBridgeChild.";
+    aError.Assign(hasInitialized
+                      ? "FEATURE_FAILURE_WEBRENDER_INITIALIZE_IPDL_POST"_ns
+                      : "FEATURE_FAILURE_WEBRENDER_INITIALIZE_IPDL_FIRST"_ns);
+    return false;
+  }
+
+  mWrChild = static_cast<WebRenderBridgeChild*>(bridge);
+
+  TextureFactoryIdentifier textureFactoryIdentifier;
+  wr::MaybeIdNamespace idNamespace;
+  // Sync ipc
+  if (!WrBridge()->SendEnsureConnected(&textureFactoryIdentifier, &idNamespace,
+                                       &aError)) {
+    gfxCriticalNote << "Failed as lost WebRenderBridgeChild.";
+    aError.Assign(hasInitialized
+                      ? "FEATURE_FAILURE_WEBRENDER_INITIALIZE_SYNC_POST"_ns
+                      : "FEATURE_FAILURE_WEBRENDER_INITIALIZE_SYNC_FIRST"_ns);
+    return false;
+  }
+
+  if (textureFactoryIdentifier.mParentBackend == LayersBackend::LAYERS_NONE ||
+      idNamespace.isNothing()) {
+    gfxCriticalNote << "Failed to connect WebRenderBridgeChild. isParent="
+                    << XRE_IsParentProcess();
+    aError.Append(hasInitialized ? "_POST"_ns : "_FIRST"_ns);
+    return false;
+  }
+
+  WrBridge()->SetWebRenderLayerManager(this);
+  WrBridge()->IdentifyTextureHost(textureFactoryIdentifier);
+  WrBridge()->SetNamespace(idNamespace.ref());
+  *aTextureFactoryIdentifier = textureFactoryIdentifier;
+
+  mDLBuilder = MakeUnique<wr::DisplayListBuilder>(
+      WrBridge()->GetPipeline(), WrBridge()->GetWebRenderBackend());
+
+  hasInitialized = true;
+  return true;
+}
+
+void WebRenderLayerManager::Destroy() { DoDestroy(/* aIsSync */ false); }
+
+void WebRenderLayerManager::DoDestroy(bool aIsSync) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (IsDestroyed()) {
+    return;
+  }
+
+  mDLBuilder = nullptr;
+  mUserData.Destroy();
+  mPartialPrerenderedAnimations.Clear();
+
+  mStateManager.Destroy();
+
+  if (WrBridge()) {
+    WrBridge()->Destroy(aIsSync);
+  }
+
+  mWebRenderCommandBuilder.Destroy();
+
+  if (mTransactionIdAllocator) {
+    // Make sure to notify the refresh driver just in case it's waiting on a
+    // pending transaction. Do this at the top of the event loop so we don't
+    // cause a paint to occur during compositor shutdown.
+    RefPtr<TransactionIdAllocator> allocator = mTransactionIdAllocator;
+    TransactionId id = mLatestTransactionId;
+
+    RefPtr<Runnable> task = NS_NewRunnableFunction(
+        "TransactionIdAllocator::NotifyTransactionCompleted",
+        [allocator, id]() -> void {
+          allocator->ClearPendingTransactions();
+          allocator->NotifyTransactionCompleted(id);
+        });
+    NS_DispatchToMainThread(task.forget());
+  }
+
+  // Forget the widget pointer in case we outlive our owning widget.
+  mWidget = nullptr;
+  mDestroyed = true;
+}
+
+WebRenderLayerManager::~WebRenderLayerManager() {
+  Destroy();
+  MOZ_COUNT_DTOR(WebRenderLayerManager);
+}
+
+CompositorBridgeChild* WebRenderLayerManager::GetCompositorBridgeChild() {
+  return WrBridge()->GetCompositorBridgeChild();
+}
+
+void WebRenderLayerManager::GetBackendName(nsAString& name) {
+  if (WrBridge()->UsingSoftwareWebRenderD3D11()) {
+    name.AssignLiteral("WebRender (Software D3D11)");
+  } else if (WrBridge()->UsingSoftwareWebRenderOpenGL()) {
+    name.AssignLiteral("WebRender (Software OpenGL)");
+  } else if (WrBridge()->UsingSoftwareWebRender()) {
+    name.AssignLiteral("WebRender (Software)");
+  } else {
+    name.AssignLiteral("WebRender");
+  }
+}
+
+uint32_t WebRenderLayerManager::StartFrameTimeRecording(int32_t aBufferSize) {
+  CompositorBridgeChild* renderer = GetCompositorBridgeChild();
+  if (renderer) {
+    uint32_t startIndex;
+    renderer->SendStartFrameTimeRecording(aBufferSize, &startIndex);
+    return startIndex;
+  }
+  return -1;
+}
+
+void WebRenderLayerManager::StopFrameTimeRecording(
+    uint32_t aStartIndex, nsTArray<float>& aFrameIntervals) {
+  CompositorBridgeChild* renderer = GetCompositorBridgeChild();
+  if (renderer) {
+    renderer->SendStopFrameTimeRecording(aStartIndex, &aFrameIntervals);
+  }
+}
+
+void WebRenderLayerManager::TakeCompositionPayloads(
+    nsTArray<CompositionPayload>& aPayloads) {
+  aPayloads.Clear();
+
+  std::swap(mPayload, aPayloads);
+}
+
+bool WebRenderLayerManager::BeginTransactionWithTarget(gfxContext* aTarget,
+                                                       const nsCString& aURL) {
+  mTarget = aTarget;
+  bool retval = BeginTransaction(aURL);
+  if (!retval) {
+    mTarget = nullptr;
+  }
+  return retval;
+}
+
+bool WebRenderLayerManager::BeginTransaction(const nsCString& aURL) {
+  if (!WrBridge()->IPCOpen()) {
+    gfxCriticalNote << "IPC Channel is already torn down unexpectedly\n";
+    return false;
+  }
+
+  mTransactionStart = TimeStamp::Now();
+  mURL = aURL;
+
+  // Increment the paint sequence number even if test logging isn't
+  // enabled in this process; it may be enabled in the parent process,
+  // and the parent process expects unique sequence numbers.
+  ++mPaintSequenceNumber;
+  if (StaticPrefs::apz_test_logging_enabled()) {
+    mApzTestData.StartNewPaint(mPaintSequenceNumber);
+  }
+  return true;
+}
+
+bool WebRenderLayerManager::EndEmptyTransaction(EndTransactionFlags aFlags) {
+  auto clearTarget = MakeScopeExit([&] { mTarget = nullptr; });
+
+  // If we haven't sent a display list (since creation or since the last time we
+  // sent ClearDisplayList to the parent) then we can't do an empty transaction
+  // because the parent doesn't have a display list for us and we need to send a
+  // display list first.
+  if (!WrBridge()->GetSentDisplayList()) {
+    return false;
+  }
+
+  mDisplayItemCache.SkipWaitingForPartialDisplayList();
+
+  // Since we don't do repeat transactions right now, just set the time
+  mAnimationReadyTime = TimeStamp::Now();
+
+  // Don't block on hidden windows on Linux as it may block all rendering.
+  const bool throttle = mWidget->IsMapped();
+  mLatestTransactionId = mTransactionIdAllocator->GetTransactionId(throttle);
+
+  if (aFlags & EndTransactionFlags::END_NO_COMPOSITE &&
+      !mWebRenderCommandBuilder.NeedsEmptyTransaction()) {
+    if (mPendingScrollUpdates.IsEmpty()) {
+      MOZ_ASSERT(!mTarget);
+      WrBridge()->SendSetFocusTarget(mFocusTarget);
+      // Revoke TransactionId to trigger next paint.
+      mTransactionIdAllocator->RevokeTransactionId(mLatestTransactionId);
+      mLatestTransactionId = mLatestTransactionId.Prev();
+      return true;
+    }
+  }
+
+  LayoutDeviceIntSize size = mWidget->GetClientSize();
+  WrBridge()->BeginTransaction();
+
+  mWebRenderCommandBuilder.EmptyTransaction();
+
+  // Get the time of when the refresh driver start its tick (if available),
+  // otherwise use the time of when LayerManager::BeginTransaction was called.
+  TimeStamp refreshStart = mTransactionIdAllocator->GetTransactionStart();
+  if (!refreshStart) {
+    refreshStart = mTransactionStart;
+  }
+
+  // Skip the synchronization for buffer since we also skip the painting during
+  // device-reset status.
+  if (!gfxPlatform::GetPlatform()->DidRenderingDeviceReset()) {
+    if (WrBridge()->GetSyncObject() &&
+        WrBridge()->GetSyncObject()->IsSyncObjectValid()) {
+      WrBridge()->GetSyncObject()->Synchronize();
+    }
+  }
+
+  GetCompositorBridgeChild()->EndCanvasTransaction();
+
+  Maybe<TransactionData> transactionData;
+  if (mStateManager.mAsyncResourceUpdates || !mPendingScrollUpdates.IsEmpty() ||
+      WrBridge()->HasWebRenderParentCommands()) {
+    transactionData.emplace();
+    transactionData->mIdNamespace = WrBridge()->GetNamespace();
+    transactionData->mPaintSequenceNumber = mPaintSequenceNumber;
+    if (mStateManager.mAsyncResourceUpdates) {
+      mStateManager.mAsyncResourceUpdates->Flush(
+          transactionData->mResourceUpdates, transactionData->mSmallShmems,
+          transactionData->mLargeShmems);
+    }
+    transactionData->mScrollUpdates = std::move(mPendingScrollUpdates);
+    for (const auto& scrollId : transactionData->mScrollUpdates.Keys()) {
+      nsLayoutUtils::NotifyPaintSkipTransaction(/*scroll id=*/scrollId);
+    }
+  }
+
+  Maybe<wr::IpcResourceUpdateQueue> nothing;
+  WrBridge()->EndEmptyTransaction(mFocusTarget, std::move(transactionData),
+                                  mLatestTransactionId,
+                                  mTransactionIdAllocator->GetVsyncId(),
+                                  mTransactionIdAllocator->GetVsyncStart(),
+                                  refreshStart, mTransactionStart, mURL);
+  mTransactionStart = TimeStamp();
+
+  MakeSnapshotIfRequired(size);
+  return true;
+}
+
+void WebRenderLayerManager::EndTransactionWithoutLayer(
+    nsDisplayList* aDisplayList, nsDisplayListBuilder* aDisplayListBuilder,
+    WrFiltersHolder&& aFilters, WebRenderBackgroundData* aBackground,
+    const double aGeckoDLBuildTime) {
+  AUTO_PROFILER_TRACING_MARKER("Paint", "WrDisplayList", GRAPHICS);
+
+  auto clearTarget = MakeScopeExit([&] { mTarget = nullptr; });
+
+  // Since we don't do repeat transactions right now, just set the time
+  mAnimationReadyTime = TimeStamp::Now();
+
+  WrBridge()->BeginTransaction();
+
+  LayoutDeviceIntSize size = mWidget->GetClientSize();
+
+  mDLBuilder->Begin(&mDisplayItemCache);
+
+  wr::IpcResourceUpdateQueue resourceUpdates(WrBridge());
+  wr::usize builderDumpIndex = 0;
+  bool containsSVGGroup = false;
+  bool dumpEnabled =
+      mWebRenderCommandBuilder.ShouldDumpDisplayList(aDisplayListBuilder);
+  Maybe<AutoDisplayItemCacheSuppressor> cacheSuppressor;
+  if (dumpEnabled) {
+    cacheSuppressor.emplace(&mDisplayItemCache);
+    printf_stderr("-- WebRender display list build --\n");
+  }
+
+  if (XRE_IsContentProcess() &&
+      StaticPrefs::gfx_webrender_debug_dl_dump_content_serialized()) {
+    mDLBuilder->DumpSerializedDisplayList();
+  }
+
+  if (aDisplayList) {
+    MOZ_ASSERT(aDisplayListBuilder && !aBackground);
+    mDisplayItemCache.SetDisplayList(aDisplayListBuilder, aDisplayList);
+
+    mWebRenderCommandBuilder.BuildWebRenderCommands(
+        *mDLBuilder, resourceUpdates, aDisplayList, aDisplayListBuilder,
+        mScrollData, std::move(aFilters));
+
+    aDisplayListBuilder->NotifyAndClearScrollFrames();
+
+    builderDumpIndex = mWebRenderCommandBuilder.GetBuilderDumpIndex();
+    containsSVGGroup = mWebRenderCommandBuilder.GetContainsSVGGroup();
+  } else {
+    // ViewToPaint does not have frame yet, then render only background clolor.
+    MOZ_ASSERT(!aDisplayListBuilder && aBackground);
+    aBackground->AddWebRenderCommands(*mDLBuilder);
+    if (dumpEnabled) {
+      printf_stderr("(no display list; background only)\n");
+      builderDumpIndex =
+          mDLBuilder->Dump(/*indent*/ 1, Some(builderDumpIndex), Nothing());
+    }
+  }
+
+  mWidget->AddWindowOverlayWebRenderCommands(WrBridge(), *mDLBuilder,
+                                             resourceUpdates);
+  if (dumpEnabled) {
+    printf_stderr("(window overlay)\n");
+    Unused << mDLBuilder->Dump(/*indent*/ 1, Some(builderDumpIndex), Nothing());
+  }
+
+  if (AsyncPanZoomEnabled()) {
+    if (mIsFirstPaint) {
+      mScrollData.SetIsFirstPaint();
+      mIsFirstPaint = false;
+    }
+    mScrollData.SetPaintSequenceNumber(mPaintSequenceNumber);
+    if (dumpEnabled) {
+      std::stringstream str;
+      str << mScrollData;
+      print_stderr(str);
+    }
+  }
+
+  // Since we're sending a full mScrollData that will include the new scroll
+  // offsets, and we can throw away the pending scroll updates we had kept for
+  // an empty transaction.
+  auto scrollIdsUpdated = ClearPendingScrollInfoUpdate();
+  for (ScrollableLayerGuid::ViewID update : scrollIdsUpdated) {
+    nsLayoutUtils::NotifyPaintSkipTransaction(update);
+  }
+
+  // Don't block on hidden windows on Linux as it may block all rendering.
+  const bool throttle = mWidget->IsMapped();
+  mLatestTransactionId = mTransactionIdAllocator->GetTransactionId(throttle);
+
+  // Get the time of when the refresh driver start its tick (if available),
+  // otherwise use the time of when LayerManager::BeginTransaction was called.
+  TimeStamp refreshStart = mTransactionIdAllocator->GetTransactionStart();
+  if (!refreshStart) {
+    refreshStart = mTransactionStart;
+  }
+
+  if (mStateManager.mAsyncResourceUpdates) {
+    if (resourceUpdates.IsEmpty()) {
+      resourceUpdates.ReplaceResources(
+          std::move(mStateManager.mAsyncResourceUpdates.ref()));
+    } else {
+      WrBridge()->UpdateResources(mStateManager.mAsyncResourceUpdates.ref());
+    }
+    mStateManager.mAsyncResourceUpdates.reset();
+  }
+  mStateManager.DiscardImagesInTransaction(resourceUpdates);
+
+  WrBridge()->RemoveExpiredFontKeys(resourceUpdates);
+
+  // Skip the synchronization for buffer since we also skip the painting during
+  // device-reset status.
+  if (!gfxPlatform::GetPlatform()->DidRenderingDeviceReset()) {
+    if (WrBridge()->GetSyncObject() &&
+        WrBridge()->GetSyncObject()->IsSyncObjectValid()) {
+      WrBridge()->GetSyncObject()->Synchronize();
+    }
+  }
+
+  GetCompositorBridgeChild()->EndCanvasTransaction();
+
+  {
+    AUTO_PROFILER_TRACING_MARKER("Paint", "ForwardDPTransaction", GRAPHICS);
+    DisplayListData dlData;
+    mDLBuilder->End(dlData);
+    resourceUpdates.Flush(dlData.mResourceUpdates, dlData.mSmallShmems,
+                          dlData.mLargeShmems);
+    dlData.mRect =
+        LayoutDeviceRect(LayoutDevicePoint(), LayoutDeviceSize(size));
+    dlData.mScrollData.emplace(std::move(mScrollData));
+    dlData.mDLDesc.gecko_display_list_type =
+        aDisplayListBuilder && aDisplayListBuilder->PartialBuildFailed()
+            ? wr::GeckoDisplayListType::Full(aGeckoDLBuildTime)
+            : wr::GeckoDisplayListType::Partial(aGeckoDLBuildTime);
+
+    // convert from nanoseconds to microseconds
+    auto duration = TimeDuration::FromMicroseconds(
+        double(dlData.mDLDesc.builder_finish_time -
+               dlData.mDLDesc.builder_start_time) /
+        1000.);
+    PerfStats::RecordMeasurement(PerfStats::Metric::WrDisplayListBuilding,
+                                 duration);
+    bool ret = WrBridge()->EndTransaction(
+        std::move(dlData), mLatestTransactionId, containsSVGGroup,
+        mTransactionIdAllocator->GetVsyncId(),
+        mTransactionIdAllocator->GetVsyncStart(), refreshStart,
+        mTransactionStart, mURL);
+    if (!ret) {
+      // Failed to send display list, reset display item cache state.
+      mDisplayItemCache.Clear();
+    }
+
+    WrBridge()->SendSetFocusTarget(mFocusTarget);
+    mFocusTarget = FocusTarget();
+  }
+
+  // Discard animations after calling WrBridge()->EndTransaction().
+  // It updates mWrEpoch in WebRenderBridgeParent. The updated mWrEpoch is
+  // necessary for deleting animations at the correct time.
+  mStateManager.DiscardCompositorAnimations();
+
+  mTransactionStart = TimeStamp();
+
+  MakeSnapshotIfRequired(size);
+  mNeedsComposite = false;
+}
+
+void WebRenderLayerManager::SetFocusTarget(const FocusTarget& aFocusTarget) {
+  mFocusTarget = aFocusTarget;
+}
+
+bool WebRenderLayerManager::AsyncPanZoomEnabled() const {
+  return mWidget->AsyncPanZoomEnabled();
+}
+
+IntRect ToOutsideIntRect(const gfxRect& aRect) {
+  return IntRect::RoundOut(aRect.X(), aRect.Y(), aRect.Width(), aRect.Height());
+}
+
+void WebRenderLayerManager::MakeSnapshotIfRequired(LayoutDeviceIntSize aSize) {
+  auto clearTarget = MakeScopeExit([&] { mTarget = nullptr; });
+
+  if (!mTarget || !mTarget->GetDrawTarget() || aSize.IsEmpty()) {
+    return;
+  }
+
+  // XXX Add other TextureData supports.
+  // Only BufferTexture is supported now.
+
+  // TODO: fixup for proper surface format.
+  // The GLES spec only guarantees that RGBA can be used with glReadPixels,
+  // so on Android we use RGBA.
+  SurfaceFormat format =
+#ifdef MOZ_WIDGET_ANDROID
+      SurfaceFormat::R8G8B8A8;
+#else
+      SurfaceFormat::B8G8R8A8;
+#endif
+  RefPtr<TextureClient> texture = TextureClient::CreateForRawBufferAccess(
+      WrBridge(), format, aSize.ToUnknownSize(), BackendType::SKIA,
+      TextureFlags::SNAPSHOT);
+  if (!texture) {
+    return;
+  }
+
+  // The other side knows our ContentParentId and WebRenderBridgeChild will
+  // ignore the one provided here in favour of what WebRenderBridgeParent
+  // already has.
+  texture->InitIPDLActor(WrBridge(), dom::ContentParentId());
+  if (!texture->GetIPDLActor()) {
+    return;
+  }
+
+  IntRect bounds = ToOutsideIntRect(mTarget->GetClipExtents());
+  bool needsYFlip = false;
+  if (!WrBridge()->SendGetSnapshot(WrapNotNull(texture->GetIPDLActor()),
+                                   &needsYFlip)) {
+    return;
+  }
+
+  TextureClientAutoLock autoLock(texture, OpenMode::OPEN_READ_ONLY);
+  if (!autoLock.Succeeded()) {
+    return;
+  }
+  RefPtr<DrawTarget> drawTarget = texture->BorrowDrawTarget();
+  if (!drawTarget || !drawTarget->IsValid()) {
+    return;
+  }
+  RefPtr<SourceSurface> snapshot = drawTarget->Snapshot();
+  /*
+    static int count = 0;
+    char filename[100];
+    snprintf(filename, 100, "output%d.png", count++);
+    printf_stderr("Writing to :%s\n", filename);
+    gfxUtils::WriteAsPNG(snapshot, filename);
+    */
+
+  Rect dst(bounds.X(), bounds.Y(), bounds.Width(), bounds.Height());
+  Rect src(0, 0, bounds.Width(), bounds.Height());
+
+  Matrix m;
+  if (needsYFlip) {
+    m = Matrix::Scaling(1.0, -1.0).PostTranslate(0.0, aSize.height);
+  }
+  SurfacePattern pattern(snapshot, ExtendMode::CLAMP, m);
+  DrawTarget* dt = mTarget->GetDrawTarget();
+  MOZ_RELEASE_ASSERT(dt);
+  dt->FillRect(dst, pattern);
+
+  mTarget = nullptr;
+}
+
+void WebRenderLayerManager::DiscardImages() {
+  wr::IpcResourceUpdateQueue resources(WrBridge());
+  mStateManager.DiscardImagesInTransaction(resources);
+  WrBridge()->UpdateResources(resources);
+}
+
+void WebRenderLayerManager::DiscardLocalImages() {
+  mStateManager.DiscardLocalImages();
+}
+
+void WebRenderLayerManager::SetLayersObserverEpoch(LayersObserverEpoch aEpoch) {
+  if (WrBridge()->IPCOpen()) {
+    WrBridge()->SendSetLayersObserverEpoch(aEpoch);
+  }
+}
+
+void WebRenderLayerManager::DidComposite(
+    TransactionId aTransactionId, const mozilla::TimeStamp& aCompositeStart,
+    const mozilla::TimeStamp& aCompositeEnd) {
+  if (IsDestroyed()) {
+    return;
+  }
+
+  MOZ_ASSERT(mWidget);
+
+  // Notifying the observers may tick the refresh driver which can cause
+  // a lot of different things to happen that may affect the lifetime of
+  // this layer manager. So let's make sure this object stays alive until
+  // the end of the method invocation.
+  RefPtr<WebRenderLayerManager> selfRef = this;
+
+  // |aTransactionId| will be > 0 if the compositor is acknowledging a shadow
+  // layers transaction.
+  if (aTransactionId.IsValid()) {
+    nsIWidgetListener* listener = mWidget->GetWidgetListener();
+    if (listener) {
+      listener->DidCompositeWindow(aTransactionId, aCompositeStart,
+                                   aCompositeEnd);
+    }
+    listener = mWidget->GetAttachedWidgetListener();
+    if (listener) {
+      listener->DidCompositeWindow(aTransactionId, aCompositeStart,
+                                   aCompositeEnd);
+    }
+    if (mTransactionIdAllocator) {
+      mTransactionIdAllocator->NotifyTransactionCompleted(aTransactionId);
+    }
+  }
+}
+
+void WebRenderLayerManager::ClearCachedResources() {
+  if (!WrBridge()->IPCOpen()) {
+    gfxCriticalNote << "IPC Channel is already torn down unexpectedly\n";
+    return;
+  }
+  WrBridge()->BeginClearCachedResources();
+  // We flush any pending async resource updates before we clear the display
+  // list items because some resources (e.g. images) might be shared between
+  // multiple layer managers, not get freed here, and we want to keep their
+  // states consistent.
+  mStateManager.FlushAsyncResourceUpdates();
+  mWebRenderCommandBuilder.ClearCachedResources();
+  DiscardImages();
+  mStateManager.ClearCachedResources();
+  WrBridge()->EndClearCachedResources();
+}
+
+void WebRenderLayerManager::ClearAnimationResources() {
+  if (!WrBridge()->IPCOpen()) {
+    gfxCriticalNote << "IPC Channel is already torn down unexpectedly\n";
+    return;
+  }
+  WrBridge()->SendClearAnimationResources();
+}
+
+void WebRenderLayerManager::WrUpdated() {
+  ClearAsyncAnimations();
+  mStateManager.mAsyncResourceUpdates.reset();
+  mWebRenderCommandBuilder.ClearCachedResources();
+  DiscardLocalImages();
+  mDisplayItemCache.Clear();
+
+  if (mWidget) {
+    if (dom::BrowserChild* browserChild = mWidget->GetOwningBrowserChild()) {
+      browserChild->SchedulePaint();
+    }
+  }
+}
+
+void WebRenderLayerManager::UpdateTextureFactoryIdentifier(
+    const TextureFactoryIdentifier& aNewIdentifier) {
+  WrBridge()->IdentifyTextureHost(aNewIdentifier);
+}
+
+TextureFactoryIdentifier WebRenderLayerManager::GetTextureFactoryIdentifier() {
+  return WrBridge()->GetTextureFactoryIdentifier();
+}
+
+void WebRenderLayerManager::SetTransactionIdAllocator(
+    TransactionIdAllocator* aAllocator) {
+  // When changing the refresh driver, the previous refresh driver may never
+  // receive updates of pending transactions it's waiting for. So clear the
+  // waiting state before assigning another refresh driver.
+  if (mTransactionIdAllocator && (aAllocator != mTransactionIdAllocator)) {
+    mTransactionIdAllocator->ClearPendingTransactions();
+
+    // We should also reset the transaction id of the new allocator to previous
+    // allocator's last transaction id, so that completed transactions for
+    // previous allocator will be ignored and won't confuse the new allocator.
+    if (aAllocator) {
+      aAllocator->ResetInitialTransactionId(
+          mTransactionIdAllocator->LastTransactionId());
+    }
+  }
+
+  mTransactionIdAllocator = aAllocator;
+}
+
+TransactionId WebRenderLayerManager::GetLastTransactionId() {
+  return mLatestTransactionId;
+}
+
+void WebRenderLayerManager::FlushRendering(wr::RenderReasons aReasons) {
+  CompositorBridgeChild* cBridge = GetCompositorBridgeChild();
+  if (!cBridge) {
+    return;
+  }
+  MOZ_ASSERT(mWidget);
+
+  // If value of IsResizingNativeWidget() is nothing, we assume that resizing
+  // might happen.
+  bool resizing = mWidget && mWidget->IsResizingNativeWidget().valueOr(true);
+
+  if (resizing) {
+    aReasons = aReasons | wr::RenderReasons::RESIZE;
+  }
+
+  // Limit async FlushRendering to !resizing and Win DComp.
+  // XXX relax the limitation
+  if (WrBridge()->GetCompositorUseDComp() && !resizing) {
+    cBridge->SendFlushRenderingAsync(aReasons);
+  } else if (mWidget->SynchronouslyRepaintOnResize() ||
+             StaticPrefs::layers_force_synchronous_resize()) {
+    cBridge->SendFlushRendering(aReasons);
+  } else {
+    cBridge->SendFlushRenderingAsync(aReasons);
+  }
+}
+
+void WebRenderLayerManager::WaitOnTransactionProcessed() {
+  CompositorBridgeChild* bridge = GetCompositorBridgeChild();
+  if (bridge) {
+    bridge->SendWaitOnTransactionProcessed();
+  }
+}
+
+void WebRenderLayerManager::SendInvalidRegion(const nsIntRegion& aRegion) {
+  // XXX Webrender does not support invalid region yet.
+
+#ifdef XP_WIN
+  // When DWM is disabled, each window does not have own back buffer. They would
+  // paint directly to a buffer that was to be displayed by the video card.
+  // WM_PAINT via SendInvalidRegion() requests necessary re-paint.
+  const bool needsInvalidate = !gfx::gfxVars::DwmCompositionEnabled();
+#else
+  const bool needsInvalidate = true;
+#endif
+  if (needsInvalidate && WrBridge()) {
+    WrBridge()->SendInvalidateRenderedFrame();
+  }
+}
+
+void WebRenderLayerManager::ScheduleComposite(wr::RenderReasons aReasons) {
+  WrBridge()->SendScheduleComposite(aReasons);
+}
+
+already_AddRefed<PersistentBufferProvider>
+WebRenderLayerManager::CreatePersistentBufferProvider(
+    const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat) {
+  if (!gfxPlatform::UseRemoteCanvas()) {
+#ifdef XP_WIN
+    // Any kind of hardware acceleration is incompatible with Win32k Lockdown
+    // We don't initialize devices here so that PersistentBufferProviderShared
+    // will fall back to using a piece of shared memory as a backing for the
+    // canvas
+    if (!IsWin32kLockedDown()) {
+      gfxPlatform::GetPlatform()->EnsureDevicesInitialized();
+    }
+#else
+    gfxPlatform::GetPlatform()->EnsureDevicesInitialized();
+#endif
+  }
+
+  RefPtr<PersistentBufferProvider> provider =
+      PersistentBufferProviderShared::Create(aSize, aFormat,
+                                             AsKnowsCompositor());
+  if (provider) {
+    return provider.forget();
+  }
+
+  return WindowRenderer::CreatePersistentBufferProvider(aSize, aFormat);
+}
+
+void WebRenderLayerManager::ClearAsyncAnimations() {
+  mStateManager.ClearAsyncAnimations();
+}
+
+void WebRenderLayerManager::WrReleasedImages(
+    const nsTArray<wr::ExternalImageKeyPair>& aPairs) {
+  mStateManager.WrReleasedImages(aPairs);
+}
+
+void WebRenderLayerManager::GetFrameUniformity(FrameUniformityData* aOutData) {
+  WrBridge()->SendGetFrameUniformity(aOutData);
+}
+
+/*static*/
+void WebRenderLayerManager::LayerUserDataDestroy(void* data) {
+  delete static_cast<LayerUserData*>(data);
+}
+
+UniquePtr<LayerUserData> WebRenderLayerManager::RemoveUserData(void* aKey) {
+  UniquePtr<LayerUserData> d(static_cast<LayerUserData*>(
+      mUserData.Remove(static_cast<gfx::UserDataKey*>(aKey))));
+  return d;
+}
+
+std::unordered_set<ScrollableLayerGuid::ViewID>
+WebRenderLayerManager::ClearPendingScrollInfoUpdate() {
+  std::unordered_set<ScrollableLayerGuid::ViewID> scrollIds(
+      mPendingScrollUpdates.Keys().cbegin(),
+      mPendingScrollUpdates.Keys().cend());
+  mPendingScrollUpdates.Clear();
+  return scrollIds;
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/WebRenderLayerManager.h b/gfx/layers/wr/WebRenderLayerManager.h
new file mode 100644
index 0000000000..e9809ea223
--- /dev/null
+++ b/gfx/layers/wr/WebRenderLayerManager.h
@@ -0,0 +1,282 @@
+/* -*- 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_WEBRENDERLAYERMANAGER_H
+#define GFX_WEBRENDERLAYERMANAGER_H
+
+#include <cstddef>                    // for size_t
+#include <cstdint>                    // for uint32_t, int32_t, INT32_MAX
+#include <string>                     // for string
+#include "Units.h"                    // for LayoutDeviceIntSize
+#include "mozilla/AlreadyAddRefed.h"  // for already_AddRefed
+#include "mozilla/Assertions.h"  // for AssertionConditionType, MOZ_ASSERT, MOZ_ASSERT_HELPER2
+#include "mozilla/Attributes.h"               // for MOZ_NON_OWNING_REF
+#include "mozilla/RefPtr.h"                   // for RefPtr
+#include "mozilla/StaticPrefs_apz.h"          // for apz_test_logging_enabled
+#include "mozilla/TimeStamp.h"                // for TimeStamp
+#include "mozilla/gfx/Point.h"                // for IntSize
+#include "mozilla/gfx/Types.h"                // for SurfaceFormat
+#include "mozilla/layers/APZTestData.h"       // for APZTestData
+#include "mozilla/layers/CompositorTypes.h"   // for TextureFactoryIdentifier
+#include "mozilla/layers/DisplayItemCache.h"  // for DisplayItemCache
+#include "mozilla/layers/FocusTarget.h"       // for FocusTarget
+#include "mozilla/layers/LayersTypes.h"  // for TransactionId, LayersBackend, CompositionPayload (ptr only), LayersBackend::...
+#include "mozilla/layers/RenderRootStateManager.h"  // for RenderRootStateManager
+#include "mozilla/layers/ScrollableLayerGuid.h"  // for ScrollableLayerGuid, ScrollableLayerGuid::ViewID
+#include "mozilla/layers/WebRenderCommandBuilder.h"  // for WebRenderCommandBuilder
+#include "mozilla/layers/WebRenderScrollData.h"      // for WebRenderScrollData
+#include "WindowRenderer.h"
+#include "nsHashKeys.h"   // for nsRefPtrHashKey
+#include "nsRegion.h"     // for nsIntRegion
+#include "nsStringFwd.h"  // for nsCString, nsAString
+#include "nsTArray.h"     // for nsTArray
+#include "nsTHashSet.h"
+
+class gfxContext;
+class nsIWidget;
+
+namespace mozilla {
+
+class nsDisplayList;
+class nsDisplayListBuilder;
+struct ActiveScrolledRoot;
+
+namespace layers {
+
+class CompositorBridgeChild;
+class KnowsCompositor;
+class Layer;
+class PCompositorBridgeChild;
+class WebRenderBridgeChild;
+class WebRenderParentCommand;
+class TransactionIdAllocator;
+class LayerUserData;
+
+class WebRenderLayerManager final : public WindowRenderer {
+  typedef nsTHashSet<RefPtr<WebRenderUserData>> WebRenderUserDataRefTable;
+
+ public:
+  explicit WebRenderLayerManager(nsIWidget* aWidget);
+  bool Initialize(PCompositorBridgeChild* aCBChild, wr::PipelineId aLayersId,
+                  TextureFactoryIdentifier* aTextureFactoryIdentifier,
+                  nsCString& aError);
+
+  void Destroy() override;
+  bool IsDestroyed() { return mDestroyed; }
+
+  void DoDestroy(bool aIsSync);
+
+ protected:
+  virtual ~WebRenderLayerManager();
+
+ public:
+  KnowsCompositor* AsKnowsCompositor() override;
+  WebRenderLayerManager* AsWebRender() override { return this; }
+  CompositorBridgeChild* GetCompositorBridgeChild() override;
+
+  // WebRender can handle images larger than the max texture size via tiling.
+  int32_t GetMaxTextureSize() const override { return INT32_MAX; }
+
+  bool BeginTransactionWithTarget(gfxContext* aTarget, const nsCString& aURL);
+  bool BeginTransaction(const nsCString& aURL) override;
+  bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT) override;
+  void EndTransactionWithoutLayer(nsDisplayList* aDisplayList,
+                                  nsDisplayListBuilder* aDisplayListBuilder,
+                                  WrFiltersHolder&& aFilters,
+                                  WebRenderBackgroundData* aBackground,
+                                  const double aGeckoDLBuildTime);
+
+  LayersBackend GetBackendType() override { return LayersBackend::LAYERS_WR; }
+  void GetBackendName(nsAString& name) override;
+
+  bool NeedsWidgetInvalidation() override { return false; }
+
+  void SetLayersObserverEpoch(LayersObserverEpoch aEpoch);
+
+  void DidComposite(TransactionId aTransactionId,
+                    const mozilla::TimeStamp& aCompositeStart,
+                    const mozilla::TimeStamp& aCompositeEnd);
+
+  void ClearCachedResources();
+  void ClearAnimationResources();
+  void UpdateTextureFactoryIdentifier(
+      const TextureFactoryIdentifier& aNewIdentifier);
+  TextureFactoryIdentifier GetTextureFactoryIdentifier();
+
+  void SetTransactionIdAllocator(TransactionIdAllocator* aAllocator);
+  TransactionId GetLastTransactionId();
+
+  void FlushRendering(wr::RenderReasons aReasons) override;
+  void WaitOnTransactionProcessed() override;
+
+  void SendInvalidRegion(const nsIntRegion& aRegion);
+
+  void ScheduleComposite(wr::RenderReasons aReasons);
+
+  void SetNeedsComposite(bool aNeedsComposite) {
+    mNeedsComposite = aNeedsComposite;
+  }
+  bool NeedsComposite() const { return mNeedsComposite; }
+  void SetIsFirstPaint() { mIsFirstPaint = true; }
+  bool GetIsFirstPaint() const { return mIsFirstPaint; }
+  void SetFocusTarget(const FocusTarget& aFocusTarget);
+
+  already_AddRefed<PersistentBufferProvider> CreatePersistentBufferProvider(
+      const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat) override;
+
+  bool AsyncPanZoomEnabled() const;
+
+  // adds an imagekey to a list of keys that will be discarded on the next
+  // transaction or destruction
+  void DiscardImages();
+  void DiscardLocalImages();
+
+  void ClearAsyncAnimations();
+  void WrReleasedImages(const nsTArray<wr::ExternalImageKeyPair>& aPairs);
+
+  WebRenderBridgeChild* WrBridge() const { return mWrChild; }
+
+  // See equivalent function in ClientLayerManager
+  void LogTestDataForCurrentPaint(ScrollableLayerGuid::ViewID aScrollId,
+                                  const std::string& aKey,
+                                  const std::string& aValue) {
+    MOZ_ASSERT(StaticPrefs::apz_test_logging_enabled(), "don't call me");
+    mApzTestData.LogTestDataForPaint(mPaintSequenceNumber, aScrollId, aKey,
+                                     aValue);
+  }
+  void LogAdditionalTestData(const std::string& aKey,
+                             const std::string& aValue) {
+    MOZ_ASSERT(StaticPrefs::apz_test_logging_enabled(), "don't call me");
+    mApzTestData.RecordAdditionalData(aKey, aValue);
+  }
+
+  // See equivalent function in ClientLayerManager
+  const APZTestData& GetAPZTestData() const { return mApzTestData; }
+
+  WebRenderCommandBuilder& CommandBuilder() { return mWebRenderCommandBuilder; }
+  WebRenderUserDataRefTable* GetWebRenderUserDataTable() {
+    return mWebRenderCommandBuilder.GetWebRenderUserDataTable();
+  }
+  WebRenderScrollData& GetScrollData() { return mScrollData; }
+
+  void WrUpdated();
+  nsIWidget* GetWidget() { return mWidget; }
+
+  uint32_t StartFrameTimeRecording(int32_t aBufferSize) override;
+  void StopFrameTimeRecording(uint32_t aStartIndex,
+                              nsTArray<float>& aFrameIntervals) override;
+
+  RenderRootStateManager* GetRenderRootStateManager() { return &mStateManager; }
+
+  void TakeCompositionPayloads(nsTArray<CompositionPayload>& aPayloads);
+
+  void GetFrameUniformity(FrameUniformityData* aOutData) override;
+
+  void RegisterPayloads(const nsTArray<CompositionPayload>& aPayload) {
+    mPayload.AppendElements(aPayload);
+    MOZ_ASSERT(mPayload.Length() < 10000);
+  }
+
+  static void LayerUserDataDestroy(void* data);
+  /**
+   * This setter can be used anytime. The user data for all keys is
+   * initially null. Ownership pases to the layer manager.
+   */
+  void SetUserData(void* aKey, LayerUserData* aData) {
+    mUserData.Add(static_cast<gfx::UserDataKey*>(aKey), aData,
+                  LayerUserDataDestroy);
+  }
+  /**
+   * This can be used anytime. Ownership passes to the caller!
+   */
+  UniquePtr<LayerUserData> RemoveUserData(void* aKey);
+
+  /**
+   * This getter can be used anytime.
+   */
+  bool HasUserData(void* aKey) {
+    return mUserData.Has(static_cast<gfx::UserDataKey*>(aKey));
+  }
+  /**
+   * This getter can be used anytime. Ownership is retained by the layer
+   * manager.
+   */
+  LayerUserData* GetUserData(void* aKey) const {
+    return static_cast<LayerUserData*>(
+        mUserData.Get(static_cast<gfx::UserDataKey*>(aKey)));
+  }
+
+  std::unordered_set<ScrollableLayerGuid::ViewID>
+  ClearPendingScrollInfoUpdate();
+
+#ifdef DEBUG
+  gfxContext* GetTarget() const { return mTarget; }
+#endif
+
+ private:
+  /**
+   * Take a snapshot of the parent context, and copy
+   * it into mTarget.
+   */
+  void MakeSnapshotIfRequired(LayoutDeviceIntSize aSize);
+
+ private:
+  nsIWidget* MOZ_NON_OWNING_REF mWidget;
+
+  RefPtr<WebRenderBridgeChild> mWrChild;
+
+  RefPtr<TransactionIdAllocator> mTransactionIdAllocator;
+  TransactionId mLatestTransactionId;
+
+  gfx::UserData mUserData;
+
+  // This holds the scroll data that we need to send to the compositor for
+  // APZ to do it's job
+  WebRenderScrollData mScrollData;
+
+  bool mNeedsComposite;
+  bool mIsFirstPaint;
+  bool mDestroyed;
+  FocusTarget mFocusTarget;
+
+  // The payload associated with currently pending painting work, for
+  // client layer managers that typically means payload that is part of the
+  // 'upcoming transaction', for HostLayerManagers this typically means
+  // what has been included in received transactions to be presented on the
+  // next composite.
+  // IMPORTANT: Clients should take care to clear this or risk it slowly
+  // growing out of control.
+  nsTArray<CompositionPayload> mPayload;
+
+  // When we're doing a transaction in order to draw to a non-default
+  // target, the layers transaction is only performed in order to send
+  // a PLayers:Update.  We save the original non-default target to
+  // mTarget, and then perform the transaction. After the transaction ends,
+  // we send a message to our remote side to capture the actual pixels
+  // being drawn to the default target, and then copy those pixels
+  // back to mTarget.
+  gfxContext* mTarget;
+
+  // See equivalent field in ClientLayerManager
+  uint32_t mPaintSequenceNumber;
+  // See equivalent field in ClientLayerManager
+  APZTestData mApzTestData;
+
+  TimeStamp mTransactionStart;
+  nsCString mURL;
+  WebRenderCommandBuilder mWebRenderCommandBuilder;
+
+  RenderRootStateManager mStateManager;
+  DisplayItemCache mDisplayItemCache;
+  UniquePtr<wr::DisplayListBuilder> mDLBuilder;
+
+  ScrollUpdatesMap mPendingScrollUpdates;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif /* GFX_WEBRENDERLAYERMANAGER_H */
diff --git a/gfx/layers/wr/WebRenderMessageUtils.h b/gfx/layers/wr/WebRenderMessageUtils.h
new file mode 100644
index 0000000000..40edf6676d
--- /dev/null
+++ b/gfx/layers/wr/WebRenderMessageUtils.h
@@ -0,0 +1,217 @@
+/* -*- 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_WEBRENDERMESSAGEUTILS_H
+#define GFX_WEBRENDERMESSAGEUTILS_H
+
+#include "chrome/common/ipc_message_utils.h"
+
+#include "ipc/EnumSerializer.h"
+#include "ipc/IPCMessageUtils.h"
+#include "mozilla/webrender/webrender_ffi.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "mozilla/dom/MediaIPCUtils.h"
+
+namespace IPC {
+
+template <>
+struct ParamTraits<mozilla::wr::ByteBuffer> {
+  typedef mozilla::wr::ByteBuffer paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mLength);
+    aWriter->WriteBytes(aParam.mData, aParam.mLength);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    size_t length;
+    return ReadParam(aReader, &length) && aResult->Allocate(length) &&
+           aReader->ReadBytesInto(aResult->mData, length);
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::wr::ImageDescriptor> {
+  typedef mozilla::wr::ImageDescriptor paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.format);
+    WriteParam(aWriter, aParam.width);
+    WriteParam(aWriter, aParam.height);
+    WriteParam(aWriter, aParam.stride);
+    WriteParam(aWriter, aParam.opacity);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    return ReadParam(aReader, &aResult->format) &&
+           ReadParam(aReader, &aResult->width) &&
+           ReadParam(aReader, &aResult->height) &&
+           ReadParam(aReader, &aResult->stride) &&
+           ReadParam(aReader, &aResult->opacity);
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::wr::GeckoDisplayListType::Tag>
+    : public ContiguousEnumSerializer<
+          mozilla::wr::GeckoDisplayListType::Tag,
+          mozilla::wr::GeckoDisplayListType::Tag::None,
+          mozilla::wr::GeckoDisplayListType::Tag::Sentinel> {};
+
+template <>
+struct ParamTraits<mozilla::wr::GeckoDisplayListType> {
+  typedef mozilla::wr::GeckoDisplayListType paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.tag);
+    switch (aParam.tag) {
+      case mozilla::wr::GeckoDisplayListType::Tag::None:
+        break;
+      case mozilla::wr::GeckoDisplayListType::Tag::Partial:
+        WriteParam(aWriter, aParam.partial._0);
+        break;
+      case mozilla::wr::GeckoDisplayListType::Tag::Full:
+        WriteParam(aWriter, aParam.full._0);
+        break;
+      default:
+        MOZ_RELEASE_ASSERT(false, "bad enum variant");
+    }
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    if (!ReadParam(aReader, &aResult->tag)) {
+      return false;
+    }
+    switch (aResult->tag) {
+      case mozilla::wr::GeckoDisplayListType::Tag::None:
+        return true;
+      case mozilla::wr::GeckoDisplayListType::Tag::Partial:
+        return ReadParam(aReader, &aResult->partial._0);
+      case mozilla::wr::GeckoDisplayListType::Tag::Full:
+        return ReadParam(aReader, &aResult->full._0);
+      default:
+        MOZ_RELEASE_ASSERT(false, "bad enum variant");
+    }
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::wr::BuiltDisplayListDescriptor> {
+  typedef mozilla::wr::BuiltDisplayListDescriptor paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.gecko_display_list_type);
+    WriteParam(aWriter, aParam.builder_start_time);
+    WriteParam(aWriter, aParam.builder_finish_time);
+    WriteParam(aWriter, aParam.send_start_time);
+    WriteParam(aWriter, aParam.total_clip_nodes);
+    WriteParam(aWriter, aParam.total_spatial_nodes);
+    WriteParam(aWriter, aParam.cache_size);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    return ReadParam(aReader, &aResult->gecko_display_list_type) &&
+           ReadParam(aReader, &aResult->builder_start_time) &&
+           ReadParam(aReader, &aResult->builder_finish_time) &&
+           ReadParam(aReader, &aResult->send_start_time) &&
+           ReadParam(aReader, &aResult->total_clip_nodes) &&
+           ReadParam(aReader, &aResult->total_spatial_nodes) &&
+           ReadParam(aReader, &aResult->cache_size);
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::wr::IdNamespace>
+    : public PlainOldDataSerializer<mozilla::wr::IdNamespace> {};
+
+template <>
+struct ParamTraits<mozilla::wr::ImageKey>
+    : public PlainOldDataSerializer<mozilla::wr::ImageKey> {};
+
+template <>
+struct ParamTraits<mozilla::wr::BlobImageKey>
+    : public PlainOldDataSerializer<mozilla::wr::BlobImageKey> {};
+
+template <>
+struct ParamTraits<mozilla::wr::FontKey>
+    : public PlainOldDataSerializer<mozilla::wr::FontKey> {};
+
+template <>
+struct ParamTraits<mozilla::wr::FontInstanceKey>
+    : public PlainOldDataSerializer<mozilla::wr::FontInstanceKey> {};
+
+template <>
+struct ParamTraits<mozilla::wr::FontInstanceOptions>
+    : public PlainOldDataSerializer<mozilla::wr::FontInstanceOptions> {};
+
+template <>
+struct ParamTraits<mozilla::wr::FontInstancePlatformOptions>
+    : public PlainOldDataSerializer<mozilla::wr::FontInstancePlatformOptions> {
+};
+
+template <>
+struct ParamTraits<mozilla::wr::ExternalImageId>
+    : public PlainOldDataSerializer<mozilla::wr::ExternalImageId> {};
+
+template <>
+struct ParamTraits<mozilla::wr::PipelineId>
+    : public PlainOldDataSerializer<mozilla::wr::PipelineId> {};
+
+template <>
+struct ParamTraits<mozilla::wr::ImageFormat>
+    : public ContiguousEnumSerializer<mozilla::wr::ImageFormat,
+                                      mozilla::wr::ImageFormat::R8,
+                                      mozilla::wr::ImageFormat::Sentinel> {};
+
+template <>
+struct ParamTraits<mozilla::wr::LayoutSize>
+    : public PlainOldDataSerializer<mozilla::wr::LayoutSize> {};
+
+template <>
+struct ParamTraits<mozilla::wr::LayoutRect>
+    : public PlainOldDataSerializer<mozilla::wr::LayoutRect> {};
+
+template <>
+struct ParamTraits<mozilla::wr::LayoutPoint>
+    : public PlainOldDataSerializer<mozilla::wr::LayoutPoint> {};
+
+template <>
+struct ParamTraits<mozilla::wr::ImageRendering>
+    : public ContiguousEnumSerializer<mozilla::wr::ImageRendering,
+                                      mozilla::wr::ImageRendering::Auto,
+                                      mozilla::wr::ImageRendering::Sentinel> {};
+
+template <>
+struct ParamTraits<mozilla::wr::MixBlendMode>
+    : public ContiguousEnumSerializer<mozilla::wr::MixBlendMode,
+                                      mozilla::wr::MixBlendMode::Normal,
+                                      mozilla::wr::MixBlendMode::Sentinel> {};
+
+template <>
+struct ParamTraits<mozilla::wr::WebRenderError>
+    : public ContiguousEnumSerializer<mozilla::wr::WebRenderError,
+                                      mozilla::wr::WebRenderError::INITIALIZE,
+                                      mozilla::wr::WebRenderError::Sentinel> {};
+
+template <>
+struct ParamTraits<mozilla::wr::MemoryReport>
+    : public PlainOldDataSerializer<mozilla::wr::MemoryReport> {};
+
+template <>
+struct ParamTraits<mozilla::wr::OpacityType>
+    : public PlainOldDataSerializer<mozilla::wr::OpacityType> {};
+
+template <>
+struct ParamTraits<mozilla::wr::ExternalImageKeyPair>
+    : public PlainOldDataSerializer<mozilla::wr::ExternalImageKeyPair> {};
+
+template <>
+struct ParamTraits<mozilla::wr::RenderReasons>
+    : public PlainOldDataSerializer<mozilla::wr::RenderReasons> {};
+
+}  // namespace IPC
+
+#endif  // GFX_WEBRENDERMESSAGEUTILS_H
diff --git a/gfx/layers/wr/WebRenderScrollData.cpp b/gfx/layers/wr/WebRenderScrollData.cpp
new file mode 100644
index 0000000000..d380d227d2
--- /dev/null
+++ b/gfx/layers/wr/WebRenderScrollData.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 "mozilla/layers/WebRenderScrollData.h"
+
+#include <ostream>
+
+#include "Units.h"
+#include "mozilla/layers/LayersMessageUtils.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/ToString.h"
+#include "mozilla/Unused.h"
+#include "nsDisplayList.h"
+#include "nsTArray.h"
+#include "UnitTransforms.h"
+
+namespace mozilla {
+namespace layers {
+
+WebRenderLayerScrollData::WebRenderLayerScrollData()
+    : mDescendantCount(-1),
+      mAncestorTransformId(ScrollableLayerGuid::NULL_SCROLL_ID),
+      mTransformIsPerspective(false),
+      mResolution(1.f),
+      mEventRegionsOverride(EventRegionsOverride::NoOverride),
+      mFixedPositionSides(mozilla::SideBits::eNone),
+      mFixedPosScrollContainerId(ScrollableLayerGuid::NULL_SCROLL_ID),
+      mStickyPosScrollContainerId(ScrollableLayerGuid::NULL_SCROLL_ID) {}
+
+WebRenderLayerScrollData::~WebRenderLayerScrollData() = default;
+
+void WebRenderLayerScrollData::InitializeRoot(int32_t aDescendantCount) {
+  mDescendantCount = aDescendantCount;
+}
+
+void WebRenderLayerScrollData::InitializeForTest(int32_t aDescendantCount) {
+  mDescendantCount = aDescendantCount;
+}
+
+void WebRenderLayerScrollData::Initialize(
+    WebRenderScrollData& aOwner, nsDisplayItem* aItem, int32_t aDescendantCount,
+    const ActiveScrolledRoot* aStopAtAsr,
+    const Maybe<gfx::Matrix4x4>& aAncestorTransform,
+    const ViewID& aAncestorTransformId) {
+  MOZ_ASSERT(aDescendantCount >= 0);  // Ensure value is valid
+  MOZ_ASSERT(mDescendantCount ==
+             -1);  // Don't allow re-setting an already set value
+  mDescendantCount = aDescendantCount;
+
+#if defined(DEBUG) || defined(MOZ_DUMP_PAINTING)
+  mInitializedFrom = aItem;
+#endif
+
+  MOZ_ASSERT(aItem);
+  aItem->UpdateScrollData(&aOwner, this);
+
+  const ActiveScrolledRoot* asr = aItem->GetActiveScrolledRoot();
+  if (ActiveScrolledRoot::IsAncestor(asr, aStopAtAsr)) {
+    // If the item's ASR is an ancestor of the stop-at ASR, then we don't need
+    // any more metrics information because we'll end up duplicating what the
+    // ancestor WebRenderLayerScrollData already has.
+    asr = nullptr;
+  }
+
+  while (asr && asr != aStopAtAsr) {
+    MOZ_ASSERT(aOwner.GetManager());
+    ScrollableLayerGuid::ViewID scrollId = asr->GetViewId();
+    if (Maybe<size_t> index = aOwner.HasMetadataFor(scrollId)) {
+      mScrollIds.AppendElement(index.ref());
+    } else {
+      Maybe<ScrollMetadata> metadata =
+          asr->mScrollableFrame->ComputeScrollMetadata(
+              aOwner.GetManager(), aItem->Frame(), aItem->ToReferenceFrame());
+      aOwner.GetBuilder()->AddScrollFrameToNotify(asr->mScrollableFrame);
+      if (metadata) {
+        MOZ_ASSERT(metadata->GetMetrics().GetScrollId() == scrollId);
+        mScrollIds.AppendElement(aOwner.AddMetadata(metadata.ref()));
+      } else {
+        MOZ_ASSERT_UNREACHABLE("Expected scroll metadata to be available!");
+      }
+    }
+    asr = asr->mParent;
+  }
+
+#ifdef DEBUG
+  // Sanity check: if we have an ancestor transform, its scroll id should
+  // match one of the scroll metadatas on this node (WebRenderScrollDataWrapper
+  // will then use the ancestor transform at the level of that scroll metadata).
+  // One exception to this is if we have no scroll metadatas, which can happen
+  // if the scroll id of the transform is on an enclosing node.
+  if (aAncestorTransformId != ScrollableLayerGuid::NULL_SCROLL_ID &&
+      !mScrollIds.IsEmpty()) {
+    bool seenAncestorTransformId = false;
+    for (size_t scrollIdIndex : mScrollIds) {
+      if (aAncestorTransformId ==
+          aOwner.GetScrollMetadata(scrollIdIndex).GetMetrics().GetScrollId()) {
+        seenAncestorTransformId = true;
+      }
+    }
+    MOZ_ASSERT(
+        seenAncestorTransformId,
+        "The ancestor transform's view ID should match one of the metrics "
+        "on this node");
+  }
+#endif
+
+  // See the comments on StackingContextHelper::mDeferredTransformItem for an
+  // overview of what deferred transforms are.
+  // aAncestorTransform, if present, is the transform from a deferred transform
+  // item that is an ancestor of |aItem|. We store this transform value
+  // separately from mTransform because in the case where we have multiple
+  // scroll metadata on this layer item, the mAncestorTransform is associated
+  // with the "topmost" scroll metadata, and the mTransform is associated with
+  // the "bottommost" scroll metadata. The code in
+  // WebRenderScrollDataWrapper::GetTransform() is responsible for combining
+  // these transforms and exposing them appropriately. Also, we don't save the
+  // ancestor transform for thumb layers, because those are a special case in
+  // APZ; we need to keep the ancestor transform for the scrollable content that
+  // the thumb scrolls, but not for the thumb itself, as it will result in
+  // incorrect visual positioning of the thumb.
+  if (aAncestorTransform &&
+      mScrollbarData.mScrollbarLayerType != ScrollbarLayerType::Thumb) {
+    mAncestorTransform = *aAncestorTransform;
+    mAncestorTransformId = aAncestorTransformId;
+  }
+}
+
+int32_t WebRenderLayerScrollData::GetDescendantCount() const {
+  MOZ_ASSERT(mDescendantCount >= 0);  // check that it was set
+  return mDescendantCount;
+}
+
+size_t WebRenderLayerScrollData::GetScrollMetadataCount() const {
+  return mScrollIds.Length();
+}
+
+void WebRenderLayerScrollData::AppendScrollMetadata(
+    WebRenderScrollData& aOwner, const ScrollMetadata& aData) {
+  mScrollIds.AppendElement(aOwner.AddMetadata(aData));
+}
+
+const ScrollMetadata& WebRenderLayerScrollData::GetScrollMetadata(
+    const WebRenderScrollData& aOwner, size_t aIndex) const {
+  MOZ_ASSERT(aIndex < mScrollIds.Length());
+  return aOwner.GetScrollMetadata(mScrollIds[aIndex]);
+}
+
+ScrollMetadata& WebRenderLayerScrollData::GetScrollMetadataMut(
+    WebRenderScrollData& aOwner, size_t aIndex) {
+  MOZ_ASSERT(aIndex < mScrollIds.Length());
+  return aOwner.GetScrollMetadataMut(mScrollIds[aIndex]);
+}
+
+CSSTransformMatrix WebRenderLayerScrollData::GetTransformTyped() const {
+  return ViewAs<CSSTransformMatrix>(GetTransform());
+}
+
+void WebRenderLayerScrollData::Dump(std::ostream& aOut,
+                                    const WebRenderScrollData& aOwner) const {
+  aOut << "WebRenderLayerScrollData(" << this
+       << "), descendantCount=" << mDescendantCount;
+#if defined(DEBUG) || defined(MOZ_DUMP_PAINTING)
+  if (mInitializedFrom) {
+    aOut << ", item=" << (void*)mInitializedFrom;
+  }
+#endif
+  if (mAsyncZoomContainerId) {
+    aOut << ", asyncZoomContainer";
+  }
+  for (size_t i = 0; i < mScrollIds.Length(); i++) {
+    aOut << ", metadata" << i << "=" << aOwner.GetScrollMetadata(mScrollIds[i]);
+  }
+  if (!mAncestorTransform.IsIdentity()) {
+    aOut << ", ancestorTransform=" << mAncestorTransform
+         << " (asr=" << mAncestorTransformId << ")";
+  }
+  if (!mTransform.IsIdentity()) {
+    aOut << ", transform=" << mTransform;
+    if (mTransformIsPerspective) {
+      aOut << ", transformIsPerspective";
+    }
+  }
+  if (mResolution != 1.f) {
+    aOut << ", resolution=" << mResolution;
+  }
+  aOut << ", visible=" << mVisibleRegion;
+  if (mReferentId) {
+    aOut << ", refLayersId=" << *mReferentId;
+  }
+  if (mEventRegionsOverride) {
+    aOut << std::hex << ", eventRegionsOverride=0x"
+         << (int)mEventRegionsOverride << std::dec;
+  }
+  if (mScrollbarData.mScrollbarLayerType != ScrollbarLayerType::None) {
+    aOut << ", scrollbarType=" << (int)mScrollbarData.mScrollbarLayerType
+         << std::hex << ", scrollbarAnimationId=0x"
+         << mScrollbarAnimationId.valueOr(0) << std::dec;
+  }
+  if (mFixedPosScrollContainerId != ScrollableLayerGuid::NULL_SCROLL_ID) {
+    aOut << ", fixedContainer=" << mFixedPosScrollContainerId << std::hex
+         << ", fixedAnimation=0x" << mFixedPositionAnimationId.valueOr(0)
+         << ", sideBits=0x" << (int)mFixedPositionSides << std::dec;
+  }
+  if (mStickyPosScrollContainerId != ScrollableLayerGuid::NULL_SCROLL_ID) {
+    aOut << ", stickyContainer=" << mStickyPosScrollContainerId << std::hex
+         << ", stickyAnimation=" << mStickyPositionAnimationId.valueOr(0)
+         << std::dec << ", stickyInner=" << mStickyScrollRangeInner
+         << ", stickyOuter=" << mStickyScrollRangeOuter;
+  }
+}
+
+WebRenderScrollData::WebRenderScrollData()
+    : mManager(nullptr),
+      mBuilder(nullptr),
+      mIsFirstPaint(false),
+      mPaintSequenceNumber(0) {}
+
+WebRenderScrollData::WebRenderScrollData(WebRenderLayerManager* aManager,
+                                         nsDisplayListBuilder* aBuilder)
+    : mManager(aManager),
+      mBuilder(aBuilder),
+      mIsFirstPaint(false),
+      mPaintSequenceNumber(0) {}
+
+bool WebRenderScrollData::Validate() const {
+  // Attempt to traverse the tree structure encoded by the descendant counts,
+  // validating as we go that everything is within bounds and properly nested.
+  // In addition, check that the traversal visits every node exactly once.
+  std::vector<size_t> visitCounts(mLayerScrollData.Length(), 0);
+  if (mLayerScrollData.Length() > 0) {
+    if (!mLayerScrollData[0].ValidateSubtree(*this, visitCounts, 0)) {
+      return false;
+    }
+  }
+  for (size_t visitCount : visitCounts) {
+    if (visitCount != 1) {
+      return false;
+    }
+  }
+  return true;
+}
+
+WebRenderLayerManager* WebRenderScrollData::GetManager() const {
+  return mManager;
+}
+
+nsDisplayListBuilder* WebRenderScrollData::GetBuilder() const {
+  return mBuilder;
+}
+
+size_t WebRenderScrollData::AddMetadata(const ScrollMetadata& aMetadata) {
+  ScrollableLayerGuid::ViewID scrollId = aMetadata.GetMetrics().GetScrollId();
+  auto p = mScrollIdMap.lookupForAdd(scrollId);
+  if (!p) {
+    // It's a scrollId we hadn't seen before
+    bool ok = mScrollIdMap.add(p, scrollId, mScrollMetadatas.Length());
+    MOZ_RELEASE_ASSERT(ok);
+    mScrollMetadatas.AppendElement(aMetadata);
+  }  // else we didn't insert, because it already existed
+  return p->value();
+}
+
+size_t WebRenderScrollData::AddLayerData(WebRenderLayerScrollData&& aData) {
+  mLayerScrollData.AppendElement(std::move(aData));
+  return mLayerScrollData.Length() - 1;
+}
+
+size_t WebRenderScrollData::GetLayerCount() const {
+  return mLayerScrollData.Length();
+}
+
+bool WebRenderLayerScrollData::ValidateSubtree(
+    const WebRenderScrollData& aParent, std::vector<size_t>& aVisitCounts,
+    size_t aCurrentIndex) const {
+  ++aVisitCounts[aCurrentIndex];
+
+  // All scroll ids must be in bounds.
+  for (size_t scrollMetadataIndex : mScrollIds) {
+    if (scrollMetadataIndex >= aParent.mScrollMetadatas.Length()) {
+      return false;
+    }
+  }
+
+  // Descendant count must be nonnegative.
+  if (mDescendantCount < 0) {
+    return false;
+  }
+  size_t descendantCount = static_cast<size_t>(mDescendantCount);
+
+  // Bounds check: for every layer, its index + its mDescendantCount
+  // must be within bounds.
+  if (aCurrentIndex + descendantCount >= aParent.mLayerScrollData.Length()) {
+    return false;
+  }
+
+  // Recurse over our children, accumulating a count of our children
+  // and their descendants as we go.
+  size_t childCount = 0;
+  size_t childDescendantCounts = 0;
+  size_t currentChildIndex = aCurrentIndex + 1;
+  while (currentChildIndex < (aCurrentIndex + descendantCount + 1)) {
+    ++childCount;
+
+    const WebRenderLayerScrollData* currentChild =
+        &aParent.mLayerScrollData[currentChildIndex];
+    childDescendantCounts += currentChild->mDescendantCount;
+    currentChild->ValidateSubtree(aParent, aVisitCounts, currentChildIndex);
+
+    // The current child's descendants come first in the array, and the next
+    // element after that is our next child.
+    currentChildIndex += (currentChild->mDescendantCount + 1);
+  }
+
+  // For a given layer, its descendant count must equal the number of
+  // children + the descendant counts of its children added together.
+  return descendantCount == (childCount + childDescendantCounts);
+}
+
+const WebRenderLayerScrollData* WebRenderScrollData::GetLayerData(
+    size_t aIndex) const {
+  if (aIndex >= mLayerScrollData.Length()) {
+    return nullptr;
+  }
+  return &(mLayerScrollData.ElementAt(aIndex));
+}
+
+WebRenderLayerScrollData* WebRenderScrollData::GetLayerData(size_t aIndex) {
+  if (aIndex >= mLayerScrollData.Length()) {
+    return nullptr;
+  }
+  return &(mLayerScrollData.ElementAt(aIndex));
+}
+
+const ScrollMetadata& WebRenderScrollData::GetScrollMetadata(
+    size_t aIndex) const {
+  MOZ_ASSERT(aIndex < mScrollMetadatas.Length());
+  return mScrollMetadatas[aIndex];
+}
+
+ScrollMetadata& WebRenderScrollData::GetScrollMetadataMut(size_t aIndex) {
+  MOZ_ASSERT(aIndex < mScrollMetadatas.Length());
+  return mScrollMetadatas[aIndex];
+}
+
+Maybe<size_t> WebRenderScrollData::HasMetadataFor(
+    const ScrollableLayerGuid::ViewID& aScrollId) const {
+  auto ptr = mScrollIdMap.lookup(aScrollId);
+  return (ptr ? Some(ptr->value()) : Nothing());
+}
+
+void WebRenderScrollData::SetIsFirstPaint() { mIsFirstPaint = true; }
+
+bool WebRenderScrollData::IsFirstPaint() const { return mIsFirstPaint; }
+
+void WebRenderScrollData::SetPaintSequenceNumber(
+    uint32_t aPaintSequenceNumber) {
+  mPaintSequenceNumber = aPaintSequenceNumber;
+}
+
+uint32_t WebRenderScrollData::GetPaintSequenceNumber() const {
+  return mPaintSequenceNumber;
+}
+
+void WebRenderScrollData::ApplyUpdates(ScrollUpdatesMap&& aUpdates,
+                                       uint32_t aPaintSequenceNumber) {
+  for (auto it = aUpdates.Iter(); !it.Done(); it.Next()) {
+    if (Maybe<size_t> index = HasMetadataFor(it.Key())) {
+      mScrollMetadatas[*index].UpdatePendingScrollInfo(std::move(it.Data()));
+    }
+  }
+  mPaintSequenceNumber = aPaintSequenceNumber;
+}
+
+void WebRenderScrollData::DumpSubtree(std::ostream& aOut, size_t aIndex,
+                                      const std::string& aIndent) const {
+  aOut << aIndent;
+  mLayerScrollData.ElementAt(aIndex).Dump(aOut, *this);
+  aOut << std::endl;
+
+  int32_t descendants = mLayerScrollData.ElementAt(aIndex).GetDescendantCount();
+  if (descendants == 0) {
+    return;
+  }
+
+  // Build a stack of indices at which this aIndex's children live. We do
+  // this because we want to dump them first-to-last but they are stored
+  // last-to-first.
+  std::stack<size_t> childIndices;
+  size_t childIndex = aIndex + 1;
+  while (descendants > 0) {
+    childIndices.push(childIndex);
+    // "1" for the child itelf, plus whatever descendants it has
+    int32_t subtreeSize =
+        1 + mLayerScrollData.ElementAt(childIndex).GetDescendantCount();
+    childIndex += subtreeSize;
+    descendants -= subtreeSize;
+    MOZ_ASSERT(descendants >= 0);
+  }
+
+  std::string indent = aIndent + "    ";
+  while (!childIndices.empty()) {
+    size_t child = childIndices.top();
+    childIndices.pop();
+    DumpSubtree(aOut, child, indent);
+  }
+}
+
+std::ostream& operator<<(std::ostream& aOut, const WebRenderScrollData& aData) {
+  aOut << "--- WebRenderScrollData (firstPaint=" << aData.mIsFirstPaint
+       << ") ---" << std::endl;
+
+  if (aData.mLayerScrollData.Length() > 0) {
+    aData.DumpSubtree(aOut, 0, std::string());
+  }
+  return aOut;
+}
+
+bool WebRenderScrollData::RepopulateMap() {
+  MOZ_ASSERT(mScrollIdMap.empty());
+  for (size_t i = 0; i < mScrollMetadatas.Length(); i++) {
+    ScrollableLayerGuid::ViewID scrollId =
+        mScrollMetadatas[i].GetMetrics().GetScrollId();
+    bool ok = mScrollIdMap.putNew(scrollId, i);
+    MOZ_RELEASE_ASSERT(ok);
+  }
+  return true;
+}
+
+}  // namespace layers
+}  // namespace mozilla
+
+namespace IPC {
+
+void ParamTraits<mozilla::layers::WebRenderLayerScrollData>::Write(
+    MessageWriter* aWriter, const paramType& aParam) {
+  WriteParam(aWriter, aParam.mDescendantCount);
+  WriteParam(aWriter, aParam.mScrollIds);
+  WriteParam(aWriter, aParam.mAncestorTransform);
+  WriteParam(aWriter, aParam.mAncestorTransformId);
+  WriteParam(aWriter, aParam.mTransform);
+  WriteParam(aWriter, aParam.mTransformIsPerspective);
+  WriteParam(aWriter, aParam.mResolution);
+  WriteParam(aWriter, aParam.mVisibleRegion);
+  WriteParam(aWriter, aParam.mRemoteDocumentSize);
+  WriteParam(aWriter, aParam.mReferentId);
+  WriteParam(aWriter, aParam.mEventRegionsOverride);
+  WriteParam(aWriter, aParam.mScrollbarData);
+  WriteParam(aWriter, aParam.mScrollbarAnimationId);
+  WriteParam(aWriter, aParam.mFixedPositionAnimationId);
+  WriteParam(aWriter, aParam.mFixedPositionSides);
+  WriteParam(aWriter, aParam.mFixedPosScrollContainerId);
+  WriteParam(aWriter, aParam.mStickyPosScrollContainerId);
+  WriteParam(aWriter, aParam.mStickyScrollRangeOuter);
+  WriteParam(aWriter, aParam.mStickyScrollRangeInner);
+  WriteParam(aWriter, aParam.mStickyPositionAnimationId);
+  WriteParam(aWriter, aParam.mZoomAnimationId);
+  WriteParam(aWriter, aParam.mAsyncZoomContainerId);
+  // Do not write |mInitializedFrom|, the pointer wouldn't be valid
+  // on the compositor side.
+}
+
+bool ParamTraits<mozilla::layers::WebRenderLayerScrollData>::Read(
+    MessageReader* aReader, paramType* aResult) {
+  return ReadParam(aReader, &aResult->mDescendantCount) &&
+         ReadParam(aReader, &aResult->mScrollIds) &&
+         ReadParam(aReader, &aResult->mAncestorTransform) &&
+         ReadParam(aReader, &aResult->mAncestorTransformId) &&
+         ReadParam(aReader, &aResult->mTransform) &&
+         ReadParam(aReader, &aResult->mTransformIsPerspective) &&
+         ReadParam(aReader, &aResult->mResolution) &&
+         ReadParam(aReader, &aResult->mVisibleRegion) &&
+         ReadParam(aReader, &aResult->mRemoteDocumentSize) &&
+         ReadParam(aReader, &aResult->mReferentId) &&
+         ReadParam(aReader, &aResult->mEventRegionsOverride) &&
+         ReadParam(aReader, &aResult->mScrollbarData) &&
+         ReadParam(aReader, &aResult->mScrollbarAnimationId) &&
+         ReadParam(aReader, &aResult->mFixedPositionAnimationId) &&
+         ReadParam(aReader, &aResult->mFixedPositionSides) &&
+         ReadParam(aReader, &aResult->mFixedPosScrollContainerId) &&
+         ReadParam(aReader, &aResult->mStickyPosScrollContainerId) &&
+         ReadParam(aReader, &aResult->mStickyScrollRangeOuter) &&
+         ReadParam(aReader, &aResult->mStickyScrollRangeInner) &&
+         ReadParam(aReader, &aResult->mStickyPositionAnimationId) &&
+         ReadParam(aReader, &aResult->mZoomAnimationId) &&
+         ReadParam(aReader, &aResult->mAsyncZoomContainerId);
+}
+
+void ParamTraits<mozilla::layers::WebRenderScrollData>::Write(
+    MessageWriter* aWriter, const paramType& aParam) {
+  WriteParam(aWriter, aParam.mScrollMetadatas);
+  WriteParam(aWriter, aParam.mLayerScrollData);
+  WriteParam(aWriter, aParam.mIsFirstPaint);
+  WriteParam(aWriter, aParam.mPaintSequenceNumber);
+}
+
+bool ParamTraits<mozilla::layers::WebRenderScrollData>::Read(
+    MessageReader* aReader, paramType* aResult) {
+  return ReadParam(aReader, &aResult->mScrollMetadatas) &&
+         ReadParam(aReader, &aResult->mLayerScrollData) &&
+         ReadParam(aReader, &aResult->mIsFirstPaint) &&
+         ReadParam(aReader, &aResult->mPaintSequenceNumber) &&
+         aResult->RepopulateMap();
+}
+
+}  // namespace IPC
diff --git a/gfx/layers/wr/WebRenderScrollData.h b/gfx/layers/wr/WebRenderScrollData.h
new file mode 100644
index 0000000000..1df766a3bf
--- /dev/null
+++ b/gfx/layers/wr/WebRenderScrollData.h
@@ -0,0 +1,363 @@
+/* -*- 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_WEBRENDERSCROLLDATA_H
+#define GFX_WEBRENDERSCROLLDATA_H
+
+#include <map>
+#include <iosfwd>
+
+#include "chrome/common/ipc_message_utils.h"
+#include "FrameMetrics.h"
+#include "ipc/IPCMessageUtils.h"
+#include "LayersTypes.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/GfxMessageUtils.h"
+#include "mozilla/layers/FocusTarget.h"
+#include "mozilla/layers/ScrollbarData.h"
+#include "mozilla/layers/WebRenderMessageUtils.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "mozilla/HashTable.h"
+#include "mozilla/Maybe.h"
+#include "nsTArrayForwardDeclare.h"
+
+namespace mozilla {
+
+class nsDisplayItem;
+class nsDisplayListBuilder;
+struct ActiveScrolledRoot;
+
+namespace layers {
+
+class APZTestAccess;
+class Layer;
+class WebRenderLayerManager;
+class WebRenderScrollData;
+
+// Data needed by APZ, per layer. One instance of this class is created for
+// each layer in the layer tree and sent over PWebRenderBridge to the APZ code.
+// Each WebRenderLayerScrollData is conceptually associated with an "owning"
+// WebRenderScrollData.
+class WebRenderLayerScrollData final {
+ public:
+  WebRenderLayerScrollData();  // needed for IPC purposes
+  WebRenderLayerScrollData(WebRenderLayerScrollData&& aOther) = default;
+  ~WebRenderLayerScrollData();
+
+  using ViewID = ScrollableLayerGuid::ViewID;
+
+  // Helper function for WebRenderScrollData::Validate().
+  bool ValidateSubtree(const WebRenderScrollData& aParent,
+                       std::vector<size_t>& aVisitCounts,
+                       size_t aCurrentIndex) const;
+
+  void InitializeRoot(int32_t aDescendantCount);
+  void Initialize(WebRenderScrollData& aOwner, nsDisplayItem* aItem,
+                  int32_t aDescendantCount,
+                  const ActiveScrolledRoot* aStopAtAsr,
+                  const Maybe<gfx::Matrix4x4>& aAncestorTransform,
+                  const ViewID& aAncestorTransformId);
+
+  int32_t GetDescendantCount() const;
+  size_t GetScrollMetadataCount() const;
+
+  void AppendScrollMetadata(WebRenderScrollData& aOwner,
+                            const ScrollMetadata& aData);
+  // Return the ScrollMetadata object that used to be on the original Layer
+  // at the given index. Since we deduplicate the ScrollMetadata objects into
+  // the array in the owning WebRenderScrollData object, we need to be passed
+  // in a reference to that owner as well.
+  const ScrollMetadata& GetScrollMetadata(const WebRenderScrollData& aOwner,
+                                          size_t aIndex) const;
+
+  gfx::Matrix4x4 GetAncestorTransform() const { return mAncestorTransform; }
+  ViewID GetAncestorTransformId() const { return mAncestorTransformId; }
+  void SetTransform(const gfx::Matrix4x4& aTransform) {
+    mTransform = aTransform;
+  }
+  gfx::Matrix4x4 GetTransform() const { return mTransform; }
+  CSSTransformMatrix GetTransformTyped() const;
+  void SetTransformIsPerspective(bool aTransformIsPerspective) {
+    mTransformIsPerspective = aTransformIsPerspective;
+  }
+  bool GetTransformIsPerspective() const { return mTransformIsPerspective; }
+  void SetResolution(float aResolution) { mResolution = aResolution; }
+  float GetResolution() const { return mResolution; }
+
+  void SetEventRegionsOverride(const EventRegionsOverride& aOverride) {
+    mEventRegionsOverride = aOverride;
+  }
+  EventRegionsOverride GetEventRegionsOverride() const {
+    return mEventRegionsOverride;
+  }
+
+  void SetVisibleRegion(const LayerIntRegion& aRegion) {
+    mVisibleRegion = aRegion;
+  }
+  const LayerIntRegion& GetVisibleRegion() const { return mVisibleRegion; }
+  void SetRemoteDocumentSize(const LayerIntSize& aRemoteDocumentSize) {
+    mRemoteDocumentSize = aRemoteDocumentSize;
+  }
+  const LayerIntSize& GetRemoteDocumentSize() const {
+    return mRemoteDocumentSize;
+  }
+  void SetReferentId(LayersId aReferentId) { mReferentId = Some(aReferentId); }
+  Maybe<LayersId> GetReferentId() const { return mReferentId; }
+
+  void SetScrollbarData(const ScrollbarData& aData) { mScrollbarData = aData; }
+  const ScrollbarData& GetScrollbarData() const { return mScrollbarData; }
+  void SetScrollbarAnimationId(const uint64_t& aId) {
+    mScrollbarAnimationId = Some(aId);
+  }
+  Maybe<uint64_t> GetScrollbarAnimationId() const {
+    return mScrollbarAnimationId;
+  }
+
+  void SetFixedPositionAnimationId(const uint64_t& aId) {
+    mFixedPositionAnimationId = Some(aId);
+  }
+  Maybe<uint64_t> GetFixedPositionAnimationId() const {
+    return mFixedPositionAnimationId;
+  }
+
+  void SetFixedPositionSides(const SideBits& aSideBits) {
+    mFixedPositionSides = aSideBits;
+  }
+  SideBits GetFixedPositionSides() const { return mFixedPositionSides; }
+
+  void SetFixedPositionScrollContainerId(ViewID aId) {
+    mFixedPosScrollContainerId = aId;
+  }
+  ViewID GetFixedPositionScrollContainerId() const {
+    return mFixedPosScrollContainerId;
+  }
+
+  void SetStickyPositionScrollContainerId(ViewID aId) {
+    mStickyPosScrollContainerId = aId;
+  }
+  ViewID GetStickyPositionScrollContainerId() const {
+    return mStickyPosScrollContainerId;
+  }
+
+  void SetStickyScrollRangeOuter(const LayerRectAbsolute& scrollRange) {
+    mStickyScrollRangeOuter = scrollRange;
+  }
+  const LayerRectAbsolute& GetStickyScrollRangeOuter() const {
+    return mStickyScrollRangeOuter;
+  }
+
+  void SetStickyScrollRangeInner(const LayerRectAbsolute& scrollRange) {
+    mStickyScrollRangeInner = scrollRange;
+  }
+  const LayerRectAbsolute& GetStickyScrollRangeInner() const {
+    return mStickyScrollRangeInner;
+  }
+
+  void SetStickyPositionAnimationId(const uint64_t& aId) {
+    mStickyPositionAnimationId = Some(aId);
+  }
+  Maybe<uint64_t> GetStickyPositionAnimationId() const {
+    return mStickyPositionAnimationId;
+  }
+
+  void SetZoomAnimationId(const uint64_t& aId) { mZoomAnimationId = Some(aId); }
+  Maybe<uint64_t> GetZoomAnimationId() const { return mZoomAnimationId; }
+
+  void SetAsyncZoomContainerId(const ViewID& aId) {
+    mAsyncZoomContainerId = Some(aId);
+  }
+  Maybe<ViewID> GetAsyncZoomContainerId() const {
+    return mAsyncZoomContainerId;
+  }
+
+  void Dump(std::ostream& aOut, const WebRenderScrollData& aOwner) const;
+
+  friend struct IPC::ParamTraits<WebRenderLayerScrollData>;
+
+ private:
+  // For test use only
+  friend class APZTestAccess;
+
+  // For use by GTests in building WebRenderLayerScrollData trees.
+  // GTests don't have a display list so they can't use Initialize().
+  void InitializeForTest(int32_t aDescendantCount);
+
+  ScrollMetadata& GetScrollMetadataMut(WebRenderScrollData& aOwner,
+                                       size_t aIndex);
+
+ private:
+  // The number of descendants this layer has (not including the layer itself).
+  // This is needed to reconstruct the depth-first layer tree traversal
+  // efficiently. Leaf layers should always have 0 descendants.
+  int32_t mDescendantCount;
+
+  // Handles to the ScrollMetadata objects that were on this layer. The values
+  // stored in this array are indices into the owning WebRenderScrollData's
+  // mScrollMetadatas array. This indirection is used to deduplicate the
+  // ScrollMetadata objects, since there is usually heavy duplication of them
+  // within a layer tree.
+  CopyableTArray<size_t> mScrollIds;
+
+  // Various data that we collect from the Layer in Initialize(), serialize
+  // over IPC, and use on the parent side in APZ.
+
+  gfx::Matrix4x4 mAncestorTransform;
+  ViewID mAncestorTransformId;
+  gfx::Matrix4x4 mTransform;
+  bool mTransformIsPerspective;
+  float mResolution;
+  LayerIntRegion mVisibleRegion;
+  // The remote documents only need their size because their origin is always
+  // (0, 0).
+  LayerIntSize mRemoteDocumentSize;
+  Maybe<LayersId> mReferentId;
+  EventRegionsOverride mEventRegionsOverride;
+  ScrollbarData mScrollbarData;
+  Maybe<uint64_t> mScrollbarAnimationId;
+  Maybe<uint64_t> mFixedPositionAnimationId;
+  SideBits mFixedPositionSides;
+  ViewID mFixedPosScrollContainerId;
+  ViewID mStickyPosScrollContainerId;
+  LayerRectAbsolute mStickyScrollRangeOuter;
+  LayerRectAbsolute mStickyScrollRangeInner;
+  Maybe<uint64_t> mStickyPositionAnimationId;
+  Maybe<uint64_t> mZoomAnimationId;
+  Maybe<ViewID> mAsyncZoomContainerId;
+
+#if defined(DEBUG) || defined(MOZ_DUMP_PAINTING)
+  // The display item for which this layer was built.
+  // This is only set on the content side.
+  nsDisplayItem* mInitializedFrom = nullptr;
+#endif
+};
+
+// Data needed by APZ, for the whole layer tree. One instance of this class
+// is created for each transaction sent over PWebRenderBridge. It is populated
+// with information from the WebRender layer tree on the client side and the
+// information is used by APZ on the parent side.
+class WebRenderScrollData {
+ public:
+  WebRenderScrollData();
+  explicit WebRenderScrollData(WebRenderLayerManager* aManager,
+                               nsDisplayListBuilder* aBuilder);
+  WebRenderScrollData(WebRenderScrollData&& aOther) = default;
+  WebRenderScrollData& operator=(WebRenderScrollData&& aOther) = default;
+  virtual ~WebRenderScrollData() = default;
+
+  // Validate that the scroll data is well-formed, and particularly that
+  // |mLayerScrollData| encodes a valid tree. This is necessary because
+  // the data can be sent over IPC from a less-trusted content process.
+  bool Validate() const;
+
+  WebRenderLayerManager* GetManager() const;
+
+  nsDisplayListBuilder* GetBuilder() const;
+
+  // Add the given ScrollMetadata if it doesn't already exist. Return an index
+  // that can be used to look up the metadata later.
+  size_t AddMetadata(const ScrollMetadata& aMetadata);
+  // Add the provided WebRenderLayerScrollData and return the index that can
+  // be used to look it up via GetLayerData.
+  size_t AddLayerData(WebRenderLayerScrollData&& aData);
+
+  size_t GetLayerCount() const;
+
+  // Return a pointer to the scroll data at the given index. Use with caution,
+  // as the pointer may be invalidated if this WebRenderScrollData is mutated.
+  const WebRenderLayerScrollData* GetLayerData(size_t aIndex) const;
+  WebRenderLayerScrollData* GetLayerData(size_t aIndex);
+
+  const ScrollMetadata& GetScrollMetadata(size_t aIndex) const;
+  Maybe<size_t> HasMetadataFor(
+      const ScrollableLayerGuid::ViewID& aScrollId) const;
+
+  void SetIsFirstPaint();
+  bool IsFirstPaint() const;
+  void SetPaintSequenceNumber(uint32_t aPaintSequenceNumber);
+  uint32_t GetPaintSequenceNumber() const;
+
+  void ApplyUpdates(ScrollUpdatesMap&& aUpdates, uint32_t aPaintSequenceNumber);
+
+  friend struct IPC::ParamTraits<WebRenderScrollData>;
+
+  friend std::ostream& operator<<(std::ostream& aOut,
+                                  const WebRenderScrollData& aData);
+
+ private:
+  // For test use only.
+  friend class WebRenderLayerScrollData;
+  ScrollMetadata& GetScrollMetadataMut(size_t aIndex);
+
+ private:
+  // This is called by the ParamTraits implementation to rebuild mScrollIdMap
+  // based on mScrollMetadatas
+  bool RepopulateMap();
+
+  // This is a helper for the dumping code
+  void DumpSubtree(std::ostream& aOut, size_t aIndex,
+                   const std::string& aIndent) const;
+
+ private:
+  // Pointer back to the layer manager; if this is non-null, it will always be
+  // valid, because the WebRenderLayerManager that created |this| will
+  // outlive |this|.
+  WebRenderLayerManager* MOZ_NON_OWNING_REF mManager;
+
+  // Pointer to the display list builder; if this is non-null, it will always be
+  // valid, because the nsDisplayListBuilder that created the layer manager will
+  // outlive |this|.
+  nsDisplayListBuilder* MOZ_NON_OWNING_REF mBuilder;
+
+  // Internal data structure used to maintain uniqueness of mScrollMetadatas.
+  // This is not serialized/deserialized over IPC, but it is rebuilt on the
+  // parent side when mScrollMetadatas is deserialized. So it should always be
+  // valid on both the child and parent.
+  // The key into this map is the scrollId of a ScrollMetadata, and the value is
+  // an index into the mScrollMetadatas array.
+  HashMap<ScrollableLayerGuid::ViewID, size_t> mScrollIdMap;
+
+  // A list of all the unique ScrollMetadata objects from the layer tree. Each
+  // ScrollMetadata in this list must have a unique scroll id.
+  nsTArray<ScrollMetadata> mScrollMetadatas;
+
+  // A list of per-layer scroll data objects, generated via a depth-first,
+  // pre-order, last-to-first traversal of the layer tree (i.e. a recursive
+  // traversal where a node N first pushes itself, followed by its children in
+  // last-to-first order). Each layer's scroll data object knows how many
+  // descendants that layer had, which allows reconstructing the traversal on
+  // the other side.
+  nsTArray<WebRenderLayerScrollData> mLayerScrollData;
+
+  bool mIsFirstPaint;
+  uint32_t mPaintSequenceNumber;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+namespace IPC {
+
+template <>
+struct ParamTraits<mozilla::layers::WebRenderLayerScrollData> {
+  typedef mozilla::layers::WebRenderLayerScrollData paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam);
+
+  static bool Read(MessageReader* aReader, paramType* aResult);
+};
+
+template <>
+struct ParamTraits<mozilla::layers::WebRenderScrollData> {
+  typedef mozilla::layers::WebRenderScrollData paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam);
+
+  static bool Read(MessageReader* aReader, paramType* aResult);
+};
+
+}  // namespace IPC
+
+#endif /* GFX_WEBRENDERSCROLLDATA_H */
diff --git a/gfx/layers/wr/WebRenderScrollDataWrapper.h b/gfx/layers/wr/WebRenderScrollDataWrapper.h
new file mode 100644
index 0000000000..9cbec76371
--- /dev/null
+++ b/gfx/layers/wr/WebRenderScrollDataWrapper.h
@@ -0,0 +1,542 @@
+/* -*- 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_WEBRENDERSCROLLDATAWRAPPER_H
+#define GFX_WEBRENDERSCROLLDATAWRAPPER_H
+
+#include "FrameMetrics.h"
+#include "mozilla/layers/APZUpdater.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/WebRenderBridgeParent.h"
+#include "mozilla/layers/WebRenderScrollData.h"
+
+namespace mozilla {
+namespace layers {
+
+/**
+ * A wrapper class around a target WebRenderLayerScrollData (henceforth,
+ * "layer") that allows user code to walk through the ScrollMetadata objects
+ * on the layer the same way it would walk through a layer tree.
+ * Consider the following layer tree:
+ *
+ *                    +---+
+ *                    | A |
+ *                    +---+
+ *                   /  |  \
+ *                  /   |   \
+ *                 /    |    \
+ *            +---+  +-----+  +---+
+ *            | B |  |  C  |  | D |
+ *            +---+  +-----+  +---+
+ *                   | SMn |
+ *                   |  .  |
+ *                   |  .  |
+ *                   |  .  |
+ *                   | SM1 |
+ *                   | SM0 |
+ *                   +-----+
+ *                   /     \
+ *                  /       \
+ *             +---+         +---+
+ *             | E |         | F |
+ *             +---+         +---+
+ *
+ * In this layer tree, there are six layers with A being the root and B,D,E,F
+ * being leaf nodes. Layer C is in the middle and has n+1 ScrollMetadata,
+ * labelled SM0...SMn. SM0 is the ScrollMetadata you get by calling
+ * c->GetScrollMetadata(0) and SMn is the ScrollMetadata you can obtain by
+ * calling c->GetScrollMetadata(c->GetScrollMetadataCount() - 1). This layer
+ * tree is conceptually equivalent to this one below:
+ *
+ *                    +---+
+ *                    | A |
+ *                    +---+
+ *                   /  |  \
+ *                  /   |   \
+ *                 /    |    \
+ *            +---+  +-----+  +---+
+ *            | B |  | Cn  |  | D |
+ *            +---+  +-----+  +---+
+ *                      |
+ *                      .
+ *                      .
+ *                      .
+ *                      |
+ *                   +-----+
+ *                   | C1  |
+ *                   +-----+
+ *                      |
+ *                   +-----+
+ *                   | C0  |
+ *                   +-----+
+ *                   /     \
+ *                  /       \
+ *             +---+         +---+
+ *             | E |         | F |
+ *             +---+         +---+
+ *
+ * In this layer tree, the layer C has been expanded into a stack of layers
+ * C1...Cn, where C1 has ScrollMetadata SM1 and Cn has ScrollMetdata Fn.
+ *
+ * The WebRenderScrollDataWrapper class allows client code to treat the first
+ * layer tree as though it were the second. That is, instead of client code
+ * having to iterate through the ScrollMetadata objects directly, it can use a
+ * WebRenderScrollDataWrapper to encapsulate that aspect of the layer tree and
+ * just walk the tree as if it were a stack of layers.
+ *
+ * The functions on this class do different things depending on which
+ * simulated layer is being wrapped. For example, if the
+ * WebRenderScrollDataWrapper is pretending to be C0, the GetPrevSibling()
+ * function will return null even though the underlying layer C does actually
+ * have a prev sibling. The WebRenderScrollDataWrapper pretending to be Cn will
+ * return B as the prev sibling.
+ *
+ * Implementation notes:
+ *
+ * The AtTopLayer() and AtBottomLayer() functions in this class refer to
+ * Cn and C0 in the second layer tree above; that is, they are predicates
+ * to test if the wrapper is simulating the topmost or bottommost layer, as
+ * those can have special behaviour.
+ *
+ * It is possible to wrap a nullptr in a WebRenderScrollDataWrapper, in which
+ * case the IsValid() function will return false. This is required to allow
+ * WebRenderScrollDataWrapper to be a MOZ_STACK_CLASS (desirable because it is
+ * used in loops and recursion).
+ *
+ * This class purposely does not expose the wrapped layer directly to avoid
+ * user code from accidentally calling functions directly on it. Instead
+ * any necessary functions should be wrapped in this class. It does expose
+ * the wrapped layer as a void* for printf purposes.
+ *
+ * The implementation may look like it special-cases mIndex == 0 and/or
+ * GetScrollMetadataCount() == 0. This is an artifact of the fact that both
+ * mIndex and GetScrollMetadataCount() are uint32_t and GetScrollMetadataCount()
+ * can return 0 but mIndex cannot store -1. This seems better than the
+ * alternative of making mIndex a int32_t that can store -1, but then having
+ * to cast to uint32_t all over the place.
+ *
+ * Note that WebRenderLayerScrollData objects are owned by WebRenderScrollData,
+ * which stores them in a flattened representation. The field mData,
+ * mLayerIndex, and mContainingSubtreeIndex are used to move around the "layers"
+ * given the flattened representation. The mMetadataIndex is used to move around
+ * the ScrollMetadata within a single layer.
+ *
+ * One important note here is that this class holds a pointer to the "owning"
+ * WebRenderScrollData. The caller must ensure that this class does not outlive
+ * the owning WebRenderScrollData, or this may result in use-after-free errors.
+ * This class being declared a MOZ_STACK_CLASS should help with that.
+ */
+class MOZ_STACK_CLASS WebRenderScrollDataWrapper final {
+ public:
+  // Basic constructor for external callers. Starts the walker at the root of
+  // the tree.
+  explicit WebRenderScrollDataWrapper(
+      const APZUpdater& aUpdater, const WebRenderScrollData* aData = nullptr)
+      : mUpdater(&aUpdater),
+        mData(aData),
+        mLayerIndex(0),
+        mContainingSubtreeLastIndex(0),
+        mLayer(nullptr),
+        mMetadataIndex(0) {
+    if (!mData) {
+      return;
+    }
+    mLayer = mData->GetLayerData(mLayerIndex);
+    if (!mLayer) {
+      return;
+    }
+
+    // sanity check on the data
+    MOZ_ASSERT(mData->GetLayerCount() ==
+               (size_t)(1 + mLayer->GetDescendantCount()));
+    mContainingSubtreeLastIndex = mData->GetLayerCount();
+
+    // See documentation in LayerMetricsWrapper.h about this. mMetadataIndex
+    // in this class is equivalent to mIndex in that class.
+    mMetadataIndex = mLayer->GetScrollMetadataCount();
+    if (mMetadataIndex > 0) {
+      mMetadataIndex--;
+    }
+  }
+
+ private:
+  // Internal constructor for walking from one WebRenderLayerScrollData to
+  // another. In this case we need to recompute the mMetadataIndex to be the
+  // "topmost" scroll metadata on the new layer.
+  WebRenderScrollDataWrapper(const APZUpdater* aUpdater,
+                             const WebRenderScrollData* aData,
+                             size_t aLayerIndex,
+                             size_t aContainingSubtreeLastIndex)
+      : mUpdater(aUpdater),
+        mData(aData),
+        mLayerIndex(aLayerIndex),
+        mContainingSubtreeLastIndex(aContainingSubtreeLastIndex),
+        mLayer(nullptr),
+        mMetadataIndex(0) {
+    MOZ_ASSERT(mData);
+    mLayer = mData->GetLayerData(mLayerIndex);
+    MOZ_ASSERT(mLayer);
+
+    // See documentation in LayerMetricsWrapper.h about this. mMetadataIndex
+    // in this class is equivalent to mIndex in that class.
+    mMetadataIndex = mLayer->GetScrollMetadataCount();
+    if (mMetadataIndex > 0) {
+      mMetadataIndex--;
+    }
+  }
+
+  // Internal constructor for walking from one metadata to another metadata on
+  // the same WebRenderLayerScrollData.
+  WebRenderScrollDataWrapper(const APZUpdater* aUpdater,
+                             const WebRenderScrollData* aData,
+                             size_t aLayerIndex,
+                             size_t aContainingSubtreeLastIndex,
+                             const WebRenderLayerScrollData* aLayer,
+                             uint32_t aMetadataIndex)
+      : mUpdater(aUpdater),
+        mData(aData),
+        mLayerIndex(aLayerIndex),
+        mContainingSubtreeLastIndex(aContainingSubtreeLastIndex),
+        mLayer(aLayer),
+        mMetadataIndex(aMetadataIndex) {
+    MOZ_ASSERT(mData);
+    MOZ_ASSERT(mLayer);
+    MOZ_ASSERT(mLayer == mData->GetLayerData(mLayerIndex));
+    MOZ_ASSERT(mMetadataIndex == 0 ||
+               mMetadataIndex < mLayer->GetScrollMetadataCount());
+  }
+
+ public:
+  bool IsValid() const { return mLayer != nullptr; }
+
+  explicit operator bool() const { return IsValid(); }
+
+  WebRenderScrollDataWrapper GetLastChild() const {
+    MOZ_ASSERT(IsValid());
+
+    if (!AtBottomLayer()) {
+      // If we're still walking around in the virtual container layers created
+      // by the ScrollMetadata array, we just need to update the metadata index
+      // and that's it.
+      return WebRenderScrollDataWrapper(mUpdater, mData, mLayerIndex,
+                                        mContainingSubtreeLastIndex, mLayer,
+                                        mMetadataIndex - 1);
+    }
+
+    // Otherwise, we need to walk to a different WebRenderLayerScrollData in
+    // mData.
+
+    // Since mData contains the layer in depth-first, last-to-first order,
+    // the index after mLayerIndex must be mLayerIndex's last child, if it
+    // has any children (indicated by GetDescendantCount() > 0). Furthermore
+    // we compute the first index outside the subtree rooted at this node
+    // (in |subtreeLastIndex|) and pass that in to the child wrapper to use as
+    // its mContainingSubtreeLastIndex.
+    if (mLayer->GetDescendantCount() > 0) {
+      size_t prevSiblingIndex = mLayerIndex + 1 + mLayer->GetDescendantCount();
+      // TODO(botond): Replace the min() with just prevSiblingIndex (which
+      // should be <= mContainingSubtreeLastIndex).
+      MOZ_ASSERT(prevSiblingIndex <= mContainingSubtreeLastIndex);
+      size_t subtreeLastIndex =
+          std::min(mContainingSubtreeLastIndex, prevSiblingIndex);
+      return WebRenderScrollDataWrapper(mUpdater, mData, mLayerIndex + 1,
+                                        subtreeLastIndex);
+    }
+
+    // We've run out of descendants. But! If the original layer was a RefLayer,
+    // then it connects to another layer tree and we need to traverse that too.
+    // So return a WebRenderScrollDataWrapper for the root of the child layer
+    // tree.
+    if (mLayer->GetReferentId()) {
+      return WebRenderScrollDataWrapper(
+          *mUpdater, mUpdater->GetScrollData(*mLayer->GetReferentId()));
+    }
+
+    return WebRenderScrollDataWrapper(*mUpdater);
+  }
+
+  WebRenderScrollDataWrapper GetPrevSibling() const {
+    MOZ_ASSERT(IsValid());
+
+    if (!AtTopLayer()) {
+      // The virtual container layers don't have siblings
+      return WebRenderScrollDataWrapper(*mUpdater);
+    }
+
+    // Skip past the descendants to get to the previous sibling. However, we
+    // might be at the last sibling already.
+    size_t prevSiblingIndex = mLayerIndex + 1 + mLayer->GetDescendantCount();
+    if (prevSiblingIndex < mContainingSubtreeLastIndex) {
+      return WebRenderScrollDataWrapper(mUpdater, mData, prevSiblingIndex,
+                                        mContainingSubtreeLastIndex);
+    }
+    return WebRenderScrollDataWrapper(*mUpdater);
+  }
+
+  const ScrollMetadata& Metadata() const {
+    MOZ_ASSERT(IsValid());
+
+    if (mMetadataIndex >= mLayer->GetScrollMetadataCount()) {
+      return *ScrollMetadata::sNullMetadata;
+    }
+    return mLayer->GetScrollMetadata(*mData, mMetadataIndex);
+  }
+
+  const FrameMetrics& Metrics() const { return Metadata().GetMetrics(); }
+
+  AsyncPanZoomController* GetApzc() const { return nullptr; }
+
+  void SetApzc(AsyncPanZoomController* aApzc) const {}
+
+  const char* Name() const { return "WebRenderScrollDataWrapper"; }
+
+  gfx::Matrix4x4 GetTransform() const {
+    MOZ_ASSERT(IsValid());
+
+    // See WebRenderLayerScrollData::Initialize for more context.
+    //  * The ancestor transform is associated with whichever layer has scroll
+    //    id matching GetAncestorTransformId().
+    //  * The resolution is associated with the "topmost" layer.
+    //  * The transform is associated with the "bottommost" layer.
+    // Multiple transforms may apply to the same layer (e.g. if there is only
+    // one scrollmetadata on the layer, then it is both "topmost" and
+    // "bottommost"), so we may need to combine the transforms.
+
+    gfx::Matrix4x4 transform;
+    // The ancestor transform is usually emitted at the layer with the
+    // matching scroll id. However, sometimes the transform ends up on
+    // a node with no scroll metadata at all. In such cases we generate
+    // a single layer, and the ancestor transform needs to be on that layer,
+    // otherwise it will be lost.
+    bool emitAncestorTransform =
+        !Metrics().IsScrollable() ||
+        Metrics().GetScrollId() == mLayer->GetAncestorTransformId();
+    if (emitAncestorTransform) {
+      transform = mLayer->GetAncestorTransform();
+    }
+    if (AtTopLayer()) {
+      float resolution = mLayer->GetResolution();
+      transform =
+          transform * gfx::Matrix4x4::Scaling(resolution, resolution, 1.f);
+    }
+    if (AtBottomLayer()) {
+      transform = mLayer->GetTransform() * transform;
+    }
+    return transform;
+  }
+
+  CSSTransformMatrix GetTransformTyped() const {
+    return ViewAs<CSSTransformMatrix>(GetTransform());
+  }
+
+  bool TransformIsPerspective() const {
+    MOZ_ASSERT(IsValid());
+
+    // mLayer->GetTransformIsPerspective() tells us whether
+    // mLayer->GetTransform() is a perspective transform. Since
+    // mLayer->GetTransform() is only used at the bottom layer, we only
+    // need to check GetTransformIsPerspective() at the bottom layer too.
+    if (AtBottomLayer()) {
+      return mLayer->GetTransformIsPerspective();
+    }
+    return false;
+  }
+
+  LayerIntRegion GetVisibleRegion() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetVisibleRegion();
+    }
+
+    return ViewAs<LayerPixel>(
+        TransformBy(mLayer->GetTransformTyped(), mLayer->GetVisibleRegion()),
+        PixelCastJustification::MovingDownToChildren);
+  }
+
+  LayerIntSize GetRemoteDocumentSize() const {
+    MOZ_ASSERT(IsValid());
+
+    if (mLayer->GetReferentId().isNothing()) {
+      return LayerIntSize();
+    }
+
+    if (AtBottomLayer()) {
+      return mLayer->GetRemoteDocumentSize();
+    }
+
+    return ViewAs<LayerPixel>(mLayer->GetRemoteDocumentSize(),
+                              PixelCastJustification::MovingDownToChildren);
+  }
+
+  Maybe<LayersId> GetReferentId() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetReferentId();
+    }
+    return Nothing();
+  }
+
+  EventRegionsOverride GetEventRegionsOverride() const {
+    MOZ_ASSERT(IsValid());
+    // Only ref layers can have an event regions override.
+    if (GetReferentId()) {
+      return mLayer->GetEventRegionsOverride();
+    }
+    return EventRegionsOverride::NoOverride;
+  }
+
+  const ScrollbarData& GetScrollbarData() const {
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetScrollbarData();
+  }
+
+  Maybe<uint64_t> GetScrollbarAnimationId() const {
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetScrollbarAnimationId();
+  }
+
+  Maybe<uint64_t> GetFixedPositionAnimationId() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetFixedPositionAnimationId();
+    }
+    return Nothing();
+  }
+
+  ScrollableLayerGuid::ViewID GetFixedPositionScrollContainerId() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetFixedPositionScrollContainerId();
+    }
+    return ScrollableLayerGuid::NULL_SCROLL_ID;
+  }
+
+  SideBits GetFixedPositionSides() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetFixedPositionSides();
+    }
+    return SideBits::eNone;
+  }
+
+  ScrollableLayerGuid::ViewID GetStickyScrollContainerId() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetStickyPositionScrollContainerId();
+    }
+    return ScrollableLayerGuid::NULL_SCROLL_ID;
+  }
+
+  const LayerRectAbsolute& GetStickyScrollRangeOuter() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetStickyScrollRangeOuter();
+    }
+
+    static const LayerRectAbsolute empty;
+    return empty;
+  }
+
+  const LayerRectAbsolute& GetStickyScrollRangeInner() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetStickyScrollRangeInner();
+    }
+
+    static const LayerRectAbsolute empty;
+    return empty;
+  }
+
+  Maybe<uint64_t> GetStickyPositionAnimationId() const {
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetStickyPositionAnimationId();
+    }
+    return Nothing();
+  }
+
+  Maybe<uint64_t> GetZoomAnimationId() const {
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetZoomAnimationId();
+  }
+
+  Maybe<ScrollableLayerGuid::ViewID> GetAsyncZoomContainerId() const {
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetAsyncZoomContainerId();
+  }
+
+  // Expose an opaque pointer to the layer. Mostly used for printf
+  // purposes. This is not intended to be a general-purpose accessor
+  // for the underlying layer.
+  const void* GetLayer() const {
+    MOZ_ASSERT(IsValid());
+    return mLayer;
+  }
+
+  template <int Level>
+  size_t Dump(gfx::TreeLog<Level>& aOut) const {
+    std::string result = "(invalid)";
+    if (!IsValid()) {
+      aOut << result;
+      return result.length();
+    }
+    if (AtBottomLayer()) {
+      if (mData != nullptr) {
+        const WebRenderLayerScrollData* layerData =
+            mData->GetLayerData(mLayerIndex);
+        if (layerData != nullptr) {
+          std::stringstream ss;
+          layerData->Dump(ss, *mData);
+          result = ss.str();
+          aOut << result;
+          return result.length();
+        }
+      }
+    }
+    return 0;
+  }
+
+ private:
+  bool AtBottomLayer() const { return mMetadataIndex == 0; }
+
+  bool AtTopLayer() const {
+    return mLayer->GetScrollMetadataCount() == 0 ||
+           mMetadataIndex == mLayer->GetScrollMetadataCount() - 1;
+  }
+
+ private:
+  const APZUpdater* mUpdater;
+  const WebRenderScrollData* mData;
+  // The index (in mData->mLayerScrollData) of the WebRenderLayerScrollData this
+  // wrapper is pointing to.
+  size_t mLayerIndex;
+  // The upper bound on the set of valid indices inside the subtree rooted at
+  // the parent of this "layer". That is, any layer index |i| in the range
+  // mLayerIndex <= i < mContainingSubtreeLastIndex is guaranteed to point to
+  // a layer that is a descendant of "parent", where "parent" is the parent
+  // layer of the layer at mLayerIndex. This is needed in order to implement
+  // GetPrevSibling() correctly.
+  size_t mContainingSubtreeLastIndex;
+  // The WebRenderLayerScrollData this wrapper is pointing to.
+  const WebRenderLayerScrollData* mLayer;
+  // The index of the scroll metadata within mLayer that this wrapper is
+  // pointing to.
+  uint32_t mMetadataIndex;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif /* GFX_WEBRENDERSCROLLDATAWRAPPER_H */
diff --git a/gfx/layers/wr/WebRenderTextureHost.cpp b/gfx/layers/wr/WebRenderTextureHost.cpp
new file mode 100644
index 0000000000..aa4215453f
--- /dev/null
+++ b/gfx/layers/wr/WebRenderTextureHost.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 "WebRenderTextureHost.h"
+
+#include "mozilla/layers/ImageDataSerializer.h"
+#include "mozilla/layers/LayersSurfaces.h"
+#include "mozilla/layers/TextureSourceProvider.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "mozilla/layers/TextureHostOGL.h"
+#endif
+
+namespace mozilla::layers {
+
+class ScheduleHandleRenderTextureOps : public wr::NotificationHandler {
+ public:
+  explicit ScheduleHandleRenderTextureOps() {}
+
+  virtual void Notify(wr::Checkpoint aCheckpoint) override {
+    if (aCheckpoint == wr::Checkpoint::FrameTexturesUpdated) {
+      MOZ_ASSERT(wr::RenderThread::IsInRenderThread());
+      wr::RenderThread::Get()->HandleRenderTextureOps();
+    } else {
+      MOZ_ASSERT(aCheckpoint == wr::Checkpoint::TransactionDropped);
+    }
+  }
+
+ protected:
+};
+
+WebRenderTextureHost::WebRenderTextureHost(
+    TextureFlags aFlags, TextureHost* aTexture,
+    const wr::ExternalImageId& aExternalImageId)
+    : TextureHost(TextureHostType::Unknown, aFlags),
+      mWrappedTextureHost(aTexture) {
+  MOZ_ASSERT(mWrappedTextureHost);
+  // The wrapped textureHost will be used in WebRender, and the WebRender could
+  // run at another thread. It's hard to control the life-time when gecko
+  // receives PTextureParent destroy message. It's possible that textureHost is
+  // still used by WebRender. So, we only accept the textureHost without
+  // DEALLOCATE_CLIENT flag here. If the buffer deallocation is controlled by
+  // parent, we could do something to make sure the wrapped textureHost is not
+  // used by WebRender and then release it.
+  MOZ_ASSERT(!(aFlags & TextureFlags::DEALLOCATE_CLIENT));
+  MOZ_COUNT_CTOR(WebRenderTextureHost);
+
+  mExternalImageId = Some(aExternalImageId);
+}
+
+WebRenderTextureHost::~WebRenderTextureHost() {
+  MOZ_COUNT_DTOR(WebRenderTextureHost);
+}
+
+wr::ExternalImageId WebRenderTextureHost::GetExternalImageKey() {
+  if (IsValid()) {
+    mWrappedTextureHost->EnsureRenderTexture(mExternalImageId);
+  }
+  MOZ_ASSERT(mWrappedTextureHost->mExternalImageId.isSome());
+  return mWrappedTextureHost->mExternalImageId.ref();
+}
+
+bool WebRenderTextureHost::IsValid() { return mWrappedTextureHost->IsValid(); }
+
+void WebRenderTextureHost::UnbindTextureSource() {
+  if (mWrappedTextureHost->AsBufferTextureHost()) {
+    mWrappedTextureHost->UnbindTextureSource();
+  }
+  // Handle read unlock
+  TextureHost::UnbindTextureSource();
+}
+
+already_AddRefed<gfx::DataSourceSurface> WebRenderTextureHost::GetAsSurface() {
+  return mWrappedTextureHost->GetAsSurface();
+}
+
+gfx::ColorDepth WebRenderTextureHost::GetColorDepth() const {
+  return mWrappedTextureHost->GetColorDepth();
+}
+
+gfx::YUVColorSpace WebRenderTextureHost::GetYUVColorSpace() const {
+  return mWrappedTextureHost->GetYUVColorSpace();
+}
+
+gfx::ColorRange WebRenderTextureHost::GetColorRange() const {
+  return mWrappedTextureHost->GetColorRange();
+}
+
+gfx::IntSize WebRenderTextureHost::GetSize() const {
+  return mWrappedTextureHost->GetSize();
+}
+
+gfx::SurfaceFormat WebRenderTextureHost::GetFormat() const {
+  return mWrappedTextureHost->GetFormat();
+}
+
+void WebRenderTextureHost::NotifyNotUsed() {
+#ifdef MOZ_WIDGET_ANDROID
+  // When SurfaceTextureHost is wrapped by RemoteTextureHostWrapper,
+  // NotifyNotUsed() is handled by SurfaceTextureHost.
+  if (IsWrappingSurfaceTextureHost() &&
+      !mWrappedTextureHost->AsRemoteTextureHostWrapper()) {
+    wr::RenderThread::Get()->NotifyNotUsed(GetExternalImageKey());
+  }
+#endif
+  if (mWrappedTextureHost->AsRemoteTextureHostWrapper()) {
+    mWrappedTextureHost->NotifyNotUsed();
+  }
+  TextureHost::NotifyNotUsed();
+}
+
+void WebRenderTextureHost::MaybeNotifyForUse(wr::TransactionBuilder& aTxn) {
+#if defined(MOZ_WIDGET_ANDROID)
+  if (IsWrappingSurfaceTextureHost() &&
+      !mWrappedTextureHost->AsRemoteTextureHostWrapper()) {
+    wr::RenderThread::Get()->NotifyForUse(GetExternalImageKey());
+    aTxn.Notify(wr::Checkpoint::FrameTexturesUpdated,
+                MakeUnique<ScheduleHandleRenderTextureOps>());
+  }
+#endif
+}
+
+bool WebRenderTextureHost::IsWrappingSurfaceTextureHost() {
+  return mWrappedTextureHost->IsWrappingSurfaceTextureHost();
+}
+
+void WebRenderTextureHost::PrepareForUse() {
+  // When SurfaceTextureHost is wrapped by RemoteTextureHostWrapper,
+  // PrepareForUse() is handled by SurfaceTextureHost.
+  if ((IsWrappingSurfaceTextureHost() &&
+       !mWrappedTextureHost->AsRemoteTextureHostWrapper()) ||
+      mWrappedTextureHost->AsBufferTextureHost()) {
+    // Call PrepareForUse on render thread.
+    // See RenderAndroidSurfaceTextureHostOGL::PrepareForUse.
+    wr::RenderThread::Get()->PrepareForUse(GetExternalImageKey());
+  }
+}
+
+gfx::SurfaceFormat WebRenderTextureHost::GetReadFormat() const {
+  return mWrappedTextureHost->GetReadFormat();
+}
+
+int32_t WebRenderTextureHost::GetRGBStride() {
+  gfx::SurfaceFormat format = GetFormat();
+  if (GetFormat() == gfx::SurfaceFormat::YUV) {
+    // XXX this stride is used until yuv image rendering by webrender is used.
+    // Software converted RGB buffers strides are aliened to 16
+    return gfx::GetAlignedStride<16>(
+        GetSize().width, BytesPerPixel(gfx::SurfaceFormat::B8G8R8A8));
+  }
+  return ImageDataSerializer::ComputeRGBStride(format, GetSize().width);
+}
+
+bool WebRenderTextureHost::NeedsDeferredDeletion() const {
+  return mWrappedTextureHost->NeedsDeferredDeletion();
+}
+
+uint32_t WebRenderTextureHost::NumSubTextures() {
+  return mWrappedTextureHost->NumSubTextures();
+}
+
+void WebRenderTextureHost::PushResourceUpdates(
+    wr::TransactionBuilder& aResources, ResourceUpdateOp aOp,
+    const Range<wr::ImageKey>& aImageKeys, const wr::ExternalImageId& aExtID) {
+  MOZ_ASSERT(GetExternalImageKey() == aExtID);
+
+  mWrappedTextureHost->PushResourceUpdates(aResources, aOp, aImageKeys, aExtID);
+}
+
+void WebRenderTextureHost::PushDisplayItems(
+    wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
+    const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
+    const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
+  MOZ_ASSERT(aImageKeys.length() > 0);
+
+  mWrappedTextureHost->PushDisplayItems(aBuilder, aBounds, aClip, aFilter,
+                                        aImageKeys, aFlags);
+}
+
+bool WebRenderTextureHost::SupportsExternalCompositing(
+    WebRenderBackend aBackend) {
+  return mWrappedTextureHost->SupportsExternalCompositing(aBackend);
+}
+
+void WebRenderTextureHost::SetAcquireFence(
+    mozilla::ipc::FileDescriptor&& aFenceFd) {
+  mWrappedTextureHost->SetAcquireFence(std::move(aFenceFd));
+}
+
+void WebRenderTextureHost::SetReleaseFence(
+    mozilla::ipc::FileDescriptor&& aFenceFd) {
+  mWrappedTextureHost->SetReleaseFence(std::move(aFenceFd));
+}
+
+mozilla::ipc::FileDescriptor WebRenderTextureHost::GetAndResetReleaseFence() {
+  return mWrappedTextureHost->GetAndResetReleaseFence();
+}
+
+AndroidHardwareBuffer* WebRenderTextureHost::GetAndroidHardwareBuffer() const {
+  return mWrappedTextureHost->GetAndroidHardwareBuffer();
+}
+
+TextureHostType WebRenderTextureHost::GetTextureHostType() {
+  return mWrappedTextureHost->GetTextureHostType();
+}
+
+}  // namespace mozilla::layers
diff --git a/gfx/layers/wr/WebRenderTextureHost.h b/gfx/layers/wr/WebRenderTextureHost.h
new file mode 100644
index 0000000000..d24d9c7304
--- /dev/null
+++ b/gfx/layers/wr/WebRenderTextureHost.h
@@ -0,0 +1,111 @@
+/* -*- 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_WEBRENDERTEXTUREHOST_H
+#define MOZILLA_GFX_WEBRENDERTEXTUREHOST_H
+
+#include "mozilla/layers/TextureHost.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+
+namespace mozilla {
+namespace layers {
+
+class SurfaceDescriptor;
+
+// This textureHost is specialized for WebRender usage. With WebRender, there is
+// no Compositor during composition. Instead, we use RendererOGL for
+// composition. So, there are some UNREACHABLE asserts for the original
+// Compositor related code path in this class. Furthermore, the RendererOGL runs
+// at RenderThead instead of Compositor thread. This class is also creating the
+// corresponding RenderXXXTextureHost used by RendererOGL at RenderThread.
+class WebRenderTextureHost : public TextureHost {
+ public:
+  WebRenderTextureHost(TextureFlags aFlags, TextureHost* aTexture,
+                       const wr::ExternalImageId& aExternalImageId);
+  virtual ~WebRenderTextureHost();
+
+  void DeallocateDeviceData() override {}
+
+  void UnbindTextureSource() override;
+
+  gfx::SurfaceFormat GetFormat() const override;
+
+  virtual void NotifyNotUsed() override;
+
+  virtual bool IsValid() override;
+
+  // Return the format used for reading the texture. Some hardware specific
+  // textureHosts use their special data representation internally, but we could
+  // treat these textureHost as the read-format when we read them.
+  // Please check TextureHost::GetReadFormat().
+  gfx::SurfaceFormat GetReadFormat() const override;
+
+  already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override;
+
+  gfx::ColorDepth GetColorDepth() const override;
+  gfx::YUVColorSpace GetYUVColorSpace() const override;
+  gfx::ColorRange GetColorRange() const override;
+
+  gfx::IntSize GetSize() const override;
+
+#ifdef MOZ_LAYERS_HAVE_LOG
+  const char* Name() override { return "WebRenderTextureHost"; }
+#endif
+
+  WebRenderTextureHost* AsWebRenderTextureHost() override { return this; }
+
+  RemoteTextureHostWrapper* AsRemoteTextureHostWrapper() override {
+    return mWrappedTextureHost->AsRemoteTextureHostWrapper();
+  }
+
+  BufferTextureHost* AsBufferTextureHost() override {
+    return mWrappedTextureHost->AsBufferTextureHost();
+  }
+
+  bool IsWrappingSurfaceTextureHost() override;
+
+  virtual void PrepareForUse() override;
+
+  wr::ExternalImageId GetExternalImageKey();
+
+  int32_t GetRGBStride();
+
+  bool NeedsDeferredDeletion() const override;
+
+  uint32_t NumSubTextures() override;
+
+  void PushResourceUpdates(wr::TransactionBuilder& aResources,
+                           ResourceUpdateOp aOp,
+                           const Range<wr::ImageKey>& aImageKeys,
+                           const wr::ExternalImageId& aExtID) override;
+
+  void PushDisplayItems(wr::DisplayListBuilder& aBuilder,
+                        const wr::LayoutRect& aBounds,
+                        const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
+                        const Range<wr::ImageKey>& aImageKeys,
+                        PushDisplayItemFlagSet aFlags) override;
+
+  bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
+
+  void SetAcquireFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
+
+  void SetReleaseFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
+
+  mozilla::ipc::FileDescriptor GetAndResetReleaseFence() override;
+
+  AndroidHardwareBuffer* GetAndroidHardwareBuffer() const override;
+
+  void MaybeNotifyForUse(wr::TransactionBuilder& aTxn);
+
+  TextureHostType GetTextureHostType() override;
+
+  const RefPtr<TextureHost> mWrappedTextureHost;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif  // MOZILLA_GFX_WEBRENDERTEXTUREHOST_H
diff --git a/gfx/layers/wr/WebRenderUserData.cpp b/gfx/layers/wr/WebRenderUserData.cpp
new file mode 100644
index 0000000000..2a767a6d18
--- /dev/null
+++ b/gfx/layers/wr/WebRenderUserData.cpp
@@ -0,0 +1,427 @@
+/* -*- 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 "WebRenderUserData.h"
+
+#include "mozilla/image/WebRenderImageProvider.h"
+#include "mozilla/layers/AnimationHelper.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/ImageClient.h"
+#include "mozilla/layers/WebRenderBridgeChild.h"
+#include "mozilla/layers/RenderRootStateManager.h"
+#include "mozilla/layers/WebRenderMessages.h"
+#include "mozilla/layers/IpcResourceUpdateQueue.h"
+#include "mozilla/layers/SharedSurfacesChild.h"
+#include "mozilla/webgpu/WebGPUChild.h"
+#include "nsDisplayListInvalidation.h"
+#include "nsIFrame.h"
+#include "WebRenderCanvasRenderer.h"
+
+using namespace mozilla::image;
+
+namespace mozilla {
+namespace layers {
+
+void WebRenderBackgroundData::AddWebRenderCommands(
+    wr::DisplayListBuilder& aBuilder) {
+  aBuilder.PushRect(mBounds, mBounds, true, true, false, mColor);
+}
+
+/* static */
+bool WebRenderUserData::SupportsAsyncUpdate(nsIFrame* aFrame) {
+  if (!aFrame) {
+    return false;
+  }
+  RefPtr<WebRenderImageData> data = GetWebRenderUserData<WebRenderImageData>(
+      aFrame, static_cast<uint32_t>(DisplayItemType::TYPE_VIDEO));
+  if (data) {
+    return data->IsAsync();
+  }
+
+  return false;
+}
+
+/* static */
+bool WebRenderUserData::ProcessInvalidateForImage(nsIFrame* aFrame,
+                                                  DisplayItemType aType,
+                                                  ImageProviderId aProviderId) {
+  MOZ_ASSERT(aFrame);
+
+  if (!aFrame->HasProperty(WebRenderUserDataProperty::Key())) {
+    aFrame->SchedulePaint();
+    return false;
+  }
+
+  auto type = static_cast<uint32_t>(aType);
+  RefPtr<WebRenderFallbackData> fallback =
+      GetWebRenderUserData<WebRenderFallbackData>(aFrame, type);
+  if (fallback) {
+    fallback->SetInvalid(true);
+    aFrame->SchedulePaint();
+    return true;
+  }
+
+  RefPtr<WebRenderImageProviderData> image =
+      GetWebRenderUserData<WebRenderImageProviderData>(aFrame, type);
+  if (image && image->Invalidate(aProviderId)) {
+    return true;
+  }
+
+  aFrame->SchedulePaint();
+  return false;
+}
+
+WebRenderUserData::WebRenderUserData(RenderRootStateManager* aManager,
+                                     uint32_t aDisplayItemKey, nsIFrame* aFrame)
+    : mManager(aManager),
+      mFrame(aFrame),
+      mDisplayItemKey(aDisplayItemKey),
+      mTable(aManager->GetWebRenderUserDataTable()),
+      mUsed(false) {}
+
+WebRenderUserData::WebRenderUserData(RenderRootStateManager* aManager,
+                                     nsDisplayItem* aItem)
+    : mManager(aManager),
+      mFrame(aItem->Frame()),
+      mDisplayItemKey(aItem->GetPerFrameKey()),
+      mTable(aManager->GetWebRenderUserDataTable()),
+      mUsed(false) {}
+
+WebRenderUserData::~WebRenderUserData() = default;
+
+void WebRenderUserData::RemoveFromTable() { mTable->Remove(this); }
+
+WebRenderBridgeChild* WebRenderUserData::WrBridge() const {
+  return mManager->WrBridge();
+}
+
+WebRenderImageData::WebRenderImageData(RenderRootStateManager* aManager,
+                                       nsDisplayItem* aItem)
+    : WebRenderUserData(aManager, aItem) {}
+
+WebRenderImageData::WebRenderImageData(RenderRootStateManager* aManager,
+                                       uint32_t aDisplayItemKey,
+                                       nsIFrame* aFrame)
+    : WebRenderUserData(aManager, aDisplayItemKey, aFrame) {}
+
+WebRenderImageData::~WebRenderImageData() {
+  ClearImageKey();
+
+  if (mPipelineId) {
+    mManager->RemovePipelineIdForCompositable(mPipelineId.ref());
+  }
+}
+
+void WebRenderImageData::ClearImageKey() {
+  if (mKey) {
+    mManager->AddImageKeyForDiscard(mKey.value());
+    if (mTextureOfImage) {
+      WrBridge()->ReleaseTextureOfImage(mKey.value());
+      mTextureOfImage = nullptr;
+    }
+    mKey.reset();
+  }
+  MOZ_ASSERT(!mTextureOfImage);
+}
+
+Maybe<wr::ImageKey> WebRenderImageData::UpdateImageKey(
+    ImageContainer* aContainer, wr::IpcResourceUpdateQueue& aResources,
+    bool aFallback) {
+  MOZ_ASSERT(aContainer);
+
+  if (mContainer != aContainer) {
+    mContainer = aContainer;
+  }
+
+  CreateImageClientIfNeeded();
+  if (!mImageClient) {
+    return Nothing();
+  }
+
+  MOZ_ASSERT(mImageClient->AsImageClientSingle());
+
+  ImageClientSingle* imageClient = mImageClient->AsImageClientSingle();
+  uint32_t oldCounter = imageClient->GetLastUpdateGenerationCounter();
+
+  bool ret = imageClient->UpdateImage(aContainer);
+  RefPtr<TextureClient> currentTexture = imageClient->GetForwardedTexture();
+  if (!ret || !currentTexture) {
+    // Delete old key
+    ClearImageKey();
+    return Nothing();
+  }
+
+  // Reuse old key if generation is not updated.
+  if (!aFallback &&
+      oldCounter == imageClient->GetLastUpdateGenerationCounter() && mKey) {
+    return mKey;
+  }
+
+  // If we already had a texture and the format hasn't changed, better to reuse
+  // the image keys than create new ones.
+  bool useUpdate = mKey.isSome() && !!mTextureOfImage && !!currentTexture &&
+                   mTextureOfImage->GetSize() == currentTexture->GetSize() &&
+                   mTextureOfImage->GetFormat() == currentTexture->GetFormat();
+
+  wr::MaybeExternalImageId extId = currentTexture->GetExternalImageKey();
+  MOZ_RELEASE_ASSERT(extId.isSome());
+
+  if (useUpdate) {
+    MOZ_ASSERT(mKey.isSome());
+    MOZ_ASSERT(mTextureOfImage);
+    aResources.PushExternalImageForTexture(
+        extId.ref(), mKey.ref(), currentTexture, /* aIsUpdate */ true);
+  } else {
+    ClearImageKey();
+    wr::WrImageKey key = WrBridge()->GetNextImageKey();
+    aResources.PushExternalImageForTexture(extId.ref(), key, currentTexture,
+                                           /* aIsUpdate */ false);
+    mKey = Some(key);
+  }
+
+  mTextureOfImage = currentTexture;
+  return mKey;
+}
+
+already_AddRefed<ImageClient> WebRenderImageData::GetImageClient() {
+  RefPtr<ImageClient> imageClient = mImageClient;
+  return imageClient.forget();
+}
+
+void WebRenderImageData::CreateAsyncImageWebRenderCommands(
+    mozilla::wr::DisplayListBuilder& aBuilder, ImageContainer* aContainer,
+    const StackingContextHelper& aSc, const LayoutDeviceRect& aBounds,
+    const LayoutDeviceRect& aSCBounds, VideoInfo::Rotation aRotation,
+    const wr::ImageRendering& aFilter, const wr::MixBlendMode& aMixBlendMode,
+    bool aIsBackfaceVisible) {
+  MOZ_ASSERT(aContainer->IsAsync());
+
+  if (mPipelineId.isSome() && mContainer != aContainer) {
+    // In this case, we need to remove the existed pipeline and create new one
+    // because the ImageContainer is changed.
+    WrBridge()->RemovePipelineIdForCompositable(mPipelineId.ref());
+    mPipelineId.reset();
+  }
+
+  if (!mPipelineId) {
+    // Alloc async image pipeline id.
+    mPipelineId =
+        Some(WrBridge()->GetCompositorBridgeChild()->GetNextPipelineId());
+    WrBridge()->AddPipelineIdForCompositable(
+        mPipelineId.ref(), aContainer->GetAsyncContainerHandle(),
+        CompositableHandleOwner::ImageBridge);
+    mContainer = aContainer;
+  }
+  MOZ_ASSERT(!mImageClient);
+
+  // Push IFrame for async image pipeline.
+  //
+  // We don't push a stacking context for this async image pipeline here.
+  // Instead, we do it inside the iframe that hosts the image. As a result,
+  // a bunch of the calculations normally done as part of that stacking
+  // context need to be done manually and pushed over to the parent side,
+  // where it will be done when we build the display list for the iframe.
+  // That happens in AsyncImagePipelineManager.
+  aBuilder.PushIFrame(aBounds, aIsBackfaceVisible, mPipelineId.ref(),
+                      /*ignoreMissingPipelines*/ false);
+
+  WrBridge()->AddWebRenderParentCommand(OpUpdateAsyncImagePipeline(
+      mPipelineId.value(), aSCBounds, aRotation, aFilter, aMixBlendMode));
+}
+
+void WebRenderImageData::CreateImageClientIfNeeded() {
+  if (!mImageClient) {
+    mImageClient = ImageClient::CreateImageClient(
+        CompositableType::IMAGE, WrBridge(), TextureFlags::DEFAULT);
+    if (!mImageClient) {
+      return;
+    }
+
+    mImageClient->Connect();
+  }
+}
+
+WebRenderImageProviderData::WebRenderImageProviderData(
+    RenderRootStateManager* aManager, nsDisplayItem* aItem)
+    : WebRenderUserData(aManager, aItem) {}
+
+WebRenderImageProviderData::WebRenderImageProviderData(
+    RenderRootStateManager* aManager, uint32_t aDisplayItemKey,
+    nsIFrame* aFrame)
+    : WebRenderUserData(aManager, aDisplayItemKey, aFrame) {}
+
+WebRenderImageProviderData::~WebRenderImageProviderData() = default;
+
+Maybe<wr::ImageKey> WebRenderImageProviderData::UpdateImageKey(
+    WebRenderImageProvider* aProvider, ImgDrawResult aDrawResult,
+    wr::IpcResourceUpdateQueue& aResources) {
+  if (mProvider != aProvider) {
+    mProvider = aProvider;
+  }
+
+  wr::ImageKey key = {};
+  nsresult rv = mProvider ? mProvider->UpdateKey(mManager, aResources, key)
+                          : NS_ERROR_FAILURE;
+  mKey = NS_SUCCEEDED(rv) ? Some(key) : Nothing();
+  mDrawResult = aDrawResult;
+  return mKey;
+}
+
+bool WebRenderImageProviderData::Invalidate(ImageProviderId aProviderId) const {
+  if (!aProviderId || !mProvider || mProvider->GetProviderId() != aProviderId ||
+      !mKey) {
+    return false;
+  }
+
+  if (mDrawResult != ImgDrawResult::SUCCESS &&
+      mDrawResult != ImgDrawResult::BAD_IMAGE) {
+    return false;
+  }
+
+  wr::ImageKey key = {};
+  nsresult rv =
+      mProvider->UpdateKey(mManager, mManager->AsyncResourceUpdates(), key);
+  return NS_SUCCEEDED(rv) && mKey.ref() == key;
+}
+
+WebRenderFallbackData::WebRenderFallbackData(RenderRootStateManager* aManager,
+                                             nsDisplayItem* aItem)
+    : WebRenderUserData(aManager, aItem), mOpacity(1.0f), mInvalid(false) {}
+
+WebRenderFallbackData::~WebRenderFallbackData() { ClearImageKey(); }
+
+void WebRenderFallbackData::SetBlobImageKey(const wr::BlobImageKey& aKey) {
+  ClearImageKey();
+  mBlobKey = Some(aKey);
+}
+
+Maybe<wr::ImageKey> WebRenderFallbackData::GetImageKey() {
+  if (mBlobKey) {
+    return Some(wr::AsImageKey(mBlobKey.value()));
+  }
+
+  if (mImageData) {
+    return mImageData->GetImageKey();
+  }
+
+  return Nothing();
+}
+
+void WebRenderFallbackData::ClearImageKey() {
+  if (mImageData) {
+    mImageData->ClearImageKey();
+    mImageData = nullptr;
+  }
+
+  if (mBlobKey) {
+    mManager->AddBlobImageKeyForDiscard(mBlobKey.value());
+    mBlobKey.reset();
+  }
+}
+
+WebRenderImageData* WebRenderFallbackData::PaintIntoImage() {
+  if (mBlobKey) {
+    mManager->AddBlobImageKeyForDiscard(mBlobKey.value());
+    mBlobKey.reset();
+  }
+
+  if (mImageData) {
+    return mImageData.get();
+  }
+
+  mImageData = MakeAndAddRef<WebRenderImageData>(mManager.get(),
+                                                 mDisplayItemKey, mFrame);
+
+  return mImageData.get();
+}
+
+WebRenderAPZAnimationData::WebRenderAPZAnimationData(
+    RenderRootStateManager* aManager, nsDisplayItem* aItem)
+    : WebRenderUserData(aManager, aItem),
+      mAnimationId(AnimationHelper::GetNextCompositorAnimationsId()) {}
+
+WebRenderAnimationData::WebRenderAnimationData(RenderRootStateManager* aManager,
+                                               nsDisplayItem* aItem)
+    : WebRenderUserData(aManager, aItem) {}
+
+WebRenderAnimationData::~WebRenderAnimationData() {
+  // It may be the case that nsDisplayItem that created this WebRenderUserData
+  // gets destroyed without getting a chance to discard the compositor animation
+  // id, so we should do it as part of cleanup here.
+  uint64_t animationId = mAnimationInfo.GetCompositorAnimationsId();
+  // animationId might be 0 if mAnimationInfo never held any active animations.
+  if (animationId) {
+    mManager->AddCompositorAnimationsIdForDiscard(animationId);
+  }
+}
+
+WebRenderCanvasData::WebRenderCanvasData(RenderRootStateManager* aManager,
+                                         nsDisplayItem* aItem)
+    : WebRenderUserData(aManager, aItem) {}
+
+WebRenderCanvasData::~WebRenderCanvasData() {
+  if (mCanvasRenderer) {
+    mCanvasRenderer->ClearCachedResources();
+  }
+}
+
+void WebRenderCanvasData::ClearCanvasRenderer() { mCanvasRenderer = nullptr; }
+
+WebRenderCanvasRendererAsync* WebRenderCanvasData::GetCanvasRenderer() {
+  return mCanvasRenderer.get();
+}
+
+WebRenderCanvasRendererAsync* WebRenderCanvasData::CreateCanvasRenderer() {
+  mCanvasRenderer = new WebRenderCanvasRendererAsync(mManager);
+  return mCanvasRenderer.get();
+}
+
+bool WebRenderCanvasData::SetCanvasRenderer(CanvasRenderer* aCanvasRenderer) {
+  if (!aCanvasRenderer || !aCanvasRenderer->AsWebRenderCanvasRendererAsync()) {
+    return false;
+  }
+
+  auto* renderer = aCanvasRenderer->AsWebRenderCanvasRendererAsync();
+  if (mManager != renderer->GetRenderRootStateManager()) {
+    return false;
+  }
+
+  mCanvasRenderer = renderer;
+  return true;
+}
+
+void WebRenderCanvasData::SetImageContainer(ImageContainer* aImageContainer) {
+  mContainer = aImageContainer;
+}
+
+ImageContainer* WebRenderCanvasData::GetImageContainer() {
+  if (!mContainer) {
+    mContainer = MakeAndAddRef<ImageContainer>();
+  }
+  return mContainer;
+}
+
+void WebRenderCanvasData::ClearImageContainer() { mContainer = nullptr; }
+
+WebRenderRemoteData::WebRenderRemoteData(RenderRootStateManager* aManager,
+                                         nsDisplayItem* aItem)
+    : WebRenderUserData(aManager, aItem) {}
+
+WebRenderRemoteData::~WebRenderRemoteData() {
+  if (mRemoteBrowser) {
+    mRemoteBrowser->UpdateEffects(mozilla::dom::EffectsInfo::FullyHidden());
+  }
+}
+
+void DestroyWebRenderUserDataTable(WebRenderUserDataTable* aTable) {
+  for (const auto& value : aTable->Values()) {
+    value->RemoveFromTable();
+  }
+  delete aTable;
+}
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/gfx/layers/wr/WebRenderUserData.h b/gfx/layers/wr/WebRenderUserData.h
new file mode 100644
index 0000000000..c8b6b33002
--- /dev/null
+++ b/gfx/layers/wr/WebRenderUserData.h
@@ -0,0 +1,385 @@
+/* -*- 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_WEBRENDERUSERDATA_H
+#define GFX_WEBRENDERUSERDATA_H
+
+#include <vector>
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/image/WebRenderImageProvider.h"
+#include "mozilla/layers/AnimationInfo.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/dom/RemoteBrowser.h"
+#include "mozilla/UniquePtr.h"
+#include "nsIFrame.h"
+#include "nsRefPtrHashtable.h"
+#include "nsTHashSet.h"
+#include "ImageTypes.h"
+#include "ImgDrawResult.h"
+#include "DisplayItemClip.h"
+
+namespace mozilla {
+
+class nsDisplayItemGeometry;
+
+namespace webgpu {
+class WebGPUChild;
+}
+
+namespace wr {
+class IpcResourceUpdateQueue;
+}
+
+namespace gfx {
+class SourceSurface;
+}
+
+namespace layers {
+
+class BasicLayerManager;
+class CanvasRenderer;
+class ImageClient;
+class ImageContainer;
+class WebRenderBridgeChild;
+class WebRenderCanvasData;
+class WebRenderCanvasRenderer;
+class WebRenderCanvasRendererAsync;
+class WebRenderImageData;
+class WebRenderImageProviderData;
+class WebRenderFallbackData;
+class RenderRootStateManager;
+class WebRenderGroupData;
+
+class WebRenderBackgroundData {
+ public:
+  WebRenderBackgroundData(wr::LayoutRect aBounds, wr::ColorF aColor)
+      : mBounds(aBounds), mColor(aColor) {}
+  void AddWebRenderCommands(wr::DisplayListBuilder& aBuilder);
+
+ protected:
+  wr::LayoutRect mBounds;
+  wr::ColorF mColor;
+};
+
+/// Parent class for arbitrary WebRender-specific data that can be associated
+/// to an nsFrame.
+class WebRenderUserData {
+ public:
+  typedef nsTHashSet<RefPtr<WebRenderUserData>> WebRenderUserDataRefTable;
+
+  static bool SupportsAsyncUpdate(nsIFrame* aFrame);
+
+  static bool ProcessInvalidateForImage(nsIFrame* aFrame, DisplayItemType aType,
+                                        image::ImageProviderId aProviderId);
+
+  NS_INLINE_DECL_REFCOUNTING(WebRenderUserData)
+
+  WebRenderUserData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+  WebRenderUserData(RenderRootStateManager* aManager, uint32_t mDisplayItemKey,
+                    nsIFrame* aFrame);
+
+  virtual WebRenderImageData* AsImageData() { return nullptr; }
+  virtual WebRenderImageProviderData* AsImageProviderData() { return nullptr; }
+  virtual WebRenderFallbackData* AsFallbackData() { return nullptr; }
+  virtual WebRenderCanvasData* AsCanvasData() { return nullptr; }
+  virtual WebRenderGroupData* AsGroupData() { return nullptr; }
+
+  enum class UserDataType {
+    eImage,
+    eFallback,
+    eAPZAnimation,
+    eAnimation,
+    eCanvas,
+    eRemote,
+    eGroup,
+    eMask,
+    eImageProvider,  // ImageLib
+    eInProcessImage,
+  };
+
+  virtual UserDataType GetType() = 0;
+  bool IsUsed() { return mUsed; }
+  void SetUsed(bool aUsed) { mUsed = aUsed; }
+  nsIFrame* GetFrame() { return mFrame; }
+  uint32_t GetDisplayItemKey() { return mDisplayItemKey; }
+  void RemoveFromTable();
+  virtual nsDisplayItemGeometry* GetGeometry() { return nullptr; }
+
+ protected:
+  virtual ~WebRenderUserData();
+
+  WebRenderBridgeChild* WrBridge() const;
+
+  RefPtr<RenderRootStateManager> mManager;
+  nsIFrame* mFrame;
+  uint32_t mDisplayItemKey;
+  WebRenderUserDataRefTable* mTable;
+  bool mUsed;
+};
+
+struct WebRenderUserDataKey {
+  WebRenderUserDataKey(uint32_t aFrameKey,
+                       WebRenderUserData::UserDataType aType)
+      : mFrameKey(aFrameKey), mType(aType) {}
+
+  bool operator==(const WebRenderUserDataKey& other) const {
+    return mFrameKey == other.mFrameKey && mType == other.mType;
+  }
+  PLDHashNumber Hash() const {
+    return HashGeneric(
+        mFrameKey,
+        static_cast<std::underlying_type<decltype(mType)>::type>(mType));
+  }
+
+  uint32_t mFrameKey;
+  WebRenderUserData::UserDataType mType;
+};
+
+typedef nsRefPtrHashtable<
+    nsGenericHashKey<mozilla::layers::WebRenderUserDataKey>, WebRenderUserData>
+    WebRenderUserDataTable;
+
+/// Holds some data used to share TextureClient/ImageClient with the parent
+/// process.
+class WebRenderImageData : public WebRenderUserData {
+ public:
+  WebRenderImageData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+  WebRenderImageData(RenderRootStateManager* aManager, uint32_t aDisplayItemKey,
+                     nsIFrame* aFrame);
+  virtual ~WebRenderImageData();
+
+  WebRenderImageData* AsImageData() override { return this; }
+  UserDataType GetType() override { return UserDataType::eImage; }
+  static UserDataType Type() { return UserDataType::eImage; }
+  Maybe<wr::ImageKey> GetImageKey() { return mKey; }
+  void SetImageKey(const wr::ImageKey& aKey);
+  already_AddRefed<ImageClient> GetImageClient();
+
+  Maybe<wr::ImageKey> UpdateImageKey(ImageContainer* aContainer,
+                                     wr::IpcResourceUpdateQueue& aResources,
+                                     bool aFallback = false);
+
+  void CreateAsyncImageWebRenderCommands(
+      mozilla::wr::DisplayListBuilder& aBuilder, ImageContainer* aContainer,
+      const StackingContextHelper& aSc, const LayoutDeviceRect& aBounds,
+      const LayoutDeviceRect& aSCBounds, VideoInfo::Rotation aRotation,
+      const wr::ImageRendering& aFilter, const wr::MixBlendMode& aMixBlendMode,
+      bool aIsBackfaceVisible);
+
+  void CreateImageClientIfNeeded();
+
+  bool IsAsync() { return mPipelineId.isSome(); }
+
+  void ClearImageKey();
+
+ protected:
+  Maybe<wr::ImageKey> mKey;
+  RefPtr<TextureClient> mTextureOfImage;
+  RefPtr<ImageClient> mImageClient;
+  Maybe<wr::PipelineId> mPipelineId;
+  RefPtr<ImageContainer> mContainer;
+};
+
+/// Holds some data used to share ImageLib results with the parent process.
+/// This may be either in the form of a blob recording or a rasterized surface.
+class WebRenderImageProviderData final : public WebRenderUserData {
+ public:
+  WebRenderImageProviderData(RenderRootStateManager* aManager,
+                             nsDisplayItem* aItem);
+  WebRenderImageProviderData(RenderRootStateManager* aManager,
+                             uint32_t aDisplayItemKey, nsIFrame* aFrame);
+  ~WebRenderImageProviderData() override;
+
+  WebRenderImageProviderData* AsImageProviderData() override { return this; }
+  UserDataType GetType() override { return UserDataType::eImageProvider; }
+  static UserDataType Type() { return UserDataType::eImageProvider; }
+
+  Maybe<wr::ImageKey> UpdateImageKey(image::WebRenderImageProvider* aProvider,
+                                     image::ImgDrawResult aDrawResult,
+                                     wr::IpcResourceUpdateQueue& aResources);
+
+  bool Invalidate(image::ImageProviderId aProviderId) const;
+
+ protected:
+  RefPtr<image::WebRenderImageProvider> mProvider;
+  Maybe<wr::ImageKey> mKey;
+  image::ImgDrawResult mDrawResult = image::ImgDrawResult::NOT_READY;
+};
+
+/// Used for fallback rendering.
+///
+/// In most cases this uses blob images but it can also render on the content
+/// side directly into a texture.
+class WebRenderFallbackData : public WebRenderUserData {
+ public:
+  WebRenderFallbackData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+  virtual ~WebRenderFallbackData();
+
+  WebRenderFallbackData* AsFallbackData() override { return this; }
+  UserDataType GetType() override { return UserDataType::eFallback; }
+  static UserDataType Type() { return UserDataType::eFallback; }
+  nsDisplayItemGeometry* GetGeometry() override { return mGeometry.get(); }
+
+  void SetInvalid(bool aInvalid) { mInvalid = aInvalid; }
+  bool IsInvalid() { return mInvalid; }
+  void SetFonts(const std::vector<RefPtr<gfx::ScaledFont>>& aFonts) {
+    mFonts = aFonts;
+  }
+  Maybe<wr::BlobImageKey> GetBlobImageKey() { return mBlobKey; }
+  void SetBlobImageKey(const wr::BlobImageKey& aKey);
+  Maybe<wr::ImageKey> GetImageKey();
+
+  /// Create a WebRenderImageData to manage the image we are about to render
+  /// into.
+  WebRenderImageData* PaintIntoImage();
+
+  std::vector<RefPtr<gfx::SourceSurface>> mExternalSurfaces;
+  UniquePtr<nsDisplayItemGeometry> mGeometry;
+  DisplayItemClip mClip;
+  nsRect mBounds;
+  nsRect mBuildingRect;
+  gfx::MatrixScales mScale;
+  float mOpacity;
+
+ protected:
+  void ClearImageKey();
+
+  std::vector<RefPtr<gfx::ScaledFont>> mFonts;
+  Maybe<wr::BlobImageKey> mBlobKey;
+  // When rendering into a blob image, mImageData is null. It is non-null only
+  // when we render directly into a texture on the content side.
+  RefPtr<WebRenderImageData> mImageData;
+  bool mInvalid;
+};
+
+class WebRenderAPZAnimationData : public WebRenderUserData {
+ public:
+  WebRenderAPZAnimationData(RenderRootStateManager* aManager,
+                            nsDisplayItem* aItem);
+  virtual ~WebRenderAPZAnimationData() = default;
+
+  UserDataType GetType() override { return UserDataType::eAPZAnimation; }
+  static UserDataType Type() { return UserDataType::eAPZAnimation; }
+  uint64_t GetAnimationId() { return mAnimationId; }
+
+ private:
+  uint64_t mAnimationId;
+};
+
+class WebRenderAnimationData : public WebRenderUserData {
+ public:
+  WebRenderAnimationData(RenderRootStateManager* aManager,
+                         nsDisplayItem* aItem);
+  virtual ~WebRenderAnimationData();
+
+  UserDataType GetType() override { return UserDataType::eAnimation; }
+  static UserDataType Type() { return UserDataType::eAnimation; }
+  AnimationInfo& GetAnimationInfo() { return mAnimationInfo; }
+
+ protected:
+  AnimationInfo mAnimationInfo;
+};
+
+class WebRenderCanvasData : public WebRenderUserData {
+ public:
+  WebRenderCanvasData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+  virtual ~WebRenderCanvasData();
+
+  WebRenderCanvasData* AsCanvasData() override { return this; }
+  UserDataType GetType() override { return UserDataType::eCanvas; }
+  static UserDataType Type() { return UserDataType::eCanvas; }
+
+  void ClearCanvasRenderer();
+  WebRenderCanvasRendererAsync* GetCanvasRenderer();
+  WebRenderCanvasRendererAsync* CreateCanvasRenderer();
+  bool SetCanvasRenderer(CanvasRenderer* aCanvasRenderer);
+
+  void SetImageContainer(ImageContainer* aImageContainer);
+  ImageContainer* GetImageContainer();
+  void ClearImageContainer();
+
+ protected:
+  RefPtr<WebRenderCanvasRendererAsync> mCanvasRenderer;
+  RefPtr<ImageContainer> mContainer;
+};
+
+class WebRenderRemoteData : public WebRenderUserData {
+ public:
+  WebRenderRemoteData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+  virtual ~WebRenderRemoteData();
+
+  UserDataType GetType() override { return UserDataType::eRemote; }
+  static UserDataType Type() { return UserDataType::eRemote; }
+
+  void SetRemoteBrowser(dom::RemoteBrowser* aBrowser) {
+    mRemoteBrowser = aBrowser;
+  }
+
+ protected:
+  RefPtr<dom::RemoteBrowser> mRemoteBrowser;
+};
+
+class WebRenderMaskData : public WebRenderUserData {
+ public:
+  explicit WebRenderMaskData(RenderRootStateManager* aManager,
+                             nsDisplayItem* aItem)
+      : WebRenderUserData(aManager, aItem),
+        mMaskStyle(nsStyleImageLayers::LayerType::Mask),
+        mShouldHandleOpacity(false) {
+    MOZ_COUNT_CTOR(WebRenderMaskData);
+  }
+  virtual ~WebRenderMaskData() {
+    MOZ_COUNT_DTOR(WebRenderMaskData);
+    ClearImageKey();
+  }
+
+  void ClearImageKey();
+  void Invalidate();
+
+  UserDataType GetType() override { return UserDataType::eMask; }
+  static UserDataType Type() { return UserDataType::eMask; }
+
+  Maybe<wr::BlobImageKey> mBlobKey;
+  std::vector<RefPtr<gfx::ScaledFont>> mFonts;
+  std::vector<RefPtr<gfx::SourceSurface>> mExternalSurfaces;
+  LayerIntRect mItemRect;
+  nsPoint mMaskOffset;
+  nsStyleImageLayers mMaskStyle;
+  gfx::MatrixScales mScale;
+  bool mShouldHandleOpacity;
+};
+
+extern void DestroyWebRenderUserDataTable(WebRenderUserDataTable* aTable);
+
+struct WebRenderUserDataProperty {
+  NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(Key, WebRenderUserDataTable,
+                                      DestroyWebRenderUserDataTable)
+};
+
+template <class T>
+already_AddRefed<T> GetWebRenderUserData(const nsIFrame* aFrame,
+                                         uint32_t aPerFrameKey) {
+  MOZ_ASSERT(aFrame);
+  WebRenderUserDataTable* userDataTable =
+      aFrame->GetProperty(WebRenderUserDataProperty::Key());
+  if (!userDataTable) {
+    return nullptr;
+  }
+
+  WebRenderUserData* data =
+      userDataTable->GetWeak(WebRenderUserDataKey(aPerFrameKey, T::Type()));
+  if (data) {
+    RefPtr<T> result = static_cast<T*>(data);
+    return result.forget();
+  }
+
+  return nullptr;
+}
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif /* GFX_WEBRENDERUSERDATA_H */