Also transfer pending in-order scripts upon element moving to new document

third_party/WebKit/Source/core/dom/ScriptRunner.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 24 matching lines @@
 #include "public/platform/WebThread.h"
 
 namespace blink {
 
 ScriptRunner::ScriptRunner(Document* document)
     : m_document(document)
     , m_taskRunner(Platform::current()->currentThread()->scheduler()->loadingTaskRunner())
     , m_numberOfInOrderScriptsWithPendingNotification(0)
     , m_isSuspended(false)
 #if !ENABLE(OILPAN)
-    , m_isDisposed(false)
     , m_weakPointerFactoryForTasks(this)
 #endif
 {
     ASSERT(document);
 #ifndef NDEBUG
     m_hasEverBeenSuspended = false;
 #endif
 }
 
 ScriptRunner::~ScriptRunner()
@@ skipping 35 matching lines @@
         scriptLoader->detach();
     for (ScriptLoader* scriptLoader : m_inOrderScriptsToExecuteSoon)
         scriptLoader->detach();
     for (ScriptLoader* scriptLoader : m_asyncScriptsToExecuteSoon)
         scriptLoader->detach();
 
     m_pendingInOrderScripts.clear();
     m_pendingAsyncScripts.clear();
     m_inOrderScriptsToExecuteSoon.clear();
     m_asyncScriptsToExecuteSoon.clear();
-    m_isDisposed = true;
+    m_numberOfInOrderScriptsWithPendingNotification = 0;
 }
 #endif
 
-void ScriptRunner::addPendingAsyncScript(ScriptLoader* scriptLoader)
-{
-    m_document->incrementLoadEventDelayCount();
-    m_pendingAsyncScripts.add(scriptLoader);
-}
-
 void ScriptRunner::queueScriptForExecution(ScriptLoader* scriptLoader, ExecutionType executionType)
 {
     ASSERT(scriptLoader);
-
+    m_document->incrementLoadEventDelayCount();
     switch (executionType) {
     case ASYNC_EXECUTION:
-        addPendingAsyncScript(scriptLoader);
+        m_pendingAsyncScripts.add(scriptLoader);
         break;
 
     case IN_ORDER_EXECUTION:
-        m_document->incrementLoadEventDelayCount();
         m_pendingInOrderScripts.append(scriptLoader);
         m_numberOfInOrderScriptsWithPendingNotification++;
         break;
     }
 }
 
 void ScriptRunner::postTask(const WebTraceLocation& webTraceLocation)
 {
     // TODO(altimin): Replace all this with `new Task(this)` when Oilpan is here.
     WeakPtrWillBeRawPtr<ScriptRunner> scriptRunnerForTask;
@@ skipping 52 matching lines @@
 
         while (!m_pendingInOrderScripts.isEmpty() && m_pendingInOrderScripts.first()->isReady()) {
             m_inOrderScriptsToExecuteSoon.append(m_pendingInOrderScripts.takeFirst());
             postTask(BLINK_FROM_HERE);
         }
 
         break;
     }
 }
 
+bool ScriptRunner::removePendingInOrderScript(ScriptLoader* scriptLoader)
+{
+    for (auto it = m_pendingInOrderScripts.begin(); it != m_pendingInOrderScripts.end(); ++it) {
+        if (*it == scriptLoader) {
+            m_pendingInOrderScripts.remove(it);
+            RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(m_numberOfInOrderScriptsWithPendingNotification > 0);
+            m_numberOfInOrderScriptsWithPendingNotification--;
+            return true;
+        }
+    }
+    return false;
+}
+
 void ScriptRunner::notifyScriptLoadError(ScriptLoader* scriptLoader, ExecutionType executionType)
 {
     switch (executionType) {
     case ASYNC_EXECUTION: {
-        bool foundLoader = m_pendingAsyncScripts.contains(scriptLoader);
-#if !ENABLE(OILPAN)
-        // If the document and ScriptRunner has been disposed of, there's
-        // no bookkeeping to be done here.
-        foundLoader = foundLoader || m_isDisposed;
-#endif
         // RELEASE_ASSERT makes us crash in a controlled way in error cases
         // where the ScriptLoader is associated with the wrong ScriptRunner
         // (otherwise we'd cause a use-after-free in ~ScriptRunner when it tries
         // to detach).
-        RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(foundLoader);
+        RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(m_pendingAsyncScripts.contains(scriptLoader));
         m_pendingAsyncScripts.remove(scriptLoader);
         break;
     }
     case IN_ORDER_EXECUTION:
-        RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(m_numberOfInOrderScriptsWithPendingNotification > 0);
-        m_numberOfInOrderScriptsWithPendingNotification--;
-
-        bool foundPendingScript = false;
-        for (auto it = m_pendingInOrderScripts.begin(); it != m_pendingInOrderScripts.end(); ++it) {
-            if (*it == scriptLoader) {
-                m_pendingInOrderScripts.remove(it);
-                foundPendingScript = true;
-                break;
-            }
-        }
-#if !ENABLE(OILPAN)
-        foundPendingScript = foundPendingScript || m_isDisposed;
-#endif
-        RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(foundPendingScript);
+        RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(removePendingInOrderScript(scriptLoader));
         break;
     }
     scriptLoader->detach();
     m_document->decrementLoadEventDelayCount();
 }
 
-void ScriptRunner::movePendingAsyncScript(Document& oldDocument, Document& newDocument, ScriptLoader* scriptLoader)
+void ScriptRunner::movePendingScript(Document& oldDocument, Document& newDocument, ScriptLoader* scriptLoader)
 {
     RefPtrWillBeRawPtr<Document> newContextDocument = newDocument.contextDocument().get();
     if (!newContextDocument) {
         // Document's contextDocument() method will return no Document if the
         // following conditions both hold:
         //
         //   - The Document wasn't created with an explicit context document
         //     and that document is otherwise kept alive.
         //   - The Document itself is detached from its frame.
         //
         // The script element's loader is in that case moved to document() and
         // its script runner, which is the non-null Document that contextDocument()
         // would return if not detached.
         ASSERT(!newDocument.frame());
         newContextDocument = &newDocument;
     }
     RefPtrWillBeRawPtr<Document> oldContextDocument = oldDocument.contextDocument().get();
     if (!oldContextDocument) {
         ASSERT(!oldDocument.frame());
         oldContextDocument = &oldDocument;
     }
     if (oldContextDocument != newContextDocument)
-        oldContextDocument->scriptRunner()->movePendingAsyncScript(newContextDocument->scriptRunner(), scriptLoader);
+        oldContextDocument->scriptRunner()->movePendingScript(newContextDocument->scriptRunner(), scriptLoader);
 }
 
-void ScriptRunner::movePendingAsyncScript(ScriptRunner* newRunner, ScriptLoader* scriptLoader)
+void ScriptRunner::movePendingScript(ScriptRunner* newRunner, ScriptLoader* scriptLoader)
 {
     if (m_pendingAsyncScripts.contains(scriptLoader)) {
-        newRunner->addPendingAsyncScript(scriptLoader);
+        newRunner->queueScriptForExecution(scriptLoader, ASYNC_EXECUTION);
         m_pendingAsyncScripts.remove(scriptLoader);
         m_document->decrementLoadEventDelayCount();
+        return;
+    }
+    if (removePendingInOrderScript(scriptLoader)) {
+        newRunner->queueScriptForExecution(scriptLoader, IN_ORDER_EXECUTION);
+        m_document->decrementLoadEventDelayCount();
     }
 }
 
 // Returns true if task was run, and false otherwise.
 bool ScriptRunner::executeTaskFromQueue(WillBeHeapDeque<RawPtrWillBeMember<ScriptLoader>>* taskQueue)
 {
     if (taskQueue->isEmpty())
         return false;
     taskQueue->takeFirst()->execute();
 
@@ skipping 23 matching lines @@
 #if ENABLE(OILPAN)
     visitor->trace(m_document);
     visitor->trace(m_pendingInOrderScripts);
     visitor->trace(m_pendingAsyncScripts);
     visitor->trace(m_asyncScriptsToExecuteSoon);
     visitor->trace(m_inOrderScriptsToExecuteSoon);
 #endif
 }
 
 } // namespace blink