Make WebTaskRunner ThreadSafeRefCounted

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 "core/CoreExport.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Noncopyable.h"
@@ skipping 27 matching lines @@
 
   ~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*,
                              Type,
                              Settings*,
                              ScriptState*,
-                             WebTaskRunner*);
+                             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; }
 
@@ skipping 42 matching lines @@
  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,
       Type scriptType,
       ScriptState* scriptState,
       v8::ScriptCompiler::CompileOptions compileOptions,
-      WebTaskRunner* loadingTaskRunner) {
+      RefPtr<WebTaskRunner> loadingTaskRunner) {
     return new ScriptStreamer(script, scriptType, scriptState, compileOptions,
-                              loadingTaskRunner);
+                              std::move(loadingTaskRunner));
   }
   ScriptStreamer(PendingScript*,
                  Type,
                  ScriptState*,
                  v8::ScriptCompiler::CompileOptions,
-                 WebTaskRunner*);
+                 RefPtr<WebTaskRunner>);
 
   void streamingComplete();
   void notifyFinishedToClient();
 
   static bool startStreamingInternal(PendingScript*,
                                      Type,
                                      Settings*,
                                      ScriptState*,
-                                     WebTaskRunner*);
+                                     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<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;
@@ skipping 23 matching lines @@
   const String m_scriptURLString;
 
   // Keep the script resource dentifier for event tracing.
   const unsigned long m_scriptResourceIdentifier;
 
   mutable Mutex m_mutex;
 
   // Encoding of the streamed script. Saved for sanity checking purposes.
   v8::ScriptCompiler::StreamedSource::Encoding m_encoding;
 
-  std::unique_ptr<WebTaskRunner> m_loadingTaskRunner;
+  RefPtr<WebTaskRunner> m_loadingTaskRunner;
 };
 
 }  // namespace blink
 
 #endif  // ScriptStreamer_h