Make ScriptStreamer and dependents Oilpan friendly.

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 "bindings/core/v8/ScriptStreamingMode.h"
 #include "core/dom/PendingScript.h"
+#include "platform/heap/Handle.h"
 #include "wtf/RefCounted.h"
 
 #include <v8.h>
 
 namespace blink {
 
 class PendingScript;
 class Resource;
 class ScriptResource;
 class ScriptResourceClient;
 class ScriptState;
 class Settings;
 class SourceStream;
 
 // 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.
-class ScriptStreamer : public RefCounted<ScriptStreamer> {
+class ScriptStreamer final : public RefCountedWillBeRefCountedGarbageCollected<ScriptStreamer> {
     WTF_MAKE_NONCOPYABLE(ScriptStreamer);
 public:
+    static PassRefPtrWillBeRawPtr<ScriptStreamer> create(ScriptResource* resource, PendingScript::Type scriptType, ScriptStreamingMode mode, ScriptState* scriptState, v8::ScriptCompiler::CompileOptions compileOptions)
+    {
+        return adoptRefWillBeNoop(new ScriptStreamer(resource, scriptType, mode, scriptState, compileOptions));
+    }
+
+    ~ScriptStreamer();
+    void trace(Visitor*);
+
     // Launches a task (on a background thread) which will stream the given
     // PendingScript into V8 as it loads. It's also possible that V8 cannot
     // stream the given script; in that case this function returns
     // false. Internally, this constructs a ScriptStreamer and attaches it to
     // the PendingScript. Use ScriptStreamer::addClient to get notified when the
     // streaming finishes.
     static void startStreaming(PendingScript&, Settings*, ScriptState*, PendingScript::Type);
 
     // Returns false if we cannot stream the given encoding.
     static bool convertEncoding(const char* encodingName, v8::ScriptCompiler::StreamedSource::Encoding*);
@@ skipping 71 matching lines @@
         return m_scriptStreamingMode == ScriptStreamingModeAllPlusBlockParsingBlocking && m_scriptType == PendingScript::ParsingBlocking;
     }
 
     static const char* startedStreamingHistogramName(PendingScript::Type);
 
     static bool startStreamingInternal(PendingScript&, Settings*, ScriptState*, PendingScript::Type);
 
     // This pointer is weak. If PendingScript and its Resource are deleted
     // before ScriptStreamer, PendingScript will notify ScriptStreamer of its
     // deletion by calling cancel().
-    ScriptResource* m_resource;
+    RawPtrWillBeMember<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;
     OwnPtr<v8::ScriptCompiler::StreamedSource> m_source;
     ScriptResourceClient* m_client;
     bool m_loadingFinished; // Whether loading from the network is done.
     // Whether the V8 side processing is done. Will be used by the main thread
@@ skipping 26 matching lines @@
     // do it, otherwise the parser thread should do it. Guarded by m_mutex.
     bool m_mainThreadWaitingForParserThread;
 
     // Encoding of the streamed script. Saved for sanity checking purposes.
     v8::ScriptCompiler::StreamedSource::Encoding m_encoding;
 };
 
 } // namespace blink
 
 #endif // ScriptStreamer_h