--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -327,43 +327,16 @@ static bool GenerateAndPushTextMask(nsIF
 
   RefPtr<SourceSurface> maskSurface = maskDT->Snapshot();
   sourceCtx->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, 1.0,
                                    maskSurface, invCurrentMatrix);
 
   return true;
 }
 
-/* static */
-void nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(
-    Layer* aLayer, nsDisplayListBuilder* aBuilder, nsDisplayItem* aItem,
-    nsIFrame* aFrame, DisplayItemType aType) {
-  // This function can be called in two ways:  from
-  // nsDisplay*::BuildLayer while constructing a layer (with all
-  // pointers non-null), or from RestyleManager's handling of
-  // UpdateOpacityLayer/UpdateTransformLayer hints.
-  MOZ_ASSERT(!aBuilder == !aItem,
-             "should only be called in two configurations, with both "
-             "aBuilder and aItem, or with neither");
-  MOZ_ASSERT(!aItem || aFrame == aItem->Frame(), "frame mismatch");
-
-  // Only send animations to a layer that is actually using
-  // off-main-thread compositing.
-  LayersBackend backend = aLayer->Manager()->GetBackendType();
-  if (!(backend == LayersBackend::LAYERS_CLIENT ||
-        backend == LayersBackend::LAYERS_WR)) {
-    return;
-  }
-
-  AnimationInfo& animationInfo = aLayer->GetAnimationInfo();
-  animationInfo.AddAnimationsForDisplayItem(aFrame, aBuilder, aItem, aType,
-                                            aLayer->Manager());
-  animationInfo.TransferMutatedFlagToLayer(aLayer);
-}
-
 nsDisplayWrapList* nsDisplayListBuilder::MergeItems(
     nsTArray<nsDisplayWrapList*>& aItems) {
   // For merging, we create a temporary item by cloning the last item of the
   // mergeable items list. This ensures that the temporary item will have the
   // correct frame and bounds.
   nsDisplayWrapList* merged = nullptr;
 
   for (nsDisplayWrapList* item : Reversed(aItems)) {
@@ -2323,19 +2296,19 @@ void nsDisplayList::Paint(nsDisplayListB
   }
 }
 
 /**
  * We paint by executing a layer manager transaction, constructing a
  * single layer representing the display list, and then making it the
  * root of the layer manager, drawing into the PaintedLayers.
  */
-already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
-    nsDisplayListBuilder* aBuilder, gfxContext* aCtx, uint32_t aFlags,
-    Maybe<double> aDisplayListBuildTime) {
+void nsDisplayList::PaintRoot(nsDisplayListBuilder* aBuilder, gfxContext* aCtx,
+                              uint32_t aFlags,
+                              Maybe<double> aDisplayListBuildTime) {
   AUTO_PROFILER_LABEL("nsDisplayList::PaintRoot", GRAPHICS);
 
   RefPtr<WebRenderLayerManager> layerManager;
   WindowRenderer* renderer = nullptr;
   bool widgetTransaction = false;
   bool doBeginTransaction = true;
   nsView* view = nullptr;
   if (aFlags & PAINT_USE_WIDGET_LAYERS) {
@@ -2357,39 +2330,39 @@ already_AddRefed<LayerManager> nsDisplay
   nsIFrame* frame = aBuilder->RootReferenceFrame();
   nsPresContext* presContext = frame->PresContext();
   PresShell* presShell = presContext->PresShell();
   Document* document = presShell->GetDocument();
 
   if (!renderer) {
     if (!aCtx) {
       NS_WARNING("Nowhere to paint into");
-      return nullptr;
+      return;
     }
     bool prevIsCompositingCheap = aBuilder->SetIsCompositingCheap(false);
     Paint(aBuilder, aCtx, presContext->AppUnitsPerDevPixel());
 
     if (document && document->IsBeingUsedAsImage()) {
       frame->ClearInvalidationStateBits();
     }
 
     aBuilder->SetIsCompositingCheap(prevIsCompositingCheap);
-    return nullptr;
+    return;
   }
 
   if (renderer->GetBackendType() == LayersBackend::LAYERS_WR) {
     MOZ_ASSERT(layerManager);
     if (doBeginTransaction) {
       if (aCtx) {
         if (!layerManager->BeginTransactionWithTarget(aCtx, nsCString())) {
-          return nullptr;
+          return;
         }
       } else {
         if (!layerManager->BeginTransaction(nsCString())) {
-          return nullptr;
+          return;
         }
       }
     }
 
     bool prevIsCompositingCheap = aBuilder->SetIsCompositingCheap(true);
     layerManager->SetTransactionIdAllocator(presContext->RefreshDriver());
 
     bool sent = false;
@@ -2431,26 +2404,26 @@ already_AddRefed<LayerManager> nsDisplay
                                layerManager->GetAnimationReadyTime());
     }
 
     if (presContext->RefreshDriver()->HasScheduleFlush()) {
       presContext->NotifyInvalidation(layerManager->GetLastTransactionId(),
                                       frame->GetRect());
     }
 
-    return layerManager.forget();
+    return;
   }
 
   FallbackRenderer* fallback = renderer->AsFallback();
   MOZ_ASSERT(fallback);
 
   if (doBeginTransaction) {
     MOZ_ASSERT(!aCtx);
     if (!fallback->BeginTransaction()) {
-      return nullptr;
+      return;
     }
   }
 
   bool temp = aBuilder->SetIsCompositingCheap(renderer->IsCompositingCheap());
   LayerManager::EndTransactionFlags flags = LayerManager::END_DEFAULT;
   if (renderer->NeedsWidgetInvalidation() && (aFlags & PAINT_NO_COMPOSITE)) {
     flags = LayerManager::END_NO_COMPOSITE;
   }
@@ -2477,17 +2450,17 @@ already_AddRefed<LayerManager> nsDisplay
     if (shouldInvalidate) {
       // If we're the fallback renderer, then we don't need to invalidate
       // as we've just drawn directly to the window and don't need to do
       // anything else.
       NS_ASSERTION(!(aFlags & PAINT_NO_COMPOSITE),
                    "Must be compositing during fallback");
     }
   }
-  return nullptr;
+  return;
 }
 
 nsDisplayItem* nsDisplayList::RemoveBottom() {
   nsDisplayItem* item = mSentinel.mAbove;
   if (!item) {
     return nullptr;
   }
   mSentinel.mAbove = item->mAbove;
@@ -6169,17 +6142,17 @@ nsDisplayScrollInfoLayer::nsDisplayScrol
       mHitInfo(aHitInfo),
       mHitArea(aHitArea) {
 #ifdef NS_BUILD_REFCNT_LOGGING
   MOZ_COUNT_CTOR(nsDisplayScrollInfoLayer);
 #endif
 }
 
 UniquePtr<ScrollMetadata> nsDisplayScrollInfoLayer::ComputeScrollMetadata(
-    nsDisplayListBuilder* aBuilder, LayerManager* aLayerManager) {
+    nsDisplayListBuilder* aBuilder, WebRenderLayerManager* aLayerManager) {
   ScrollMetadata metadata = nsLayoutUtils::ComputeScrollMetadata(
       mScrolledFrame, mScrollFrame, mScrollFrame->GetContent(),
       ReferenceFrame(), aLayerManager, mScrollParentId, mScrollFrame->GetSize(),
       Nothing(), false);
   metadata.GetMetrics().SetIsScrollInfoLayer(true);
   nsIScrollableFrame* scrollableFrame = mScrollFrame->GetScrollTargetFrame();
   if (scrollableFrame) {
     aBuilder->AddScrollFrameToNotify(scrollableFrame);