Make ScriptStreamer and dependents Oilpan friendly.

Source/bindings/core/v8/ScriptStreamer.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 "config.h"
 #include "bindings/core/v8/ScriptStreamer.h"
 
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/dom/Document.h"
@@ skipping 394 matching lines @@
         while (!isFinished()) {
             ASSERT(!m_parsingFinished);
             ASSERT(!m_streamingSuppressed);
             m_mainThreadWaitingForParserThread = true;
             m_parsingFinishedCondition.wait(m_mutex);
         }
     }
 
     // Calling notifyFinishedToClient can result into the upper layers dropping
     // references to ScriptStreamer. Keep it alive until this function ends.
-    RefPtr<ScriptStreamer> protect(this);
+    RefPtrWillBeRawPtr<ScriptStreamer> protect(this);

[marja, 2015/01/22 08:21:57]

... and why is WillBeRawPtr correct? As this is only meant to protect the
ScriptStreamer, an a raw pointer won't protect anything, doesn't sound correct.
What will protect ScriptStremer in the future? (And then I guess that this
should just be removed.)

[haraken, 2015/01/22 08:24:50]

In oilpan, you don't need to protect it because conservative scanning will find
on-stack pointers automatically.

 
     notifyFinishedToClient();
 
     if (m_mainThreadWaitingForParserThread) {
         ASSERT(m_parsingFinished);
         ASSERT(!m_streamingSuppressed);
         // streamingComplete won't be called, so do the ramp-down work
         // here.
         deref();
     }
@@ skipping 10 matching lines @@
     , m_streamingSuppressed(false)
     , m_compileOptions(compileOptions)
     , m_scriptState(scriptState)
     , m_scriptType(scriptType)
     , m_scriptStreamingMode(mode)
     , m_mainThreadWaitingForParserThread(false)
     , 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.
 {
 }
 
+ScriptStreamer::~ScriptStreamer()
+{
+}
+
+void ScriptStreamer::trace(Visitor* visitor)
+{
+    visitor->trace(m_resource);
+}
+
 void ScriptStreamer::streamingComplete()
 {
     // The background task is completed; do the necessary ramp-down in the main
     // thread.
     ASSERT(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
@@ skipping 81 matching lines @@
     // Decide what kind of cached data we should produce while streaming. By
     // default, we generate the parser cache for streamed scripts, to emulate
     // the non-streaming behavior (see V8ScriptRunner::compileScript).
     v8::ScriptCompiler::CompileOptions compileOption = v8::ScriptCompiler::kProduceParserCache;
     if (settings->v8CacheOptions() == V8CacheOptionsCode || settings->v8CacheOptions() == V8CacheOptionsCodeCompressed)
         compileOption = v8::ScriptCompiler::kProduceCodeCache;
 
     // 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(adoptRef(new ScriptStreamer(resource, scriptType, settings->v8ScriptStreamingMode(), scriptState, compileOption)));
+    script.setStreamer(ScriptStreamer::create(resource, scriptType, settings->v8ScriptStreamingMode(), scriptState, compileOption));
 
     return true;
 }
 
 } // namespace blink