Bug 1722258 - Convert more LayerManager usage to use WindowRenderer. r=miko

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

dom/ipc/BrowserBridgeParent.cpp

@@ -141,7 +141,7 @@ void BrowserBridgeParent::Destroy() {
 }
 
 IPCResult BrowserBridgeParent::RecvShow(const OwnerShowInfo& aOwnerInfo) {
-  mBrowserParent->AttachLayerManager();
+  mBrowserParent->AttachWindowRenderer();
   Unused << mBrowserParent->SendShow(mBrowserParent->GetShowInfo(), aOwnerInfo);
   return IPC_OK();
 }

dom/ipc/BrowserChild.cpp

@@ -2672,12 +2672,12 @@ mozilla::ipc::IPCResult BrowserChild::RecvRenderLayers(
     MOZ_ASSERT(mPuppetWidget);
     RefPtr<LayerManager> lm =
         mPuppetWidget->GetWindowRenderer()->AsLayerManager();
-    MOZ_ASSERT(lm);
+    if (lm) {
-
+      // We send the current layer observer epoch to the compositor so that
-    // We send the current layer observer epoch to the compositor so that
+      // BrowserParent knows whether a layer update notification corresponds to
-    // BrowserParent knows whether a layer update notification corresponds to
+      // the latest RecvRenderLayers request that was made.
-    // the latest RecvRenderLayers request that was made.
+      lm->SetLayersObserverEpoch(mLayersObserverEpoch);
-    lm->SetLayersObserverEpoch(mLayersObserverEpoch);
+    }
   }
 
   mRenderLayers = aEnabled;
@@ -2855,8 +2855,9 @@ void BrowserChild::InitRenderingState(
     InitAPZState();
     RefPtr<LayerManager> lm =
         mPuppetWidget->GetWindowRenderer()->AsLayerManager();
-    MOZ_ASSERT(lm);
+    if (lm) {
-    lm->SetLayersObserverEpoch(mLayersObserverEpoch);
+      lm->SetLayersObserverEpoch(mLayersObserverEpoch);
+    }
   } else {
     NS_WARNING("Fallback to BasicLayerManager");
     mLayersConnected = Some(false);
@@ -3154,7 +3155,9 @@ void BrowserChild::DidComposite(mozilla::layers::TransactionId aTransactionId,
       mPuppetWidget->GetWindowRenderer()->AsLayerManager();
   MOZ_ASSERT(lm);
 
-  lm->DidComposite(aTransactionId, aCompositeStart, aCompositeEnd);
+  if (lm) {
+    lm->DidComposite(aTransactionId, aCompositeStart, aCompositeEnd);
+  }
 }
 
 void BrowserChild::DidRequestComposite(const TimeStamp& aCompositeReqStart,
@@ -3185,9 +3188,9 @@ void BrowserChild::ClearCachedResources() {
   MOZ_ASSERT(mPuppetWidget);
   RefPtr<LayerManager> lm =
       mPuppetWidget->GetWindowRenderer()->AsLayerManager();
-  MOZ_ASSERT(lm);
+  if (lm) {
-
+    lm->ClearCachedResources();
-  lm->ClearCachedResources();
+  }
 
   if (nsCOMPtr<Document> document = GetTopLevelDocument()) {
     nsPresContext* presContext = document->GetPresContext();
@@ -3201,9 +3204,9 @@ void BrowserChild::InvalidateLayers() {
   MOZ_ASSERT(mPuppetWidget);
   RefPtr<LayerManager> lm =
       mPuppetWidget->GetWindowRenderer()->AsLayerManager();
-  MOZ_ASSERT(lm);
+  if (lm) {
-
+    FrameLayerBuilder::InvalidateAllLayers(lm);
-  FrameLayerBuilder::InvalidateAllLayers(lm);
+  }
 }
 
 void BrowserChild::SchedulePaint() {
@@ -3259,8 +3262,9 @@ void BrowserChild::ReinitRendering() {
   InitAPZState();
   RefPtr<LayerManager> lm =
       mPuppetWidget->GetWindowRenderer()->AsLayerManager();
-  MOZ_ASSERT(lm);
+  if (lm) {
-  lm->SetLayersObserverEpoch(mLayersObserverEpoch);
+    lm->SetLayersObserverEpoch(mLayersObserverEpoch);
+  }
 
   nsCOMPtr<Document> doc(GetTopLevelDocument());
   doc->NotifyLayerManagerRecreated();
@@ -3271,10 +3275,10 @@ void BrowserChild::ReinitRenderingForDeviceReset() {
 
   RefPtr<LayerManager> lm =
       mPuppetWidget->GetWindowRenderer()->AsLayerManager();
-  if (WebRenderLayerManager* wlm = lm->AsWebRenderLayerManager()) {
+  if (lm && lm->AsWebRenderLayerManager()) {
-    wlm->DoDestroy(/* aIsSync */ true);
+    lm->AsWebRenderLayerManager()->DoDestroy(/* aIsSync */ true);
-  } else if (ClientLayerManager* clm = lm->AsClientLayerManager()) {
+  } else if (lm && lm->AsClientLayerManager()) {
-    if (ShadowLayerForwarder* fwd = clm->AsShadowForwarder()) {
+    if (ShadowLayerForwarder* fwd = lm->AsShadowForwarder()) {
       // Force the LayerTransactionChild to synchronously shutdown. It is
       // okay to do this early, we'll simply stop sending messages. This
       // step is necessary since otherwise the compositor will think we
@@ -3312,8 +3316,9 @@ void BrowserChild::NotifyJankedAnimations(
   MOZ_ASSERT(mPuppetWidget);
   RefPtr<LayerManager> lm =
       mPuppetWidget->GetWindowRenderer()->AsLayerManager();
-  MOZ_ASSERT(lm);
+  if (lm) {
-  lm->UpdatePartialPrerenderedAnimations(aJankedAnimations);
+    lm->UpdatePartialPrerenderedAnimations(aJankedAnimations);
+  }
 }
 
 mozilla::ipc::IPCResult BrowserChild::RecvRequestNotifyAfterRemotePaint() {

dom/ipc/BrowserParent.cpp

@@ -912,8 +912,8 @@ void BrowserParent::InitRendering() {
 #endif
 }
 
-bool BrowserParent::AttachLayerManager() {
+bool BrowserParent::AttachWindowRenderer() {
-  return !!mRemoteLayerTreeOwner.AttachLayerManager();
+  return mRemoteLayerTreeOwner.AttachWindowRenderer();
 }
 
 void BrowserParent::MaybeShowFrame() {
@@ -931,7 +931,7 @@ bool BrowserParent::Show(const OwnerShowInfo& aOwnerInfo) {
   }
 
   MOZ_ASSERT(mRemoteLayerTreeOwner.IsInitialized());
-  if (!mRemoteLayerTreeOwner.AttachLayerManager()) {
+  if (!mRemoteLayerTreeOwner.AttachWindowRenderer()) {
     return false;
   }
 

dom/ipc/BrowserParent.h

@@ -455,7 +455,7 @@ class BrowserParent final : public PBrowserParent,
   void ResumeLoad(uint64_t aPendingSwitchID);
 
   void InitRendering();
-  bool AttachLayerManager();
+  bool AttachWindowRenderer();
   void MaybeShowFrame();
 
   bool Show(const OwnerShowInfo&);

gfx/layers/LayerManager.h

@@ -144,8 +144,6 @@ class DidCompositeObserver {
  * root layer, and each container layer holds a reference to its children.
  */
 class LayerManager : public WindowRenderer {
-  NS_INLINE_DECL_REFCOUNTING(LayerManager)
-
  protected:
   typedef mozilla::gfx::DrawTarget DrawTarget;
   typedef mozilla::gfx::IntSize IntSize;
@@ -160,7 +158,7 @@ class LayerManager : public WindowRenderer {
    * for its widget going away.  After this call, only user data calls
    * are valid on the layer manager.
    */
-  virtual void Destroy();
+  void Destroy() override;
   bool IsDestroyed() { return mDestroyed; }
 
   virtual LayerManager* AsLayerManager() override { return this; }
@@ -507,15 +505,6 @@ class LayerManager : public WindowRenderer {
   static bool IsLogEnabled();
   static mozilla::LogModule* GetLog();
 
-  bool IsCompositingCheap(LayersBackend aBackend) {
-    // LayersBackend::LAYERS_NONE is an error state, but in that case we should
-    // try to avoid loading the compositor!
-    return LayersBackend::LAYERS_BASIC != aBackend &&
-           LayersBackend::LAYERS_NONE != aBackend;
-  }
-
-  virtual bool IsCompositingCheap() { return true; }
-
   bool IsInTransaction() const { return mInTransaction; }
 
   virtual void SetRegionToClear(const nsIntRegion& aRegion) {
@@ -524,8 +513,6 @@ class LayerManager : public WindowRenderer {
 
   virtual float RequestProperty(const nsAString& property) { return -1; }
 
-  const TimeStamp& GetAnimationReadyTime() const { return mAnimationReadyTime; }
-
   virtual bool AsyncPanZoomEnabled() const { return false; }
 
   static void LayerUserDataDestroy(void* data);
@@ -600,9 +587,6 @@ class LayerManager : public WindowRenderer {
 
   // Used for tracking CONTENT_FRAME_TIME_WITH_SVG
   bool mContainsSVG;
-  // The time when painting most recently finished. This is recorded so that
-  // we can time any play-pending animations from this point.
-  TimeStamp mAnimationReadyTime;
   // The count of pixels that were painted in the current transaction.
   uint32_t mPaintedPixelCount;
   // The payload associated with currently pending painting work, for

gfx/layers/client/ClientLayerManager.cpp

@@ -766,8 +766,10 @@ ShadowableLayer* ClientLayerManager::Hold(Layer* aLayer) {
 bool ClientLayerManager::IsCompositingCheap() {
   // Whether compositing is cheap depends on the parent backend.
   return mForwarder->mShadowManager &&
-         LayerManager::IsCompositingCheap(
+         (mForwarder->GetCompositorBackendType() !=
-             mForwarder->GetCompositorBackendType());
+              LayersBackend::LAYERS_NONE &&
+          mForwarder->GetCompositorBackendType() !=
+              LayersBackend::LAYERS_BASIC);
 }
 
 bool ClientLayerManager::AreComponentAlphaLayersEnabled() {

layout/base/PresShell.cpp

@@ -6438,6 +6438,8 @@ void PresShell::Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
     return;
   }
 
+  bgcolor = NS_ComposeColors(bgcolor, mCanvasBackgroundColor);
+
   if (!layerManager) {
     // TODO: Once we support WindowRenderers that aren't a LayerManager,
     // then we need to handle this single color case for them.
@@ -6445,10 +6447,8 @@ void PresShell::Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
   }
 
   if (layerManager->GetBackendType() == layers::LayersBackend::LAYERS_WR) {
-    nsPresContext* pc = GetPresContext();
     LayoutDeviceRect bounds = LayoutDeviceRect::FromAppUnits(
-        pc->GetVisibleArea(), pc->AppUnitsPerDevPixel());
+        presContext->GetVisibleArea(), presContext->AppUnitsPerDevPixel());
-    bgcolor = NS_ComposeColors(bgcolor, mCanvasBackgroundColor);
     WebRenderBackgroundData data(wr::ToLayoutRect(bounds),
                                  wr::ToColorF(ToDeviceColor(bgcolor)));
     WrFiltersHolder wrFilters;
@@ -6461,10 +6461,8 @@ void PresShell::Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
 
   RefPtr<ColorLayer> root = layerManager->CreateColorLayer();
   if (root) {
-    nsPresContext* pc = GetPresContext();
+    nsIntRect bounds = presContext->GetVisibleArea().ToOutsidePixels(
-    nsIntRect bounds =
+        presContext->AppUnitsPerDevPixel());
-        pc->GetVisibleArea().ToOutsidePixels(pc->AppUnitsPerDevPixel());
-    bgcolor = NS_ComposeColors(bgcolor, mCanvasBackgroundColor);
     root->SetColor(ToDeviceColor(bgcolor));
     root->SetVisibleRegion(LayerIntRegion::FromUnknownRegion(bounds));
     layerManager->SetRoot(root);

layout/ipc/RemoteLayerTreeOwner.cpp

@@ -30,19 +30,17 @@ using namespace mozilla::layers;
 namespace mozilla {
 namespace layout {
 
-static already_AddRefed<LayerManager> GetLayerManager(
+static already_AddRefed<WindowRenderer> GetWindowRenderer(
     BrowserParent* aBrowserParent) {
-  RefPtr<LayerManager> lm;
+  RefPtr<WindowRenderer> renderer;
   if (Element* element = aBrowserParent->GetOwnerElement()) {
-    if (WindowRenderer* renderer =
+    renderer = nsContentUtils::WindowRendererForContent(element);
-            nsContentUtils::WindowRendererForContent(element)) {
+    if (renderer) {
-      lm = renderer->AsLayerManager();
+      return renderer.forget();
-      return lm.forget();
     }
-    if (WindowRenderer* renderer =
+    renderer = nsContentUtils::WindowRendererForDocument(element->OwnerDoc());
-            nsContentUtils::WindowRendererForDocument(element->OwnerDoc())) {
+    if (renderer) {
-      lm = renderer->AsLayerManager();
+      return renderer.forget();
-      return lm.forget();
     }
   }
   return nullptr;
@@ -51,7 +49,6 @@ static already_AddRefed<LayerManager> GetLayerManager(
 RemoteLayerTreeOwner::RemoteLayerTreeOwner()
     : mLayersId{0},
       mBrowserParent(nullptr),
-      mLayerManager(nullptr),
       mInitialized(false),
       mLayersConnected(false) {}
 
@@ -63,9 +60,9 @@ bool RemoteLayerTreeOwner::Initialize(BrowserParent* aBrowserParent) {
   }
 
   mBrowserParent = aBrowserParent;
-  RefPtr<LayerManager> lm = GetLayerManager(mBrowserParent);
+  RefPtr<WindowRenderer> renderer = GetWindowRenderer(mBrowserParent);
   PCompositorBridgeChild* compositor =
-      lm ? lm->GetCompositorBridgeChild() : nullptr;
+      renderer ? renderer->GetCompositorBridgeChild() : nullptr;
   mTabProcessId = mBrowserParent->Manager()->OtherPid();
 
   // Our remote frame will push layers updates to the compositor,
@@ -84,53 +81,56 @@ void RemoteLayerTreeOwner::Destroy() {
   }
 
   mBrowserParent = nullptr;
-  mLayerManager = nullptr;
+  mWindowRenderer = nullptr;
 }
 
 void RemoteLayerTreeOwner::EnsureLayersConnected(
     CompositorOptions* aCompositorOptions) {
-  RefPtr<LayerManager> lm = GetLayerManager(mBrowserParent);
+  RefPtr<WindowRenderer> renderer = GetWindowRenderer(mBrowserParent);
-  if (!lm) {
+  if (!renderer) {
     return;
   }
 
-  if (!lm->GetCompositorBridgeChild()) {
+  if (!renderer->GetCompositorBridgeChild()) {
     return;
   }
 
-  mLayersConnected = lm->GetCompositorBridgeChild()->SendNotifyChildRecreated(
+  mLayersConnected =
-      mLayersId, &mCompositorOptions);
+      renderer->GetCompositorBridgeChild()->SendNotifyChildRecreated(
+          mLayersId, &mCompositorOptions);
   *aCompositorOptions = mCompositorOptions;
 }
 
-LayerManager* RemoteLayerTreeOwner::AttachLayerManager() {
+bool RemoteLayerTreeOwner::AttachWindowRenderer() {
-  RefPtr<LayerManager> lm;
+  RefPtr<WindowRenderer> renderer;
   if (mBrowserParent) {
-    lm = GetLayerManager(mBrowserParent);
+    renderer = GetWindowRenderer(mBrowserParent);
   }
 
   // Perhaps the document containing this frame currently has no presentation?
-  if (lm && lm->GetCompositorBridgeChild() && lm != mLayerManager) {
+  if (renderer && renderer->GetCompositorBridgeChild() &&
+      renderer != mWindowRenderer) {
     mLayersConnected =
-        lm->GetCompositorBridgeChild()->SendAdoptChild(mLayersId);
+        renderer->GetCompositorBridgeChild()->SendAdoptChild(mLayersId);
-    FrameLayerBuilder::InvalidateAllLayers(lm);
+    FrameLayerBuilder::InvalidateAllLayers(renderer->AsLayerManager());
   }
 
-  mLayerManager = std::move(lm);
+  mWindowRenderer = std::move(renderer);
-  return mLayerManager;
+  return !!mWindowRenderer;
 }
 
 void RemoteLayerTreeOwner::OwnerContentChanged() {
-  Unused << AttachLayerManager();
+  Unused << AttachWindowRenderer();
 }
 
 void RemoteLayerTreeOwner::GetTextureFactoryIdentifier(
     TextureFactoryIdentifier* aTextureFactoryIdentifier) const {
-  RefPtr<LayerManager> lm =
+  RefPtr<WindowRenderer> renderer =
-      mBrowserParent ? GetLayerManager(mBrowserParent) : nullptr;
+      mBrowserParent ? GetWindowRenderer(mBrowserParent) : nullptr;
   // Perhaps the document containing this frame currently has no presentation?
-  if (lm) {
+  if (renderer && renderer->AsLayerManager()) {
-    *aTextureFactoryIdentifier = lm->GetTextureFactoryIdentifier();
+    *aTextureFactoryIdentifier =
+        renderer->AsLayerManager()->GetTextureFactoryIdentifier();
   } else {
     *aTextureFactoryIdentifier = TextureFactoryIdentifier();
   }

layout/ipc/RemoteLayerTreeOwner.h

@@ -49,7 +49,7 @@ class RemoteLayerTreeOwner final {
   void Destroy();
 
   void EnsureLayersConnected(CompositorOptions* aCompositorOptions);
-  LayerManager* AttachLayerManager();
+  bool AttachWindowRenderer();
   void OwnerContentChanged();
 
   LayersId GetLayersId() const { return mLayersId; }
@@ -73,7 +73,7 @@ class RemoteLayerTreeOwner final {
   CompositorOptions mCompositorOptions;
 
   dom::BrowserParent* mBrowserParent;
-  RefPtr<LayerManager> mLayerManager;
+  RefPtr<WindowRenderer> mWindowRenderer;
 
   bool mInitialized;
   // A flag that indicates whether or not the compositor knows about the

layout/painting/WindowRenderer.h

@@ -12,8 +12,8 @@
 #include "mozilla/layers/ScrollableLayerGuid.h"  // for ScrollableLayerGuid, ScrollableLayerGuid::ViewID
 #include "nsRefPtrHashtable.h"  // for nsRefPtrHashtable
 
+class gfxContext;
 namespace mozilla {
-
 namespace layers {
 class LayerManager;
 class WebRenderLayerManager;
@@ -81,7 +81,21 @@ class FrameRecorder {
   FramesTimingRecording mRecording;
 };
 
+/**
+ * WindowRenderer is the retained rendering object owned by an nsIWidget for
+ * drawing the contents of that window, the role previously handled by
+ * LayerManager.
+ *
+ * It can be WebRender, (deprecated) Layers, or an immediate-mode
+ * FallbackRenderer.
+ *
+ * The intention is for LayerManager to be removed entirely in the near future,
+ * with WebRender inheriting directly from this class. It is likely that more
+ * cleanup can be done once that happens.
+ */
 class WindowRenderer : public FrameRecorder {
+  NS_INLINE_DECL_REFCOUNTING(WindowRenderer)
+
  public:
   // Cast to implementation types.
   virtual layers::LayerManager* AsLayerManager() { return nullptr; }
@@ -117,6 +131,8 @@ class WindowRenderer : public FrameRecorder {
   virtual bool EndEmptyTransaction(
       EndTransactionFlags aFlags = END_DEFAULT) = 0;
 
+  virtual void Destroy() {}
+
   /**
    * Type of layer manager this is. This is to be used sparsely in order to
    * avoid a lot of Layers backend specific code. It should be used only when
@@ -154,6 +170,8 @@ class WindowRenderer : public FrameRecorder {
    */
   virtual void WaitOnTransactionProcessed() {}
 
+  virtual bool IsCompositingCheap() { return true; }
+
   /**
    * Return the name of the layer manager's backend.
    */
@@ -196,13 +214,21 @@ class WindowRenderer : public FrameRecorder {
   void UpdatePartialPrerenderedAnimations(
       const nsTArray<uint64_t>& aJankedAnimations);
 
+  const TimeStamp& GetAnimationReadyTime() const { return mAnimationReadyTime; }
+
  protected:
+  virtual ~WindowRenderer() = default;
+
   // Transform animations which are not fully pre-rendered because it's on a
   // large frame.  We need to update the pre-rendered area once after we tried
   // to composite area which is outside of the pre-rendered area on the
   // compositor.
   nsRefPtrHashtable<nsUint64HashKey, dom::Animation>
       mPartialPrerenderedAnimations;
+
+  // The time when painting most recently finished. This is recorded so that
+  // we can time any play-pending animations from this point.
+  TimeStamp mAnimationReadyTime;
 };
 
 }  // namespace mozilla

layout/painting/nsDisplayList.cpp

@@ -2284,7 +2284,7 @@ static void TriggerPendingAnimations(Document& aDoc,
   aDoc.EnumerateSubDocuments(recurse);
 }
 
-LayerManager* nsDisplayListBuilder::GetWidgetLayerManager(nsView** aView) {
+WindowRenderer* nsDisplayListBuilder::GetWidgetWindowRenderer(nsView** aView) {
   if (aView) {
     *aView = RootReferenceFrame()->GetView();
   }
@@ -2294,10 +2294,15 @@ LayerManager* nsDisplayListBuilder::GetWidgetLayerManager(nsView** aView) {
   }
   nsIWidget* window = RootReferenceFrame()->GetNearestWidget();
   if (window) {
-    WindowRenderer* renderer = window->GetWindowRenderer();
+    return window->GetWindowRenderer();
-    if (renderer) {
+  }
-      return renderer->AsLayerManager();
+  return nullptr;
-    }
+}
+
+LayerManager* nsDisplayListBuilder::GetWidgetLayerManager(nsView** aView) {
+  WindowRenderer* renderer = GetWidgetWindowRenderer();
+  if (renderer) {
+    return renderer->AsLayerManager();
   }
   return nullptr;
 }
@@ -2465,13 +2470,17 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
   AUTO_PROFILER_LABEL("nsDisplayList::PaintRoot", GRAPHICS);
 
   RefPtr<LayerManager> layerManager;
+  WindowRenderer* renderer = nullptr;
   bool widgetTransaction = false;
   bool doBeginTransaction = true;
   nsView* view = nullptr;
   if (aFlags & PAINT_USE_WIDGET_LAYERS) {
-    layerManager = aBuilder->GetWidgetLayerManager(&view);
+    renderer = aBuilder->GetWidgetWindowRenderer(&view);
-    if (layerManager) {
+    if (renderer) {
-      layerManager->SetContainsSVG(false);
+      layerManager = renderer->AsLayerManager();
+      if (layerManager) {
+        layerManager->SetContainsSVG(false);
+      }
 
       doBeginTransaction = !(aFlags & PAINT_EXISTING_TRANSACTION);
       widgetTransaction = true;
@@ -2483,7 +2492,7 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
   PresShell* presShell = presContext->PresShell();
   Document* document = presShell->GetDocument();
 
-  if (!layerManager) {
+  if (!renderer) {
     if (!aCtx) {
       NS_WARNING("Nowhere to paint into");
       return nullptr;
@@ -2499,7 +2508,8 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
     return nullptr;
   }
 
-  if (layerManager->GetBackendType() == LayersBackend::LAYERS_WR) {
+  if (renderer->GetBackendType() == LayersBackend::LAYERS_WR) {
+    MOZ_ASSERT(layerManager);
     if (doBeginTransaction) {
       if (aCtx) {
         if (!layerManager->BeginTransactionWithTarget(aCtx)) {
@@ -2571,39 +2581,40 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
   UniquePtr<LayerProperties> props;
 
   bool computeInvalidRect =
-      (computeInvalidFunc || (!layerManager->IsCompositingCheap() &&
+      (computeInvalidFunc || (!renderer->IsCompositingCheap() &&
-                              layerManager->NeedsWidgetInvalidation())) &&
+                              renderer->NeedsWidgetInvalidation())) &&
       widgetTransaction;
 
-  if (computeInvalidRect) {
+  if (computeInvalidRect && layerManager) {
     props = LayerProperties::CloneFrom(layerManager->GetRoot());
   }
 
   if (doBeginTransaction) {
     if (aCtx) {
+      MOZ_ASSERT(layerManager);
       if (!layerManager->BeginTransactionWithTarget(aCtx)) {
         return nullptr;
       }
     } else {
-      if (!layerManager->BeginTransaction()) {
+      if (!renderer->BeginTransaction()) {
         return nullptr;
       }
     }
   }
 
-  bool temp =
+  bool temp = aBuilder->SetIsCompositingCheap(renderer->IsCompositingCheap());
-      aBuilder->SetIsCompositingCheap(layerManager->IsCompositingCheap());
   LayerManager::EndTransactionFlags flags = LayerManager::END_DEFAULT;
-  if (layerManager->NeedsWidgetInvalidation() &&
+  if (renderer->NeedsWidgetInvalidation() && (aFlags & PAINT_NO_COMPOSITE)) {
-      (aFlags & PAINT_NO_COMPOSITE)) {
     flags = LayerManager::END_NO_COMPOSITE;
   }
 
-  MaybeSetupTransactionIdAllocator(layerManager, presContext);
+  if (layerManager) {
+    MaybeSetupTransactionIdAllocator(layerManager, presContext);
+  }
 
   bool sent = false;
   if (aFlags & PAINT_IDENTICAL_DISPLAY_LIST) {
-    sent = layerManager->EndEmptyTransaction(flags);
+    sent = renderer->EndEmptyTransaction(flags);
   }
 
   if (!sent) {
@@ -2634,7 +2645,7 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
 
   aBuilder->SetIsCompositingCheap(temp);
 
-  if (document && widgetTransaction) {
+  if (document && widgetTransaction && layerManager) {
     TriggerPendingAnimations(*document, layerManager->GetAnimationReadyTime());
   }
 
@@ -2644,11 +2655,11 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
                                    computeInvalidFunc)) {
       invalid = nsIntRect::MaxIntRect();
     }
-  } else if (widgetTransaction) {
+  } else if (widgetTransaction && layerManager) {
     LayerProperties::ClearInvalidations(layerManager->GetRoot());
   }
 
-  bool shouldInvalidate = layerManager->NeedsWidgetInvalidation();
+  bool shouldInvalidate = renderer->NeedsWidgetInvalidation();
 
   if (view) {
     if (props) {
@@ -2677,7 +2688,9 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
     }
   }
 
-  layerManager->SetUserData(&gLayerManagerLayerBuilder, nullptr);
+  if (layerManager) {
+    layerManager->SetUserData(&gLayerManagerLayerBuilder, nullptr);
+  }
   return layerManager.forget();
 }
 

layout/painting/nsDisplayList.h

@@ -422,6 +422,7 @@ class nsDisplayListBuilder {
     mTemporaryItems.AppendElement(aItem);
   }
 
+  WindowRenderer* GetWidgetWindowRenderer(nsView** aView = nullptr);
   layers::LayerManager* GetWidgetLayerManager(nsView** aView = nullptr);
 
   /**

view/nsViewManager.cpp

@@ -336,6 +336,9 @@ void nsViewManager::Refresh(nsView* aView,
         // Try to just Composite the current WindowRenderer contents. If
         // that fails then we need tor repaint, and request that it gets
         // composited as well.
+        // Once BasicLayerManager is removed, Composite will never succeed, so
+        // we can remove it and only have the call to Paint for
+        // FallbackRenderer.
         if (!presShell->Composite(aView)) {
           presShell->Paint(aView, damageRegion, PaintFlags::PaintComposite);
         }

widget/PuppetWidget.cpp

@@ -21,6 +21,7 @@
 #include "mozilla/PresShell.h"
 #include "mozilla/SchedulerGroup.h"
 #include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/StaticPrefs_gfx.h"
 #include "mozilla/TextComposition.h"
 #include "mozilla/TextEventDispatcher.h"
 #include "mozilla/TextEvents.h"
@@ -117,7 +118,7 @@ void PuppetWidget::InfallibleCreate(nsIWidget* aParent,
   PuppetWidget* parent = static_cast<PuppetWidget*>(aParent);
   if (parent) {
     parent->SetChild(this);
-    mLayerManager = parent->GetWindowRenderer()->AsLayerManager();
+    mWindowRenderer = parent->GetWindowRenderer();
   } else {
     Resize(mBounds.X(), mBounds.Y(), mBounds.Width(), mBounds.Height(), false);
   }
@@ -165,10 +166,10 @@ void PuppetWidget::Destroy() {
     mMemoryPressureObserver = nullptr;
   }
   mChild = nullptr;
-  if (mLayerManager) {
+  if (mWindowRenderer) {
-    mLayerManager->Destroy();
+    mWindowRenderer->Destroy();
   }
-  mLayerManager = nullptr;
+  mWindowRenderer = nullptr;
   mBrowserChild = nullptr;
 }
 
@@ -586,13 +587,13 @@ bool PuppetWidget::GetEditCommands(NativeKeyBindingsType aType,
 }
 
 WindowRenderer* PuppetWidget::GetWindowRenderer() {
-  if (!mLayerManager) {
+  if (!mWindowRenderer) {
     if (XRE_IsParentProcess()) {
       // On the parent process there is no CompositorBridgeChild which confuses
       // some layers code, so we use basic layers instead. Note that we create
       // a non-retaining layer manager since we don't care about performance.
-      mLayerManager = new BasicLayerManager(BasicLayerManager::BLM_OFFSCREEN);
+      mWindowRenderer = new BasicLayerManager(BasicLayerManager::BLM_OFFSCREEN);
-      return mLayerManager;
+      return mWindowRenderer;
     }
 
     // If we know for sure that the parent side of this BrowserChild is not
@@ -601,10 +602,10 @@ WindowRenderer* PuppetWidget::GetWindowRenderer() {
     // can do drawing in this process.
     MOZ_ASSERT(!mBrowserChild ||
                mBrowserChild->IsLayersConnected() != Some(true));
-    mLayerManager = new BasicLayerManager(this);
+    mWindowRenderer = CreateBasicLayerManager();
   }
 
-  return mLayerManager;
+  return mWindowRenderer;
 }
 
 bool PuppetWidget::CreateRemoteLayerManager(
@@ -626,7 +627,7 @@ bool PuppetWidget::CreateRemoteLayerManager(
   // it if we successfully create its successor because a partially initialized
   // layer manager is worse than a fully initialized but shutdown layer manager.
   DestroyLayerManager();
-  mLayerManager = std::move(lm);
+  mWindowRenderer = std::move(lm);
   return true;
 }
 
@@ -1006,8 +1007,9 @@ void PuppetWidget::PaintNowIfNeeded() {
 
 void PuppetWidget::OnMemoryPressure(layers::MemoryPressureReason aWhy) {
   if (aWhy != MemoryPressureReason::LOW_MEMORY_ONGOING && !mVisible &&
-      mLayerManager && XRE_IsContentProcess()) {
+      mWindowRenderer && mWindowRenderer->AsLayerManager() &&
-    mLayerManager->ClearCachedResources();
+      XRE_IsContentProcess()) {
+    mWindowRenderer->AsLayerManager()->ClearCachedResources();
   }
 }
 

widget/PuppetWidget.h

@@ -181,7 +181,7 @@ class PuppetWidget : public nsBaseWidget,
   bool CreateRemoteLayerManager(
       const std::function<bool(LayerManager*)>& aInitializeFunc);
 
-  bool HasLayerManager() { return !!mLayerManager; }
+  bool HasLayerManager() { return !!mWindowRenderer; }
 
   virtual void SetInputContext(const InputContext& aContext,
                                const InputContextAction& aAction) override;

widget/android/nsWindow.cpp

@@ -2186,21 +2186,21 @@ nsresult nsWindow::MakeFullScreen(bool aFullScreen, nsIScreen*) {
 }
 
 mozilla::WindowRenderer* nsWindow::GetWindowRenderer() {
-  if (mLayerManager) {
+  if (mWindowRenderer) {
-    return mLayerManager;
+    return mWindowRenderer;
   }
 
   if (mIsDisablingWebRender) {
     CreateLayerManager();
     mIsDisablingWebRender = false;
-    return mLayerManager;
+    return mWindowRenderer;
   }
 
   return nullptr;
 }
 
 void nsWindow::CreateLayerManager() {
-  if (mLayerManager) {
+  if (mWindowRenderer) {
     return;
   }
 
@@ -2216,7 +2216,7 @@ void nsWindow::CreateLayerManager() {
   if (ShouldUseOffMainThreadCompositing()) {
     LayoutDeviceIntRect rect = GetBounds();
     CreateCompositor(rect.Width(), rect.Height());
-    if (mLayerManager) {
+    if (mWindowRenderer) {
       return;
     }
 
@@ -2226,7 +2226,7 @@ void nsWindow::CreateLayerManager() {
 
   if (!ComputeShouldAccelerate() || sFailedToCreateGLContext) {
     printf_stderr(" -- creating basic, not accelerated\n");
-    mLayerManager = CreateBasicLayerManager();
+    mWindowRenderer = CreateBasicLayerManager();
   }
 }
 

widget/gtk/nsWindow.cpp

@@ -705,10 +705,10 @@ void nsWindow::Destroy() {
   mCreated = false;
 
   /** Need to clean our LayerManager up while still alive */
-  if (mLayerManager) {
+  if (mWindowRenderer) {
-    mLayerManager->Destroy();
+    mWindowRenderer->Destroy();
   }
-  mLayerManager = nullptr;
+  mWindowRenderer = nullptr;
 
 #ifdef MOZ_WAYLAND
   // Shut down our local vsync source
@@ -3529,7 +3529,8 @@ gboolean nsWindow::OnExposeEvent(cairo_t* cr) {
 
   bool painted = false;
   {
-    if (renderer->GetBackendType() == LayersBackend::LAYERS_BASIC) {
+    if (renderer->GetBackendType() == LayersBackend::LAYERS_NONE ||
+        renderer->GetBackendType() == LayersBackend::LAYERS_BASIC) {
       if (GetTransparencyMode() == eTransparencyTransparent &&
           layerBuffering == BufferMode::BUFFER_NONE && mHasAlphaVisual) {
         // If our draw target is unbuffered and we use an alpha channel,
@@ -6117,9 +6118,9 @@ LayoutDeviceIntSize nsWindow::GetSafeWindowSize(LayoutDeviceIntSize aSize) {
   // we also must ensure that the window can fit in a Cairo surface.
   LayoutDeviceIntSize result = aSize;
   int32_t maxSize = 32767;
-  if (mLayerManager && mLayerManager->AsKnowsCompositor()) {
+  if (mWindowRenderer && mWindowRenderer->AsKnowsCompositor()) {
-    maxSize = std::min(maxSize,
+    maxSize = std::min(
-                       mLayerManager->AsKnowsCompositor()->GetMaxTextureSize());
+        maxSize, mWindowRenderer->AsKnowsCompositor()->GetMaxTextureSize());
   }
   if (result.width > maxSize) {
     result.width = maxSize;
@@ -6135,9 +6136,9 @@ void nsWindow::EnsureGrabs(void) {
 }
 
 void nsWindow::CleanLayerManagerRecursive(void) {
-  if (mLayerManager) {
+  if (mWindowRenderer) {
-    mLayerManager->Destroy();
+    mWindowRenderer->Destroy();
-    mLayerManager = nullptr;
+    mWindowRenderer = nullptr;
   }
 
   DestroyCompositor();
@@ -8284,7 +8285,7 @@ nsIWidget::WindowRenderer* nsWindow::GetWindowRenderer() {
     // Prevent external code from triggering the re-creation of the
     // LayerManager/Compositor during shutdown. Just return what we currently
     // have, which is most likely null.
-    return mLayerManager;
+    return mWindowRenderer;
   }
 
   return nsBaseWidget::GetWindowRenderer();
@@ -8305,9 +8306,9 @@ void nsWindow::SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) {
 }
 
 void nsWindow::ClearCachedResources() {
-  if (mLayerManager && mLayerManager->GetBackendType() ==
+  if (mWindowRenderer && mWindowRenderer->GetBackendType() ==
-                           mozilla::layers::LayersBackend::LAYERS_BASIC) {
+                             mozilla::layers::LayersBackend::LAYERS_BASIC) {
-    mLayerManager->ClearCachedResources();
+    mWindowRenderer->AsLayerManager()->ClearCachedResources();
   }
 
   GList* children = gdk_window_peek_children(mGdkWindow);

widget/nsBaseWidget.cpp

@@ -154,7 +154,6 @@ nsBaseWidget::nsBaseWidget()
     : mWidgetListener(nullptr),
       mAttachedWidgetListener(nullptr),
       mPreviouslyAttachedWidgetListener(nullptr),
-      mLayerManager(nullptr),
       mCompositorVsyncDispatcher(nullptr),
       mBorderStyle(eBorderStyle_none),
       mBounds(0, 0, 0, 0),
@@ -390,10 +389,10 @@ void nsBaseWidget::DestroyCompositor() {
 // This prevents the layer manager from starting a new transaction during
 // shutdown.
 void nsBaseWidget::RevokeTransactionIdAllocator() {
-  if (!mLayerManager) {
+  if (!mWindowRenderer || !mWindowRenderer->AsLayerManager()) {
     return;
   }
-  mLayerManager->SetTransactionIdAllocator(nullptr);
+  mWindowRenderer->AsLayerManager()->SetTransactionIdAllocator(nullptr);
 }
 
 void nsBaseWidget::ReleaseContentController() {
@@ -404,9 +403,9 @@ void nsBaseWidget::ReleaseContentController() {
 }
 
 void nsBaseWidget::DestroyLayerManager() {
-  if (mLayerManager) {
+  if (mWindowRenderer) {
-    mLayerManager->Destroy();
+    mWindowRenderer->Destroy();
-    mLayerManager = nullptr;
+    mWindowRenderer = nullptr;
   }
   DestroyCompositor();
 }
@@ -436,8 +435,9 @@ void nsBaseWidget::FreeLocalesChangedObserver() {
 nsBaseWidget::~nsBaseWidget() {
   IMEStateManager::WidgetDestroyed(this);
 
-  if (mLayerManager) {
+  if (mWindowRenderer && mWindowRenderer->AsLayerManager()) {
-    if (BasicLayerManager* mgr = mLayerManager->AsBasicLayerManager()) {
+    if (BasicLayerManager* mgr =
+            mWindowRenderer->AsLayerManager()->AsBasicLayerManager()) {
       mgr->ClearRetainerWidget();
     }
   }
@@ -881,12 +881,10 @@ nsresult nsBaseWidget::MakeFullScreen(bool aFullScreen, nsIScreen* aScreen) {
 }
 
 nsBaseWidget::AutoLayerManagerSetup::AutoLayerManagerSetup(
-    nsBaseWidget* aWidget, gfxContext* aTarget, BufferMode aDoubleBuffering,
+    nsBaseWidget* aWidget, gfxContext* aTarget, BufferMode aDoubleBuffering)
-    ScreenRotation aRotation)
     : mWidget(aWidget) {
-  LayerManager* lm = mWidget->GetWindowRenderer()
+  WindowRenderer* renderer = mWidget->GetWindowRenderer();
-                         ? mWidget->GetWindowRenderer()->AsLayerManager()
+  LayerManager* lm = renderer ? renderer->AsLayerManager() : nullptr;
-                         : nullptr;
   NS_ASSERTION(
       !lm || lm->GetBackendType() == LayersBackend::LAYERS_BASIC,
       "AutoLayerManagerSetup instantiated for non-basic layer backend!");
@@ -894,7 +892,8 @@ nsBaseWidget::AutoLayerManagerSetup::AutoLayerManagerSetup(
     mLayerManager = lm->AsBasicLayerManager();
     if (mLayerManager) {
       mLayerManager->SetDefaultTarget(aTarget);
-      mLayerManager->SetDefaultTargetConfiguration(aDoubleBuffering, aRotation);
+      mLayerManager->SetDefaultTargetConfiguration(aDoubleBuffering,
+                                                   ROTATION_0);
     }
   }
 }
@@ -1482,7 +1481,7 @@ void nsBaseWidget::CreateCompositor(int aWidth, int aHeight) {
 
   WindowUsesOMTC();
 
-  mLayerManager = std::move(lm);
+  mWindowRenderer = std::move(lm);
 
   // Only track compositors for top-level windows, since other window types
   // may use the basic compositor.  Except on the OS X - see bug 1306383
@@ -1494,7 +1493,7 @@ void nsBaseWidget::CreateCompositor(int aWidth, int aHeight) {
 
   if (getCompositorFromThisWindow) {
     gfxPlatform::GetPlatform()->NotifyCompositorCreated(
-        mLayerManager->GetCompositorBackendType());
+        mWindowRenderer->GetCompositorBackendType());
   }
 }
 
@@ -1508,7 +1507,7 @@ bool nsBaseWidget::ShouldUseOffMainThreadCompositing() {
 }
 
 WindowRenderer* nsBaseWidget::GetWindowRenderer() {
-  if (!mLayerManager) {
+  if (!mWindowRenderer) {
     if (!mShutdownObserver) {
       // We are shutting down, do not try to re-create a LayerManager
       return nullptr;
@@ -1518,14 +1517,14 @@ WindowRenderer* nsBaseWidget::GetWindowRenderer() {
       CreateCompositor();
     }
 
-    if (!mLayerManager) {
+    if (!mWindowRenderer) {
-      mLayerManager = CreateBasicLayerManager();
+      mWindowRenderer = CreateBasicLayerManager();
     }
   }
-  return mLayerManager;
+  return mWindowRenderer;
 }
 
-LayerManager* nsBaseWidget::CreateBasicLayerManager() {
+WindowRenderer* nsBaseWidget::CreateBasicLayerManager() {
   return new BasicLayerManager(this);
 }
 
@@ -1534,10 +1533,10 @@ CompositorBridgeChild* nsBaseWidget::GetRemoteRenderer() {
 }
 
 void nsBaseWidget::ClearCachedWebrenderResources() {
-  if (!mLayerManager || !mLayerManager->AsWebRenderLayerManager()) {
+  if (!mWindowRenderer || !mWindowRenderer->AsWebRender()) {
     return;
   }
-  mLayerManager->ClearCachedResources();
+  mWindowRenderer->AsWebRender()->ClearCachedResources();
 }
 
 already_AddRefed<gfx::DrawTarget> nsBaseWidget::StartRemoteDrawing() {

widget/nsBaseWidget.h

@@ -43,6 +43,7 @@ class gfxContext;
 namespace mozilla {
 class CompositorVsyncDispatcher;
 class LiveResizeListener;
+class FallbackRenderer;
 
 #ifdef ACCESSIBILITY
 namespace a11y {
@@ -396,8 +397,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {
   class AutoLayerManagerSetup {
    public:
     AutoLayerManagerSetup(nsBaseWidget* aWidget, gfxContext* aTarget,
-                          BufferMode aDoubleBuffering,
+                          BufferMode aDoubleBuffering);
-                          ScreenRotation aRotation = mozilla::ROTATION_0);
     ~AutoLayerManagerSetup();
 
    private:
@@ -574,7 +574,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {
     return nsIWidget::CreateChildWindow();
   }
 
-  LayerManager* CreateBasicLayerManager();
+  WindowRenderer* CreateBasicLayerManager();
 
   nsPopupType PopupType() const { return mPopupType; }
 
@@ -700,7 +700,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {
   nsIWidgetListener* mWidgetListener;
   nsIWidgetListener* mAttachedWidgetListener;
   nsIWidgetListener* mPreviouslyAttachedWidgetListener;
-  RefPtr<LayerManager> mLayerManager;
+  RefPtr<WindowRenderer> mWindowRenderer;
   RefPtr<CompositorSession> mCompositorSession;
   RefPtr<CompositorBridgeChild> mCompositorBridgeChild;
 

widget/windows/nsWindow.cpp

@@ -2075,7 +2075,7 @@ void nsWindow::Move(double aX, double aY) {
       // Workaround SetWindowPos bug with D3D9. If our window has a clip
       // region, some drivers or OSes may incorrectly copy into the clipped-out
       // area.
-      if (IsPlugin() && !mLayerManager && mClipRects &&
+      if (IsPlugin() && !mWindowRenderer && mClipRects &&
           (mClipRectCount != 1 ||
            !mClipRects[0].IsEqualInterior(
                LayoutDeviceIntRect(0, 0, mBounds.Width(), mBounds.Height())))) {
@@ -4081,8 +4081,8 @@ bool nsWindow::HasPendingInputEvent() {
  **************************************************************/
 
 WindowRenderer* nsWindow::GetWindowRenderer() {
-  if (mLayerManager) {
+  if (mWindowRenderer) {
-    return mLayerManager;
+    return mWindowRenderer;
   }
 
   if (!mLocalesChangedObserver) {
@@ -4093,12 +4093,12 @@ WindowRenderer* nsWindow::GetWindowRenderer() {
   ::GetClientRect(mWnd, &windowRect);
 
   // Try OMTC first.
-  if (!mLayerManager && ShouldUseOffMainThreadCompositing()) {
+  if (!mWindowRenderer && ShouldUseOffMainThreadCompositing()) {
     gfxWindowsPlatform::GetPlatform()->UpdateRenderMode();
     CreateCompositor();
   }
 
-  if (!mLayerManager) {
+  if (!mWindowRenderer) {
     MOZ_ASSERT(!mCompositorSession && !mCompositorBridgeChild);
     MOZ_ASSERT(!mCompositorWidgetDelegate);
 
@@ -4113,15 +4113,15 @@ WindowRenderer* nsWindow::GetWindowRenderer() {
     mBasicLayersSurface =
         new InProcessWinCompositorWidget(initData, options, this);
     mCompositorWidgetDelegate = mBasicLayersSurface;
-    mLayerManager = CreateBasicLayerManager();
+    mWindowRenderer = CreateBasicLayerManager();
   }
 
-  NS_ASSERTION(mLayerManager, "Couldn't provide a valid layer manager.");
+  NS_ASSERTION(mWindowRenderer, "Couldn't provide a valid window renderer.");
 
-  if (mLayerManager) {
+  if (mWindowRenderer) {
     // Update the size constraints now that the layer manager has been
     // created.
-    KnowsCompositor* knowsCompositor = mLayerManager->AsKnowsCompositor();
+    KnowsCompositor* knowsCompositor = mWindowRenderer->AsKnowsCompositor();
     if (knowsCompositor) {
       SizeConstraints c = mSizeConstraints;
       mMaxTextureSize = knowsCompositor->GetMaxTextureSize();
@@ -4131,7 +4131,7 @@ WindowRenderer* nsWindow::GetWindowRenderer() {
     }
   }
 
-  return mLayerManager;
+  return mWindowRenderer;
 }
 
 /**************************************************************
@@ -8034,9 +8034,9 @@ BOOL CALLBACK nsWindow::ClearResourcesCallback(HWND aWnd, LPARAM aMsg) {
 }
 
 void nsWindow::ClearCachedResources() {
-  if (mLayerManager &&
+  if (mWindowRenderer &&
-      mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC) {
+      mWindowRenderer->GetBackendType() == LayersBackend::LAYERS_BASIC) {
-    mLayerManager->ClearCachedResources();
+    mWindowRenderer->AsLayerManager()->ClearCachedResources();
   }
   ::EnumChildWindows(mWnd, nsWindow::ClearResourcesCallback, 0);
 }