Simplify ScriptStreamer lifetime handling.

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/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/WebScheduler.h"
+#include "wtf/Deque.h"
 #include "wtf/text/TextEncodingRegistry.h"
 
 namespace blink {
 
 namespace {
 
 void recordStartedStreamingHistogram(ScriptStreamer::Type scriptType, int reason)
 {
     switch (scriptType) {
     case ScriptStreamer::ParsingBlocking: {
@@ skipping 119 matching lines @@
     }
 
     void discardQueuedData()
     {
         while (!m_data.isEmpty()) {
             std::pair<const uint8_t*, size_t> next_data = m_data.takeFirst();
             delete[] next_data.first;
         }
     }
 
-    WTF::Deque<std::pair<const uint8_t*, size_t>> m_data;
+    Deque<std::pair<const uint8_t*, size_t>> m_data;
     bool m_finished;
     Mutex m_mutex;
     ThreadCondition m_haveData;
 };
 
 
 // SourceStream implements the streaming interface towards V8. The main
 // functionality is preparing the data to give to V8 on main thread, and
 // actually giving the data (via GetMoreData which is called on a background
 // thread).
@@ skipping 352 matching lines @@
             return;
         }
 
         ASSERT(!m_stream);
         ASSERT(!m_source);
         m_stream = new SourceStream(m_loadingTaskRunner.get());
         // m_source takes ownership of m_stream.
         m_source = adoptPtr(new v8::ScriptCompiler::StreamedSource(m_stream, m_encoding));
 
         ScriptState::Scope scope(m_scriptState.get());
-        WTF::OwnPtr<v8::ScriptCompiler::ScriptStreamingTask> scriptStreamingTask(adoptPtr(v8::ScriptCompiler::StartStreamingScript(m_scriptState->isolate(), m_source.get(), m_compileOptions)));
+        OwnPtr<v8::ScriptCompiler::ScriptStreamingTask> scriptStreamingTask(adoptPtr(v8::ScriptCompiler::StartStreamingScript(m_scriptState->isolate(), m_source.get(), m_compileOptions)));
         if (!scriptStreamingTask) {
             // V8 cannot stream the script.
             suppressStreaming();
             m_stream = 0;
             m_source.clear();
             recordNotStreamingReasonHistogram(m_scriptType, V8CannotStream);
             recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
-        // ScriptStreamer needs to stay alive as long as the background task is
-        // running. This is taken care of with a manual ref() & deref() pair;
-        // the corresponding deref() is in streamingComplete.
-        ref();
         ScriptStreamerThread::shared()->postTask(threadSafeBind(&ScriptStreamerThread::runScriptStreamingTask, scriptStreamingTask.release(), AllowCrossThreadAccess(this)));
         recordStartedStreamingHistogram(m_scriptType, 1);
     }
     if (m_stream)
         m_stream->didReceiveData(this, lengthOfBOM);
 }
 
 void ScriptStreamer::notifyFinished(Resource* resource)
 {
     ASSERT(isMainThread());
@@ skipping 51 matching lines @@
 {
     // 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
     // background task finishes.
-    if (m_detached || m_streamingSuppressed) {
-        deref();
+    if (m_detached || m_streamingSuppressed)
         return;
-    }
 
     // We have now streamed the whole script to V8 and it has parsed the
     // script. We're ready for the next step: compiling and executing the
     // script.
     notifyFinishedToClient();
-
-    // The background thread no longer holds an implicit reference.
-    deref();
 }
 
 void ScriptStreamer::notifyFinishedToClient()
 {
     ASSERT(isMainThread());
     // Usually, the loading will be finished first, and V8 will still need some
     // 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
@@ skipping 38 matching lines @@
 
     // 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(script, scriptType, scriptState, compileOption, loadingTaskRunner));
 
     return true;
 }
 
 } // namespace blink