third_party/WebKit/Source/bindings/core/v8/ScriptStreamer.cpp - chromium/src - Git at Google

 // 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"
 #include "core/dom/PendingScript.h"
 #include "core/fetch/CachedMetadata.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/frame/Settings.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/WebScheduler.h"
 #include "wtf/Deque.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/TextEncodingRegistry.h"
 #include <memory>

 namespace blink {

 namespace {

 void recordStartedStreamingHistogram(ScriptStreamer::Type scriptType,
                                      int reason) {
   switch (scriptType) {
     case ScriptStreamer::ParsingBlocking: {
       DEFINE_STATIC_LOCAL(
           EnumerationHistogram, parseBlockingHistogram,
           ("WebCore.Scripts.ParsingBlocking.StartedStreaming", 2));
       parseBlockingHistogram.count(reason);
       break;
     }
     case ScriptStreamer::Deferred: {
       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:
       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,
   Reload,
   ContextNotValid,
   EncodingNotSupported,
   ThreadBusy,
   V8CannotStream,
   ScriptTooSmall,
   NotStreamingReasonEnd
 };

 void recordNotStreamingReasonHistogram(ScriptStreamer::Type scriptType,
                                        NotStreamingReason reason) {
   switch (scriptType) {
     case ScriptStreamer::ParsingBlocking: {
       DEFINE_STATIC_LOCAL(EnumerationHistogram, parseBlockingHistogram,
                           ("WebCore.Scripts.ParsingBlocking.NotStreamingReason",
                            NotStreamingReasonEnd));
       parseBlockingHistogram.count(reason);
       break;
     }
     case ScriptStreamer::Deferred: {
       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:
       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 {
   WTF_MAKE_NONCOPYABLE(SourceStreamDataQueue);

  public:
   SourceStreamDataQueue() : m_finished(false) {}

   ~SourceStreamDataQueue() { discardQueuedData(); }

   void clear() {
     MutexLocker locker(m_mutex);
     m_finished = false;
     discardQueuedData();
   }

   void produce(const uint8_t* data, size_t length) {
     MutexLocker locker(m_mutex);
     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();
   }

   void consume(const uint8_t** data, size_t* length) {
     MutexLocker locker(m_mutex);
     while (!tryGetData(data, length))
       m_haveData.wait(m_mutex);
   }

  private:
   bool tryGetData(const uint8_t** data, size_t* length) {
     ASSERT(m_mutex.locked());
     if (!m_data.isEmpty()) {
       std::pair<const uint8_t*, size_t> next_data = m_data.takeFirst();
       *data = next_data.first;
       *length = next_data.second;
       return true;
     }
     if (m_finished) {
       *length = 0;
       return true;
     }
     return false;
   }

   void discardQueuedData() {
     while (!m_data.isEmpty()) {
       std::pair<const uint8_t*, size_t> next_data = m_data.takeFirst();
       delete[] next_data.first;
     }
   }

   Deque<std::pair<const uint8_t*, size_t>> m_data;
   bool m_finished;
   Mutex m_mutex;
   ThreadCondition m_haveData;
 };

 // SourceStream implements the streaming interface towards V8. The main
 // functionality is preparing the data to give to V8 on main thread, and
 // actually giving the data (via GetMoreData which is called on a background
 // 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_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 {
     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;
   }

   void didFinishLoading() {
     DCHECK(isMainThread());
     m_finished = true;
     m_dataQueue.finish();
   }

   void didReceiveData(ScriptStreamer* streamer) {
     DCHECK(isMainThread());
     prepareDataOnMainThread(streamer);
   }

   void cancel() {
     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) {
     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).
     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();
   }

   void fetchDataFromResourceBuffer() {
     DCHECK(isMainThread());
     MutexLocker locker(m_mutex);

     DCHECK(!m_finished);
     if (m_cancelled) {
       m_dataQueue.finish();
       return;
     }

     // Get as much data from the ResourceBuffer as we can.
     const char* data = nullptr;
     while (size_t length =
                m_resourceBuffer->getSomeData(data, m_queueTailPosition)) {
       // 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;
     }
   }

   // 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.

   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
   // sure negative cases here.
   bool startedStreaming = startStreamingInternal(
       script, scriptType, settings, scriptState, loadingTaskRunner);
   if (!startedStreaming)
     recordStartedStreamingHistogram(scriptType, 0);
 }

 bool ScriptStreamer::convertEncoding(
     const char* encodingName,
     v8::ScriptCompiler::StreamedSource::Encoding* encoding) {
   // Here's a list of encodings we can use for streaming. These are
   // the canonical names.
   if (strcmp(encodingName, "windows-1252") == 0 ||
       strcmp(encodingName, "ISO-8859-1") == 0 ||
       strcmp(encodingName, "US-ASCII") == 0) {
     *encoding = v8::ScriptCompiler::StreamedSource::ONE_BYTE;
     return true;
   }
   if (strcmp(encodingName, "UTF-8") == 0) {
     *encoding = v8::ScriptCompiler::StreamedSource::UTF8;
     return true;
   }
   // We don't stream other encodings; especially we don't stream two
   // byte scripts to avoid the handling of endianness. Most scripts
   // are Latin1 or UTF-8 anyway, so this should be enough for most
   // real world purposes.
   return false;
 }

 bool ScriptStreamer::isFinished() const {
   MutexLocker locker(m_mutex);
   return m_loadingFinished && (m_parsingFinished || m_streamingSuppressed);
 }

 void ScriptStreamer::streamingCompleteOnBackgroundThread() {
   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() {
   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);
   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) {
   DCHECK(isMainThread());
   DCHECK_EQ(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.
     DCHECK(resource->resourceBuffer());
     if (resource->resourceBuffer()->size() < s_smallScriptThreshold)
       return;
     m_haveEnoughDataForStreaming = true;

     {
       // 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. Supress
       // streaming if the encoding is unsupported.
       //
       // 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;
       }
     }

     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;
     }

     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);
 }

 void ScriptStreamer::notifyFinished(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)
     m_stream->didFinishLoading();
   m_loadingFinished = true;

   notifyFinishedToClient();
 }

 ScriptStreamer::ScriptStreamer(
     PendingScript* script,
     Type scriptType,
     ScriptState* scriptState,
     v8::ScriptCompiler::CompileOptions compileOptions,
     WebTaskRunner* loadingTaskRunner)
     : m_pendingScript(script),
       m_resource(script->resource()),
       m_detached(false),
       m_stream(0),
       m_loadingFinished(false),
       m_parsingFinished(false),
       m_haveEnoughDataForStreaming(false),
       m_streamingSuppressed(false),
       m_compileOptions(compileOptions),
       m_scriptState(scriptState),
       m_scriptType(scriptType),
       m_scriptURLString(m_resource->url().copy().getString()),
       m_scriptResourceIdentifier(m_resource->identifier()),
       m_encoding(
           v8::ScriptCompiler::StreamedSource::
               TWO_BYTE)  // Unfortunately there's no dummy encoding value in the enum; let's use one we don't stream.
       ,
       m_loadingTaskRunner(loadingTaskRunner->clone()) {}

 ScriptStreamer::~ScriptStreamer() {}

 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.
   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() {
   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) {
   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()) {
     recordNotStreamingReasonHistogram(scriptType, Reload);
     // 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: the Content-Length HTTP header is not sent for chunked
   // downloads.

   // Decide what kind of cached data we should produce while streaming. Only
   // produce parser cache if the non-streaming compile takes advantage of it.
   v8::ScriptCompiler::CompileOptions compileOption =
       v8::ScriptCompiler::kNoCompileOptions;
   if (settings->v8CacheOptions() == V8CacheOptionsParse)
     compileOption = v8::ScriptCompiler::kProduceParserCache;

   // 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
	// 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"
	#include "core/dom/PendingScript.h"
	#include "core/fetch/CachedMetadata.h"
	#include "core/fetch/ScriptResource.h"
	#include "core/frame/Settings.h"
	#include "core/html/parser/TextResourceDecoder.h"
	#include "platform/CrossThreadFunctional.h"
	#include "platform/Histogram.h"
	#include "platform/SharedBuffer.h"
	#include "platform/TraceEvent.h"
	#include "public/platform/WebScheduler.h"
	#include "wtf/Deque.h"
	#include "wtf/PtrUtil.h"
	#include "wtf/text/TextEncodingRegistry.h"
	#include <memory>

	namespace blink {

	namespace {

	void recordStartedStreamingHistogram(ScriptStreamer::Type scriptType,
	int reason) {
	switch (scriptType) {
	case ScriptStreamer::ParsingBlocking: {
	DEFINE_STATIC_LOCAL(
	EnumerationHistogram, parseBlockingHistogram,
	("WebCore.Scripts.ParsingBlocking.StartedStreaming", 2));
	parseBlockingHistogram.count(reason);
	break;
	}
	case ScriptStreamer::Deferred: {
	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:
	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,
	Reload,
	ContextNotValid,
	EncodingNotSupported,
	ThreadBusy,
	V8CannotStream,
	ScriptTooSmall,
	NotStreamingReasonEnd
	};

	void recordNotStreamingReasonHistogram(ScriptStreamer::Type scriptType,
	NotStreamingReason reason) {
	switch (scriptType) {
	case ScriptStreamer::ParsingBlocking: {
	DEFINE_STATIC_LOCAL(EnumerationHistogram, parseBlockingHistogram,
	("WebCore.Scripts.ParsingBlocking.NotStreamingReason",
	NotStreamingReasonEnd));
	parseBlockingHistogram.count(reason);
	break;
	}
	case ScriptStreamer::Deferred: {
	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:
	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 {
	WTF_MAKE_NONCOPYABLE(SourceStreamDataQueue);

	public:
	SourceStreamDataQueue() : m_finished(false) {}

	~SourceStreamDataQueue() { discardQueuedData(); }

	void clear() {
	MutexLocker locker(m_mutex);
	m_finished = false;
	discardQueuedData();
	}

	void produce(const uint8_t* data, size_t length) {
	MutexLocker locker(m_mutex);
	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();
	}

	void consume(const uint8_t** data, size_t* length) {
	MutexLocker locker(m_mutex);
	while (!tryGetData(data, length))
	m_haveData.wait(m_mutex);
	}

	private:
	bool tryGetData(const uint8_t** data, size_t* length) {
	ASSERT(m_mutex.locked());
	if (!m_data.isEmpty()) {
	std::pair<const uint8_t*, size_t> next_data = m_data.takeFirst();
	*data = next_data.first;
	*length = next_data.second;
	return true;
	}
	if (m_finished) {
	*length = 0;
	return true;
	}
	return false;
	}

	void discardQueuedData() {
	while (!m_data.isEmpty()) {
	std::pair<const uint8_t*, size_t> next_data = m_data.takeFirst();
	delete[] next_data.first;
	}
	}

	Deque<std::pair<const uint8_t*, size_t>> m_data;
	bool m_finished;
	Mutex m_mutex;
	ThreadCondition m_haveData;
	};

	// SourceStream implements the streaming interface towards V8. The main
	// functionality is preparing the data to give to V8 on main thread, and
	// actually giving the data (via GetMoreData which is called on a background
	// 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_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 {
	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;
	}

	void didFinishLoading() {
	DCHECK(isMainThread());
	m_finished = true;
	m_dataQueue.finish();
	}

	void didReceiveData(ScriptStreamer* streamer) {
	DCHECK(isMainThread());
	prepareDataOnMainThread(streamer);
	}

	void cancel() {
	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) {
	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).
	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();
	}

	void fetchDataFromResourceBuffer() {
	DCHECK(isMainThread());
	MutexLocker locker(m_mutex);

	DCHECK(!m_finished);
	if (m_cancelled) {
	m_dataQueue.finish();
	return;
	}

	// Get as much data from the ResourceBuffer as we can.
	const char* data = nullptr;
	while (size_t length =
	m_resourceBuffer->getSomeData(data, m_queueTailPosition)) {
	// 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;
	}
	}

	// 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.

	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
	// sure negative cases here.
	bool startedStreaming = startStreamingInternal(
	script, scriptType, settings, scriptState, loadingTaskRunner);
	if (!startedStreaming)
	recordStartedStreamingHistogram(scriptType, 0);
	}

	bool ScriptStreamer::convertEncoding(
	const char* encodingName,
	v8::ScriptCompiler::StreamedSource::Encoding* encoding) {
	// Here's a list of encodings we can use for streaming. These are
	// the canonical names.
	if (strcmp(encodingName, "windows-1252") == 0 \|\|
	strcmp(encodingName, "ISO-8859-1") == 0 \|\|
	strcmp(encodingName, "US-ASCII") == 0) {
	*encoding = v8::ScriptCompiler::StreamedSource::ONE_BYTE;
	return true;
	}
	if (strcmp(encodingName, "UTF-8") == 0) {
	*encoding = v8::ScriptCompiler::StreamedSource::UTF8;
	return true;
	}
	// We don't stream other encodings; especially we don't stream two
	// byte scripts to avoid the handling of endianness. Most scripts
	// are Latin1 or UTF-8 anyway, so this should be enough for most
	// real world purposes.
	return false;
	}

	bool ScriptStreamer::isFinished() const {
	MutexLocker locker(m_mutex);
	return m_loadingFinished && (m_parsingFinished \|\| m_streamingSuppressed);
	}

	void ScriptStreamer::streamingCompleteOnBackgroundThread() {
	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() {
	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);
	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) {
	DCHECK(isMainThread());
	DCHECK_EQ(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.
	DCHECK(resource->resourceBuffer());
	if (resource->resourceBuffer()->size() < s_smallScriptThreshold)
	return;
	m_haveEnoughDataForStreaming = true;

	{
	// 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. Supress
	// streaming if the encoding is unsupported.
	//
	// 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;
	}
	}

	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;
	}

	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);
	}

	void ScriptStreamer::notifyFinished(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)
	m_stream->didFinishLoading();
	m_loadingFinished = true;

	notifyFinishedToClient();
	}

	ScriptStreamer::ScriptStreamer(
	PendingScript* script,
	Type scriptType,
	ScriptState* scriptState,
	v8::ScriptCompiler::CompileOptions compileOptions,
	WebTaskRunner* loadingTaskRunner)
	: m_pendingScript(script),
	m_resource(script->resource()),
	m_detached(false),
	m_stream(0),
	m_loadingFinished(false),
	m_parsingFinished(false),
	m_haveEnoughDataForStreaming(false),
	m_streamingSuppressed(false),
	m_compileOptions(compileOptions),
	m_scriptState(scriptState),
	m_scriptType(scriptType),
	m_scriptURLString(m_resource->url().copy().getString()),
	m_scriptResourceIdentifier(m_resource->identifier()),
	m_encoding(
	v8::ScriptCompiler::StreamedSource::
	TWO_BYTE) // Unfortunately there's no dummy encoding value in the enum; let's use one we don't stream.
	,
	m_loadingTaskRunner(loadingTaskRunner->clone()) {}

	ScriptStreamer::~ScriptStreamer() {}

	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.
	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() {
	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) {
	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()) {
	recordNotStreamingReasonHistogram(scriptType, Reload);
	// 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: the Content-Length HTTP header is not sent for chunked
	// downloads.

	// Decide what kind of cached data we should produce while streaming. Only
	// produce parser cache if the non-streaming compile takes advantage of it.
	v8::ScriptCompiler::CompileOptions compileOption =
	v8::ScriptCompiler::kNoCompileOptions;
	if (settings->v8CacheOptions() == V8CacheOptionsParse)
	compileOption = v8::ScriptCompiler::kProduceParserCache;

	// 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