Stream scripts to V8 as they load - Blink side.

Source/bindings/core/v8/V8ScriptStreamerThread.cpp

Index: Source/bindings/core/v8/V8ScriptStreamerThread.cpp
diff --git a/Source/bindings/core/v8/V8ScriptStreamerThread.cpp b/Source/bindings/core/v8/V8ScriptStreamerThread.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db45bc4918e84c4532182a2b0d995fa69dda7f0d
--- /dev/null
+++ b/Source/bindings/core/v8/V8ScriptStreamerThread.cpp
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2014 Google Inc. All rights reserved.

[haraken, 2014/08/17 16:05:27]

Nit: Use the 3-line copyright.

[marja, 2014/08/20 11:45:56]

Done.

+ *
+ * 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
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY 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 "config.h"
+#include "bindings/core/v8/V8ScriptStreamerThread.h"
+
+#include "bindings/core/v8/V8ScriptStreamer.h"
+#include "platform/Task.h"
+#include "public/platform/Platform.h"
+#include "wtf/MainThread.h"
+#include "wtf/PassOwnPtr.h"
+
+namespace blink {
+
+static V8ScriptStreamerThread* s_sharedThread = 0;
+
+void V8ScriptStreamerThread::init()
+{
+    ASSERT(!s_sharedThread);

[haraken, 2014/08/17 16:05:27]

Add ASSERT(isMainThread()).

[marja, 2014/08/20 11:45:56]

Done.

+    s_sharedThread = new V8ScriptStreamerThread();
+}
+
+void V8ScriptStreamerThread::shutdown()
+{
+    ASSERT(s_sharedThread);

[haraken, 2014/08/17 16:05:27]

Add ASSERT(isMainThread()).

[marja, 2014/08/20 11:45:56]

That doesn't seem to be true. :/ It's not true in HTMLParserThread::shutdown()
either.

(I suspect it's a red herring, something like we cannot retrieve sane thread IDs
at this point of the shutdown. But I don't know for sure.)

[haraken, 2014/08/20 15:00:18]

OK :)

+    // currentThread will always be non-null in production, but can be null in
+    // Chromium unit tests.
+    if (blink::Platform::current()->currentThread() && s_sharedThread->isRunning()
+        && s_sharedThread->isRunningTask()) {

[haraken, 2014/08/17 16:05:27]

Why is the s_sharedThread->isRunningTask() check needed?

Probably can we completely get rid of the m_runningTask flag?

[marja, 2014/08/20 11:45:56]

Can't it be that Blink is ramping down but the V8 side is still processing data
(that is, the thread is running the task)? I thought that that's possible; thus
this code. Am I misinformed?

[haraken, 2014/08/20 15:00:18]

I agree that it's possible that the streaming thread is running a task when the
main thread wants to shut down the streaming thread. However, in that case, is
it safe to forcibly delete the streaming thread without waiting for the task
completion? (I don't think it's safe.)

We should probably send a cancel notification to the streaming thread, wait for
the streaming thread to process the cancel task, and then gracefully shut down
the streaming thread. (I don't know how much it will block the main thread. Even
if it's a shutdown sequence, we're not allowed to block the main thread for a
long time.)

[marja, 2014/09/09 17:00:26]

Yes, I don't think it's safe either, and that's why I was confused since I
thought you just suggested that above :) Ahh, but now I think I understand what
you mean: that we should still have this code to carefully ramp down the
streaming thread, but we shouldn't check isRunningTask() in the above if? Can
there be a race that isRunningTask() is false and we decide to not run this
code, but a task gets scheduled in between - I don't think so, since the main
thread is scheduling all the tasks. However, it's always safe to run this ramp
down code (maybe in the future some non-main threads might schedule streaming
tasks?), so I can remove the isRunningTask() check from the if.
This is essentially what this code is doing. When the script is no longer
needed, the call chain is: HTMLScriptRunner::detach ->
PendingScript::stopWatchingForLoad -> ScriptStreamer::cancel, so, we have
already cancelled, but the V8 side will realize the cancellation only when it
requests the data the next time. So here we make sure we give it time to realize
it and ramp down its own operations before we shut down the thread.

+        // 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;
+        s_sharedThread->postTask(new Task(WTF::bind(&V8ScriptStreamerThread::markAsCompleted, s_sharedThread, &taskSynchronizer)));
+        taskSynchronizer.waitForTaskCompletion();
+    }
+    delete s_sharedThread;
+    s_sharedThread = 0;
+}
+
+V8ScriptStreamerThread* V8ScriptStreamerThread::shared()
+{
+    return s_sharedThread;
+}
+
+void V8ScriptStreamerThread::postTask(WebThread::Task* task)
+{
+    m_runningTask = true;

[haraken, 2014/08/17 16:05:27]

Add ASSERT(isMainThread()).

[marja, 2014/08/20 11:45:56]

Done.

+    platformThread().postTask(task);
+}
+
+blink::WebThread& V8ScriptStreamerThread::platformThread()
+{
+    if (!isRunning()) {
+        m_thread = adoptPtr(blink::Platform::current()->createThread("V8ScriptStreamerThread"));
+    }
+    return *m_thread;
+}
+
+ScriptStreamingTask::ScriptStreamingTask(v8::ScriptCompiler::ScriptStreamingTask* task, V8ScriptStreamer* 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(&V8ScriptStreamerThread::taskDone, 0);
+    callOnMainThread(WTF::bind(&V8ScriptStreamer::streamingComplete, m_streamer));
+}
+
+} // namespace blink