[PageLifecycle] Emit proper events when freezing and resuming.

Author: magomez

Source/WebCore/dom/Document.cpp

@@ -9250,6 +9250,29 @@ bool Document::lazyImageLoadingEnabled() const
     return m_settings->lazyImageLoadingEnabled() && !m_quirks->shouldDisableLazyImageLoadingQuirk();
 }
 
+// https://wicg.github.io/page-lifecycle/spec.html#freeze-steps
+void Document::freeze()
+{
+    if (m_frozen)
+        return;
+
+    m_frozen = true;
+    dispatchEvent(Event::create(eventNames().freezeEvent, Event::CanBubble::No, Event::IsCancelable::No));
+}
+
+// https://wicg.github.io/page-lifecycle/spec.html#resume-steps
+void Document::resume(CompletionHandler<void(Document&)>&& completionHandler)
+{
+    if (!m_frozen)
+        return;
+
+    eventLoop().queueTask(TaskSource::UserInteraction, [document = Ref { *this }, this, completionHandler = WTFMove(completionHandler)] () mutable {
+        dispatchEvent(Event::create(eventNames().resumeEvent, Event::CanBubble::No, Event::IsCancelable::No));
+        m_frozen = false;
+        completionHandler(document);
+    });
+}
+
 } // namespace WebCore
 
 #undef DOCUMENT_RELEASE_LOG

Source/WebCore/dom/Document.h

@@ -1696,6 +1696,9 @@ class Document
     // This should be used over the settings lazy loading image flag due to a quirk, which may occur causing website images to fail to load properly.
     bool lazyImageLoadingEnabled() const;
 
+    void freeze();
+    void resume(CompletionHandler<void(Document&)>&&);
+
 protected:
     enum ConstructionFlags { Synthesized = 1, NonRenderedPlaceholder = 1 << 1 };
     WEBCORE_EXPORT Document(Frame*, const Settings&, const URL&, DocumentClasses = { }, unsigned constructionFlags = 0, ScriptExecutionContextIdentifier = { });
@@ -2292,6 +2295,8 @@ class Document
     Vector<Function<void()>> m_whenIsVisibleHandlers;
 
     WeakHashSet<Element> m_elementsWithPendingUserAgentShadowTreeUpdates;
+
+    bool m_frozen { false };
 };
 
 Element* eventTargetElementForDocument(Document*);

Source/WebCore/dom/Document.idl

@@ -94,6 +94,9 @@ typedef (HTMLScriptElement or SVGScriptElement) HTMLOrSVGScriptElement;
 
     // Non standard: It has been dropped from Blink already.
     RenderingContext? getCSSCanvasContext(DOMString contextId, DOMString name, long width, long height);
+
+    [EnabledBySetting=PageLifecycleAPIEnabled] attribute EventHandler onfreeze;
+    [EnabledBySetting=PageLifecycleAPIEnabled] attribute EventHandler onresume;
 };
 
 enum DocumentReadyState { "loading", "interactive", "complete" };

Source/WebCore/dom/EventNames.h

@@ -130,6 +130,7 @@ namespace WebCore {
     macro(focusin) \
     macro(focusout) \
     macro(formdata) \
+    macro(freeze) \
     macro(gamepadconnected) \
     macro(gamepaddisconnected) \
     macro(gatheringstatechange) \

Source/WebCore/history/BackForwardCache.cpp

@@ -403,7 +403,7 @@ static void destroyRenderTree(Frame& mainFrame)
     }
 }
 
-static void firePageHideEventRecursively(Frame& frame)
+static void firePageHideEventRecursively(Frame& frame, bool usePageLifecycleEvents)
 {
     auto* document = frame.document();
     if (!document)
@@ -415,10 +415,11 @@ static void firePageHideEventRecursively(Frame& frame)
     // https://html.spec.whatwg.org/multipage/browsers.html#unload-a-document
     IgnoreOpensDuringUnloadCountIncrementer ignoreOpensDuringUnloadCountIncrementer(document);
 
-    frame.loader().stopLoading(UnloadEventPolicy::UnloadAndPageHide);
+    UnloadEventPolicy eventPolicy = usePageLifecycleEvents ? UnloadEventPolicy::None : UnloadEventPolicy::UnloadAndPageHide;
+    frame.loader().stopLoading(eventPolicy);
 
     for (RefPtr<Frame> child = frame.tree().firstChild(); child; child = child->tree().nextSibling())
-        firePageHideEventRecursively(*child);
+        firePageHideEventRecursively(*child, usePageLifecycleEvents);
 }
 
 std::unique_ptr<CachedPage> BackForwardCache::trySuspendPage(Page& page, ForceSuspension forceSuspension)
@@ -438,7 +439,7 @@ std::unique_ptr<CachedPage> BackForwardCache::trySuspendPage(Page& page, ForceSu
         focusController->setFocusedFrame(&page.mainFrame());
 
     // Fire the pagehide event in all frames.
-    firePageHideEventRecursively(page.mainFrame());
+    firePageHideEventRecursively(page.mainFrame(), m_usePageLifecycleEvents);
 
     destroyRenderTree(page.mainFrame());
 

Source/WebCore/history/BackForwardCache.h

@@ -69,6 +69,8 @@ class BackForwardCache {
     void markPagesForCaptionPreferencesChanged();
 #endif
 
+    void setUsePageLifecycleEvents(bool use) { m_usePageLifecycleEvents = use; }
+
 private:
     BackForwardCache();
     ~BackForwardCache() = delete; // Make sure nobody accidentally calls delete -- WebCore does not delete singletons.
@@ -87,6 +89,8 @@ class BackForwardCache {
     bool m_isInRemoveAllItemsForPage { false };
 #endif
 
+    bool m_usePageLifecycleEvents { false };
+
     friend class WTF::NeverDestroyed<BackForwardCache>;
 };
 

Source/WebKit/WebProcess/WebPage/WebPage.cpp

@@ -3789,15 +3789,42 @@ void WebPage::suspend(CompletionHandler<void(bool)>&& completionHandler)
     if (!m_page)
         return completionHandler(false);
 
+    m_isLifecycleSuspended = true;
+
+    // Suspend all the documents, so they can send the freeze event to the apps.
+    m_page->forEachDocument([] (Document& document) {
+        document.freeze();
+    });
+
     freezeLayerTree(LayerTreeFreezeReason::PageSuspended);
 
+    BackForwardCache::singleton().setUsePageLifecycleEvents(true);
     m_cachedPage = BackForwardCache::singleton().suspendPage(*m_page);
+    BackForwardCache::singleton().setUsePageLifecycleEvents(false);
     ASSERT(m_cachedPage);
     if (auto mainFrame = m_mainFrame->coreFrame())
         mainFrame->loader().detachFromAllOpenedFrames();
     completionHandler(true);
 }
 
+class ResumeEventNotifier : public RefCounted<ResumeEventNotifier> {
+public:
+    ResumeEventNotifier() = default;
+    virtual ~ResumeEventNotifier() = default;
+
+    void setCompletionHandler(CompletionHandler<void()>&& completionHandler) { m_completionHandler = WTFMove(completionHandler); };
+    void addDocument(Ref<Document> document) { m_documents.add(document); };
+    void removeDocument(Ref<Document> document) {
+        m_documents.remove(document);
+        if (m_documents.isEmpty())
+            m_completionHandler();
+    }
+
+private:
+    CompletionHandler<void()> m_completionHandler;
+    HashSet<Ref<Document>> m_documents;
+};
+
 void WebPage::resume(CompletionHandler<void(bool)>&& completionHandler)
 {
     WEBPAGE_RELEASE_LOG(Loading, "resume: m_page=%p", m_page.get());
@@ -3811,7 +3838,22 @@ void WebPage::resume(CompletionHandler<void(bool)>&& completionHandler)
 
     cachedPage->restore(*m_page);
     unfreezeLayerTree(LayerTreeFreezeReason::PageSuspended);
-    completionHandler(true);
+
+    // Create a notifier that will call the completionHandler once all the documents
+    // have dispatched their resume event.
+    Ref<ResumeEventNotifier> notifier = adoptRef(*new ResumeEventNotifier());
+    notifier->setCompletionHandler([this, completionHandler = std::exchange(completionHandler, { })] () mutable {
+        m_isLifecycleSuspended = false;
+        completionHandler(true);
+    });
+
+    // Resume all the documents.
+    m_page->forEachDocument([notifier] (Document& document) {
+        notifier->addDocument(document);
+        document.resume([protectedNotifier = Ref { notifier }] (Document& document) {
+            protectedNotifier->removeDocument(document);
+        });
+    });
 }
 
 IntPoint WebPage::screenToRootView(const IntPoint& point)

Source/WebKit/WebProcess/WebPage/WebPage.h

@@ -2429,6 +2429,7 @@ class WebPage : public API::ObjectImpl<API::Object::Type::BundlePage>, public IP
 
     OptionSet<LayerTreeFreezeReason> m_layerTreeFreezeReasons;
     bool m_isSuspended { false };
+    bool m_isLifecycleSuspended { false };
     bool m_needsFontAttributes { false };
     bool m_firstFlushAfterCommit { false };
 #if PLATFORM(COCOA)