Bug 1646835 - move SWGL context creation into specific SWGL RenderCompositors. r=jrmuizel

Currently RendererOGL has mixed-in details of SWGL context creation which becomes messy
and slightly unanticipated based on the nomenclature and structure of RendererOGL. Based
on other work in bug 1646835, it becomes more natural to move this context creation into
the specific SWGL RenderCompositors so that RendererOGL can be agnostic to any SWGL
details.

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

gfx/webrender_bindings/RenderCompositor.cpp

@@ -10,6 +10,7 @@
 #include "mozilla/gfx/gfxVars.h"
 #include "mozilla/layers/SyncObject.h"
 #include "mozilla/webrender/RenderCompositorOGL.h"
+#include "mozilla/webrender/RenderCompositorSWGL.h"
 #include "mozilla/widget/CompositorWidget.h"
 
 #ifdef XP_WIN
@@ -112,6 +113,15 @@ void wr_compositor_unmap_tile(void* aCompositor) {
 /* static */
 UniquePtr<RenderCompositor> RenderCompositor::Create(
     RefPtr<widget::CompositorWidget>&& aWidget) {
+  if (gfx::gfxVars::UseSoftwareWebRender()) {
+#ifdef XP_MACOSX
+    // Mac uses NativeLayerCA
+    return RenderCompositorNativeSWGL::Create(std::move(aWidget));
+#else
+    return RenderCompositorSWGL::Create(std::move(aWidget));
+#endif
+  }
+
 #ifdef XP_WIN
   if (gfx::gfxVars::UseWebRenderANGLE()) {
     return RenderCompositorANGLE::Create(std::move(aWidget));
@@ -142,10 +152,7 @@ RenderCompositor::RenderCompositor(RefPtr<widget::CompositorWidget>&& aWidget)
 
 RenderCompositor::~RenderCompositor() = default;
 
-bool RenderCompositor::MakeCurrent() {
-  gl::GLContext* context = gl();
-  return !context || context->MakeCurrent();
-}
+bool RenderCompositor::MakeCurrent() { return gl()->MakeCurrent(); }
 
 bool RenderCompositor::IsContextLost() {
   // XXX Add glGetGraphicsResetStatus handling for checking rendering context

gfx/webrender_bindings/RenderCompositor.h

@@ -60,17 +60,13 @@ class RenderCompositor {
   // Update FrameId when WR rendering does not happen.
   virtual RenderedFrameId UpdateFrameId() { return GetNextRenderFrameId(); }
 
-  // Return a data mapping of the underlying framebuffer if possible.
-  virtual bool GetMappedBuffer(uint8_t** aData, int32_t* aStride) {
-    return false;
-  }
-
   virtual void Pause() = 0;
   virtual bool Resume() = 0;
   // Called when WR rendering is skipped
   virtual void Update() {}
 
   virtual gl::GLContext* gl() const { return nullptr; }
+  virtual void* swgl() const { return nullptr; }
 
   virtual bool MakeCurrent();
 

gfx/webrender_bindings/RenderCompositorNative.cpp

@@ -42,7 +42,12 @@ UniquePtr<RenderCompositor> RenderCompositorNativeOGL::Create(
 /* static */
 UniquePtr<RenderCompositor> RenderCompositorNativeSWGL::Create(
     RefPtr<widget::CompositorWidget>&& aWidget) {
-  return MakeUnique<RenderCompositorNativeSWGL>(std::move(aWidget));
+  void* ctx = wr_swgl_create_context();
+  if (!ctx) {
+    gfxCriticalNote << "Failed SWGL context creation for WebRender";
+    return nullptr;
+  }
+  return MakeUnique<RenderCompositorNativeSWGL>(std::move(aWidget), ctx);
 }
 
 RenderCompositorNative::RenderCompositorNative(
@@ -90,8 +95,19 @@ RenderCompositorNativeOGL::~RenderCompositorNativeOGL() {
 }
 
 RenderCompositorNativeSWGL::RenderCompositorNativeSWGL(
-    RefPtr<widget::CompositorWidget>&& aWidget)
-    : RenderCompositorNative(std::move(aWidget)) {}
+    RefPtr<widget::CompositorWidget>&& aWidget, void* aContext)
+    : RenderCompositorNative(std::move(aWidget)), mContext(aContext) {
+  MOZ_ASSERT(mContext);
+}
+
+RenderCompositorNativeSWGL::~RenderCompositorNativeSWGL() {
+  wr_swgl_destroy_context(mContext);
+}
+
+bool RenderCompositorNativeSWGL::MakeCurrent() {
+  wr_swgl_make_current(mContext);
+  return true;
+}
 
 bool RenderCompositorNative::BeginFrame() {
   if (!MakeCurrent()) {
@@ -143,6 +159,8 @@ bool RenderCompositorNativeSWGL::InitDefaultFramebuffer(
     if (!MapNativeLayer(mNativeLayerForEntireWindow, aBounds, aBounds)) {
       return false;
     }
+    wr_swgl_init_default_framebuffer(mContext, aBounds.width, aBounds.height,
+                                     mLayerStride, mLayerData);
   }
   return true;
 }
@@ -367,16 +385,6 @@ void RenderCompositorNativeSWGL::UnmapNativeLayer() {
   mLayerStride = 0;
 }
 
-bool RenderCompositorNativeSWGL::GetMappedBuffer(uint8_t** aData,
-                                                 int32_t* aStride) {
-  if (mNativeLayerForEntireWindow && mLayerData) {
-    *aData = mLayerData;
-    *aStride = mLayerStride;
-    return true;
-  }
-  return false;
-}
-
 bool RenderCompositorNativeSWGL::MapTile(wr::NativeTileId aId,
                                          wr::DeviceIntRect aDirtyRect,
                                          wr::DeviceIntRect aValidRect,

gfx/webrender_bindings/RenderCompositorNative.h

@@ -164,7 +164,13 @@ class RenderCompositorNativeSWGL : public RenderCompositorNative {
   static UniquePtr<RenderCompositor> Create(
       RefPtr<widget::CompositorWidget>&& aWidget);
 
-  RenderCompositorNativeSWGL(RefPtr<widget::CompositorWidget>&& aWidget);
+  RenderCompositorNativeSWGL(RefPtr<widget::CompositorWidget>&& aWidget,
+                             void* aContext);
+  virtual ~RenderCompositorNativeSWGL();
+
+  void* swgl() const override { return mContext; }
+
+  bool MakeCurrent() override;
 
   void CancelFrame() override;
 
@@ -173,8 +179,6 @@ class RenderCompositorNativeSWGL : public RenderCompositorNative {
                int32_t* aStride) override;
   void UnmapTile() override;
 
-  bool GetMappedBuffer(uint8_t** aData, int32_t* aStride) override;
-
  protected:
   bool InitDefaultFramebuffer(const gfx::IntRect& aBounds) override;
   void DoSwap() override;
@@ -184,6 +188,7 @@ class RenderCompositorNativeSWGL : public RenderCompositorNative {
                       const gfx::IntRect& aValidRect);
   void UnmapNativeLayer();
 
+  void* mContext = nullptr;
   RefPtr<gfx::DrawTarget> mLayerTarget;
   uint8_t* mLayerData = nullptr;
   int32_t mLayerStride = 0;

gfx/webrender_bindings/RenderCompositorSWGL.cpp

@@ -14,15 +14,23 @@ namespace wr {
 /* static */
 UniquePtr<RenderCompositor> RenderCompositorSWGL::Create(
     RefPtr<widget::CompositorWidget>&& aWidget) {
-  return MakeUnique<RenderCompositorSWGL>(std::move(aWidget));
+  void* ctx = wr_swgl_create_context();
+  if (!ctx) {
+    gfxCriticalNote << "Failed SWGL context creation for WebRender";
+    return nullptr;
+  }
+  return MakeUnique<RenderCompositorSWGL>(std::move(aWidget), ctx);
 }
 
 RenderCompositorSWGL::RenderCompositorSWGL(
-    RefPtr<widget::CompositorWidget>&& aWidget)
-    : RenderCompositor(std::move(aWidget)) {
+    RefPtr<widget::CompositorWidget>&& aWidget, void* aContext)
+    : RenderCompositor(std::move(aWidget)), mContext(aContext) {
+  MOZ_ASSERT(mContext);
 }
 
-RenderCompositorSWGL::~RenderCompositorSWGL() {}
+RenderCompositorSWGL::~RenderCompositorSWGL() {
+  wr_swgl_destroy_context(mContext);
+}
 
 void RenderCompositorSWGL::ClearMappedBuffer() {
   mMappedData = nullptr;
@@ -30,6 +38,11 @@ void RenderCompositorSWGL::ClearMappedBuffer() {
   mDT = nullptr;
 }
 
+bool RenderCompositorSWGL::MakeCurrent() {
+  wr_swgl_make_current(mContext);
+  return true;
+}
+
 bool RenderCompositorSWGL::BeginFrame() {
   // Request a new draw target to use from the widget...
   ClearMappedBuffer();
@@ -79,6 +92,9 @@ bool RenderCompositorSWGL::BeginFrame() {
     mMappedStride = map.mStride;
   }
   MOZ_ASSERT(mMappedData != nullptr && mMappedStride > 0);
+  wr_swgl_make_current(mContext);
+  wr_swgl_init_default_framebuffer(mContext, bounds.width, bounds.height,
+                                   mMappedStride, mMappedData);
   return true;
 }
 

gfx/webrender_bindings/RenderCompositorSWGL.h

@@ -18,22 +18,18 @@ class RenderCompositorSWGL : public RenderCompositor {
   static UniquePtr<RenderCompositor> Create(
       RefPtr<widget::CompositorWidget>&& aWidget);
 
-  RenderCompositorSWGL(RefPtr<widget::CompositorWidget>&& aWidget);
+  RenderCompositorSWGL(RefPtr<widget::CompositorWidget>&& aWidget,
+                       void* aContext);
   virtual ~RenderCompositorSWGL();
 
+  void* swgl() const override { return mContext; }
+
+  bool MakeCurrent() override;
+
   bool BeginFrame() override;
   void CancelFrame() override;
   RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) final;
 
-  bool GetMappedBuffer(uint8_t** aData, int32_t* aStride) override {
-    if (mMappedData) {
-      *aData = mMappedData;
-      *aStride = mMappedStride;
-      return true;
-    }
-    return false;
-  }
-
   void Pause() override;
   bool Resume() override;
 
@@ -43,6 +39,7 @@ class RenderCompositorSWGL : public RenderCompositor {
   CompositorCapabilities GetCompositorCapabilities() override;
 
  private:
+  void* mContext = nullptr;
   RefPtr<DrawTarget> mDT;
   LayoutDeviceIntRegion mRegion;
   RefPtr<DataSourceSurface> mSurface;

gfx/webrender_bindings/RenderThread.cpp

@@ -777,9 +777,13 @@ void RenderThread::InitDeviceTask() {
   MOZ_ASSERT(IsInRenderThread());
   MOZ_ASSERT(!mSharedGL);
 
+  if (gfx::gfxVars::UseSoftwareWebRender()) {
+    // Ensure we don't instantiate any shared GL context when SW-WR is used.
+    return;
+  }
+
   mSharedGL = CreateGLContext();
-  if (gfx::gfxVars::UseWebRenderProgramBinaryDisk() &&
-      !gfx::gfxVars::UseSoftwareWebRender()) {
+  if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) {
     mProgramCache = MakeUnique<WebRenderProgramCache>(ThreadPool().Raw());
   }
   // Query the shared GL context to force the
@@ -867,7 +871,7 @@ gl::GLContext* RenderThread::SharedGL() {
     mSharedGL = CreateGLContext();
     mShaders = nullptr;
   }
-  if (mSharedGL && !mShaders && !gfx::gfxVars::UseSoftwareWebRender()) {
+  if (mSharedGL && !mShaders) {
     mShaders = MakeUnique<WebRenderShaders>(mSharedGL, mProgramCache.get());
   }
 

gfx/webrender_bindings/RendererOGL.cpp

@@ -50,14 +50,12 @@ void wr_renderer_unlock_external_image(void* aObj, wr::ExternalImageId aId,
 RendererOGL::RendererOGL(RefPtr<RenderThread>&& aThread,
                          UniquePtr<RenderCompositor> aCompositor,
                          wr::WindowId aWindowId, wr::Renderer* aRenderer,
-                         layers::CompositorBridgeParent* aBridge,
-                         void* aSoftwareContext)
+                         layers::CompositorBridgeParent* aBridge)
     : mThread(aThread),
       mCompositor(std::move(aCompositor)),
       mRenderer(aRenderer),
       mBridge(aBridge),
       mWindowId(aWindowId),
-      mSoftwareContext(aSoftwareContext),
       mDisableNativeCompositor(false) {
   MOZ_ASSERT(mThread);
   MOZ_ASSERT(mCompositor);
@@ -68,9 +66,6 @@ RendererOGL::RendererOGL(RefPtr<RenderThread>&& aThread,
 
 RendererOGL::~RendererOGL() {
   MOZ_COUNT_DTOR(RendererOGL);
-  if (mSoftwareContext) {
-    wr_swgl_make_current(mSoftwareContext);
-  }
   if (!mCompositor->MakeCurrent()) {
     gfxCriticalNote
         << "Failed to make render context current during destroying.";
@@ -78,9 +73,6 @@ RendererOGL::~RendererOGL() {
   } else {
     wr_renderer_delete(mRenderer);
   }
-  if (mSoftwareContext) {
-    wr_swgl_destroy_context(mSoftwareContext);
-  }
 }
 
 wr::WrExternalImageHandler RendererOGL::GetExternalImageHandler() {
@@ -134,15 +126,6 @@ RenderedFrameId RendererOGL::UpdateAndRender(
 
   auto size = mCompositor->GetBufferSize();
 
-  if (mSoftwareContext) {
-    wr_swgl_make_current(mSoftwareContext);
-    uint8_t* data = nullptr;
-    int32_t stride = 0;
-    mCompositor->GetMappedBuffer(&data, &stride);
-    wr_swgl_init_default_framebuffer(mSoftwareContext, size.width, size.height,
-                                     stride, data);
-  }
-
   wr_renderer_update(mRenderer);
 
   bool fullRender = mCompositor->RequestFullRender();

gfx/webrender_bindings/RendererOGL.h

@@ -84,8 +84,7 @@ class RendererOGL {
   /// This can be called on the render thread only.
   RendererOGL(RefPtr<RenderThread>&& aThread,
               UniquePtr<RenderCompositor> aCompositor, wr::WindowId aWindowId,
-              wr::Renderer* aRenderer, layers::CompositorBridgeParent* aBridge,
-              void* aSoftwareContext = nullptr);
+              wr::Renderer* aRenderer, layers::CompositorBridgeParent* aBridge);
 
   /// This can be called on the render thread only.
   void Pause();
@@ -118,7 +117,6 @@ class RendererOGL {
   wr::Renderer* mRenderer;
   layers::CompositorBridgeParent* mBridge;
   wr::WindowId mWindowId;
-  void* mSoftwareContext;
   TimeStamp mFrameStartTime;
 
   bool mDisableNativeCompositor;

gfx/webrender_bindings/WebRenderAPI.cpp

@@ -70,11 +70,6 @@ class NewRenderer : public RendererEvent {
     *mUseDComp = compositor->UseDComp();
     *mUseTripleBuffering = compositor->UseTripleBuffering();
 
-    void* swCtx = nullptr;
-    if (gfx::gfxVars::UseSoftwareWebRender()) {
-      swCtx = wr_swgl_create_context();
-    }
-
     // Only allow the panic on GL error functionality in nightly builds,
     // since it (deliberately) crashes the GPU process if any GL call
     // returns an error code.
@@ -103,7 +98,8 @@ class NewRenderer : public RendererEvent {
 #else
             false,
 #endif
-            swCtx, compositor->gl(), compositor->SurfaceOriginIsTopLeft(),
+            compositor->swgl(), compositor->gl(),
+            compositor->SurfaceOriginIsTopLeft(),
             aRenderThread.GetProgramCache()
                 ? aRenderThread.GetProgramCache()->Raw()
                 : nullptr,
@@ -122,9 +118,6 @@ class NewRenderer : public RendererEvent {
             StaticPrefs::gfx_webrender_enable_gpu_markers_AtStartup(),
             panic_on_gl_error)) {
       // wr_window_new puts a message into gfxCriticalNote if it returns false
-      if (swCtx) {
-        wr_swgl_destroy_context(swCtx);
-      }
       return;
     }
     MOZ_ASSERT(wrRenderer);
@@ -132,7 +125,7 @@ class NewRenderer : public RendererEvent {
     RefPtr<RenderThread> thread = &aRenderThread;
     auto renderer =
         MakeUnique<RendererOGL>(std::move(thread), std::move(compositor),
-                                aWindowId, wrRenderer, mBridge, swCtx);
+                                aWindowId, wrRenderer, mBridge);
     if (wrRenderer && renderer) {
       wr::WrExternalImageHandler handler = renderer->GetExternalImageHandler();
       wr_renderer_set_external_image_handler(wrRenderer, &handler);