Rename threadSafeBind() to crossThreadBind()

third_party/WebKit/Source/modules/fetch/CompositeDataConsumerHandleTest.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/CompositeDataConsumerHandle.h"
 
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
-#include "platform/ThreadSafeFunctional.h"
+#include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Locker.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
@@ skipping 35 matching lines @@
 class ThreadingRegistrationTest : public DataConsumerHandleTestUtil::ThreadingTestBase {
 public:
     using Self = ThreadingRegistrationTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
     void run()
     {
         ThreadHolder holder(this);
         m_waitableEvent = wrapUnique(new WaitableEvent());
 
-        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::createHandle, wrapPassRefPtr(this)));
-        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, wrapPassRefPtr(this)));
+        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::createHandle, wrapPassRefPtr(this)));
+        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
 private:
     ThreadingRegistrationTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
     void obtainReader()
     {
         m_reader = m_handle->obtainReader(&m_client);
-        postTaskToUpdatingThread(BLINK_FROM_HERE, threadSafeBind(&Self::update, wrapPassRefPtr(this)));
+        postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
     }
     void update()
     {
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater.clear();
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::resetReader, wrapPassRefPtr(this)));
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::signalDone, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
     }
 
     std::unique_ptr<WebDataConsumerHandle> m_handle;
     CrossThreadPersistent<CompositeDataConsumerHandle::Updater> m_updater;
 };
 
 class ThreadingRegistrationDeleteHandleTest : public DataConsumerHandleTestUtil::ThreadingTestBase {
 public:
     using Self = ThreadingRegistrationDeleteHandleTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
     void run()
     {
         ThreadHolder holder(this);
         m_waitableEvent = wrapUnique(new WaitableEvent());
 
-        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::createHandle, wrapPassRefPtr(this)));
-        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, wrapPassRefPtr(this)));
+        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::createHandle, wrapPassRefPtr(this)));
+        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
 private:
     ThreadingRegistrationDeleteHandleTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
 
     void obtainReader()
     {
         m_reader = m_handle->obtainReader(&m_client);
-        postTaskToUpdatingThread(BLINK_FROM_HERE, threadSafeBind(&Self::update, wrapPassRefPtr(this)));
+        postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
     }
     void update()
     {
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater.clear();
         m_handle = nullptr;
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::resetReader, wrapPassRefPtr(this)));
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::signalDone, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
     }
 
     std::unique_ptr<WebDataConsumerHandle> m_handle;
     CrossThreadPersistent<CompositeDataConsumerHandle::Updater> m_updater;
 };
 
 class ThreadingRegistrationDeleteReaderTest : public DataConsumerHandleTestUtil::ThreadingTestBase {
 public:
     using Self = ThreadingRegistrationDeleteReaderTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
     void run()
     {
         ThreadHolder holder(this);
         m_waitableEvent = wrapUnique(new WaitableEvent());
 
-        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::createHandle, wrapPassRefPtr(this)));
-        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, wrapPassRefPtr(this)));
+        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::createHandle, wrapPassRefPtr(this)));
+        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
 private:
     ThreadingRegistrationDeleteReaderTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
 
     void obtainReader()
     {
         m_reader = m_handle->obtainReader(&m_client);
-        postTaskToUpdatingThread(BLINK_FROM_HERE, threadSafeBind(&Self::update, wrapPassRefPtr(this)));
+        postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
     }
     void update()
     {
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::resetReader, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater.clear();
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::resetReader, wrapPassRefPtr(this)));
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::signalDone, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
     }
 
     std::unique_ptr<WebDataConsumerHandle> m_handle;
     CrossThreadPersistent<CompositeDataConsumerHandle::Updater> m_updater;
 };
 
 class ThreadingUpdatingReaderWhileUpdatingTest : public DataConsumerHandleTestUtil::ThreadingTestBase {
 public:
     using Self = ThreadingUpdatingReaderWhileUpdatingTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
     void run()
     {
         ThreadHolder holder(this);
         m_waitableEvent = wrapUnique(new WaitableEvent());
         m_updateEvent = wrapUnique(new WaitableEvent());
 
-        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::createHandle, wrapPassRefPtr(this)));
-        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, wrapPassRefPtr(this)));
+        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::createHandle, wrapPassRefPtr(this)));
+        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
 private:
     ThreadingUpdatingReaderWhileUpdatingTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
 
     void obtainReader()
     {
         m_reader = m_handle->obtainReader(&m_client);
-        postTaskToUpdatingThread(BLINK_FROM_HERE, threadSafeBind(&Self::update, wrapPassRefPtr(this)));
+        postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
         m_updateEvent->wait();
     }
 
     void update()
     {
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::reobtainReader, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::reobtainReader, wrapPassRefPtr(this)));
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater.clear();
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::resetReader, wrapPassRefPtr(this)));
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::signalDone, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
         m_updateEvent->signal();
     }
 
     void reobtainReader()
     {
         m_reader = nullptr;
         m_reader = m_handle->obtainReader(&m_client);
     }
 
     std::unique_ptr<WebDataConsumerHandle> m_handle;
     CrossThreadPersistent<CompositeDataConsumerHandle::Updater> m_updater;
     std::unique_ptr<WaitableEvent> m_updateEvent;
 };
 
 class ThreadingRegistrationUpdateTwiceAtOneTimeTest : public DataConsumerHandleTestUtil::ThreadingTestBase {
 public:
     using Self = ThreadingRegistrationUpdateTwiceAtOneTimeTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
     void run()
     {
         ThreadHolder holder(this);
         m_waitableEvent = wrapUnique(new WaitableEvent());
         m_updateEvent = wrapUnique(new WaitableEvent());
 
-        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::createHandle, wrapPassRefPtr(this)));
-        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, wrapPassRefPtr(this)));
+        postTaskToUpdatingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::createHandle, wrapPassRefPtr(this)));
+        postTaskToReadingThreadAndWait(BLINK_FROM_HERE, crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
 private:
     ThreadingRegistrationUpdateTwiceAtOneTimeTest() = default;
 
     void createHandle()
     {
         m_handle = CompositeDataConsumerHandle::create(DataConsumerHandle::create("handle1", m_context), &m_updater);
         m_waitableEvent->signal();
     }
 
     void obtainReader()
     {
         m_reader = m_handle->obtainReader(&m_client);
-        postTaskToUpdatingThread(BLINK_FROM_HERE, threadSafeBind(&Self::update, wrapPassRefPtr(this)));
+        postTaskToUpdatingThread(BLINK_FROM_HERE, crossThreadBind(&Self::update, wrapPassRefPtr(this)));
         // Stalls this thread while updating handles.
         m_updateEvent->wait();
     }
     void update()
     {
         m_updater->update(DataConsumerHandle::create("handle2", m_context));
         m_updater->update(DataConsumerHandle::create("handle3", m_context));
         m_updateEvent->signal();
         m_updater.clear();
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::resetReader, wrapPassRefPtr(this)));
-        postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::signalDone, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::resetReader, wrapPassRefPtr(this)));
+        postTaskToReadingThread(BLINK_FROM_HERE, crossThreadBind(&Self::signalDone, wrapPassRefPtr(this)));
     }
 
     std::unique_ptr<WebDataConsumerHandle> m_handle;
     CrossThreadPersistent<CompositeDataConsumerHandle::Updater> m_updater;
     std::unique_ptr<WaitableEvent> m_updateEvent;
 };
 
 TEST(CompositeDataConsumerHandleTest, Read)
 {
     char buffer[20];
@@ skipping 214 matching lines @@
 {
     RefPtr<DataConsumerHandleTestUtil::ThreadingHandleNoNotificationTest> test = DataConsumerHandleTestUtil::ThreadingHandleNoNotificationTest::create();
     CompositeDataConsumerHandle::Updater* updater = nullptr;
     // Test this function doesn't crash.
     test->run(CompositeDataConsumerHandle::create(createDoneDataConsumerHandle(), &updater));
 }
 
 } // namespace
 
 } // namespace blink