Bug 1688096 - Part 2. Add/use flag to CompositorOptions to allow SW-WR on a per widget basis. r=mattwoodrow

The pref gfx.webrender.software.unaccelerated-widget.allow may be used
to allow software WebRender to be used with new windows/popups that have
transparency on Windows. Otherwise they would fallback to basic layers.

Similarly, the pref gfx.webrender.software.unaccelerated-widget.force
may be used to force software WebRender for all windows that would
fallback to basic layers.

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

gfx/ipc/CompositorOptions.h

@@ -32,22 +32,37 @@ class CompositorOptions {
   CompositorOptions()
       : mUseAPZ(false),
         mUseWebRender(false),
+        mUseSoftwareWebRender(false),
+        mAllowSoftwareWebRenderD3D11(false),
         mUseAdvancedLayers(false),
         mInitiallyPaused(false) {}
 
-  CompositorOptions(bool aUseAPZ, bool aUseWebRender)
+  CompositorOptions(bool aUseAPZ, bool aUseWebRender,
+                    bool aUseSoftwareWebRender)
       : mUseAPZ(aUseAPZ),
         mUseWebRender(aUseWebRender),
+        mUseSoftwareWebRender(aUseSoftwareWebRender),
+        mAllowSoftwareWebRenderD3D11(false),
         mUseAdvancedLayers(false),
-        mInitiallyPaused(false) {}
+        mInitiallyPaused(false) {
+    MOZ_ASSERT_IF(aUseSoftwareWebRender, aUseWebRender);
+  }
 
   bool UseAPZ() const { return mUseAPZ; }
   bool UseWebRender() const { return mUseWebRender; }
+  bool UseSoftwareWebRender() const { return mUseSoftwareWebRender; }
+  bool AllowSoftwareWebRenderD3D11() const {
+    return mAllowSoftwareWebRenderD3D11;
+  }
   bool UseAdvancedLayers() const { return mUseAdvancedLayers; }
   bool InitiallyPaused() const { return mInitiallyPaused; }
 
   void SetUseAPZ(bool aUseAPZ) { mUseAPZ = aUseAPZ; }
 
+  void SetAllowSoftwareWebRenderD3D11(bool aAllowSoftwareWebRenderD3D11) {
+    mAllowSoftwareWebRenderD3D11 = aAllowSoftwareWebRenderD3D11;
+  }
+
   void SetUseAdvancedLayers(bool aUseAdvancedLayers) {
     mUseAdvancedLayers = aUseAdvancedLayers;
   }
@@ -58,6 +73,9 @@ class CompositorOptions {
 
   bool operator==(const CompositorOptions& aOther) const {
     return mUseAPZ == aOther.mUseAPZ && mUseWebRender == aOther.mUseWebRender &&
+           mUseSoftwareWebRender == aOther.mUseSoftwareWebRender &&
+           mAllowSoftwareWebRenderD3D11 ==
+               aOther.mAllowSoftwareWebRenderD3D11 &&
            mUseAdvancedLayers == aOther.mUseAdvancedLayers;
   }
 
@@ -66,6 +84,8 @@ class CompositorOptions {
  private:
   bool mUseAPZ;
   bool mUseWebRender;
+  bool mUseSoftwareWebRender;
+  bool mAllowSoftwareWebRenderD3D11;
   bool mUseAdvancedLayers;
   bool mInitiallyPaused;
 

gfx/layers/ipc/LayersMessageUtils.h

@@ -810,6 +810,8 @@ struct ParamTraits<mozilla::layers::CompositorOptions> {
   static void Write(Message* aMsg, const paramType& aParam) {
     WriteParam(aMsg, aParam.mUseAPZ);
     WriteParam(aMsg, aParam.mUseWebRender);
+    WriteParam(aMsg, aParam.mUseSoftwareWebRender);
+    WriteParam(aMsg, aParam.mAllowSoftwareWebRenderD3D11);
     WriteParam(aMsg, aParam.mUseAdvancedLayers);
     WriteParam(aMsg, aParam.mInitiallyPaused);
   }
@@ -818,6 +820,8 @@ struct ParamTraits<mozilla::layers::CompositorOptions> {
                    paramType* aResult) {
     return ReadParam(aMsg, aIter, &aResult->mUseAPZ) &&
            ReadParam(aMsg, aIter, &aResult->mUseWebRender) &&
+           ReadParam(aMsg, aIter, &aResult->mUseSoftwareWebRender) &&
+           ReadParam(aMsg, aIter, &aResult->mAllowSoftwareWebRenderD3D11) &&
            ReadParam(aMsg, aIter, &aResult->mUseAdvancedLayers) &&
            ReadParam(aMsg, aIter, &aResult->mInitiallyPaused);
   }

gfx/webrender_bindings/RenderCompositor.cpp

@@ -149,14 +149,14 @@ void wr_partial_present_compositor_set_buffer_damage_region(
 /* static */
 UniquePtr<RenderCompositor> RenderCompositor::Create(
     RefPtr<widget::CompositorWidget>&& aWidget, nsACString& aError) {
-  if (gfx::gfxVars::UseSoftwareWebRender()) {
+  if (aWidget->GetCompositorOptions().UseSoftwareWebRender()) {
 #ifdef XP_MACOSX
     // Mac uses NativeLayerCA
     if (!gfxPlatform::IsHeadless()) {
       return RenderCompositorNativeSWGL::Create(std::move(aWidget), aError);
     }
 #elif defined(XP_WIN)
-    if (StaticPrefs::gfx_webrender_software_d3d11_AtStartup() &&
+    if (aWidget->GetCompositorOptions().AllowSoftwareWebRenderD3D11() &&
         gfx::gfxConfig::IsEnabled(gfx::Feature::D3D11_COMPOSITING)) {
       UniquePtr<RenderCompositor> comp =
           RenderCompositorD3D11SWGL::Create(std::move(aWidget), aError);

modules/libpref/init/StaticPrefList.yaml

@@ -4841,6 +4841,20 @@
   value: 2
   mirror: always
 
+# Whether to allow widgets that don't support acceleration to use WebRender
+# software backend
+- name: gfx.webrender.software.unaccelerated-widget.allow
+  type: RelaxedAtomicBool
+  value: @IS_NIGHTLY_BUILD@
+  mirror: always
+
+# Whether to force widgets that don't support acceleration to use WebRender
+# software backend
+- name: gfx.webrender.software.unaccelerated-widget.force
+  type: RelaxedAtomicBool
+  value: false
+  mirror: always
+
 # Use vsync events generated by hardware
 - name: gfx.work-around-driver-bugs
   type: bool

widget/nsBaseWidget.cpp

@@ -29,6 +29,7 @@
 #include "mozilla/Sprintf.h"
 #include "mozilla/StaticPrefs_apz.h"
 #include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_gfx.h"
 #include "mozilla/StaticPrefs_layers.h"
 #include "mozilla/StaticPrefs_layout.h"
 #include "mozilla/TextEventDispatcher.h"
@@ -826,6 +827,10 @@ bool nsBaseWidget::ComputeShouldAccelerate() {
          WidgetTypeSupportsAcceleration();
 }
 
+bool nsBaseWidget::WidgetTypePrefersSoftwareWebRender() const {
+  return StaticPrefs::gfx_webrender_software_unaccelerated_widget_force();
+}
+
 bool nsBaseWidget::UseAPZ() {
   return (gfxPlatform::AsyncPanZoomEnabled() &&
           (WindowType() == eWindowType_toplevel ||
@@ -1211,13 +1216,30 @@ already_AddRefed<LayerManager> nsBaseWidget::CreateCompositorSession(
     // EnsureGPUReady(). It could update gfxVars and gfxConfigs.
     gpu->EnsureGPUReady();
 
-    // If widget type does not supports acceleration, we use ClientLayerManager
-    // even when gfxVars::UseWebRender() is true. WebRender could coexist only
-    // with BasicCompositor.
-    bool enableWR =
-        gfx::gfxVars::UseWebRender() && WidgetTypeSupportsAcceleration();
+    // If widget type does not supports acceleration, we may be allowed to use
+    // software WebRender instead. If not, then we use ClientLayerManager even
+    // when gfxVars::UseWebRender() is true. WebRender could coexist only with
+    // BasicCompositor.
+    bool supportsAcceleration = WidgetTypeSupportsAcceleration();
+    bool enableWR;
+    bool enableSWWR;
+    if (supportsAcceleration) {
+      enableWR = gfx::gfxVars::UseWebRender();
+      enableSWWR = gfx::gfxVars::UseSoftwareWebRender();
+    } else if (WidgetTypePrefersSoftwareWebRender()) {
+      enableWR = enableSWWR = gfx::gfxVars::UseWebRender();
+    } else {
+      enableWR = enableSWWR = false;
+    }
     bool enableAPZ = UseAPZ();
-    CompositorOptions options(enableAPZ, enableWR);
+    CompositorOptions options(enableAPZ, enableWR, enableSWWR);
+
+#ifdef XP_WIN
+    if (supportsAcceleration) {
+      options.SetAllowSoftwareWebRenderD3D11(
+          StaticPrefs::gfx_webrender_software_d3d11_AtStartup());
+    }
+#endif
 
 #ifdef MOZ_WIDGET_ANDROID
     if (!GetNativeData(NS_JAVA_SURFACE)) {

widget/nsBaseWidget.h

@@ -292,6 +292,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {
     return NS_ERROR_NOT_IMPLEMENTED;
   }
   bool ComputeShouldAccelerate();
+  virtual bool WidgetTypePrefersSoftwareWebRender() const;
   virtual bool WidgetTypeSupportsAcceleration() { return true; }
   [[nodiscard]] virtual nsresult OnDefaultButtonLoaded(
       const LayoutDeviceIntRect& aButtonRect) override {

widget/windows/nsWindow.cpp

@@ -148,6 +148,7 @@
 #include "ScreenHelperWin.h"
 #include "mozilla/StaticPrefs_apz.h"
 #include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_gfx.h"
 #include "mozilla/StaticPrefs_layout.h"
 
 #include "nsIGfxInfo.h"
@@ -4081,7 +4082,7 @@ LayerManager* nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
         reinterpret_cast<uintptr_t>(static_cast<nsIWidget*>(this)),
         mTransparencyMode, mSizeMode);
     // If we're not using the compositor, the options don't actually matter.
-    CompositorOptions options(false, false);
+    CompositorOptions options(false, false, false);
     mBasicLayersSurface =
         new InProcessWinCompositorWidget(initData, options, this);
     mCompositorWidgetDelegate = mBasicLayersSurface;
@@ -8498,6 +8499,12 @@ void nsWindow::PickerClosed() {
   }
 }
 
+bool nsWindow::WidgetTypePrefersSoftwareWebRender() const {
+  return (StaticPrefs::gfx_webrender_software_unaccelerated_widget_allow() &&
+          mTransparencyMode == eTransparencyTransparent) ||
+         nsBaseWidget::WidgetTypePrefersSoftwareWebRender();
+}
+
 bool nsWindow::WidgetTypeSupportsAcceleration() {
   // We don't currently support using an accelerated layer manager with
   // transparent windows so don't even try. I'm also not sure if we even

widget/windows/nsWindow.h

@@ -296,6 +296,7 @@ class nsWindow final : public nsWindowBase {
    * Misc.
    */
   virtual bool AutoErase(HDC dc);
+  bool WidgetTypePrefersSoftwareWebRender() const override;
   bool WidgetTypeSupportsAcceleration() override;
 
   void ForcePresent();