[PageLifecycle] Destroy/recreate gl assets on freeze/resume.

Author: magomez

Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

@@ -8037,6 +8037,12 @@ void WebGLRenderingContextBase::maybeRestoreContext()
     if (!hostWindow)
         return;
 
+    if (frame->settings().nonCompositedWebGLEnabled()) {
+        // If the context was lost because the browser was frozen, the nativeWindow will have changed
+        // when resuming, so we need to set the vale again.
+        m_attributes.nativeWindowID = hostWindow->nativeWindowID();
+    }
+
     RefPtr<GraphicsContextGL> context = hostWindow->createGraphicsContextGL(m_attributes);
     if (!context) {
         if (m_contextLostState->mode == RealLostContext)

Source/WebKit/Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.cpp

@@ -429,5 +429,52 @@ void ThreadedCompositor::targetRefreshRateDidChange(unsigned rate)
     m_displayRefreshMonitor->setTargetRefreshRate(rate);
 }
 
+void ThreadedCompositor::destroyGLResourcesAfterSuspend(bool destroyNativeWindow)
+{
+    // This must be called with the RunLoop suspended.
+    if (m_suspendedCount <= 0)
+        return;
+
+    m_scene->detach();
+    m_compositingRunLoop->performTaskSync([this, protectedThis = Ref { *this }, destroyNativeWindow] {
+        if (m_context) {
+            if (!m_context->makeContextCurrent())
+                return;
+
+            updateSceneWithoutRendering();
+            m_scene->purgeGLResources();
+            m_context = nullptr;
+        }
+
+        if (destroyNativeWindow) {
+            m_client.didDestroyGLContext();
+            m_nativeSurfaceHandle = 0;
+        }
+
+        m_scene = nullptr;
+    });
+}
+
+void ThreadedCompositor::recreateGLResourcesBeforeResume(bool nativeWindowWasDestroyed)
+{
+    // This must be called with the RunLoop suspended.
+    if (m_suspendedCount <= 0)
+        return;
+
+    m_compositingRunLoop->performTaskSync([this, protectedThis = Ref { *this }, nativeWindowWasDestroyed] {
+        m_scene = adoptRef(new CoordinatedGraphicsScene(this));
+
+        if (nativeWindowWasDestroyed)
+            m_nativeSurfaceHandle = m_client.nativeSurfaceHandleForCompositing();
+
+        createGLContext();
+        if (m_context) {
+            if (!m_nativeSurfaceHandle)
+                m_paintFlags |= TextureMapper::PaintingMirrored;
+        }
+    });
+}
+
+
 }
 #endif // USE(COORDINATED_GRAPHICS)

Source/WebKit/Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.h

@@ -83,6 +83,9 @@ class ThreadedCompositor : public CoordinatedGraphicsSceneClient, public ThreadS
     void resume();
     void renderSingleFrame();
 
+    void destroyGLResourcesAfterSuspend(bool);
+    void recreateGLResourcesBeforeResume(bool);
+
 private:
     ThreadedCompositor(Client&, ThreadedDisplayRefreshMonitor::Client&, WebCore::PlatformDisplayID, const WebCore::IntSize&, float scaleFactor, WebCore::TextureMapper::PaintFlags, bool);
 

Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/DrawingAreaCoordinatedGraphics.cpp

@@ -947,4 +947,21 @@ void DrawingAreaCoordinatedGraphics::renderSingleFrameIfRenderingPaused()
     m_layerTreeHost->renderSingleFrameWhilePaused();
 }
 
+
+void DrawingAreaCoordinatedGraphics::destroyGLResourcesAfterSuspend()
+{
+    if (!m_isPaintingSuspended || !m_usingPageLifecycle || !m_layerTreeHost)
+        return;
+
+    m_layerTreeHost->destroyGLResourcesAfterSuspend();
+}
+
+void DrawingAreaCoordinatedGraphics::recreateGLResourcesBeforeResume()
+{
+    if (!m_isPaintingSuspended || !m_usingPageLifecycle || !m_layerTreeHost)
+        return;
+
+    m_layerTreeHost->recreateGLResourcesBeforeResume();
+}
+
 } // namespace WebKit

Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/DrawingAreaCoordinatedGraphics.h

@@ -111,6 +111,9 @@ class DrawingAreaCoordinatedGraphics final : public DrawingArea {
 
     void renderSingleFrameIfRenderingPaused() final;
 
+    void destroyGLResourcesAfterSuspend() final;
+    void recreateGLResourcesBeforeResume() final;
+
     uint64_t m_backingStoreStateID { 0 };
 
     // Whether painting is enabled. If painting is disabled, any calls to setNeedsDisplay and scroll are ignored.

Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/LayerTreeHost.cpp

@@ -57,6 +57,7 @@ LayerTreeHost::LayerTreeHost(WebPage& webPage)
     , m_layerFlushTimer(RunLoop::main(), this, &LayerTreeHost::layerFlushTimerFired)
     , m_coordinator(webPage, *this)
     , m_usingPageLifecycle(webPage.corePage()->settings().pageLifecycleAPIEnabled())
+    , m_destroyNativeWindowOnSuspend(webPage.corePage()->settings().pageLifecycleAPIDestroyWindowOnFreeze())
 {
 #if USE(GLIB_EVENT_LOOP)
     m_layerFlushTimer.setPriority(RunLoopSourcePriority::LayerFlushTimer);
@@ -557,6 +558,31 @@ void LayerTreeHost::commitTransientZoom(double scale, FloatPoint origin)
 }
 #endif
 
+void LayerTreeHost::destroyGLResourcesAfterSuspend()
+{
+    if (!m_isSuspended || !m_usingPageLifecycle)
+        return;
+
+    // Tell the ThreadedCompositor to release its OpenGL resources.
+    m_compositor->destroyGLResourcesAfterSuspend(m_destroyNativeWindowOnSuspend);
+
+    // Destroy the sharingContext.
+    auto& display = PlatformDisplay::sharedDisplayForCompositing();
+    display.sharingGLContext()->makeContextCurrent();
+    display.clearSharingGLContext();
+}
+
+void LayerTreeHost::recreateGLResourcesBeforeResume()
+{
+    if (!m_isSuspended || !m_usingPageLifecycle)
+        return;
+
+    // The sharingContext will be automatically recreated when any GLContext is created.
+
+    // Tell the ThreadedCompositor to recreate its OpenGL resources.
+    m_compositor->recreateGLResourcesBeforeResume(m_destroyNativeWindowOnSuspend);
+}
+
 } // namespace WebKit
 
 #endif // USE(COORDINATED_GRAPHICS)

Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/LayerTreeHost.h

@@ -107,6 +107,9 @@ class LayerTreeHost
 
     uint64_t nativeWindowID() { return m_surface->window(); }
 
+    void destroyGLResourcesAfterSuspend();
+    void recreateGLResourcesBeforeResume();
+
 private:
 #if USE(COORDINATED_GRAPHICS)
     void layerFlushTimerFired();
@@ -222,6 +225,7 @@ class LayerTreeHost
     WebCore::FloatPoint m_transientZoomOrigin;
 #endif
     bool m_usingPageLifecycle { false };
+    bool m_destroyNativeWindowOnSuspend { false };
 };
 
 #if !USE(COORDINATED_GRAPHICS)

Source/WebKit/WebProcess/WebPage/DrawingArea.h

@@ -158,6 +158,9 @@ class DrawingArea : public IPC::MessageReceiver, public WebCore::DisplayRefreshM
 
     virtual void renderSingleFrameIfRenderingPaused() { };
 
+    virtual void destroyGLResourcesAfterSuspend() { };
+    virtual void recreateGLResourcesBeforeResume() { };
+
 protected:
     DrawingArea(DrawingAreaType, DrawingAreaIdentifier, WebPage&);
 

Source/WebKit/WebProcess/WebPage/WebPage.cpp

@@ -3805,6 +3805,10 @@ void WebPage::suspend(CompletionHandler<void(bool)>&& completionHandler)
     ASSERT(m_cachedPage);
     if (auto mainFrame = m_mainFrame->coreFrame())
         mainFrame->loader().detachFromAllOpenedFrames();
+
+    // Now that the page has been suspended, destroy the OpenGL resources used for rendering.
+    m_drawingArea->destroyGLResourcesAfterSuspend();
+
     completionHandler(true);
 }
 
@@ -3837,6 +3841,9 @@ void WebPage::resume(CompletionHandler<void(bool)>&& completionHandler)
     if (!cachedPage)
         return completionHandler(false);
 
+    // Before resuming the page, recreate the OpenGL resources required for rendering.
+    m_drawingArea->recreateGLResourcesBeforeResume();
+
     cachedPage->restore(*m_page);
     unfreezeLayerTree(LayerTreeFreezeReason::PageSuspended);