Split ScriptStreamer and ScriptStreamerImpl, preparing for unit testing

third_party/WebKit/Source/bindings/core/v8/ScriptStreamerImpl.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/ScriptStreamerImpl.h"
 
 #include <memory>
 #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/frame/Settings.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/loader/resource/ScriptResource.h"
@@ skipping 162 matching lines @@
 
  public:
   explicit SourceStream(RefPtr<WebTaskRunner> loading_task_runner)
       : v8::ScriptCompiler::ExternalSourceStream(),
         cancelled_(false),
         finished_(false),
         queue_lead_position_(0),
         queue_tail_position_(0),
         loading_task_runner_(std::move(loading_task_runner)) {}
 
-  virtual ~SourceStream() override {}
+  ~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(mutex_);
       if (cancelled_)
         return 0;
     }
     size_t length = 0;
     // This will wait until there is data.
     data_queue_.Consume(src, &length);
     {
       MutexLocker locker(mutex_);
       if (cancelled_)
         return 0;
     }
     queue_lead_position_ += length;
     return length;
   }
 
   void DidFinishLoading() {
     DCHECK(IsMainThread());
     finished_ = true;
     data_queue_.Finish();
   }
 
-  void DidReceiveData(ScriptStreamer* streamer) {
+  void DidReceiveData(ScriptStreamerImpl* 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(mutex_);
       cancelled_ = true;
     }
     data_queue_.Finish();
   }
 
  private:
-  void PrepareDataOnMainThread(ScriptStreamer* streamer) {
+  void PrepareDataOnMainThread(ScriptStreamerImpl* streamer) {
     DCHECK(IsMainThread());
 
     if (cancelled_) {
       data_queue_.Finish();
       return;
     }
 
     // The Resource must still be alive; otherwise we should've cancelled
     // the streaming (if we have cancelled, the background thread is not
     // waiting).
@@ skipping 70 matching lines @@
   //   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 data_queue_;  // Thread safe.
   size_t queue_lead_position_;        // Only used by v8 thread.
   size_t queue_tail_position_;  // Used by both threads; guarded by m_mutex.
 
   RefPtr<WebTaskRunner> loading_task_runner_;
 };
 
-size_t ScriptStreamer::small_script_threshold_ = 30 * 1024;
+size_t ScriptStreamerImpl::small_script_threshold_ = 30 * 1024;
 
-void ScriptStreamer::StartStreaming(PendingScript* script,
-                                    Type script_type,
-                                    Settings* settings,
-                                    ScriptState* script_state,
-                                    RefPtr<WebTaskRunner> loading_task_runner) {
+void ScriptStreamerImpl::StartStreaming(
+    PendingScript* script,
+    Type script_type,
+    Settings* settings,
+    ScriptState* script_state,
+    RefPtr<WebTaskRunner> loading_task_runner) {
   // 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 started_streaming =
       StartStreamingInternal(script, script_type, settings, script_state,
                              std::move(loading_task_runner));
   if (!started_streaming)
     RecordStartedStreamingHistogram(script_type, 0);
 }
 
-bool ScriptStreamer::ConvertEncoding(
+bool ScriptStreamerImpl::ConvertEncoding(
     const char* encoding_name,
     v8::ScriptCompiler::StreamedSource::Encoding* encoding) {
   // Here's a list of encodings we can use for streaming. These are
   // the canonical names.
   if (strcmp(encoding_name, "windows-1252") == 0 ||
       strcmp(encoding_name, "ISO-8859-1") == 0 ||
       strcmp(encoding_name, "US-ASCII") == 0) {
     *encoding = v8::ScriptCompiler::StreamedSource::ONE_BYTE;
     return true;
   }
   if (strcmp(encoding_name, "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 {
+bool ScriptStreamerImpl::IsFinished() const {
   DCHECK(IsMainThread());
   return loading_finished_ && (parsing_finished_ || streaming_suppressed_);
 }
 
-void ScriptStreamer::StreamingCompleteOnBackgroundThread() {
+void ScriptStreamerImpl::StreamingCompleteOnBackgroundThread() {
   DCHECK(!IsMainThread());
 
   // notifyFinished might already be called, or it might be called in the
   // future (if the parsing finishes earlier because of a parse error).
   loading_task_runner_->PostTask(
-      BLINK_FROM_HERE, CrossThreadBind(&ScriptStreamer::StreamingComplete,
+      BLINK_FROM_HERE, CrossThreadBind(&ScriptStreamerImpl::StreamingComplete,
                                        WrapCrossThreadPersistent(this)));
 
-  // The task might delete ScriptStreamer, so it's not safe to do anything
+  // The task might delete ScriptStreamerImpl, 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.
 }
 
-void ScriptStreamer::Cancel() {
+void ScriptStreamerImpl::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.
   detached_ = true;
   resource_ = 0;
   if (stream_)
     stream_->Cancel();
 }
 
-void ScriptStreamer::SuppressStreaming() {
+void ScriptStreamerImpl::SuppressStreaming() {
   DCHECK(IsMainThread());
   DCHECK(!loading_finished_);
   // It can be that the parsing task has already finished (e.g., if there was
   // a parse error).
   streaming_suppressed_ = true;
 }
 
-void ScriptStreamer::NotifyAppendData(ScriptResource* resource) {
+void ScriptStreamerImpl::NotifyAppendData(ScriptResource* resource) {
   DCHECK(IsMainThread());
   CHECK_EQ(resource_, resource);
   if (streaming_suppressed_)
     return;
   if (!have_enough_data_for_streaming_) {
     // 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() < small_script_threshold_)
@@ skipping 72 matching lines @@
     ScriptStreamerThread::Shared()->PostTask(
         CrossThreadBind(&ScriptStreamerThread::RunScriptStreamingTask,
                         WTF::Passed(std::move(script_streaming_task)),
                         WrapCrossThreadPersistent(this)));
     RecordStartedStreamingHistogram(script_type_, 1);
   }
   if (stream_)
     stream_->DidReceiveData(this);
 }
 
-void ScriptStreamer::NotifyFinished(Resource* resource) {
+void ScriptStreamerImpl::NotifyFinished(Resource* resource) {
   DCHECK(IsMainThread());
   CHECK_EQ(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 (!have_enough_data_for_streaming_) {
     RecordNotStreamingReasonHistogram(script_type_, kScriptTooSmall);
     RecordStartedStreamingHistogram(script_type_, 0);
     SuppressStreaming();
   }
   if (stream_)
     stream_->DidFinishLoading();
   loading_finished_ = true;
 
   NotifyFinishedToClient();
 }
 
-ScriptStreamer::ScriptStreamer(
+ScriptStreamerImpl::ScriptStreamerImpl(
     PendingScript* script,
     Type script_type,
     ScriptState* script_state,
     v8::ScriptCompiler::CompileOptions compile_options,
     RefPtr<WebTaskRunner> loading_task_runner)
     : pending_script_(script),
       resource_(script->GetResource()),
       detached_(false),
       stream_(0),
       loading_finished_(false),
       parsing_finished_(false),
       have_enough_data_for_streaming_(false),
       streaming_suppressed_(false),
       compile_options_(compile_options),
       script_state_(script_state),
       script_type_(script_type),
       script_url_string_(resource_->Url().Copy().GetString()),
       script_resource_identifier_(resource_->Identifier()),
       // Unfortunately there's no dummy encoding value in the enum; let's use
       // one we don't stream.
       encoding_(v8::ScriptCompiler::StreamedSource::TWO_BYTE),
       loading_task_runner_(std::move(loading_task_runner)) {}
 
-ScriptStreamer::~ScriptStreamer() {}
+ScriptStreamerImpl::~ScriptStreamerImpl() {}
 
-DEFINE_TRACE(ScriptStreamer) {
+DEFINE_TRACE(ScriptStreamerImpl) {
   visitor->Trace(pending_script_);
   visitor->Trace(resource_);
+  ScriptStreamer::Trace(visitor);
 }
 
-void ScriptStreamer::StreamingComplete() {
+void ScriptStreamerImpl::StreamingComplete() {
   // The background task is completed; do the necessary ramp-down in the main
   // thread.
   DCHECK(IsMainThread());
   parsing_finished_ = true;
 
   // 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 (detached_ || streaming_suppressed_)
     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() {
+void ScriptStreamerImpl::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.
   if (!IsFinished())
     return;
 
   pending_script_->StreamingFinished();
 }
 
-bool ScriptStreamer::StartStreamingInternal(
+bool ScriptStreamerImpl::StartStreamingInternal(
     PendingScript* script,
     Type script_type,
     Settings* settings,
     ScriptState* script_state,
     RefPtr<WebTaskRunner> loading_task_runner) {
   DCHECK(IsMainThread());
   DCHECK(script_state->ContextIsValid());
   ScriptResource* resource = script->GetResource();
   if (resource->IsLoaded()) {
     RecordNotStreamingReasonHistogram(script_type, kAlreadyLoaded);
@@ skipping 14 matching lines @@
   // 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 compile_option =
       v8::ScriptCompiler::kNoCompileOptions;
   if (settings->GetV8CacheOptions() == kV8CacheOptionsParse)
     compile_option = 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
+  // The Resource might go out of scope if the script is no longer needed.
+  // This makes PendingScript notify the ScriptStreamerImpl when it is
   // destroyed.
-  script->SetStreamer(ScriptStreamer::Create(script, script_type, script_state,
-                                             compile_option,
-                                             std::move(loading_task_runner)));
+  script->SetStreamer(ScriptStreamerImpl::Create(
+      script, script_type, script_state, compile_option,
+      std::move(loading_task_runner)));
 
   return true;
 }
 
 }  // namespace blink