Adapt ScriptStreamer to recent changes in v8 streaming.

third_party/WebKit/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 "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"
@@ skipping 28 matching lines @@
         DEFINE_STATIC_LOCAL(EnumerationHistogram, deferredHistogram, ("WebCore.Scripts.Deferred.StartedStreaming", 2));
         deferredHistogram.count(reason);
         break;
     }
     case ScriptStreamer::Async: {
         DEFINE_STATIC_LOCAL(EnumerationHistogram, asyncHistogram, ("WebCore.Scripts.Async.StartedStreaming", 2));
         asyncHistogram.count(reason);
         break;
     }
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
     }
 }
 
 // For tracking why some scripts are not streamed. Not streaming is part of
 // normal operation (e.g., script already loaded, script too small) and doesn't
 // necessarily indicate a failure.
 enum NotStreamingReason {
     AlreadyLoaded,
     NotHTTP,
@@ skipping 18 matching lines @@
         DEFINE_STATIC_LOCAL(EnumerationHistogram, deferredHistogram, ("WebCore.Scripts.Deferred.NotStreamingReason", NotStreamingReasonEnd));
         deferredHistogram.count(reason);
         break;
     }
     case ScriptStreamer::Async: {
         DEFINE_STATIC_LOCAL(EnumerationHistogram, asyncHistogram, ("WebCore.Scripts.Async.NotStreamingReason", NotStreamingReasonEnd));
         asyncHistogram.count(reason);
         break;
     }
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
     }
 }
 
 } // namespace
 
 // 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 10 matching lines @@
     void clear()
     {
         MutexLocker locker(m_mutex);
         m_finished = false;
         discardQueuedData();
     }
 
     void produce(const uint8_t* data, size_t length)
     {
         MutexLocker locker(m_mutex);
-        ASSERT(!m_finished);
+        DCHECK(!m_finished);
         m_data.append(std::make_pair(data, length));
         m_haveData.signal();
     }
 
     void finish()
     {
         MutexLocker locker(m_mutex);
         m_finished = true;
         m_haveData.signal();
     }
@@ skipping 43 matching lines @@
 // thread).
 class SourceStream : public v8::ScriptCompiler::ExternalSourceStream {
     WTF_MAKE_NONCOPYABLE(SourceStream);
 public:
     explicit SourceStream(WebTaskRunner* loadingTaskRunner)
         : v8::ScriptCompiler::ExternalSourceStream()
         , m_cancelled(false)
         , m_finished(false)
         , m_queueLeadPosition(0)
         , m_queueTailPosition(0)
-        , m_bookmarkPosition(0)
-        , m_lengthOfBOM(0)
         , m_loadingTaskRunner(loadingTaskRunner->clone())
     {
     }
 
     virtual ~SourceStream() override { }
 
     // Called by V8 on a background thread. Should block until we can return
     // some data.
     size_t GetMoreData(const uint8_t** src) override
     {
-        ASSERT(!isMainThread());
+        DCHECK(!isMainThread());
         {
             MutexLocker locker(m_mutex);
             if (m_cancelled)
                 return 0;
         }
         size_t length = 0;
         // This will wait until there is data.
         m_dataQueue.consume(src, &length);
         {
             MutexLocker locker(m_mutex);
             if (m_cancelled)
                 return 0;
         }
         m_queueLeadPosition += length;
         return length;
     }
 
-    // Called by V8 on background thread.
-    bool SetBookmark() override
-    {
-        ASSERT(!isMainThread());
-        m_bookmarkPosition = m_queueLeadPosition;
-        return true;
-    }
-
-    // Called by V8 on background thread.
-    void ResetToBookmark() override
-    {
-        ASSERT(!isMainThread());
-        {
-            MutexLocker locker(m_mutex);
-            m_queueLeadPosition = m_bookmarkPosition;
-            // See comments at m_lengthOfBOM declaration below for why
-            // we need this here.
-            m_queueTailPosition = m_bookmarkPosition + m_lengthOfBOM;
-            m_dataQueue.clear();
-        }
-
-        // Inform main thread to re-queue the data.
-        m_loadingTaskRunner->postTask(
-            BLINK_FROM_HERE, crossThreadBind(&SourceStream::fetchDataFromResourceBuffer, crossThreadUnretained(this), 0));
-    }
-
     void didFinishLoading()
     {
-        ASSERT(isMainThread());
-
-        // ResetToBookmark may reset the data queue's 'finished' status,
-        // so we may need to re-finish after a ResetToBookmark happened.
-        // We do this by remembering m_finished, and always checking for it
-        // at the end ot fetchDataFromResourceBuffer.
+        DCHECK(isMainThread());
         m_finished = true;
-        fetchDataFromResourceBuffer(0);
+        m_dataQueue.finish();
     }
 
-    void didReceiveData(ScriptStreamer* streamer, size_t lengthOfBOM)
+    void didReceiveData(ScriptStreamer* streamer)
     {
-        ASSERT(isMainThread());
-        prepareDataOnMainThread(streamer, lengthOfBOM);
+        DCHECK(isMainThread());
+        prepareDataOnMainThread(streamer);
     }
 
     void cancel()
     {
-        ASSERT(isMainThread());
+        DCHECK(isMainThread());
         // The script is no longer needed by the upper layers. Stop streaming
         // it. The next time GetMoreData is called (or woken up), it will return
         // 0, which will be interpreted as EOS by V8 and the parsing will
         // fail. ScriptStreamer::streamingComplete will be called, and at that
         // point we will release the references to SourceStream.
         {
             MutexLocker locker(m_mutex);
             m_cancelled = true;
         }
         m_dataQueue.finish();
     }
 
 private:
-    void prepareDataOnMainThread(ScriptStreamer* streamer, size_t lengthOfBOM)
+    void prepareDataOnMainThread(ScriptStreamer* streamer)
     {
-        ASSERT(isMainThread());
+        DCHECK(isMainThread());
 
         // The Resource must still be alive; otherwise we should've cancelled
         // the streaming (if we have cancelled, the background thread is not
         // waiting).
-        ASSERT(streamer->resource());
-
-        // BOM can only occur at the beginning of the data.
-        ASSERT(lengthOfBOM == 0 || m_queueTailPosition == 0);
+        DCHECK(streamer->resource());
 
         if (!streamer->resource()->response().cacheStorageCacheName().isNull()) {
             streamer->suppressStreaming();
             cancel();
             return;
         }
 
         CachedMetadataHandler* cacheHandler = streamer->resource()->cacheHandler();
         RefPtr<CachedMetadata> codeCache(cacheHandler ? cacheHandler->cachedMetadata(V8ScriptRunner::tagForCodeCache(cacheHandler)) : nullptr);
         if (codeCache.get())  {
             // The resource has a code cache, so it's unnecessary to stream and
             // parse the code. Cancel the streaming and resume the non-streaming
             // code path.
             streamer->suppressStreaming();
             cancel();
             return;
         }
 
         if (!m_resourceBuffer) {
             // We don't have a buffer yet. Try to get it from the resource.
             m_resourceBuffer = streamer->resource()->resourceBuffer();
         }
 
-        fetchDataFromResourceBuffer(lengthOfBOM);
+        fetchDataFromResourceBuffer();
     }
 
-    void fetchDataFromResourceBuffer(size_t lengthOfBOM)
+    void fetchDataFromResourceBuffer()
     {
-        ASSERT(isMainThread());
-        MutexLocker locker(m_mutex); // For m_cancelled + m_queueTailPosition.
+        DCHECK(isMainThread());
+        MutexLocker locker(m_mutex);
 
-        if (lengthOfBOM > 0) {
-            ASSERT(!m_lengthOfBOM); // There should be only one BOM.
-            m_lengthOfBOM = lengthOfBOM;
-        }
-
+        DCHECK(!m_finished);
         if (m_cancelled) {
             m_dataQueue.finish();
             return;
         }
 
         // Get as much data from the ResourceBuffer as we can.
         const char* data = nullptr;
-        Vector<const char*> chunks;
-        Vector<size_t> chunkLengths;
-        size_t bufferLength = 0;
         while (size_t length = m_resourceBuffer->getSomeData(data, m_queueTailPosition)) {
-            // FIXME: Here we can limit based on the total length, if it turns
-            // out that we don't want to give all the data we have (memory
-            // vs. speed).
-            chunks.append(data);
-            chunkLengths.append(length);
-            bufferLength += length;
+            // Copy the data chunks into a new buffer, since we're going to
+            // give the data to a background thread.
+            uint8_t* copiedData = new uint8_t[length];
+            memcpy(copiedData, data, length);
+            m_dataQueue.produce(copiedData, length);
+
             m_queueTailPosition += length;
         }
-
-        // Copy the data chunks into a new buffer, since we're going to give the
-        // data to a background thread.
-        if (bufferLength > lengthOfBOM) {
-            size_t totalLength = bufferLength - lengthOfBOM;
-            uint8_t* copiedData = new uint8_t[totalLength];
-            size_t offset = 0;
-            size_t offsetInChunk = lengthOfBOM;
-            for (size_t i = 0; i < chunks.size(); ++i) {
-                if (offsetInChunk >= chunkLengths[i]) {
-                    offsetInChunk -= chunkLengths[i];
-                    continue;
-                }
-
-                size_t dataLength = chunkLengths[i] - offsetInChunk;
-                memcpy(copiedData + offset, chunks[i] + offsetInChunk, dataLength);
-                offset += dataLength;
-                // BOM is in the beginning of the buffer.
-                offsetInChunk = 0;
-            }
-            m_dataQueue.produce(copiedData, totalLength);
-        }
-
-        if (m_finished)
-            m_dataQueue.finish();
     }
 
     // For coordinating between the main thread and background thread tasks.
     // Guards m_cancelled and m_queueTailPosition.
     Mutex m_mutex;
 
     // The shared buffer containing the resource data + state variables.
     // Used by both threads, guarded by m_mutex.
     bool m_cancelled;
     bool m_finished;
 
     RefPtr<const SharedBuffer> m_resourceBuffer; // Only used by the main thread.
 
     // The queue contains the data to be passed to the V8 thread.
     //   queueLeadPosition: data we have handed off to the V8 thread.
     //   queueTailPosition: end of data we have enqued in the queue.
     //   bookmarkPosition: position of the bookmark.
     SourceStreamDataQueue m_dataQueue; // Thread safe.
     size_t m_queueLeadPosition; // Only used by v8 thread.
     size_t m_queueTailPosition; // Used by both threads; guarded by m_mutex.
-    size_t m_bookmarkPosition; // Only used by v8 thread.
-
-    // BOM (Unicode Byte Order Mark) handling:
-    // This class is responsible for stripping out the BOM, since Chrome
-    // delivers the input stream potentially with BOM, but V8 doesn't want
-    // to see the BOM. This is mostly easy to do, except for a funky edge
-    // condition with bookmarking:
-    // - m_queueLeadPosition counts the bytes that V8 has received
-    //   (i.e., without BOM)
-    // - m_queueTailPosition counts the bytes that Chrome has sent
-    //   (i.e., with BOM)
-    // So when resetting the bookmark, we have to adjust the lead position
-    // to account for the BOM (which happens implicitly in the regular
-    // streaming case).
-    // We store this separately, to avoid having to guard all
-    // m_queueLeadPosition references with a mutex.
-    size_t m_lengthOfBOM; // Used by both threads; guarded by m_mutex.
 
     std::unique_ptr<WebTaskRunner> m_loadingTaskRunner;
 };
 
 size_t ScriptStreamer::s_smallScriptThreshold = 30 * 1024;
 
 void ScriptStreamer::startStreaming(PendingScript* script, Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
     // 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
@@ skipping 25 matching lines @@
 }
 
 bool ScriptStreamer::isFinished() const
 {
     MutexLocker locker(m_mutex);
     return m_loadingFinished && (m_parsingFinished || m_streamingSuppressed);
 }
 
 void ScriptStreamer::streamingCompleteOnBackgroundThread()
 {
-    ASSERT(!isMainThread());
+    DCHECK(!isMainThread());
     {
         MutexLocker locker(m_mutex);
         m_parsingFinished = true;
     }
 
     // notifyFinished might already be called, or it might be called in the
     // future (if the parsing finishes earlier because of a parse error).
     m_loadingTaskRunner->postTask(BLINK_FROM_HERE, crossThreadBind(&ScriptStreamer::streamingComplete, wrapCrossThreadPersistent(this)));
 
     // The task might delete ScriptStreamer, so it's not safe to do anything
     // after posting it. Note that there's no way to guarantee that this
     // function has returned before the task is ran - however, we should not
     // access the "this" object after posting the task. (Especially, we should
     // not be holding the mutex at this point.)
 }
 
 void ScriptStreamer::cancel()
 {
-    ASSERT(isMainThread());
+    DCHECK(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;
     if (m_stream)
         m_stream->cancel();
 }
 
 void ScriptStreamer::suppressStreaming()
 {
     MutexLocker locker(m_mutex);
-    ASSERT(!m_loadingFinished);
+    DCHECK(!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);
+    DCHECK(isMainThread());
+    DCHECK_EQ(m_resource, resource);
     {
         MutexLocker locker(m_mutex);
         if (m_streamingSuppressed)
             return;
     }
-    size_t lengthOfBOM = 0;
     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.
-        ASSERT(resource->resourceBuffer());
+        DCHECK(resource->resourceBuffer());
         if (resource->resourceBuffer()->size() < s_smallScriptThreshold)
             return;
         m_haveEnoughDataForStreaming = true;
 
-        // 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.  In
-        // addition, check for byte order marks. Note that checking the byte
-        // order mark might change the encoding. We cannot decode the full text
-        // here, because it might contain incomplete UTF-8 characters. Also note
-        // that have at least s_smallScriptThreshold worth of data, which is more
-        // than enough for detecting a BOM.
-        constexpr size_t maximumLengthOfBOM = 4;
-        char maybeBOM[maximumLengthOfBOM] = {};
-        if (!resource->resourceBuffer()->getPartAsBytes(maybeBOM, static_cast<size_t>(0), maximumLengthOfBOM)) {
-            NOTREACHED();
-            return;
+        {
+            // Check for BOM (byte order marks), because that might change our
+            // understanding of the data encoding.
+            constexpr size_t maximumLengthOfBOM = 4;
+            char maybeBOM[maximumLengthOfBOM] = {};
+            if (!resource->resourceBuffer()->getPartAsBytes(maybeBOM, static_cast<size_t>(0), maximumLengthOfBOM)) {
+                NOTREACHED();
+                return;
+            }
+
+            std::unique_ptr<TextResourceDecoder> decoder(TextResourceDecoder::create("application/javascript", resource->encoding()));
+            decoder->checkForBOM(maybeBOM, maximumLengthOfBOM);
+
+            // The encoding may change when we see the BOM. Check for BOM now
+            // and update the encoding from the decoder when necessary. Abort
+            // streaming if the encoding is different from the one we started

[marja, 2016/09/20 19:03:55]

This comment is not correct: we don't abort streaming if the encoding is
different. convertEncoding returns false when the encoding not supported, and in
that case we suppress the streaming. In other cases we just update m_encoding
and carry on.

A side though from checking convertEncoding: as we don't stream two byte
scripts, is the V8 side of TwoByteExternalStreamingStream dead code?

[vogelheim, 2016/09/22 08:15:14]

Within Chromium: Yes, I think so.

This is a bit suprising... The V8 API supports it. Options are:

1, We keep TwoByteExternalStreamingStream in (despite it not being used by
Chromium, I believe not by node.js or other clients either).
2, We UNREACHABLE() it in the API.
3, Or we change the API to remove it.

Not sure I think about this, yet.

At least it has unit tests, now. :-]

[vogelheim, 2016/09/22 08:15:14]

Done.

+            // with.
+            //
+            // Also note that have at least s_smallScriptThreshold worth of
+            // data, which is more than enough for detecting a BOM.
+            if (!convertEncoding(decoder->encoding().name(), &m_encoding)) {
+                suppressStreaming();
+                recordNotStreamingReasonHistogram(m_scriptType, EncodingNotSupported);
+                recordStartedStreamingHistogram(m_scriptType, 0);
+                return;
+            }
         }
 
-        std::unique_ptr<TextResourceDecoder> decoder(TextResourceDecoder::create("application/javascript", resource->encoding()));
-        lengthOfBOM = decoder->checkForBOM(maybeBOM, maximumLengthOfBOM);
-
-        // Maybe the encoding changed because we saw the BOM; get the encoding
-        // from the decoder.
-        if (!convertEncoding(decoder->encoding().name(), &m_encoding)) {
-            suppressStreaming();
-            recordNotStreamingReasonHistogram(m_scriptType, EncodingNotSupported);
-            recordStartedStreamingHistogram(m_scriptType, 0);
-            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();
             recordNotStreamingReasonHistogram(m_scriptType, ThreadBusy);
             recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
         if (!m_scriptState->contextIsValid()) {
             suppressStreaming();
             recordNotStreamingReasonHistogram(m_scriptType, ContextNotValid);
             recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
-        ASSERT(!m_stream);
-        ASSERT(!m_source);
+        DCHECK(!m_stream);
+        DCHECK(!m_source);
         m_stream = new SourceStream(m_loadingTaskRunner.get());
         // m_source takes ownership of m_stream.
         m_source = wrapUnique(new v8::ScriptCompiler::StreamedSource(m_stream, m_encoding));
 
         ScriptState::Scope scope(m_scriptState.get());
         std::unique_ptr<v8::ScriptCompiler::ScriptStreamingTask> scriptStreamingTask(wrapUnique(v8::ScriptCompiler::StartStreamingScript(m_scriptState->isolate(), m_source.get(), m_compileOptions)));
         if (!scriptStreamingTask) {
             // V8 cannot stream the script.
             suppressStreaming();
             m_stream = 0;
             m_source.reset();
             recordNotStreamingReasonHistogram(m_scriptType, V8CannotStream);
             recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
         ScriptStreamerThread::shared()->postTask(crossThreadBind(&ScriptStreamerThread::runScriptStreamingTask, passed(std::move(scriptStreamingTask)), wrapCrossThreadPersistent(this)));
         recordStartedStreamingHistogram(m_scriptType, 1);
     }
     if (m_stream)
-        m_stream->didReceiveData(this, lengthOfBOM);
+        m_stream->didReceiveData(this);
 }
 
 void ScriptStreamer::notifyFinished(Resource* resource)
 {
-    ASSERT(isMainThread());
-    ASSERT(m_resource == resource);
+    DCHECK(isMainThread());
+    DCHECK_EQ(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) {
         recordNotStreamingReasonHistogram(m_scriptType, ScriptTooSmall);
         recordStartedStreamingHistogram(m_scriptType, 0);
         suppressStreaming();
     }
     if (m_stream)
@@ skipping 29 matching lines @@
 DEFINE_TRACE(ScriptStreamer)
 {
     visitor->trace(m_pendingScript);
     visitor->trace(m_resource);
 }
 
 void ScriptStreamer::streamingComplete()
 {
     // The background task is completed; do the necessary ramp-down in the main
     // thread.
-    ASSERT(isMainThread());
+    DCHECK(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)
         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();
 }
 
 void ScriptStreamer::notifyFinishedToClient()
 {
-    ASSERT(isMainThread());
+    DCHECK(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())
         return;
 
     m_pendingScript->streamingFinished();
 }
 
 bool ScriptStreamer::startStreamingInternal(PendingScript* script, Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
-    ASSERT(isMainThread());
-    ASSERT(scriptState->contextIsValid());
+    DCHECK(isMainThread());
+    DCHECK(scriptState->contextIsValid());
     ScriptResource* resource = script->resource();
     if (resource->isLoaded()) {
         recordNotStreamingReasonHistogram(scriptType, AlreadyLoaded);
         return false;
     }
     if (!resource->url().protocolIsInHTTPFamily()) {
         recordNotStreamingReasonHistogram(scriptType, NotHTTP);
         return false;
     }
     if (resource->isCacheValidator()) {
@@ skipping 15 matching lines @@
 
     // 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(ScriptStreamer::create(script, scriptType, scriptState, compileOption, loadingTaskRunner));
 
     return true;
 }
 
 } // namespace blink