Reland: Script streaming: Add an option to make the main thread block (wait for parsing)

Source/bindings/core/v8/ScriptStreamer.cpp

 // 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/ScriptStreamer.h"
 
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/PendingScript.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/frame/Settings.h"
 #include "platform/SharedBuffer.h"
+#include "platform/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "wtf/MainThread.h"
 #include "wtf/text/TextEncodingRegistry.h"
 
 namespace blink {
 
 // For passing data between the main thread (producer) and the streamer thread
 // (consumer). The main thread prepares the data (copies it from Resource) and
 // the streamer thread feeds it to V8.
 class SourceStreamDataQueue {
@@ skipping 191 matching lines @@
 void ScriptStreamer::startStreaming(PendingScript& script, Settings* settings, ScriptState* scriptState, PendingScript::Type scriptType)
 {
     // We don't yet know whether the script will really be streamed. E.g.,
     // suppressing streaming for short scripts is done later. Record only the
     // sure negative cases here.
     bool startedStreaming = startStreamingInternal(script, settings, scriptState, scriptType);
     if (!startedStreaming)
         blink::Platform::current()->histogramEnumeration(startedStreamingHistogramName(scriptType), 0, 2);
 }
 
-void ScriptStreamer::streamingComplete()
+void ScriptStreamer::streamingCompleteOnBackgroundThread()
 {
-    ASSERT(isMainThread());
-    // It's possible that the corresponding Resource was deleted before V8
-    // finished streaming. In that case, the data or the notification is not
-    // needed. In addition, if the streaming is suppressed, the non-streaming
-    // code path will resume after the resource has loaded, before the
-    // background task finishes.
-    if (m_detached || m_streamingSuppressed) {
-        deref();
-        return;
+    ASSERT(!isMainThread());
+    MutexLocker locker(m_mutex);
+    m_parsingFinished = true;
+    // In the blocking case, the main thread is normally waiting at this
+    // point, but it can also happen that the load is not yet finished
+    // (e.g., a parse error). In that case, notifyFinished will be called
+    // eventually and it will not wait on m_parsingFinishedCondition.
+
+    // In the non-blocking case, notifyFinished might already be called, or it
+    // might be called in the future. In any case, do the cleanup here.
+    if (m_mainThreadWaitingForParserThread) {
+        m_parsingFinishedCondition.signal();
+    } else {
+        callOnMainThread(WTF::bind(&ScriptStreamer::streamingComplete, this));
     }
-
-    // We have now streamed the whole script to V8 and it has parsed the
-    // script. We're ready for the next step: compiling and executing the
-    // script.
-    m_parsingFinished = true;
-
-    notifyFinishedToClient();
-
-    // The background thread no longer holds an implicit reference.
-    deref();
 }
 
 void ScriptStreamer::cancel()
 {
     ASSERT(isMainThread());
     // The upper layer doesn't need the script any more, but streaming might
     // still be ongoing. Tell SourceStream to try to cancel it whenever it gets
     // the control the next time. It can also be that V8 has already completed
     // its operations and streamingComplete will be called soon.
     m_detached = true;
     m_resource = 0;
     m_stream->cancel();
 }
 
 void ScriptStreamer::suppressStreaming()
 {
-    ASSERT(!m_parsingFinished);
+    MutexLocker locker(m_mutex);
     ASSERT(!m_loadingFinished);
+    // It can be that the parsing task has already finished (e.g., if there was
+    // a parse error).
     m_streamingSuppressed = true;
 }
 
 void ScriptStreamer::notifyAppendData(ScriptResource* resource)
 {
     ASSERT(isMainThread());
     ASSERT(m_resource == resource);
-    if (m_streamingSuppressed)
-        return;
+    {
+        MutexLocker locker(m_mutex);
+        if (m_streamingSuppressed)
+            return;
+    }
     if (!m_haveEnoughDataForStreaming) {
         // Even if the first data chunk is small, the script can still be big
         // enough - wait until the next data chunk comes before deciding whether
         // to start the streaming.
         if (resource->resourceBuffer()->size() < kSmallScriptThreshold) {
             return;
         }
         m_haveEnoughDataForStreaming = true;
         const char* histogramName = startedStreamingHistogramName(m_scriptType);
         if (ScriptStreamerThread::shared()->isRunningTask()) {
             // At the moment we only have one thread for running the tasks. A
             // new task shouldn't be queued before the running task completes,
             // because the running task can block and wait for data from the
             // network.
             suppressStreaming();
             blink::Platform::current()->histogramEnumeration(histogramName, 0, 2);
             return;
         }
         ASSERT(m_task);
         // ScriptStreamer needs to stay alive as long as the background task is
         // running. This is taken care of with a manual ref() & deref() pair;
-        // the corresponding deref() is in streamingComplete.
+        // the corresponding deref() is in streamingComplete or in
+        // notifyFinished.
         ref();
         ScriptStreamingTask* task = new ScriptStreamingTask(m_task.release(), this);
         ScriptStreamerThread::shared()->postTask(task);
         blink::Platform::current()->histogramEnumeration(histogramName, 1, 2);
     }
     m_stream->didReceiveData();
 }
 
 void ScriptStreamer::notifyFinished(Resource* resource)
 {
     ASSERT(isMainThread());
     ASSERT(m_resource == resource);
     // A special case: empty and small scripts. We didn't receive enough data to
     // start the streaming before this notification. In that case, there won't
     // be a "parsing complete" notification either, and we should not wait for
     // it.
     if (!m_haveEnoughDataForStreaming) {
         const char* histogramName = startedStreamingHistogramName(m_scriptType);
         blink::Platform::current()->histogramEnumeration(histogramName, 0, 2);
         suppressStreaming();
     }
     m_stream->didFinishLoading();
     m_loadingFinished = true;
+
+    if (shouldBlockMainThread()) {
+        // Make the main thead wait until the streaming is complete, to make
+        // sure that the script gets the main thread's attention as early as
+        // possible (for possible compiling, if the client wants to do it
+        // right away). Note that blocking here is not any worse than the
+        // non-streaming code path where the main thread eventually blocks
+        // to parse the script.
+        TRACE_EVENT0("v8", "v8.mainThreadWaitingForParserThread");
+        MutexLocker locker(m_mutex);
+        while (!isFinished()) {
+            ASSERT(!m_parsingFinished);
+            ASSERT(!m_streamingSuppressed);
+            m_mainThreadWaitingForParserThread = true;
+            m_parsingFinishedCondition.wait(m_mutex);
+        }
+    }
+
+    // Calling notifyFinishedToClient can result into the upper layers dropping
+    // references to ScriptStreamer. Keep it alive until this function ends.
+    RefPtr<ScriptStreamer> protect(this);
+
     notifyFinishedToClient();
+
+    if (m_mainThreadWaitingForParserThread) {
+        ASSERT(m_parsingFinished);
+        ASSERT(!m_streamingSuppressed);
+        // streamingComplete won't be called, so do the ramp-down work
+        // here.
+        deref();
+    }
 }
 
-ScriptStreamer::ScriptStreamer(ScriptResource* resource, v8::ScriptCompiler::StreamedSource::Encoding encoding, PendingScript::Type scriptType)
+ScriptStreamer::ScriptStreamer(ScriptResource* resource, v8::ScriptCompiler::StreamedSource::Encoding encoding, PendingScript::Type scriptType, ScriptStreamingMode mode)
     : m_resource(resource)
     , m_detached(false)
     , m_stream(new SourceStream(this))
     , m_source(m_stream, encoding) // m_source takes ownership of m_stream.
     , m_client(0)
     , m_loadingFinished(false)
     , m_parsingFinished(false)
     , m_haveEnoughDataForStreaming(false)
     , m_streamingSuppressed(false)
     , m_scriptType(scriptType)
+    , m_scriptStreamingMode(mode)
+    , m_mainThreadWaitingForParserThread(false)
 {
 }
 
+void ScriptStreamer::streamingComplete()
+{
+    // The background task is completed; do the necessary ramp-down in the main
+    // thread.
+    ASSERT(isMainThread());
+
+    // It's possible that the corresponding Resource was deleted before V8
+    // finished streaming. In that case, the data or the notification is not
+    // needed. In addition, if the streaming is suppressed, the non-streaming
+    // code path will resume after the resource has loaded, before the
+    // background task finishes.
+    if (m_detached || m_streamingSuppressed) {
+        deref();
+        return;
+    }
+
+    // We have now streamed the whole script to V8 and it has parsed the
+    // script. We're ready for the next step: compiling and executing the
+    // script.
+    notifyFinishedToClient();
+
+    // The background thread no longer holds an implicit reference.
+    deref();
+}
+
 void ScriptStreamer::notifyFinishedToClient()
 {
     ASSERT(isMainThread());
     // Usually, the loading will be finished first, and V8 will still need some
     // time to catch up. But the other way is possible too: if V8 detects a
     // parse error, the V8 side can complete before loading has finished. Send
     // the notification after both loading and V8 side operations have
     // completed. Here we also check that we have a client: it can happen that a
     // function calling notifyFinishedToClient was already scheduled in the task
     // queue and the upper layer decided that it's not interested in the script
     // and called removeClient.
-    if (isFinished() && m_client)
+    {
+        MutexLocker locker(m_mutex);
+        if (!isFinished())
+            return;
+    }
+    if (m_client)
         m_client->notifyFinished(m_resource);
 }
 
 const char* ScriptStreamer::startedStreamingHistogramName(PendingScript::Type scriptType)
 {
     switch (scriptType) {
     case PendingScript::ParsingBlocking:
         return "WebCore.Scripts.ParsingBlocking.StartedStreaming";
         break;
     case PendingScript::Deferred:
         return "WebCore.Scripts.Deferred.StartedStreaming";
         break;
     case PendingScript::Async:
         return "WebCore.Scripts.Async.StartedStreaming";
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
     return 0;
 }
 
 bool ScriptStreamer::startStreamingInternal(PendingScript& script, Settings* settings, ScriptState* scriptState, PendingScript::Type scriptType)
 {
     ASSERT(isMainThread());
     if (!settings || !settings->v8ScriptStreamingEnabled())
         return false;
+    if (settings->v8ScriptStreamingMode() == ScriptStreamingModeOnlyAsyncAndDefer
+        && scriptType == PendingScript::ParsingBlocking)
+        return false;
+
     ScriptResource* resource = script.resource();
     ASSERT(!resource->isLoaded());
     if (!resource->url().protocolIsInHTTPFamily())
         return false;
     if (resource->resourceToRevalidate()) {
         // This happens e.g., during reloads. We're actually not going to load
         // the current Resource of the PendingScript but switch to another
         // Resource -> don't stream.
         return false;
     }
@@ skipping 21 matching lines @@
         return false;
     }
 
     if (!scriptState->contextIsValid())
         return false;
     ScriptState::Scope scope(scriptState);
 
     // The Resource might go out of scope if the script is no longer needed. We
     // will soon call PendingScript::setStreamer, which makes the PendingScript
     // notify the ScriptStreamer when it is destroyed.
-    RefPtr<ScriptStreamer> streamer = adoptRef(new ScriptStreamer(resource, encoding, scriptType));
+    RefPtr<ScriptStreamer> streamer = adoptRef(new ScriptStreamer(resource, encoding, scriptType, settings->v8ScriptStreamingMode()));
 
     // Decide what kind of cached data we should produce while streaming. By
     // default, we generate the parser cache for streamed scripts, to emulate
     // the non-streaming behavior (see V8ScriptRunner::compileScript).
     v8::ScriptCompiler::CompileOptions compileOption = v8::ScriptCompiler::kProduceParserCache;
     if (settings->v8CacheOptions() == V8CacheOptionsCode)
         compileOption = v8::ScriptCompiler::kProduceCodeCache;
     v8::ScriptCompiler::ScriptStreamingTask* scriptStreamingTask = v8::ScriptCompiler::StartStreamingScript(scriptState->isolate(), &(streamer->m_source), compileOption);
     if (scriptStreamingTask) {
         streamer->m_task = adoptPtr(scriptStreamingTask);
         script.setStreamer(streamer.release());
         return true;
     }
     // Otherwise, V8 cannot stream the script.
     return false;
 }
 
 } // namespace blink