Rename threadSafeBind() to crossThreadBind()

third_party/WebKit/Source/modules/fetch/DataConsumerTee.cpp

 // Copyright 2015 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 "modules/fetch/DataConsumerTee.h"
 
 #include "core/dom/ActiveDOMObject.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchBlobDataConsumerHandle.h"
-#include "platform/ThreadSafeFunctional.h"
+#include "platform/CrossThreadFunctional.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Deque.h"
 #include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/ThreadingPrimitives.h"
@@ skipping 156 matching lines @@
     void notify()
     {
         {
             MutexLocker locker(m_mutex);
             if (!m_client) {
                 // No client is registered.
                 return;
             }
             ASSERT(m_readerThread);
             if (!m_readerThread->isCurrentThread()) {
-                m_readerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&DestinationContext::notify, wrapPassRefPtr(this)));
+                m_readerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, crossThreadBind(&DestinationContext::notify, wrapPassRefPtr(this)));
                 return;
             }
         }
         // The reading thread is the current thread.
         if (m_client)
             m_client->didGetReadable();
     }
 
     Mutex& mutex() { return m_mutex; }
 
@@ skipping 63 matching lines @@
 };
 
 class DestinationReader final : public WebDataConsumerHandle::Reader {
 public:
     DestinationReader(PassRefPtr<DestinationContext::Proxy> contextProxy, WebDataConsumerHandle::Client* client)
         : m_contextProxy(contextProxy)
     {
         MutexLocker locker(context()->mutex());
         context()->attachReader(client);
         if (client) {
-            // We need to use threadSafeBind here to retain the context. Note
+            // We need to use crossThreadBind here to retain the context. Note
             // |context()| return value is of type DestinationContext*, not
             // PassRefPtr<DestinationContext>.
-            Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&DestinationContext::notify, wrapPassRefPtr(context())));
+            Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, crossThreadBind(&DestinationContext::notify, wrapPassRefPtr(context())));
         }
     }
     ~DestinationReader() override
     {
         MutexLocker locker(context()->mutex());
         context()->detachReader();
     }
 
     Result beginRead(const void** buffer, Flags, size_t* available) override
     {
@@ skipping 140 matching lines @@
     }
 
     std::unique_ptr<WebDataConsumerHandle> webDest1, webDest2;
     DataConsumerTee::create(executionContext, static_cast<std::unique_ptr<WebDataConsumerHandle>>(std::move(src)), &webDest1, &webDest2);
     *dest1 = createFetchDataConsumerHandleFromWebHandle(std::move(webDest1));
     *dest2 = createFetchDataConsumerHandleFromWebHandle(std::move(webDest2));
     return;
 }
 
 } // namespace blink