ScriptStreamer: make state variables main-thread-only.

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 341 matching lines @@
     return true;
   }
   // We don't stream other encodings; especially we don't stream two
   // byte scripts to avoid the handling of endianness. Most scripts
   // are Latin1 or UTF-8 anyway, so this should be enough for most
   // real world purposes.
   return false;
 }
 
 bool ScriptStreamer::isFinished() const {
-  MutexLocker locker(m_mutex);
+  DCHECK(isMainThread());
   return m_loadingFinished && (m_parsingFinished || m_streamingSuppressed);
 }
 
 void ScriptStreamer::streamingCompleteOnBackgroundThread() {
   DCHECK(!isMainThread());
-  {
-    MutexLocker locker(m_mutex);
-    m_parsingFinished = true;
-  }
 
   // notifyFinished might already be called, or it might be called in the
   // future (if the parsing finishes earlier because of a parse error).
   m_loadingTaskRunner->postTask(
       BLINK_FROM_HERE, crossThreadBind(&ScriptStreamer::streamingComplete,
                                        wrapCrossThreadPersistent(this)));
 
   // The task might delete ScriptStreamer, so it's not safe to do anything
   // after posting it. Note that there's no way to guarantee that this
   // function has returned before the task is ran - however, we should not
-  // access the "this" object after posting the task. (Especially, we should
-  // not be holding the mutex at this point.)
+  // access the "this" object after posting the task.
 }
 
 void ScriptStreamer::cancel() {
   DCHECK(isMainThread());
   // The upper layer doesn't need the script any more, but streaming might
   // still be ongoing. Tell SourceStream to try to cancel it whenever it gets
   // the control the next time. It can also be that V8 has already completed
   // its operations and streamingComplete will be called soon.
   m_detached = true;
   m_resource = 0;
   if (m_stream)
     m_stream->cancel();
 }
 
 void ScriptStreamer::suppressStreaming() {
-  MutexLocker locker(m_mutex);
+  DCHECK(isMainThread());
   DCHECK(!m_loadingFinished);
   // It can be that the parsing task has already finished (e.g., if there was
   // a parse error).
   m_streamingSuppressed = true;
 }
 
 void ScriptStreamer::notifyAppendData(ScriptResource* resource) {
   DCHECK(isMainThread());
   CHECK_EQ(m_resource, resource);
-  {
-    MutexLocker locker(m_mutex);
-    if (m_streamingSuppressed)
-      return;
-  }
+  if (m_streamingSuppressed)
+    return;
   if (!m_haveEnoughDataForStreaming) {
     // Even if the first data chunk is small, the script can still be big
     // enough - wait until the next data chunk comes before deciding whether
     // to start the streaming.
     DCHECK(resource->resourceBuffer());
     if (resource->resourceBuffer()->size() < s_smallScriptThreshold)
       return;
     m_haveEnoughDataForStreaming = true;
 
     {
@@ skipping 122 matching lines @@
 
 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.
   DCHECK(isMainThread());
+  m_parsingFinished = true;
 
   // 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)
     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();
 }
 
 void ScriptStreamer::notifyFinishedToClient() {
   DCHECK(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
-  // 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.
+  // completed.
   if (!isFinished())
     return;
 
   m_pendingScript->streamingFinished();
 }
 
 bool ScriptStreamer::startStreamingInternal(
     PendingScript* script,
     Type scriptType,
     Settings* settings,
@@ skipping 32 matching lines @@
   // needed. This makes PendingScript notify the ScriptStreamer when it is
   // destroyed.
   script->setStreamer(ScriptStreamer::create(script, scriptType, scriptState,
                                              compileOption,
                                              std::move(loadingTaskRunner)));
 
   return true;
 }
 
 }  // namespace blink