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

Source/bindings/core/v8/ScriptStreamer.h

 // 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.
 
 #ifndef ScriptStreamer_h
 #define ScriptStreamer_h
 
+#include "bindings/core/v8/ScriptStreamingMode.h"
 #include "core/dom/PendingScript.h"
 #include "wtf/RefCounted.h"
 
 #include <v8.h>
 
 namespace blink {
 
 class PendingScript;
 class Resource;
 class ScriptResource;
@@ skipping 57 matching lines @@
         ASSERT(m_client == client);
         m_client = 0;
     }
 
     // Called by PendingScript when data arrives from the network.
     void notifyAppendData(ScriptResource*);
     void notifyFinished(Resource*);
 
     // Called by ScriptStreamingTask when it has streamed all data to V8 and V8
     // has processed it.
-    void streamingComplete();
+    void streamingCompleteOnBackgroundThread();
 
     static void setSmallScriptThresholdForTesting(size_t threshold)
     {
         kSmallScriptThreshold = threshold;
     }
 
     static size_t smallScriptThreshold() { return kSmallScriptThreshold; }
 
 private:
     // Scripts whose first data chunk is smaller than this constant won't be
     // streamed. Non-const for testing.
     static size_t kSmallScriptThreshold;
 
-    ScriptStreamer(ScriptResource*, v8::ScriptCompiler::StreamedSource::Encoding, PendingScript::Type);
+    ScriptStreamer(ScriptResource*, v8::ScriptCompiler::StreamedSource::Encoding, PendingScript::Type, ScriptStreamingMode);
 
+    void streamingComplete();
     void notifyFinishedToClient();
 
+    bool shouldBlockMainThread() const
+    {
+        return m_scriptStreamingMode == ScriptStreamingModeAllPlusBlockParsingBlocking && m_scriptType == PendingScript::ParsingBlocking;
+    }
+
     static const char* startedStreamingHistogramName(PendingScript::Type);
 
     static bool startStreamingInternal(PendingScript&, Settings*, ScriptState*, PendingScript::Type);
 
     // This pointer is weak. If PendingScript and its Resource are deleted
     // before ScriptStreamer, PendingScript will notify ScriptStreamer of its
     // deletion by calling cancel().
     ScriptResource* m_resource;
     // Whether ScriptStreamer is detached from the Resource. In those cases, the
     // script data is not needed any more, and the client won't get notified
     // when the loading and streaming are done.
     bool m_detached;
 
     SourceStream* m_stream;
     v8::ScriptCompiler::StreamedSource m_source;
     ScriptResourceClient* m_client;
     WTF::OwnPtr<v8::ScriptCompiler::ScriptStreamingTask> m_task;
     bool m_loadingFinished; // Whether loading from the network is done.
-    bool m_parsingFinished; // Whether the V8 side processing is done.
+    // Whether the V8 side processing is done. Will be used by the main thread
+    // and the streamer thread; guarded by m_mutex.
+    bool m_parsingFinished;
     // Whether we have received enough data to start the streaming.
     bool m_haveEnoughDataForStreaming;
 
     // Whether the script source code should be retrieved from the Resource
     // instead of the ScriptStreamer.
     bool m_streamingSuppressed;
 
     // What kind of cached data V8 produces during streaming.
     unsigned m_cachedDataType;
 
     // For recording metrics for different types of scripts separately.
     PendingScript::Type m_scriptType;
+
+    // Streaming mode defines whether the main thread should block and wait for
+    // the parsing to complete after the load has finished. See
+    // ScriptStreamer::notifyFinished for more information.
+    ScriptStreamingMode m_scriptStreamingMode;
+    Mutex m_mutex;
+    ThreadCondition m_parsingFinishedCondition;
 };
 
 } // namespace blink
 
 #endif // ScriptStreamer_h