Teach ScriptRunner how to yield and post on loading task queue

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 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/dom/ScriptRunner.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ScriptLoader.h"
 #include "platform/heap/Handle.h"
+#include "platform/scheduler/Scheduler.h"
+#include "wtf/Functional.h"
 
 namespace blink {
 
 ScriptRunner::ScriptRunner(Document* document)
     : m_document(document)
-    , m_timer(this, &ScriptRunner::timerFired)
+    , m_executeScriptsTaskFactory(WTF::bind(&ScriptRunner::executeScripts, this))
 {
     ASSERT(document);
 }
 
 ScriptRunner::~ScriptRunner()
 {
 #if !ENABLE(OILPAN)
     // Make sure that ScriptLoaders don't keep their PendingScripts alive.
     for (ScriptLoader* scriptLoader : m_scriptsToExecuteInOrder)
         scriptLoader->detach();
@@ skipping 21 matching lines @@
 
     case IN_ORDER_EXECUTION:
         m_document->incrementLoadEventDelayCount();
         m_scriptsToExecuteInOrder.append(scriptLoader);
         break;
     }
 }
 
 void ScriptRunner::suspend()
 {
-    m_timer.stop();
+    m_executeScriptsTaskFactory.cancel();
 }
 
 void ScriptRunner::resume()
 {
     if (hasPendingScripts())
-        m_timer.startOneShot(0, FROM_HERE);
+        Scheduler::shared()->postLoadingTask(FROM_HERE, m_executeScriptsTaskFactory.task());
 }
 
 void ScriptRunner::notifyScriptReady(ScriptLoader* scriptLoader, ExecutionType executionType)
 {
     switch (executionType) {
     case ASYNC_EXECUTION:
         ASSERT(m_pendingAsyncScripts.contains(scriptLoader));
         m_scriptsToExecuteSoon.append(scriptLoader);
         m_pendingAsyncScripts.remove(scriptLoader);
         break;
 
     case IN_ORDER_EXECUTION:
         ASSERT(!m_scriptsToExecuteInOrder.isEmpty());
         break;
     }
-    m_timer.startOneShot(0, FROM_HERE);
+    // FIXME: Rename task() so that it's obvious it cancels any pending task.
+    Scheduler::shared()->postLoadingTask(FROM_HERE, m_executeScriptsTaskFactory.task());

[marja, 2015/02/20 09:34:37]

Hmm, so, does this mean that if the task is already in the task queue, we take
it out and post another one which goes to the end of the task queue? Why is that
desired behavior? Shouldn't we rather not post a task if there's one in flight
already?

[alex clarke (OOO till 29th), 2015/02/20 11:59:34]

Good point, this lead to some discussion in the office.  The actual behavior of
the Blink Timer Heap is quite complicated.  In the case where it's lightly
loaded, calling m_timer.startOneShot(0, ...) at time T+0 and T+1 will cause the
underlying chromium timer to get cancelled and another task to get posted to
call the shared platform timers (i.e. identical behavior to this).   If the
Blink Timer heap is heavily loaded, it's quite likely that calling
m_timer.startOneShot(0, ...) the second time won't change the first entry in the
timer heap.

Anyway I think it's probably best to use the in-flight task if one exists
because in a (likely theoretical) scenario where a very large number of
notifyScriptReady calls happen we might get unreasonable delay.

As a side note I look forward to the day when we can delete the Blink Timer
Heap, the behavior of that code is far too difficult to reason about.

 }
 
 void ScriptRunner::notifyScriptLoadError(ScriptLoader* scriptLoader, ExecutionType executionType)
 {
     switch (executionType) {
     case ASYNC_EXECUTION:
         ASSERT(m_pendingAsyncScripts.contains(scriptLoader));
         m_pendingAsyncScripts.remove(scriptLoader);
         scriptLoader->detach();
         m_document->decrementLoadEventDelayCount();
@@ skipping 33 matching lines @@
 
 void ScriptRunner::movePendingAsyncScript(ScriptRunner* newRunner, ScriptLoader* scriptLoader)
 {
     if (m_pendingAsyncScripts.contains(scriptLoader)) {
         newRunner->addPendingAsyncScript(scriptLoader);
         m_pendingAsyncScripts.remove(scriptLoader);
         m_document->decrementLoadEventDelayCount();
     }
 }
 
-void ScriptRunner::timerFired(Timer<ScriptRunner>* timer)
+void ScriptRunner::executeScripts()
 {
-    ASSERT_UNUSED(timer, timer == &m_timer);
-
     RefPtrWillBeRawPtr<Document> protect(m_document.get());
 
-    WillBeHeapVector<RawPtrWillBeMember<ScriptLoader> > scriptLoaders;
-    scriptLoaders.swap(m_scriptsToExecuteSoon);
+    // New scripts are always appended to m_scriptsToExecuteSoon and m_scriptsToExecuteInOrder (never prepended)
+    // so as long as we keep track of the current totals, we can ensure the order of execution if new scripts
+    // are added while executing the current ones.
+    // NOTE a yield followed by a notifyScriptReady(... ASYNC_EXECUTION) will result in that script executing
+    // before any pre-existing ScriptsToExecuteInOrder.
+    size_t numScriptsToExecuteSoon = m_scriptsToExecuteSoon.size();
+    size_t numScriptsToExecuteInOrder = m_scriptsToExecuteInOrder.size();
+    for (size_t i = 0; i < numScriptsToExecuteSoon; i++) {
+        if (Scheduler::shared()->shouldYieldForHighPriorityWork()) {

[sof, 2015/02/20 07:48:50]

Add a private helper method to avoid the repetition of these details,

  if (shouldYieldForHighPriorityWork())
      return;

[alex clarke (OOO till 29th), 2015/02/20 11:59:34]

Done.

+            Scheduler::shared()->postLoadingTask(FROM_HERE, m_executeScriptsTaskFactory.task());
+            return;
+        }
+        m_scriptsToExecuteSoon.takeFirst()->execute();
+        m_document->decrementLoadEventDelayCount();
+    }
 
-    size_t numInOrderScriptsToExecute = 0;
-    for (; numInOrderScriptsToExecute < m_scriptsToExecuteInOrder.size() && m_scriptsToExecuteInOrder[numInOrderScriptsToExecute]->isReady(); ++numInOrderScriptsToExecute)
-        scriptLoaders.append(m_scriptsToExecuteInOrder[numInOrderScriptsToExecute]);
-    if (numInOrderScriptsToExecute)
-        m_scriptsToExecuteInOrder.remove(0, numInOrderScriptsToExecute);
-
-    size_t size = scriptLoaders.size();
-    for (size_t i = 0; i < size; ++i) {
-        scriptLoaders[i]->execute();
+    for (size_t i = 0; i < numScriptsToExecuteInOrder; i++) {
+        if (!m_scriptsToExecuteInOrder.first()->isReady()) {

[sof, 2015/02/20 07:48:50]

Let's add an assert about non-emptiness, just in case.

[alex clarke (OOO till 29th), 2015/02/20 11:59:34]

Done.

+            break;
+        }

[sof, 2015/02/20 07:48:50]

Redundant braces.

[alex clarke (OOO till 29th), 2015/02/20 11:59:34]

Done.

+        if (Scheduler::shared()->shouldYieldForHighPriorityWork()) {
+            Scheduler::shared()->postLoadingTask(FROM_HERE, m_executeScriptsTaskFactory.task());
+            return;
+        }
+        m_scriptsToExecuteInOrder.takeFirst()->execute();
         m_document->decrementLoadEventDelayCount();
     }
 }
 
 void ScriptRunner::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_document);
     visitor->trace(m_scriptsToExecuteInOrder);
     visitor->trace(m_scriptsToExecuteSoon);
     visitor->trace(m_pendingAsyncScripts);
 #endif
 }
 
 }