Rename threadSafeBind() to crossThreadBind()

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/CrossThreadFunctional.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/PtrUtil.h"
 #include "wtf/text/TextEncodingRegistry.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
@@ skipping 197 matching lines @@
             MutexLocker locker(m_mutex);
             m_queueLeadPosition = m_bookmarkPosition;
             // See comments at m_lengthOfBOM declaration below for why
             // we need this here.
             m_queueTailPosition = m_bookmarkPosition + m_lengthOfBOM;
             m_dataQueue.clear();
         }
 
         // Inform main thread to re-queue the data.
         m_loadingTaskRunner->postTask(
-            BLINK_FROM_HERE, threadSafeBind(&SourceStream::fetchDataFromResourceBuffer, crossThreadUnretained(this), 0));
+            BLINK_FROM_HERE, crossThreadBind(&SourceStream::fetchDataFromResourceBuffer, crossThreadUnretained(this), 0));
     }
 
     void didFinishLoading()
     {
         ASSERT(isMainThread());
 
         // ResetToBookmark may reset the data queue's 'finished' status,
         // so we may need to re-finish after a ResetToBookmark happened.
         // We do this by remembering m_finished, and always checking for it
         // at the end ot fetchDataFromResourceBuffer.
@@ skipping 188 matching lines @@
 void ScriptStreamer::streamingCompleteOnBackgroundThread()
 {
     ASSERT(!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, threadSafeBind(&ScriptStreamer::streamingComplete, wrapCrossThreadPersistent(this)));
+    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.)
 }
 
 void ScriptStreamer::cancel()
 {
@@ skipping 87 matching lines @@
         if (!scriptStreamingTask) {
             // V8 cannot stream the script.
             suppressStreaming();
             m_stream = 0;
             m_source.reset();
             recordNotStreamingReasonHistogram(m_scriptType, V8CannotStream);
             recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
-        ScriptStreamerThread::shared()->postTask(threadSafeBind(&ScriptStreamerThread::runScriptStreamingTask, passed(std::move(scriptStreamingTask)), wrapCrossThreadPersistent(this)));
+        ScriptStreamerThread::shared()->postTask(crossThreadBind(&ScriptStreamerThread::runScriptStreamingTask, passed(std::move(scriptStreamingTask)), wrapCrossThreadPersistent(this)));
         recordStartedStreamingHistogram(m_scriptType, 1);
     }
     if (m_stream)
         m_stream->didReceiveData(this, lengthOfBOM);
 }
 
 void ScriptStreamer::notifyFinished(Resource* resource)
 {
     ASSERT(isMainThread());
     ASSERT(m_resource == resource);
@@ skipping 111 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