Stream scripts to V8 as they load - Blink side.

Source/bindings/core/v8/ScriptStreamerThread.cpp

Index: Source/bindings/core/v8/ScriptStreamerThread.cpp
diff --git a/Source/bindings/core/v8/ScriptStreamerThread.cpp b/Source/bindings/core/v8/ScriptStreamerThread.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ea29cb28c7c25b5deca1791baf78ef67022f5f9
--- /dev/null
+++ b/Source/bindings/core/v8/ScriptStreamerThread.cpp
@@ -0,0 +1,79 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "bindings/core/v8/ScriptStreamerThread.h"
+
+#include "bindings/core/v8/ScriptStreamer.h"
+#include "platform/Task.h"
+#include "public/platform/Platform.h"
+#include "wtf/MainThread.h"
+#include "wtf/PassOwnPtr.h"
+
+namespace blink {
+
+static ScriptStreamerThread* s_sharedThread = 0;
+
+void ScriptStreamerThread::init()
+{
+    ASSERT(!s_sharedThread);
+    ASSERT(isMainThread());
+    s_sharedThread = new ScriptStreamerThread();
+}
+
+void ScriptStreamerThread::shutdown()
+{
+    ASSERT(s_sharedThread);
+    // currentThread will always be non-null in production, but can be null in
+    // Chromium unit tests.
+    if (blink::Platform::current()->currentThread() && s_sharedThread->isRunning()) {
+        // The streaming task should exit soon, because the corresponding
+        // PendingScript should already be destroyed, and it has cancelled the
+        // streaming. However, the V8 side operations might still be ongoing.
+        // When V8 asks for more data the next time, the cancelling will take
+        // effect.
+        TaskSynchronizer taskSynchronizer;

[jochen (gone - plz use gerrit), 2014/09/11 12:45:08]

you don't need the task synchronizer, the delete s_sharedThread below will block
until all tasks are finished

[marja, 2014/09/15 17:45:26]

Hmm, looks like WebThreadImpl dtor indeed waits.

I poked this code a bit, and realized it wasn't doing what I thought it was
doing (copied from HTMLParserThread...) basically, I shut down chrome while a
script was streaming (I made V8 to sleep to make sure I'm really in the middle
of the streaming), and shutdown() for the thread of interest didn't even ever
get called o.O (That doesn't seem to be a mess-up in my code, just that
CoreInitializer::shutdown() doesn't seem to be ran for the process of interest,
or at least my debug prints there don't show. Maybe the renderer shutdown is
more violent... anyhow, beyond the scope of this CL.)

So anyhow, this code is by no means doing what it should, so I deleted it.

+        s_sharedThread->postTask(new Task(WTF::bind(&ScriptStreamerThread::markAsCompleted, s_sharedThread, &taskSynchronizer)));
+        taskSynchronizer.waitForTaskCompletion();
+    }
+    delete s_sharedThread;
+    s_sharedThread = 0;
+}
+
+ScriptStreamerThread* ScriptStreamerThread::shared()
+{
+    return s_sharedThread;
+}
+
+void ScriptStreamerThread::postTask(WebThread::Task* task)
+{
+    ASSERT(isMainThread());
+    ASSERT(!m_runningTask);
+    m_runningTask = true;
+    platformThread().postTask(task);
+}
+
+blink::WebThread& ScriptStreamerThread::platformThread()
+{
+    if (!isRunning()) {
+        m_thread = adoptPtr(blink::Platform::current()->createThread("ScriptStreamerThread"));
+    }
+    return *m_thread;
+}
+
+ScriptStreamingTask::ScriptStreamingTask(v8::ScriptCompiler::ScriptStreamingTask* task, ScriptStreamer* streamer)
+    : m_v8Task(adoptPtr(task)), m_streamer(streamer) { }
+
+void ScriptStreamingTask::run()
+{
+    // Running the task can and will block: SourceStream::GetSomeData will get
+    // called and it will block and wait for data from the network.
+    m_v8Task->Run();
+    // Post a task to the main thread to signal that V8 has completed the
+    // streaming.
+    callOnMainThread(&ScriptStreamerThread::taskDone, 0);
+    callOnMainThread(WTF::bind(&ScriptStreamer::streamingComplete, m_streamer));
+}
+
+} // namespace blink