[PageLifecycle] Release WebGL GCGLContext on freeze and recreate on resume.

Author: magomez

Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

@@ -1308,8 +1308,9 @@ void WebGLRenderingContextBase::destroyGraphicsContextGL()
     removeActivityStateChangeObserver();
 
     if (m_context) {
-        // first release the big textures allocated for the FBOs
-        m_context->reshape(0,0);
+        // first release the big textures allocated for the FBOs. Need to set (1, 1) because
+        // (0, 0) produces an error on the GL layer.
+        m_context->reshape(1, 1);
         m_context->setClient(nullptr);
         m_context = nullptr;
         removeActiveContext(*this);
@@ -6786,14 +6787,44 @@ const char* WebGLRenderingContextBase::activeDOMObjectName() const
     return "WebGLRenderingContext";
 }
 
-void WebGLRenderingContextBase::suspend(ReasonForSuspension)
+void WebGLRenderingContextBase::suspend(ReasonForSuspension reason)
 {
+    if (reason != ReasonForSuspension::BackForwardCache)
+        return;
+
+    // forceLostContext() will queue a task to dispatch the contextLost event. This task won't
+    // be executed until resume, when the events are enabled again.
+    forceLostContext(WebGLRenderingContextBase::SyntheticLostContext);
+    destroyGraphicsContextGL();
     m_isSuspended = true;
 }
 
 void WebGLRenderingContextBase::resume()
 {
     m_isSuspended = false;
+
+    // The composition requirements update for the page, which will set the appropriate proxy to the
+    // GraphicsLayer created for this WebGL context, will be updated after this function, but before
+    // any task that we may schedule. Due to this, we need to create the GCGLContext now, we cannot
+    // call forceRestoreContext() that will use a timer to call maybeRestoreContext(), we
+    // need to call maybeRestoreContext() directly.
+
+    // At some point after this function ends, the task to dispatch the contextLost event that was scheduled
+    // on suspend will run. The problem is that maybeRestoreContext() later in this function will create a new
+    // GCGLContext now, so when the task runs, context is not lost anymore and the event won't be sent. Set
+    // m_forceDispatchContextLostEvent so the task sends the event even if the context was already restored.
+    m_forceDispatchContextLostEvent =  true;
+
+    // Set restoreRequested to true so maybeRestoreContext() really performs the restore.
+    m_contextLostState->restoreRequested = true;
+
+    // Set m_queueContextRestoredEvent so maybeRestoreContext() doesn't send the contextRestored
+    // event immediately, but queues it. We need to do this because the contextRestored event that was
+    // queued on suspension hasn't run yet, and needs ro run before the contextRestored event is
+    // dispatched.
+    m_queueContextRestoredEvent = true;
+
+    maybeRestoreContext();
 }
 
 bool WebGLRenderingContextBase::getBooleanParameter(GCGLenum pname)
@@ -7961,10 +7992,14 @@ void WebGLRenderingContextBase::scheduleTaskToDispatchContextLostEvent()
 
     // It is safe to capture |this| because we keep the canvas element alive and it owns |this|.
     queueTaskKeepingObjectAlive(*canvas, TaskSource::WebGL, [this, canvas] {
-        if (isContextStopped())
-            return;
-        if (!isContextLost())
-            return;
+        if (m_forceDispatchContextLostEvent)
+            m_forceDispatchContextLostEvent = false;
+        else {
+            if (isContextStopped())
+                return;
+            if (!isContextLost())
+                return;
+        }
         auto event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, Event::CanBubble::No, Event::IsCancelable::Yes, emptyString());
         canvas->dispatchEvent(event);
         m_contextLostState->restoreRequested = event->defaultPrevented();
@@ -8016,6 +8051,21 @@ void WebGLRenderingContextBase::maybeRestoreContext()
     m_contextLostState = std::nullopt;
     setupFlags();
     initializeNewContext();
+
+    if (m_queueContextRestoredEvent) {
+        m_queueContextRestoredEvent = false;
+
+        // It is safe to capture |this| because we keep the canvas element alive and it owns |this|.
+        queueTaskKeepingObjectAlive(*canvas, TaskSource::WebGL, [this, canvas] {
+            if (isContextStopped())
+                return;
+            if (isContextLost())
+                return;
+            canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, Event::CanBubble::No, Event::IsCancelable::Yes, emptyString()));
+        });
+        return;
+    }
+
     if (!isContextLost())
         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, Event::CanBubble::No, Event::IsCancelable::Yes, emptyString()));
 }

Source/WebCore/html/canvas/WebGLRenderingContextBase.h

@@ -1213,6 +1213,8 @@ class WebGLRenderingContextBase : public GraphicsContextGL::Client, public GPUBa
 #endif
     // The ordinal number of when the context was last active (drew, read pixels).
     uint64_t m_activeOrdinal { 0 };
+    bool m_queueContextRestoredEvent { false };
+    bool m_forceDispatchContextLostEvent { false };
 };
 
 #if !USE(ANGLE)