Retire unnecessary ScriptStreamer back reference from SourceStream.

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 71 matching lines @@
 };
 
 
 // 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).
 class SourceStream : public v8::ScriptCompiler::ExternalSourceStream {
     WTF_MAKE_NONCOPYABLE(SourceStream);
 public:
-    SourceStream(ScriptStreamer* streamer)
+    SourceStream()
         : v8::ScriptCompiler::ExternalSourceStream()
-        , m_streamer(streamer)
         , m_cancelled(false)
         , m_dataPosition(0) { }
 
     virtual ~SourceStream() { }
 
     // Called by V8 on a background thread. Should block until we can return
     // some data.
     virtual size_t GetMoreData(const uint8_t** src) override
     {
         ASSERT(!isMainThread());
@@ skipping 12 matching lines @@
         }
         return length;
     }
 
     void didFinishLoading()
     {
         ASSERT(isMainThread());
         m_dataQueue.finish();
     }
 
-    void didReceiveData(size_t lengthOfBOM)
+    void didReceiveData(ScriptStreamer* streamer, size_t lengthOfBOM)
     {
         ASSERT(isMainThread());
-        prepareDataOnMainThread(lengthOfBOM);
+        prepareDataOnMainThread(streamer, lengthOfBOM);
     }
 
     void cancel()
     {
         ASSERT(isMainThread());
         // The script is no longer needed by the upper layers. Stop streaming
         // it. The next time GetMoreData is called (or woken up), it will return
         // 0, which will be interpreted as EOS by V8 and the parsing will
         // fail. ScriptStreamer::streamingComplete will be called, and at that
         // point we will release the references to SourceStream.
         {
             MutexLocker locker(m_mutex);
             m_cancelled = true;
         }
         m_dataQueue.finish();
     }
 
 private:
-    void prepareDataOnMainThread(size_t lengthOfBOM)
+    void prepareDataOnMainThread(ScriptStreamer* streamer, size_t lengthOfBOM)
     {
         ASSERT(isMainThread());
         // The Resource must still be alive; otherwise we should've cancelled
         // the streaming (if we have cancelled, the background thread is not
         // waiting).
-        ASSERT(m_streamer->resource());
+        ASSERT(streamer->resource());
 
         // BOM can only occur at the beginning of the data.
         ASSERT(lengthOfBOM == 0 || m_dataPosition == 0);
 
-        if (m_streamer->resource()->cachedMetadata(V8ScriptRunner::tagForCodeCache(m_streamer->resource()))) {
+        if (streamer->resource()->cachedMetadata(V8ScriptRunner::tagForCodeCache(streamer->resource()))) {
             // The resource has a code cache, so it's unnecessary to stream and
             // parse the code. Cancel the streaming and resume the non-streaming
             // code path.
-            m_streamer->suppressStreaming();
+            streamer->suppressStreaming();
             {
                 MutexLocker locker(m_mutex);
                 m_cancelled = true;
             }
             m_dataQueue.finish();
             return;
         }
 
         if (!m_resourceBuffer) {
             // We don't have a buffer yet. Try to get it from the resource.
-            SharedBuffer* buffer = m_streamer->resource()->resourceBuffer();
+            SharedBuffer* buffer = streamer->resource()->resourceBuffer();
             m_resourceBuffer = RefPtr<SharedBuffer>(buffer);
         }
 
         // Get as much data from the ResourceBuffer as we can.
         const char* data = 0;
         Vector<const char*> chunks;
         Vector<unsigned> chunkLengths;
         size_t dataLength = 0;
         while (unsigned length = m_resourceBuffer->getSomeData(data, m_dataPosition)) {
             // FIXME: Here we can limit based on the total length, if it turns
@@ skipping 13 matching lines @@
             for (size_t i = 0; i < chunks.size(); ++i) {
                 memcpy(copiedData + offset, chunks[i] + lengthOfBOM, chunkLengths[i] - lengthOfBOM);
                 offset += chunkLengths[i] - lengthOfBOM;
                 // BOM is only in the first chunk
                 lengthOfBOM = 0;
             }
             m_dataQueue.produce(copiedData, dataLength);
         }
     }
 
-    ScriptStreamer* m_streamer;
-
     // For coordinating between the main thread and background thread tasks.
     // Guarded by m_mutex.
     bool m_cancelled;
     Mutex m_mutex;
 
     unsigned m_dataPosition; // Only used by the main thread.
     RefPtr<SharedBuffer> m_resourceBuffer; // Only used by the main thread.
     SourceStreamDataQueue m_dataQueue; // Thread safe.
 };
 
@@ skipping 123 matching lines @@
         }
 
         if (!m_scriptState->contextIsValid()) {
             suppressStreaming();
             blink::Platform::current()->histogramEnumeration(histogramName, 0, 2);
             return;
         }
 
         ASSERT(!m_stream);
         ASSERT(!m_source);
-        m_stream = new SourceStream(this);
+        m_stream = new SourceStream();
         // 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)));
         if (!scriptStreamingTask) {
             // V8 cannot stream the script.
             suppressStreaming();
             m_stream = 0;
             m_source.clear();
             blink::Platform::current()->histogramEnumeration(histogramName, 0, 2);
             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 or in
         // notifyFinished.
         ref();
         ScriptStreamingTask* task = new ScriptStreamingTask(scriptStreamingTask.release(), this);
         ScriptStreamerThread::shared()->postTask(task);
         blink::Platform::current()->histogramEnumeration(histogramName, 1, 2);
     }
     if (m_stream)
-        m_stream->didReceiveData(lengthOfBOM);
+        m_stream->didReceiveData(this, lengthOfBOM);
 }
 
 void ScriptStreamer::notifyFinished(Resource* resource)
 {
     ASSERT(isMainThread());
     ASSERT(m_resource == resource);
     // A special case: empty and small scripts. We didn't receive enough data to
     // start the streaming before this notification. In that case, there won't
     // be a "parsing complete" notification either, and we should not wait for
     // it.
@@ skipping 156 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(adoptRef(new ScriptStreamer(resource, scriptType, settings->v8ScriptStreamingMode(), scriptState, compileOption)));
 
     return true;
 }
 
 } // namespace blink