Bug 1721537 - Simplify nsIWidget::GetLayerManager by removing unused parameters. r=miko

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

dom/base/nsContentUtils.cpp

@@ -6685,29 +6685,17 @@ already_AddRefed<LayerManager> nsContentUtils::LayerManagerForContent(
   return nullptr;
 }
 
-static already_AddRefed<LayerManager> LayerManagerForDocumentInternal(
+already_AddRefed<LayerManager> nsContentUtils::LayerManagerForDocument(
-    const Document* aDoc, bool aRequirePersistent) {
+    const Document* aDoc) {
   nsIWidget* widget = nsContentUtils::WidgetForDocument(aDoc);
   if (widget) {
-    RefPtr<LayerManager> manager = widget->GetLayerManager(
+    RefPtr<LayerManager> manager = widget->GetLayerManager();
-        aRequirePersistent ? nsIWidget::LAYER_MANAGER_PERSISTENT
-                           : nsIWidget::LAYER_MANAGER_CURRENT);
     return manager.forget();
   }
 
   return nullptr;
 }
 
-already_AddRefed<LayerManager> nsContentUtils::LayerManagerForDocument(
-    const Document* aDoc) {
-  return LayerManagerForDocumentInternal(aDoc, false);
-}
-
-already_AddRefed<LayerManager>
-nsContentUtils::PersistentLayerManagerForDocument(Document* aDoc) {
-  return LayerManagerForDocumentInternal(aDoc, true);
-}
-
 bool nsContentUtils::AllowXULXBLForPrincipal(nsIPrincipal* aPrincipal) {
   if (!aPrincipal) {
     return false;

dom/base/nsContentUtils.h

@@ -2374,23 +2374,6 @@ class nsContentUtils {
   static already_AddRefed<mozilla::layers::LayerManager> LayerManagerForContent(
       const nsIContent* aContent);
 
-  /**
-   * Returns a layer manager to use for the given document. Basically we
-   * look up the document hierarchy for the first document which has
-   * a presentation with an associated widget, and use that widget's
-   * layer manager. In addition to the normal layer manager lookup this will
-   * specifically request a persistent layer manager. This means that the layer
-   * manager is expected to remain the layer manager for the document in the
-   * forseeable future. This function should be used carefully as it may change
-   * the document's layer manager.
-   *
-   * @param aDoc the document for which to return a layer manager.
-   * @param aAllowRetaining an outparam that states whether the returned
-   * layer manager should be used for retained layers
-   */
-  static already_AddRefed<mozilla::layers::LayerManager>
-  PersistentLayerManagerForDocument(Document* aDoc);
-
   /**
    * Determine whether a content node is focused or not,
    *

dom/base/nsDOMWindowUtils.cpp

@@ -2545,8 +2545,7 @@ nsDOMWindowUtils::GetLayerManagerType(nsAString& aType) {
   nsCOMPtr<nsIWidget> widget = GetWidget();
   if (!widget) return NS_ERROR_FAILURE;
 
-  LayerManager* mgr =
+  LayerManager* mgr = widget->GetLayerManager();
-      widget->GetLayerManager(nsIWidget::LAYER_MANAGER_PERSISTENT);
   if (!mgr) return NS_ERROR_FAILURE;
 
   mgr->GetBackendName(aType);

dom/canvas/CanvasRenderingContext2D.cpp

@@ -1418,8 +1418,7 @@ static already_AddRefed<LayerManager> LayerManagerFromCanvasElement(
     return nullptr;
   }
 
-  return nsContentUtils::PersistentLayerManagerForDocument(
+  return nsContentUtils::LayerManagerForDocument(aCanvasElement->OwnerDoc());
-      aCanvasElement->OwnerDoc());
 }
 
 bool CanvasRenderingContext2D::TrySharedTarget(

widget/PuppetWidget.cpp

@@ -585,9 +585,7 @@ bool PuppetWidget::GetEditCommands(NativeKeyBindingsType aType,
   return true;
 }
 
-LayerManager* PuppetWidget::GetLayerManager(
+LayerManager* PuppetWidget::GetLayerManager() {
-    PLayerTransactionChild* aShadowManager, LayersBackend aBackendHint,
-    LayerManagerPersistence aPersistence) {
   if (!mLayerManager) {
     if (XRE_IsParentProcess()) {
       // On the parent process there is no CompositorBridgeChild which confuses

widget/PuppetWidget.h

@@ -171,10 +171,7 @@ class PuppetWidget : public nsBaseWidget,
     return eTransparencyTransparent;
   }
 
-  virtual LayerManager* GetLayerManager(
+  virtual LayerManager* GetLayerManager() override;
-      PLayerTransactionChild* aShadowManager = nullptr,
-      LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
-      LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
 
   // This is used for creating remote layer managers and for re-creating
   // them after a compositor reset. The lambda aInitializeFunc is used to

widget/android/nsWindow.cpp

@@ -2176,8 +2176,7 @@ nsresult nsWindow::MakeFullScreen(bool aFullScreen, nsIScreen*) {
   return NS_OK;
 }
 
-mozilla::layers::LayerManager* nsWindow::GetLayerManager(
+mozilla::layers::LayerManager* nsWindow::GetLayerManager() {
-    PLayerTransactionChild*, LayersBackend, LayerManagerPersistence) {
   if (mLayerManager) {
     return mLayerManager;
   }

widget/android/nsWindow.h

@@ -178,10 +178,7 @@ class nsWindow final : public nsBaseWidget {
                                const InputContextAction& aAction) override;
   virtual InputContext GetInputContext() override;
 
-  LayerManager* GetLayerManager(
+  LayerManager* GetLayerManager() override;
-      PLayerTransactionChild* aShadowManager = nullptr,
-      LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
-      LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
 
   virtual bool NeedsPaint() override;
 

widget/cocoa/nsCocoaWindow.h

@@ -296,10 +296,7 @@ class nsCocoaWindow final : public nsBaseWidget, public nsPIWidgetCocoa {
 
   virtual void Invalidate(const LayoutDeviceIntRect& aRect) override;
   virtual nsresult ConfigureChildren(const nsTArray<Configuration>& aConfigurations) override;
-  virtual LayerManager* GetLayerManager(
+  virtual LayerManager* GetLayerManager() override;
-      PLayerTransactionChild* aShadowManager = nullptr,
-      LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
-      LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
   virtual nsresult DispatchEvent(mozilla::WidgetGUIEvent* aEvent, nsEventStatus& aStatus) override;
   virtual void CaptureRollupEvents(nsIRollupListener* aListener, bool aDoCapture) override;
   [[nodiscard]] virtual nsresult GetAttention(int32_t aCycleCount) override;

widget/cocoa/nsCocoaWindow.mm

@@ -1035,11 +1035,9 @@ nsresult nsCocoaWindow::ConfigureChildren(const nsTArray<Configuration>& aConfig
   return NS_OK;
 }
 
-LayerManager* nsCocoaWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
+LayerManager* nsCocoaWindow::GetLayerManager() {
-                                             LayersBackend aBackendHint,
-                                             LayerManagerPersistence aPersistence) {
   if (mPopupContentView) {
-    return mPopupContentView->GetLayerManager(aShadowManager, aBackendHint, aPersistence);
+    return mPopupContentView->GetLayerManager();
   }
   return nullptr;
 }

widget/gtk/nsWindow.cpp

@@ -8276,9 +8276,7 @@ nsresult nsWindow::BeginResizeDrag(WidgetGUIEvent* aEvent, int32_t aHorizontal,
   return NS_OK;
 }
 
-nsIWidget::LayerManager* nsWindow::GetLayerManager(
+nsIWidget::LayerManager* nsWindow::GetLayerManager() {
-    PLayerTransactionChild* aShadowManager, LayersBackend aBackendHint,
-    LayerManagerPersistence aPersistence) {
   if (mIsDestroyed) {
     // Prevent external code from triggering the re-creation of the
     // LayerManager/Compositor during shutdown. Just return what we currently
@@ -8286,8 +8284,7 @@ nsIWidget::LayerManager* nsWindow::GetLayerManager(
     return mLayerManager;
   }
 
-  return nsBaseWidget::GetLayerManager(aShadowManager, aBackendHint,
+  return nsBaseWidget::GetLayerManager();
-                                       aPersistence);
 }
 
 void nsWindow::SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) {

widget/gtk/nsWindow.h

@@ -598,10 +598,7 @@ class nsWindow final : public nsBaseWidget {
   void DispatchMissedButtonReleases(GdkEventCrossing* aGdkEvent);
 
   // nsBaseWidget
-  virtual LayerManager* GetLayerManager(
+  virtual LayerManager* GetLayerManager() override;
-      PLayerTransactionChild* aShadowManager = nullptr,
-      LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
-      LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
 
   void SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) override;
 

widget/headless/HeadlessWidget.cpp

@@ -250,11 +250,8 @@ LayoutDeviceIntPoint HeadlessWidget::WidgetToScreenOffset() {
   return mTopLevel->GetBounds().TopLeft();
 }
 
-LayerManager* HeadlessWidget::GetLayerManager(
+LayerManager* HeadlessWidget::GetLayerManager() {
-    PLayerTransactionChild* aShadowManager, LayersBackend aBackendHint,
+  return nsBaseWidget::GetLayerManager();
-    LayerManagerPersistence aPersistence) {
-  return nsBaseWidget::GetLayerManager(aShadowManager, aBackendHint,
-                                       aPersistence);
 }
 
 void HeadlessWidget::SetCompositorWidgetDelegate(

widget/headless/HeadlessWidget.h

@@ -100,10 +100,7 @@ class HeadlessWidget : public nsBaseWidget {
   }
   virtual InputContext GetInputContext() override { return mInputContext; }
 
-  virtual LayerManager* GetLayerManager(
+  virtual LayerManager* GetLayerManager() override;
-      PLayerTransactionChild* aShadowManager = nullptr,
-      LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
-      LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
 
   void SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) override;
 

widget/nsBaseWidget.cpp

@@ -1505,9 +1505,7 @@ bool nsBaseWidget::ShouldUseOffMainThreadCompositing() {
   return gfxPlatform::UsesOffMainThreadCompositing();
 }
 
-LayerManager* nsBaseWidget::GetLayerManager(
+LayerManager* nsBaseWidget::GetLayerManager() {
-    PLayerTransactionChild* aShadowManager, LayersBackend aBackendHint,
-    LayerManagerPersistence aPersistence) {
   if (!mLayerManager) {
     if (!mShutdownObserver) {
       // We are shutting down, do not try to re-create a LayerManager
@@ -1515,11 +1513,6 @@ LayerManager* nsBaseWidget::GetLayerManager(
     }
     // Try to use an async compositor first, if possible
     if (ShouldUseOffMainThreadCompositing()) {
-      // e10s uses the parameter to pass in the shadow manager from the
-      // BrowserChild so we don't expect to see it there since this doesn't
-      // support e10s.
-      NS_ASSERTION(aShadowManager == nullptr,
-                   "Async Compositor not supported with e10s");
       CreateCompositor();
     }
 

widget/nsBaseWidget.h

@@ -218,10 +218,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {
                           nsIScreen* aScreen = nullptr) override;
   void InfallibleMakeFullScreen(bool aFullScreen, nsIScreen* aScreen = nullptr);
 
-  LayerManager* GetLayerManager(
+  LayerManager* GetLayerManager() override;
-      PLayerTransactionChild* aShadowManager = nullptr,
-      LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
-      LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
 
   // A remote compositor session tied to this window has been lost and IPC
   // messages will no longer work. The widget must clean up any lingering

widget/nsIWidget.h

@@ -1294,24 +1294,7 @@ class nsIWidget : public nsISupports {
    * Return the widget's LayerManager. The layer tree for that
    * LayerManager is what gets rendered to the widget.
    */
-  inline LayerManager* GetLayerManager() {
+  virtual LayerManager* GetLayerManager() = 0;
-    return GetLayerManager(nullptr, mozilla::layers::LayersBackend::LAYERS_NONE,
-                           LAYER_MANAGER_CURRENT);
-  }
-
-  inline LayerManager* GetLayerManager(LayerManagerPersistence aPersistence) {
-    return GetLayerManager(nullptr, mozilla::layers::LayersBackend::LAYERS_NONE,
-                           aPersistence);
-  }
-
-  /**
-   * Like GetLayerManager(), but prefers creating a layer manager of
-   * type |aBackendHint| instead of what would normally be created.
-   * LayersBackend::LAYERS_NONE means "no hint".
-   */
-  virtual LayerManager* GetLayerManager(
-      PLayerTransactionChild* aShadowManager, LayersBackend aBackendHint,
-      LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) = 0;
 
   /**
    * Called before each layer manager transaction to allow any preparation

widget/windows/nsWindow.cpp

@@ -4080,9 +4080,7 @@ bool nsWindow::HasPendingInputEvent() {
  *
  **************************************************************/
 
-LayerManager* nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
+LayerManager* nsWindow::GetLayerManager() {
-                                        LayersBackend aBackendHint,
-                                        LayerManagerPersistence aPersistence) {
   if (mLayerManager) {
     return mLayerManager;
   }
@@ -4097,12 +4095,6 @@ LayerManager* nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
   // Try OMTC first.
   if (!mLayerManager && ShouldUseOffMainThreadCompositing()) {
     gfxWindowsPlatform::GetPlatform()->UpdateRenderMode();
-
-    // e10s uses the parameter to pass in the shadow manager from the
-    // BrowserChild so we don't expect to see it there since this doesn't
-    // support e10s.
-    NS_ASSERTION(aShadowManager == nullptr,
-                 "Async Compositor not supported with e10s");
     CreateCompositor();
   }
 

widget/windows/nsWindow.h

@@ -210,10 +210,7 @@ class nsWindow final : public nsWindowBase {
                                    bool aDoCapture) override;
   [[nodiscard]] virtual nsresult GetAttention(int32_t aCycleCount) override;
   virtual bool HasPendingInputEvent() override;
-  virtual LayerManager* GetLayerManager(
+  virtual LayerManager* GetLayerManager() override;
-      PLayerTransactionChild* aShadowManager = nullptr,
-      LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
-      LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
   void SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) override;
   [[nodiscard]] virtual nsresult OnDefaultButtonLoaded(
       const LayoutDeviceIntRect& aButtonRect) override;