Make Resource RefCountedWillBeGarbageCollectedFinalized, attempt #2

third_party/WebKit/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 "bindings/core/v8/ScriptStreamer.h"
 
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
@@ skipping 559 matching lines @@
         m_stream->didFinishLoading();
     m_loadingFinished = true;
 
     // Calling notifyFinishedToClient can result into the upper layers dropping
     // references to ScriptStreamer. Keep it alive until this function ends.
     RefPtrWillBeRawPtr<ScriptStreamer> protect(this);
 
     notifyFinishedToClient();
 }
 
-ScriptStreamer::ScriptStreamer(ScriptResource* resource, Type scriptType, ScriptState* scriptState, v8::ScriptCompiler::CompileOptions compileOptions, WebTaskRunner* loadingTaskRunner)
-    : m_resource(resource)
+ScriptStreamer::ScriptStreamer(PendingScript* script, Type scriptType, ScriptState* scriptState, v8::ScriptCompiler::CompileOptions compileOptions, WebTaskRunner* loadingTaskRunner)
+    : m_pendingScript(script)
+    , m_resource(script->resource())
     , m_detached(false)
     , m_stream(0)
-    , m_client(0)
     , m_loadingFinished(false)
     , m_parsingFinished(false)
     , m_haveEnoughDataForStreaming(false)
     , m_streamingSuppressed(false)
     , m_compileOptions(compileOptions)
     , m_scriptState(scriptState)
     , m_scriptType(scriptType)
     , 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.
     , m_loadingTaskRunner(adoptPtr(loadingTaskRunner->clone()))
 {
 }
 
 ScriptStreamer::~ScriptStreamer()
 {
 }
 
 DEFINE_TRACE(ScriptStreamer)
 {
+    visitor->trace(m_pendingScript);
     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
@@ skipping 22 matching lines @@
     // 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. Here we also check that we have a client: it can happen that a
     // function calling notifyFinishedToClient was already scheduled in the task
     // queue and the upper layer decided that it's not interested in the script
     // and called removeClient.
     if (!isFinished())
         return;
 
-    if (m_client)
-        m_client->notifyFinished(m_resource);
+    m_pendingScript->streamingFinished();
 }
 
 bool ScriptStreamer::startStreamingInternal(PendingScript* script, Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
     ASSERT(isMainThread());
     ASSERT(scriptState->contextIsValid());
     ScriptResource* resource = script->resource();
     if (resource->isLoaded()) {
         recordNotStreamingReasonHistogram(scriptType, AlreadyLoaded);
         return false;
@@ skipping 15 matching lines @@
 
     // 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 compileOption = v8::ScriptCompiler::kNoCompileOptions;
     if (settings->v8CacheOptions() == V8CacheOptionsParse)
         compileOption = 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
     // destroyed.
-    script->setStreamer(ScriptStreamer::create(resource, scriptType, scriptState, compileOption, loadingTaskRunner));
+    script->setStreamer(ScriptStreamer::create(script, scriptType, scriptState, compileOption, loadingTaskRunner));
 
     return true;
 }
 
 } // namespace blink