Script streaming: detect encoding later.

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"
@@ skipping 235 matching lines @@
 
 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();
+    if (m_stream)
+        m_stream->cancel();
 }
 
 void ScriptStreamer::suppressStreaming()
 {
     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;
 }
 
+unsigned ScriptStreamer::cachedDataType() const
+{
+    if (m_compileOptions == v8::ScriptCompiler::kProduceParserCache) {
+        return V8ScriptRunner::tagForParserCache();
+    }
+    if (m_compileOptions == v8::ScriptCompiler::kProduceCodeCache) {
+        return V8ScriptRunner::tagForCodeCache();
+    }
+    return 0;
+}
+
 void ScriptStreamer::notifyAppendData(ScriptResource* resource)
 {
     ASSERT(isMainThread());
     ASSERT(m_resource == resource);
     {
         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);
+
+        // Encoding should be detected only when we have some data. It's
+        // possible that resource->encoding() returns a different encoding
+        // before the loading has started and after we got some data.
+        WTF::TextEncoding textEncoding(resource->encoding());
+        const char* encodingName = textEncoding.name();
+
+        // Here's a list of encodings we can use for streaming. These are
+        // the canonical names.
+        v8::ScriptCompiler::StreamedSource::Encoding encoding;
+        if (strcmp(encodingName, "windows-1252") == 0
+            || strcmp(encodingName, "ISO-8859-1") == 0
+            || strcmp(encodingName, "US-ASCII") == 0) {
+            encoding = v8::ScriptCompiler::StreamedSource::ONE_BYTE;
+        } else if (strcmp(encodingName, "UTF-8") == 0) {
+            encoding = v8::ScriptCompiler::StreamedSource::UTF8;
+        } else {
+            // We don't stream other encodings; especially we don't stream two
+            // byte scripts to avoid the handling of byte order marks. Most
+            // scripts are Latin1 or UTF-8 anyway, so this should be enough for
+            // most real world purposes.
+            suppressStreaming();
+            blink::Platform::current()->histogramEnumeration(histogramName, 0, 2);
+            return;
+        }
         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);
+
+        ASSERT(!m_stream);
+        ASSERT(!m_source);
+        m_stream = new SourceStream(this);
+        // m_source takes ownership of m_stream.
+        m_source = adoptPtr(new v8::ScriptCompiler::StreamedSource(m_stream, encoding));
+
+        ScriptState::Scope scope(m_scriptState.get());

[haraken, 2014/11/04 10:36:38]

I guess you need to check:

  if (!m_scriptState->contextIsValid())
    return;

before using the ScriptState.

[marja, 2014/11/04 10:41:39]

Ok; this is already checked in startStreamingInternal but I guess the context
can get invalid meanwhile. Not sure whether it would be best to remove the check
in startStreamingInternal, but afaics it's not very significant one way or
another.

+        WTF::OwnPtr<v8::ScriptCompiler::ScriptStreamingTask> scriptStreamingTask(adoptPtr(v8::ScriptCompiler::StartStreamingScript(m_scriptState->isolate(), m_source.get(), m_compileOptions)));
+        if (!scriptStreamingTask) {
+            // V8 cannot stream the script.
+            suppressStreaming();
+            m_stream = 0;
+            m_source.clear();
+            blink::Platform::current()->histogramEnumeration(histogramName, 0, 2);
+            return;
+        }
+
         // 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 or in
         // notifyFinished.
         ref();
-        ScriptStreamingTask* task = new ScriptStreamingTask(m_task.release(), this);
+        ScriptStreamingTask* task = new ScriptStreamingTask(scriptStreamingTask.release(), this);
         ScriptStreamerThread::shared()->postTask(task);
         blink::Platform::current()->histogramEnumeration(histogramName, 1, 2);
     }
-    m_stream->didReceiveData();
+    if (m_stream)
+        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();
+    if (m_stream)
+        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");
@@ skipping 14 matching lines @@
 
     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, ScriptStreamingMode mode)
+ScriptStreamer::ScriptStreamer(ScriptResource* resource, PendingScript::Type scriptType, ScriptStreamingMode mode, ScriptState* scriptState, v8::ScriptCompiler::CompileOptions compileOptions)
     : m_resource(resource)
     , m_detached(false)
-    , m_stream(new SourceStream(this))
-    , m_source(m_stream, encoding) // m_source takes ownership of m_stream.
+    , m_stream(0)
     , m_client(0)
     , m_loadingFinished(false)
     , m_parsingFinished(false)
     , m_haveEnoughDataForStreaming(false)
     , m_streamingSuppressed(false)
+    , m_compileOptions(compileOptions)
+    , m_scriptState(scriptState)
     , 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.
@@ skipping 73 matching lines @@
     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;
     }
     // We cannot filter out short scripts, even if we wait for the HTTP headers
     // to arrive. In general, the web servers don't seem to send the
     // Content-Length HTTP header for scripts.
 
-    WTF::TextEncoding textEncoding(resource->encoding());
-    const char* encodingName = textEncoding.name();
-
-    // Here's a list of encodings we can use for streaming. These are
-    // the canonical names.
-    v8::ScriptCompiler::StreamedSource::Encoding encoding;
-    if (strcmp(encodingName, "windows-1252") == 0
-        || strcmp(encodingName, "ISO-8859-1") == 0
-        || strcmp(encodingName, "US-ASCII") == 0) {
-        encoding = v8::ScriptCompiler::StreamedSource::ONE_BYTE;
-    } else if (strcmp(encodingName, "UTF-8") == 0) {
-        encoding = v8::ScriptCompiler::StreamedSource::UTF8;
-    } else {
-        // We don't stream other encodings; especially we don't stream two byte
-        // scripts to avoid the handling of byte order marks. Most scripts are
-        // Latin1 or UTF-8 anyway, so this should be enough for most real world
-        // purposes.
-        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, 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;
+
+    // The Resource might go out of scope if the script is no longer
+    // needed. This makes PendingScript notify the ScriptStreamer when it is
+    // destroyed.
+    script.setStreamer(adoptRef(new ScriptStreamer(resource, scriptType, settings->v8ScriptStreamingMode(), scriptState, compileOption)));
+
+    return true;
 }
 
 } // namespace blink