[PageLifecycle] Render single frame when launching hidden and resuming.

Author: magomez

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

@@ -181,6 +181,19 @@ void ThreadedCompositor::resume()
     m_compositingRunLoop->scheduleUpdate();
 }
 
+void ThreadedCompositor::renderSingleFrame()
+{
+    m_compositingRunLoop->performTaskSync([this, protectedThis = Ref { *this }] {
+        // This must be called with the RunLoop suspended.
+        if (m_suspendedCount <= 0)
+            return;
+
+        m_scene->setActive(true);
+        renderLayerTree();
+        m_scene->setActive(false);
+    });
+}
+
 void ThreadedCompositor::setScaleFactor(float scale)
 {
     Locker locker { m_attributes.lock };

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

@@ -81,6 +81,7 @@ class ThreadedCompositor : public CoordinatedGraphicsSceneClient, public ThreadS
     void suspend();
     void suspendToTransparent();
     void resume();
+    void renderSingleFrame();
 
 private:
     ThreadedCompositor(Client&, ThreadedDisplayRefreshMonitor::Client&, WebCore::PlatformDisplayID, const WebCore::IntSize&, float scaleFactor, WebCore::TextureMapper::PaintFlags, bool);

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

@@ -82,6 +82,10 @@ DrawingAreaCoordinatedGraphics::DrawingAreaCoordinatedGraphics(WebPage& webPage,
         m_webPage.corePage()->suspendActiveDOMObjectsAndAnimations();
         m_isViewSuspended = true;
     }
+
+    // Launch on hidden state situation.
+    if (m_usingPageLifecycle && !parameters.activityState.contains(ActivityState::IsVisible))
+        suspendPainting();
 }
 
 DrawingAreaCoordinatedGraphics::~DrawingAreaCoordinatedGraphics() = default;
@@ -935,4 +939,12 @@ uint64_t DrawingAreaCoordinatedGraphics::nativeWindowID() const
     return m_layerTreeHost ? m_layerTreeHost->nativeWindowID() : 0;
 }
 
+void DrawingAreaCoordinatedGraphics::renderSingleFrameIfRenderingPaused()
+{
+    if (!m_isPaintingSuspended || !m_usingPageLifecycle || !m_layerTreeHost)
+        return;
+
+    m_layerTreeHost->renderSingleFrameWhilePaused();
+}
+
 } // namespace WebKit

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

@@ -109,6 +109,8 @@ class DrawingAreaCoordinatedGraphics final : public DrawingArea {
 
     uint64_t nativeWindowID() const final;
 
+    void renderSingleFrameIfRenderingPaused() 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

@@ -56,6 +56,7 @@ LayerTreeHost::LayerTreeHost(WebPage& webPage)
     , m_viewportController(webPage.size())
     , m_layerFlushTimer(RunLoop::main(), this, &LayerTreeHost::layerFlushTimerFired)
     , m_coordinator(webPage, *this)
+    , m_usingPageLifecycle(webPage.corePage()->settings().pageLifecycleAPIEnabled())
 {
 #if USE(GLIB_EVENT_LOOP)
     m_layerFlushTimer.setPriority(RunLoopSourcePriority::LayerFlushTimer);
@@ -273,6 +274,22 @@ void LayerTreeHost::resumeRendering()
     m_compositor->resume();
 }
 
+void LayerTreeHost::renderSingleFrameWhilePaused()
+{
+    // This allows painting a single frame while the rendering has been paused without
+    // actually resuming it. This is only used on 2 cases when page lifecycle is enabled:
+    // - When launching the application on hidden state.
+    // - When resuming from suspension into hidden state.
+
+    if (!m_isSuspended || !m_usingPageLifecycle)
+        return;
+
+    m_isSuspended = false;
+    renderNextFrame(true);
+    m_isSuspended = true;
+    m_compositor->renderSingleFrame();
+}
+
 GraphicsLayerFactory* LayerTreeHost::graphicsLayerFactory()
 {
     return &m_coordinator;

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

@@ -85,6 +85,7 @@ class LayerTreeHost
 
     void pauseRendering(bool toTransparent = false);
     void resumeRendering();
+    void renderSingleFrameWhilePaused();
 
     WebCore::GraphicsLayerFactory* graphicsLayerFactory();
 
@@ -220,6 +221,7 @@ class LayerTreeHost
     double m_transientZoomScale { 1 };
     WebCore::FloatPoint m_transientZoomOrigin;
 #endif
+    bool m_usingPageLifecycle { false };
 };
 
 #if !USE(COORDINATED_GRAPHICS)

Source/WebKit/WebProcess/WebPage/DrawingArea.h

@@ -156,6 +156,8 @@ class DrawingArea : public IPC::MessageReceiver, public WebCore::DisplayRefreshM
 
     virtual uint64_t nativeWindowID() const = 0;
 
+    virtual void renderSingleFrameIfRenderingPaused() { };
+
 protected:
     DrawingArea(DrawingAreaType, DrawingAreaIdentifier, WebPage&);
 

Source/WebKit/WebProcess/WebPage/WebPage.cpp

@@ -583,6 +583,7 @@ WebPage::WebPage(PageIdentifier pageID, WebPageCreationParameters&& parameters)
 #if ENABLE(APP_HIGHLIGHTS)
     , m_appHighlightsVisible(parameters.appHighlightsVisible)
 #endif
+    , m_renderSingleFrameIfRenderingPausedTimer(*this, &WebPage::renderSingleFrameIfRenderingPausedTimerFired)
 {
     ASSERT(m_identifier);
     WEBPAGE_RELEASE_LOG(Loading, "constructor:");
@@ -3844,6 +3845,9 @@ void WebPage::resume(CompletionHandler<void(bool)>&& completionHandler)
     Ref<ResumeEventNotifier> notifier = adoptRef(*new ResumeEventNotifier());
     notifier->setCompletionHandler([this, completionHandler = std::exchange(completionHandler, { })] () mutable {
         m_isLifecycleSuspended = false;
+        // This is the last step of the resume before moving into hidden state, so we want to request
+        // a single frame here.
+        m_drawingArea->renderSingleFrameIfRenderingPaused();
         completionHandler(true);
     });
 
@@ -7259,6 +7263,15 @@ void WebPage::dispatchDidReachLayoutMilestone(OptionSet<WebCore::LayoutMilestone
         updateIntrinsicContentSizeIfNeeded(mainFrameView()->autoSizingIntrinsicContentSize());
     }
 
+    if (milestones.contains(DidFirstLayout) && m_page->settings().pageLifecycleAPIEnabled() && !m_isLifecycleSuspended) {
+        // The page finished its first layout. This can happen when the page is loaded for the first time or
+        // when the view is resuming. If m_isLifecycleSuspended is false it means that it's the first load
+        // so this is the point where we want to request a single frame if the view is hidden. We cannot try
+        // to render the frame directly because scripts are disallowed at this point, and we may need them when
+        // rendering, so request the frame with a timer.
+        m_renderSingleFrameIfRenderingPausedTimer.startOneShot(0_s);
+    }
+
     send(Messages::WebPageProxy::DidReachLayoutMilestone(milestones));
 }
 
@@ -8250,6 +8263,11 @@ void WebPage::clearNotificationPermissionState()
 }
 #endif
 
+void WebPage::renderSingleFrameIfRenderingPausedTimerFired()
+{
+    m_drawingArea->renderSingleFrameIfRenderingPaused();
+}
+
 } // namespace WebKit
 
 #undef WEBPAGE_RELEASE_LOG

Source/WebKit/WebProcess/WebPage/WebPage.h

@@ -2031,6 +2031,8 @@ class WebPage : public API::ObjectImpl<API::Object::Type::BundlePage>, public IP
     bool hasPendingEditorStateUpdate() const;
     bool shouldAvoidComputingPostLayoutDataForEditorState() const;
 
+    void renderSingleFrameIfRenderingPausedTimerFired();
+
     WebCore::PageIdentifier m_identifier;
 
     std::unique_ptr<WebCore::Page> m_page;
@@ -2510,6 +2512,7 @@ class WebPage : public API::ObjectImpl<API::Object::Type::BundlePage>, public IP
 #if ENABLE(IMAGE_ANALYSIS_ENHANCEMENTS)
     WeakHashSet<WebCore::HTMLImageElement> m_elementsToExcludeFromRemoveBackground;
 #endif
+    WebCore::Timer m_renderSingleFrameIfRenderingPausedTimer;
 };
 
 #if !PLATFORM(IOS_FAMILY)