Reland of Split PendingScript into PendingScript and ClassicPendingScript

third_party/WebKit/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 <memory>
 
 #include "core/CoreExport.h"
+#include "platform/WebTaskRunner.h"
 #include "platform/heap/Handle.h"
 #include "platform/wtf/Noncopyable.h"
 #include "platform/wtf/text/WTFString.h"
 #include "v8/include/v8.h"
 
 namespace blink {
 
-class PendingScript;
+class ClassicPendingScript;
 class Resource;
 class ScriptResource;
 class ScriptState;
 class Settings;
 class SourceStream;
 class WebTaskRunner;
 
 // ScriptStreamer streams incomplete script data to V8 so that it can be parsed
-// while it's loaded. PendingScript holds a reference to ScriptStreamer. At the
-// moment, ScriptStreamer is only used for parser blocking scripts; this means
-// that the Document stays stable and no other scripts are executing while we're
-// streaming. It is possible, though, that Document and the PendingScript are
-// destroyed while the streaming is in progress, and ScriptStreamer handles it
-// gracefully.
+// while it's loaded. ClassicPendingScript holds a reference to ScriptStreamer.
+// At the moment, ScriptStreamer is only used for parser blocking scripts; this
+// means that the Document stays stable and no other scripts are executing
+// while we're streaming. It is possible, though, that Document and the
+// ClassicPendingScript are destroyed while the streaming is in progress, and
+// ScriptStreamer handles it gracefully.
 class CORE_EXPORT ScriptStreamer final
     : public GarbageCollectedFinalized<ScriptStreamer> {
   WTF_MAKE_NONCOPYABLE(ScriptStreamer);
 
  public:
   enum Type { ParsingBlocking, Deferred, Async };
 
   ~ScriptStreamer();
   DECLARE_TRACE();
 
   // Launches a task (on a background thread) which will stream the given
-  // PendingScript into V8 as it loads.
-  static void startStreaming(PendingScript*,
+  // ClassicPendingScript into V8 as it loads.
+  static void startStreaming(ClassicPendingScript*,
                              Type,
                              Settings*,
                              ScriptState*,
                              RefPtr<WebTaskRunner>);
 
   // Returns false if we cannot stream the given encoding.
   static bool convertEncoding(const char* encodingName,
                               v8::ScriptCompiler::StreamedSource::Encoding*);
 
   bool isFinished() const;
 
   v8::ScriptCompiler::StreamedSource* source() { return m_source.get(); }
   ScriptResource* resource() const { return m_resource; }
 
   // Called when the script is not needed any more (e.g., loading was
-  // cancelled). After calling cancel, PendingScript can drop its reference to
-  // ScriptStreamer, and ScriptStreamer takes care of eventually deleting
-  // itself (after the V8 side has finished too).
+  // cancelled). After calling cancel, ClassicPendingScript can drop its
+  // reference to ScriptStreamer, and ScriptStreamer takes care of eventually
+  // deleting itself (after the V8 side has finished too).
   void cancel();
 
   // When the streaming is suppressed, the data is not given to V8, but
   // ScriptStreamer still watches the resource load and notifies the upper
   // layers when loading is finished. It is used in situations when we have
   // started streaming but then we detect we don't want to stream (e.g., when
   // we have the code cache for the script) and we still want to parse and
   // execute it when it has finished loading.
   void suppressStreaming();
   bool streamingSuppressed() const { return m_streamingSuppressed; }
 
   v8::ScriptCompiler::CompileOptions compileOptions() const {
     return m_compileOptions;
   }
 
-  // Called by PendingScript when data arrives from the network.
+  // Called by ClassicPendingScript 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 streamingCompleteOnBackgroundThread();
 
   v8::ScriptCompiler::StreamedSource::Encoding encoding() const {
     return m_encoding;
   }
 
   const String& scriptURLString() const { return m_scriptURLString; }
   unsigned long scriptResourceIdentifier() const {
     return m_scriptResourceIdentifier;
   }
 
   static void setSmallScriptThresholdForTesting(size_t threshold) {
     s_smallScriptThreshold = threshold;
   }
 
   static size_t smallScriptThreshold() { return s_smallScriptThreshold; }
 
  private:
   // Scripts whose first data chunk is smaller than this constant won't be
   // streamed. Non-const for testing.
   static size_t s_smallScriptThreshold;
 
   static ScriptStreamer* create(
-      PendingScript* script,
+      ClassicPendingScript* script,
       Type scriptType,
       ScriptState* scriptState,
       v8::ScriptCompiler::CompileOptions compileOptions,
       RefPtr<WebTaskRunner> loadingTaskRunner) {
     return new ScriptStreamer(script, scriptType, scriptState, compileOptions,
                               std::move(loadingTaskRunner));
   }
-  ScriptStreamer(PendingScript*,
+  ScriptStreamer(ClassicPendingScript*,
                  Type,
                  ScriptState*,
                  v8::ScriptCompiler::CompileOptions,
                  RefPtr<WebTaskRunner>);
 
   void streamingComplete();
   void notifyFinishedToClient();
 
-  static bool startStreamingInternal(PendingScript*,
+  static bool startStreamingInternal(ClassicPendingScript*,
                                      Type,
                                      Settings*,
                                      ScriptState*,
                                      RefPtr<WebTaskRunner>);
 
-  Member<PendingScript> m_pendingScript;
-  // This pointer is weak. If PendingScript and its Resource are deleted
-  // before ScriptStreamer, PendingScript will notify ScriptStreamer of its
-  // deletion by calling cancel().
+  Member<ClassicPendingScript> m_pendingScript;
+  // This pointer is weak. If ClassicPendingScript and its Resource are deleted
+  // before ScriptStreamer, ClassicPendingScript will notify ScriptStreamer of
+  // its deletion by calling cancel().
   Member<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;
   std::unique_ptr<v8::ScriptCompiler::StreamedSource> m_source;
   bool m_loadingFinished;  // Whether loading from the network is done.
   bool m_parsingFinished;  // Whether the V8 side processing is done.
@@ skipping 20 matching lines @@
 
   // Encoding of the streamed script. Saved for sanity checking purposes.
   v8::ScriptCompiler::StreamedSource::Encoding m_encoding;
 
   RefPtr<WebTaskRunner> m_loadingTaskRunner;
 };
 
 }  // namespace blink
 
 #endif  // ScriptStreamer_h