Move ResourceOwner on to the oilpan heap.

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"
 #include "core/dom/PendingScript.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/frame/Settings.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "platform/SharedBuffer.h"
 #include "platform/Task.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "wtf/MainThread.h"
 #include "wtf/text/TextEncodingRegistry.h"
 
 namespace blink {
 
 namespace {
 
-const char* startedStreamingHistogramName(PendingScript::Type scriptType)
+const char* startedStreamingHistogramName(ScriptStreamer::Type scriptType)
 {
     switch (scriptType) {
-    case PendingScript::ParsingBlocking:
+    case ScriptStreamer::ParsingBlocking:
         return "WebCore.Scripts.ParsingBlocking.StartedStreaming";
         break;
-    case PendingScript::Deferred:
+    case ScriptStreamer::Deferred:
         return "WebCore.Scripts.Deferred.StartedStreaming";
         break;
-    case PendingScript::Async:
+    case ScriptStreamer::Async:
         return "WebCore.Scripts.Async.StartedStreaming";
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
     return 0;
 }
 
 // For tracking why some scripts are not streamed. Not streaming is part of
 // normal operation (e.g., script already loaded, script too small) and doesn't
 // necessarily indicate a failure.
 enum NotStreamingReason {
     AlreadyLoaded,
     NotHTTP,
     Reload,
     ContextNotValid,
     EncodingNotSupported,
     ThreadBusy,
     V8CannotStream,
     ScriptTooSmall,
     NotStreamingReasonEnd
 };
 
-const char* notStreamingReasonHistogramName(PendingScript::Type scriptType)
+const char* notStreamingReasonHistogramName(ScriptStreamer::Type scriptType)
 {
     switch (scriptType) {
-    case PendingScript::ParsingBlocking:
+    case ScriptStreamer::ParsingBlocking:
         return "WebCore.Scripts.ParsingBlocking.NotStreamingReason";
         break;
-    case PendingScript::Deferred:
+    case ScriptStreamer::Deferred:
         return "WebCore.Scripts.Deferred.NotStreamingReason";
         break;
-    case PendingScript::Async:
+    case ScriptStreamer::Async:
         return "WebCore.Scripts.Async.NotStreamingReason";
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
     return 0;
 }
 
 } // namespace
@@ skipping 288 matching lines @@
     // streaming case).
     // We store this separately, to avoid having to guard all
     // m_queueLeadPosition references with a mutex.
     size_t m_lengthOfBOM; // Used by both threads; guarded by m_mutex.
 
     OwnPtr<WebTaskRunner> m_loadingTaskRunner;
 };
 
 size_t ScriptStreamer::kSmallScriptThreshold = 30 * 1024;
 
-void ScriptStreamer::startStreaming(PendingScript& script, PendingScript::Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
+void ScriptStreamer::startStreaming(PendingScript* script, Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
     // We don't yet know whether the script will really be streamed. E.g.,
     // suppressing streaming for short scripts is done later. Record only the
     // sure negative cases here.
     bool startedStreaming = startStreamingInternal(script, scriptType, settings, scriptState, loadingTaskRunner);
     if (!startedStreaming)
         Platform::current()->histogramEnumeration(startedStreamingHistogramName(scriptType), 0, 2);
 }
 
 bool ScriptStreamer::convertEncoding(const char* encodingName, v8::ScriptCompiler::StreamedSource::Encoding* encoding)
@@ skipping 169 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, PendingScript::Type scriptType, ScriptState* scriptState, v8::ScriptCompiler::CompileOptions compileOptions, WebTaskRunner* loadingTaskRunner)
+ScriptStreamer::ScriptStreamer(ScriptResource* resource, Type scriptType, ScriptState* scriptState, v8::ScriptCompiler::CompileOptions compileOptions, WebTaskRunner* loadingTaskRunner)
     : m_resource(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)
@@ skipping 48 matching lines @@
     // 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);
 }
 
-bool ScriptStreamer::startStreamingInternal(PendingScript& script, PendingScript::Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
+bool ScriptStreamer::startStreamingInternal(PendingScript* script, Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
     ASSERT(isMainThread());
     ASSERT(scriptState->contextIsValid());
-    ScriptResource* resource = script.resource();
+    ScriptResource* resource = script->resource();
     if (resource->isLoaded()) {
         Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(scriptType), AlreadyLoaded, NotStreamingReasonEnd);
         return false;
     }
     if (!resource->url().protocolIsInHTTPFamily()) {
         Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(scriptType), NotHTTP, NotStreamingReasonEnd);
         return false;
     }
     if (resource->isCacheValidator()) {
         Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(scriptType), Reload, NotStreamingReasonEnd);
         // This happens e.g., during reloads. We're actually not going to load
         // the current Resource of the PendingScript but switch to another
         // Resource -> don't stream.
         return false;
     }
     // We cannot filter out short scripts, even if we wait for the HTTP headers
     // to arrive: the Content-Length HTTP header is not sent for chunked
     // downloads.
 
     // 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(resource, scriptType, scriptState, compileOption, loadingTaskRunner));
 
     return true;
 }
 
 } // namespace blink