Changeset 214014 in webkit

Timestamp:

Mar 15, 2017 3:44:59 PM (7 years ago)

Author:

dbates@webkit.org

Message:

Iteratively dispatch DOM events after restoring a cached page
​https://bugs.webkit.org/show_bug.cgi?id=169703
<rdar://problem/31075903>

Reviewed by Brady Eidson.

Make dispatching of DOM events when restoring a page from the page cache symmetric with
dispatching of events when saving a page to the page cache.

• history/CachedFrame.cpp:

(WebCore::CachedFrameBase::restore): Move code to dispatch events from here to FrameLoader::didRestoreFromCachedPage().

• loader/FrameLoader.cpp:

(WebCore::FrameLoader::commitProvisionalLoad): Ensure that no DOM events are dispatched during
restoration of a cached page. Call didRestoreFromCachedPage() after restoring the page to
dispatch DOM events on the restored frames.
(WebCore::FrameLoader::willRestoreFromCachedPage): Renamed; formerly named prepareForCachedPageRestore().
(WebCore::FrameLoader::didRestoreFromCachedPage): Added.
(WebCore::FrameLoader::prepareForCachedPageRestore): Renamed to willRestoreFromCachedPage().

• loader/FrameLoader.h:
• page/FrameTree.cpp:

(WebCore::FrameTree::traverseNextInPostOrderWithWrap): Returns the next Frame* in a post-order
traversal of the frame tree optionally wrapping around to the deepest first child in the tree.
(WebCore::FrameTree::deepFirstChild): Added.

• page/FrameTree.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• history/CachedFrame.cpp (modified) (3 diffs)
• loader/FrameLoader.cpp (modified) (5 diffs)
• loader/FrameLoader.h (modified) (1 diff)
• page/FrameTree.cpp (modified) (1 diff)
• page/FrameTree.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-03-15  Daniel Bates  <dabates@apple.com>
+
+        Iteratively dispatch DOM events after restoring a cached page
+        https://bugs.webkit.org/show_bug.cgi?id=169703
+        <rdar://problem/31075903>
+
+        Reviewed by Brady Eidson.
+
+        Make dispatching of DOM events when restoring a page from the page cache symmetric with
+        dispatching of events when saving a page to the page cache.
+
+        * history/CachedFrame.cpp:
+        (WebCore::CachedFrameBase::restore): Move code to dispatch events from here to FrameLoader::didRestoreFromCachedPage().
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::commitProvisionalLoad): Ensure that no DOM events are dispatched during
+        restoration of a cached page. Call didRestoreFromCachedPage() after restoring the page to
+        dispatch DOM events on the restored frames.
+        (WebCore::FrameLoader::willRestoreFromCachedPage): Renamed; formerly named prepareForCachedPageRestore().
+        (WebCore::FrameLoader::didRestoreFromCachedPage): Added.
+        (WebCore::FrameLoader::prepareForCachedPageRestore): Renamed to willRestoreFromCachedPage().
+        * loader/FrameLoader.h:
+        * page/FrameTree.cpp:
+        (WebCore::FrameTree::traverseNextInPostOrderWithWrap): Returns the next Frame* in a post-order
+        traversal of the frame tree optionally wrapping around to the deepest first child in the tree.
+        (WebCore::FrameTree::deepFirstChild): Added.
+        * page/FrameTree.h:
+
 2017-03-15  Dave Hyatt  <hyatt@apple.com>
 

trunk/Source/WebCore/history/CachedFrame.cpp

@@ -36 +36 @@
 #include "FrameLoaderClient.h"
 #include "FrameView.h"
-#include "HistoryController.h"
-#include "HistoryItem.h"
 #include "Logging.h"
 #include "MainFrame.h"
 #include "Page.h"
 #include "PageCache.h"
-#include "PageTransitionEvent.h"
 #include "SVGDocumentExtensions.h"
 #include "ScriptController.h"
@@ -117 +114 @@
         frame.tree().appendChild(childFrame->view()->frame());
         childFrame->open();
+        ASSERT_WITH_SECURITY_IMPLICATION(m_document == frame.document());
     }
 
@@ -132 +130 @@
 #endif
 
-    // FIXME: update Page Visibility state here.
-    // https://bugs.webkit.org/show_bug.cgi?id=116770
-    m_document->enqueuePageshowEvent(PageshowEventPersisted);
-
-    HistoryItem* historyItem = frame.loader().history().currentItem();
-    if (historyItem && historyItem->stateObject())
-        m_document->enqueuePopstateEvent(historyItem->stateObject());
-
     frame.view()->didRestoreFromPageCache();
 }

trunk/Source/WebCore/loader/FrameLoader.cpp

@@ -87 +87 @@
 #include "MemoryCache.h"
 #include "MemoryRelease.h"
+#include "NoEventDispatchAssertion.h"
 #include "Page.h"
 #include "PageCache.h"
@@ -1814 +1815 @@
         m_frame.page()->chrome().setDispatchViewportDataDidChangeSuppressed(true);
 #endif
-        prepareForCachedPageRestore();
+        willRestoreFromCachedPage();
 
         // Start request for the main resource and dispatch didReceiveResponse before the load is committed for
@@ -1826 +1827 @@
         std::optional<HasInsecureContent> hasInsecureContent = cachedPage->cachedMainFrame()->hasInsecureContent();
 
-        // FIXME: This API should be turned around so that we ground CachedPage into the Page.
-        cachedPage->restore(*m_frame.page());
+        {
+            // Do not dispatch DOM events as their JavaScript listeners could cause the page to be put
+            // into the page cache before we have finished restoring it from the page cache.
+            NoEventDispatchAssertion assertNoEventDispatch;
+
+            // FIXME: This API should be turned around so that we ground CachedPage into the Page.
+            cachedPage->restore(*m_frame.page());
+        }
 
         dispatchDidCommitLoad(hasInsecureContent);
+
+        didRestoreFromCachedPage();
+
 #if PLATFORM(IOS)
         m_frame.page()->chrome().setDispatchViewportDataDidChangeSuppressed(false);
@@ -2048 +2058 @@
 }
 
-void FrameLoader::prepareForCachedPageRestore()
+void FrameLoader::willRestoreFromCachedPage()
 {
     ASSERT(!m_frame.tree().parent());
@@ -2064 +2074 @@
         window->setStatus(String());
         window->setDefaultStatus(String());
+    }
+}
+
+void FrameLoader::didRestoreFromCachedPage()
+{
+    // Dispatching JavaScript events can cause frame destruction.
+    auto& mainFrame = m_frame.page()->mainFrame();
+    Vector<Ref<Frame>> childFrames;
+    for (auto* child = mainFrame.tree().traverseNextInPostOrderWithWrap(true); child; child = child->tree().traverseNextInPostOrderWithWrap(false))
+        childFrames.append(*child);
+
+    for (auto& child : childFrames) {
+        if (!child->tree().isDescendantOf(&mainFrame))
+            continue;
+        auto* document = child->document();
+        if (!document)
+            continue;
+
+        // FIXME: Update Page Visibility state here.
+        // https://bugs.webkit.org/show_bug.cgi?id=116770
+        document->enqueuePageshowEvent(PageshowEventPersisted);
+
+        auto* historyItem = child->loader().history().currentItem();
+        if (historyItem && historyItem->stateObject())
+            document->enqueuePopstateEvent(historyItem->stateObject());
     }
 }

trunk/Source/WebCore/loader/FrameLoader.h

@@ -346 +346 @@
 
     void closeOldDataSources();
-    void prepareForCachedPageRestore();
+    void willRestoreFromCachedPage();
+    void didRestoreFromCachedPage();
 
     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);

trunk/Source/WebCore/page/FrameTree.cpp

@@ -432 +432 @@
 }
 
+Frame* FrameTree::traverseNextInPostOrderWithWrap(bool wrap) const
+{
+    if (m_nextSibling)
+        return m_nextSibling->tree().deepFirstChild();
+    if (m_parent)
+        return m_parent;
+    if (wrap)
+        return deepFirstChild();
+    return nullptr;
+}
+
+Frame* FrameTree::deepFirstChild() const
+{
+    Frame* result = &m_thisFrame;
+    while (auto* next = result->tree().firstChild())
+        result = next;
+    return result;
+}
+
 Frame* FrameTree::deepLastChild() const
 {

trunk/Source/WebCore/page/FrameTree.h

@@ -65 +65 @@
     WEBCORE_EXPORT Frame* traverseNextWithWrap(bool) const;
     WEBCORE_EXPORT Frame* traversePreviousWithWrap(bool) const;
-    
+
+    Frame* traverseNextInPostOrderWithWrap(bool) const;
+
     WEBCORE_EXPORT void appendChild(Frame&);
     void detachFromParent() { m_parent = nullptr; }
@@ -86 +88 @@
 
 private:
+    Frame* deepFirstChild() const;
     Frame* deepLastChild() const;