[Async][WIP] Call FrameLoader::checkCompleted() asynchronously to avoid sync body.onload()

third_party/WebKit/Source/core/loader/FrameLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
  * Copyright (C) 2011 Kris Jordan <krisjordan@gmail.com>
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ skipping 16 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/loader/FrameLoader.h"
 
+#include "base/debug/stack_trace.h"
+
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ViewportDescription.h"
 #include "core/editing/Editor.h"
 #include "core/editing/commands/UndoStack.h"
 #include "core/events/GestureEvent.h"
@@ skipping 174 matching lines @@
     }
 
     if (!defers) {
         if (m_deferredHistoryLoad) {
             load(FrameLoadRequest(nullptr, m_deferredHistoryLoad->m_request),
                 m_deferredHistoryLoad->m_loadType, m_deferredHistoryLoad->m_item.get(),
                 m_deferredHistoryLoad->m_historyLoadType);
             m_deferredHistoryLoad.clear();
         }
         m_frame->navigationScheduler().startTimer();
-        scheduleCheckCompleted();
+        checkCompleted(0);
     }
 }
 
 void FrameLoader::saveScrollState()
 {
     if (!m_currentItem || !m_frame->view())
         return;
 
     // Shouldn't clobber anything if we might still restore later.
     if (needsHistoryItemRestore(m_loadType) && m_documentLoader && !m_documentLoader->initialScrollState().wasScrolledByUser)
@@ skipping 242 matching lines @@
     // This can be called from the LocalFrame's destructor, in which case we shouldn't protect ourselves
     // because doing so will cause us to re-enter the destructor when protector goes out of scope.
     // Null-checking the FrameView indicates whether or not we're in the destructor.
     RefPtrWillBeRawPtr<LocalFrame> protect(m_frame->view() ? m_frame.get() : nullptr);
 
     m_progressTracker->finishedParsing();
 
     if (client())
         client()->dispatchDidFinishDocumentLoad(m_documentLoader ? m_documentLoader->isCommittedButEmpty() : true);
 
-    checkCompleted();
+    checkCompleted(1);
 
     if (!m_frame->view())
         return; // We are being destroyed by something checkCompleted called.
 
     // Check if the scrollbars are really needed for the content.
     // If not, remove them, relayout, and repaint.
     m_frame->view()->restoreScrollbar();
     processFragment(m_frame->document()->url(), NavigationToDifferentDocument);
 }
 
@@ skipping 53 matching lines @@
 static bool shouldSendCompleteNotification(LocalFrame* frame)
 {
     // FIXME: We might have already sent stop notifications and be re-completing.
     if (!frame->isLoading())
         return false;
     // Only send didStopLoading() if there are no navigations in progress at all,
     // whether committed, provisional, or pending.
     return frame->loader().documentLoader()->sentDidFinishLoad() && !frame->loader().provisionalDocumentLoader() && !frame->loader().client()->hasPendingNavigation();
 }
 
-void FrameLoader::checkCompleted()
+void FrameLoader::checkCompletedNow(int)
 {
+    // fprintf(stderr, "checkCompletedNow(%p)\n", this);
+    // base::debug::StackTrace().Print();
     RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
-    if (!shouldComplete(m_frame->document()))
+    if (!shouldComplete(m_frame->document())) {
+        // fprintf(stderr, "checkCompletedNow(%p): not shouldComplete(0\n", this);
         return;
+    }
 
     // OK, completed.
     m_frame->document()->setReadyState(Document::Complete);
-    if (m_frame->document()->loadEventStillNeeded())
+    if (m_frame->document()->loadEventStillNeeded()) {
+        // fprintf(stderr, "checkCompletedNow(%p): implicitClose()\n", this);
         m_frame->document()->implicitClose();
+    }
 
     m_frame->navigationScheduler().startTimer();
 
-    if (m_frame->view())
+    if (m_frame->view()) {
+        // fprintf(stderr, "checkCompletedNow(%p): handleLoadCompleted()\n", this);
         m_frame->view()->handleLoadCompleted();
+    }
 
     // The readystatechanged or load event may have disconnected this frame.
     if (!m_frame->client())
         return;
 
     if (shouldSendFinishNotification(m_frame)) {
         // Report mobile vs. desktop page statistics. This will only report on Android.
+        // fprintf(stderr, "checkCompletedNow(%p): Finish Notification\n", this);
         if (m_frame->isMainFrame())
             m_frame->document()->viewportDescription().reportMobilePageStats(m_frame);
         m_documentLoader->setSentDidFinishLoad();
         client()->dispatchDidFinishLoad();
         // Finishing the load can detach the frame when running layout tests.
         if (!m_frame->client())
             return;
     }
 
     if (shouldSendCompleteNotification(m_frame)) {
+        // fprintf(stderr, "checkCompletedNow(%p): Complete Notification\n", this);
         m_progressTracker->progressCompleted();
         // Retry restoring scroll offset since finishing loading disables content
         // size clamping.
         restoreScrollPositionAndViewState();
 
         m_loadType = FrameLoadTypeStandard;
         m_frame->localDOMWindow()->finishedLoading();
     }
 
+    // fprintf(stderr, "checkCompletedNow(%p): Check Parent Notification\n", this);
     Frame* parent = m_frame->tree().parent();
     if (parent && parent->isLocalFrame())
-        toLocalFrame(parent)->loader().checkCompleted();
+        toLocalFrame(parent)->loader().checkCompleted(2);
 }
 
 void FrameLoader::checkTimerFired(Timer<FrameLoader>*)
 {
     if (Page* page = m_frame->page()) {
         if (page->defersLoading())
             return;
     }
-    checkCompleted();
+    checkCompletedNow(-1);
 }
 
-void FrameLoader::scheduleCheckCompleted()
+void FrameLoader::checkCompleted(int n)
 {
+/*
+ID Can be sync?
+0  ?             FrameLoader::setDefersLoading(bool defers)
+1  N             FrameLoader::finishedParsing()
+2  Y             FrameLoader::checkCompletedNow
+3  Y?            FrameLoader::loadInSameDocument
+4  Y?            FrameLoader::detach
+5  N             FrameLoader::receivedMainResourceError
+6  N             FrameFetchContext::didLoadResource() - matters
+7  ?             Document::close()
+8  ?             Document::loadEventDelayTimerFired
+9  ?             WebRemoteFrameImpl::didStopLoading()
+10 ?             HTMLImportTreeRoot::stateDidChange()
+
+*/
+/*
+    fprintf(stderr, "checkCompleted(%d)\n", n);
+    if (n == 6)
+      base::debug::StackTrace().Print();
+*/
+    if ((1<<2) & (1<<n)) {
+        checkCompletedNow(-1);
+    } else {
     if (!m_checkTimer.isActive())
         m_checkTimer.startOneShot(0, BLINK_FROM_HERE);
+    }
 }
 
 Frame* FrameLoader::opener()
 {
     return client() ? client()->opener() : 0;
 }
 
 void FrameLoader::setOpener(LocalFrame* opener)
 {
     // If the frame is already detached, the opener has already been cleared.
@@ skipping 72 matching lines @@
     if (hashChange) {
         // If we were in the autoscroll/panScroll mode we want to stop it before following the link to the anchor
         m_frame->eventHandler().stopAutoscroll();
         m_frame->localDOMWindow()->enqueueHashchangeEvent(oldURL, url);
     }
     m_documentLoader->setIsClientRedirect(clientRedirect == ClientRedirect);
     updateForSameDocumentNavigation(url, SameDocumentNavigationDefault, nullptr, ScrollRestorationAuto, frameLoadType);
 
     m_documentLoader->initialScrollState().wasScrolledByUser = false;
 
-    checkCompleted();
+    checkCompleted(3);
 
     m_frame->localDOMWindow()->statePopped(stateObject ? stateObject : SerializedScriptValue::nullValue());
 
     if (historyLoadType == HistorySameDocumentLoad)
         restoreScrollPositionAndViewState();
 
     // We need to scroll to the fragment whether or not a hash change occurred, since
     // the user might have scrolled since the previous navigation.
     processFragment(url, NavigationWithinSameDocument);
 }
@@ skipping 263 matching lines @@
 
     m_frame->document()->suppressLoadEvent();
     if (m_provisionalDocumentLoader)
         m_provisionalDocumentLoader->stopLoading();
     if (m_documentLoader)
         m_documentLoader->stopLoading();
     m_frame->document()->cancelParsing();
 
     detachDocumentLoader(m_provisionalDocumentLoader);
 
+    if (m_checkTimer.isActive())
+        checkCompletedNow(-1);
     m_checkTimer.stop();
     m_frame->navigationScheduler().cancel();
 
     m_inStopAllLoaders = false;
+    // checkCompletedNow();
 }
 
 void FrameLoader::didAccessInitialDocument()
 {
     // We only need to notify the client once, and only for the main frame.
     if (isLoadingMainFrame() && !m_didAccessInitialDocument) {
         m_didAccessInitialDocument = true;
         // Notify asynchronously, since this is called within a JavaScript security check.
         m_didAccessInitialDocumentTimer.startOneShot(0, BLINK_FROM_HERE);
     }
@@ skipping 179 matching lines @@
 {
 #if !ENABLE(OILPAN)
     // The caller must protect a reference to m_frame.
     ASSERT(m_frame->refCount() > 1);
 #endif
     detachDocumentLoader(m_documentLoader);
     detachDocumentLoader(m_provisionalDocumentLoader);
 
     Frame* parent = m_frame->tree().parent();
     if (parent && parent->isLocalFrame())
-        toLocalFrame(parent)->loader().scheduleCheckCompleted();
+        toLocalFrame(parent)->loader().checkCompleted(4);
     if (m_progressTracker) {
         m_progressTracker->dispose();
         m_progressTracker.clear();
     }
 }
 
 void FrameLoader::receivedMainResourceError(DocumentLoader* loader, const ResourceError& error)
 {
     // Retain because the stop may release the last reference to it.
     RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
@@ skipping 18 matching lines @@
     } else {
         ASSERT(loader == m_documentLoader);
         if (m_frame->document()->parser())
             m_frame->document()->parser()->stopParsing();
         m_documentLoader->setSentDidFinishLoad();
         if (!m_provisionalDocumentLoader && m_frame->isLoading()) {
             client()->dispatchDidFailLoad(error, historyCommitType);
             m_progressTracker->progressCompleted();
         }
     }
-    checkCompleted();
+    checkCompleted(5);
 }
 
 bool FrameLoader::shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType loadType, const KURL& url)
 {
     // We don't do this if we are submitting a form with method other than "GET", explicitly reloading,
     // currently displaying a frameset, or if the URL does not have a fragment.
     return (!isFormSubmission || equalIgnoringCase(httpMethod, HTTPNames::GET))
         && loadType != FrameLoadTypeReload
         && loadType != FrameLoadTypeReloadFromOrigin
         && loadType != FrameLoadTypeSame
@@ skipping 121 matching lines @@
     if (!shouldClose(navigationType == NavigationTypeReload))
         return;
 
     m_frame->document()->cancelParsing();
 
     if (m_provisionalDocumentLoader) {
         m_provisionalDocumentLoader->stopLoading();
         detachDocumentLoader(m_provisionalDocumentLoader);
     }
 
+    if (m_checkTimer.isActive())
+        checkCompletedNow(-1);
+    m_checkTimer.stop();
+
     // beforeunload fired above, and detaching a DocumentLoader can fire
     // events, which can detach this frame.
     if (!m_frame->host())
         return;
 
     m_provisionalDocumentLoader = client()->createDocumentLoader(m_frame, request, frameLoadRequest.substituteData().isValid() ? frameLoadRequest.substituteData() : defaultSubstituteDataForURL(request.url()));
     m_provisionalDocumentLoader->setNavigationType(navigationType);
     m_provisionalDocumentLoader->setReplacesCurrentHistoryItem(type == FrameLoadTypeReplaceCurrentItem);
     m_provisionalDocumentLoader->setIsClientRedirect(frameLoadRequest.clientRedirect() == ClientRedirect);
 
     InspectorInstrumentation::didStartProvisionalLoad(m_frame);
 
     m_frame->navigationScheduler().cancel();
+
+    if (m_checkTimer.isActive())
+        checkCompletedNow(-1);
     m_checkTimer.stop();
 
     m_loadType = type;
 
     if (frameLoadRequest.form())
         client()->dispatchWillSubmitForm(frameLoadRequest.form());
 
     m_progressTracker->progressStarted();
     if (m_provisionalDocumentLoader->isClientRedirect())
         m_provisionalDocumentLoader->appendRedirect(m_frame->document()->url());
@@ skipping 151 matching lines @@
     // FIXME: We need a way to propagate insecure requests policy flags to
     // out-of-process frames. For now, we'll always use default behavior.
     if (!parentFrame->isLocalFrame())
         return nullptr;
 
     ASSERT(toLocalFrame(parentFrame)->document());
     return toLocalFrame(parentFrame)->document()->insecureNavigationsToUpgrade();
 }
 
 } // namespace blink