[WTF] Remove unnecessary indirection of WTF::Thread entry point
authorutatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 19 Jul 2017 10:44:57 +0000 (10:44 +0000)
committerutatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 19 Jul 2017 10:44:57 +0000 (10:44 +0000)
https://bugs.webkit.org/show_bug.cgi?id=174291

Reviewed by Mark Lam.

Now wtfThreadEntryPoint is almost the same. Only the difference is function signature due to platform APIs.
We remove ThreadFunctionInvocation indirection in ThreadingPthread.cpp and ThreadingWin.cpp.

Also, ThreadFunctionInvocation keeps a RefPtr to the Thread object. This was previously needed to keep the
Thread object alive until the thread itself could install the ThreadHolder into its thread local storage.
The ThreadHolder has a Ref that keeps the Thread object alive for the lifetime of the thread. Since
Thread::create() now waits for the thread to be initialized before returning and Thread::create() hold a Ref
to the Thread object, we are guaranteed that the Thread object will be alive long enough for it to be installed
in the thread's ThreadHolder, and we no longer need ThreadFunctionInvocation.

And we also simplify ThreadHolder::initialize a bit. Now Thread::create waits for the completion of Thread
initialization. So, after establishing thread handle, we can call ThreadHolder::initialize before completing
Thread initialization.

Also we drop errno.h ifdefs in ThreadingWin.cpp. This is introduced to support WinCE. But now WinCE port is removed.

* WTF.xcodeproj/project.pbxproj:
* wtf/ThreadFunctionInvocation.h: Removed.
* wtf/ThreadHolder.h:
* wtf/ThreadHolderWin.cpp:
(WTF::ThreadHolder::initialize):
* wtf/Threading.cpp:
(WTF::Thread::entryPoint):
(WTF::Thread::create):
(WTF::threadEntryPoint): Deleted.
* wtf/Threading.h:
* wtf/ThreadingPthreads.cpp:
(WTF::Thread::initializeCurrentThreadEvenIfNonWTFCreated):
(WTF::wtfThreadEntryPoint):
(WTF::Thread::establishHandle):
(WTF::Thread::initializeCurrentThreadInternal):
(WTF::Thread::current):
(WTF::Thread::establishPlatformSpecificHandle):
(WTF::Thread::createInternal): Deleted.
(WTF::Thread::establish): Deleted.
* wtf/ThreadingWin.cpp:
(WTF::Thread::initializeCurrentThreadEvenIfNonWTFCreated):
(WTF::Thread::initializeCurrentThreadInternal):
(WTF::wtfThreadEntryPoint):
(WTF::Thread::establishHandle):
(WTF::Thread::current):
(WTF::Thread::establishPlatformSpecificHandle):
(WTF::Thread::createInternal): Deleted.
(WTF::Thread::establish): Deleted.
* wtf/win/MainThreadWin.cpp:
(WTF::initializeMainThreadPlatform):

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@219654 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WTF/ChangeLog
Source/WTF/WTF.xcodeproj/project.pbxproj
Source/WTF/wtf/ThreadFunctionInvocation.h [deleted file]
Source/WTF/wtf/ThreadHolder.h
Source/WTF/wtf/ThreadHolderWin.cpp
Source/WTF/wtf/Threading.cpp
Source/WTF/wtf/Threading.h
Source/WTF/wtf/ThreadingPthreads.cpp
Source/WTF/wtf/ThreadingWin.cpp
Source/WTF/wtf/win/MainThreadWin.cpp

index b0bca92..65ff3d0 100644 (file)
@@ -1,5 +1,59 @@
 2017-07-19  Yusuke Suzuki  <utatane.tea@gmail.com>
 
+        [WTF] Remove unnecessary indirection of WTF::Thread entry point
+        https://bugs.webkit.org/show_bug.cgi?id=174291
+
+        Reviewed by Mark Lam.
+
+        Now wtfThreadEntryPoint is almost the same. Only the difference is function signature due to platform APIs.
+        We remove ThreadFunctionInvocation indirection in ThreadingPthread.cpp and ThreadingWin.cpp.
+
+        Also, ThreadFunctionInvocation keeps a RefPtr to the Thread object. This was previously needed to keep the
+        Thread object alive until the thread itself could install the ThreadHolder into its thread local storage.
+        The ThreadHolder has a Ref that keeps the Thread object alive for the lifetime of the thread. Since
+        Thread::create() now waits for the thread to be initialized before returning and Thread::create() hold a Ref
+        to the Thread object, we are guaranteed that the Thread object will be alive long enough for it to be installed
+        in the thread's ThreadHolder, and we no longer need ThreadFunctionInvocation.
+
+        And we also simplify ThreadHolder::initialize a bit. Now Thread::create waits for the completion of Thread
+        initialization. So, after establishing thread handle, we can call ThreadHolder::initialize before completing
+        Thread initialization.
+
+        Also we drop errno.h ifdefs in ThreadingWin.cpp. This is introduced to support WinCE. But now WinCE port is removed.
+
+        * WTF.xcodeproj/project.pbxproj:
+        * wtf/ThreadFunctionInvocation.h: Removed.
+        * wtf/ThreadHolder.h:
+        * wtf/ThreadHolderWin.cpp:
+        (WTF::ThreadHolder::initialize):
+        * wtf/Threading.cpp:
+        (WTF::Thread::entryPoint):
+        (WTF::Thread::create):
+        (WTF::threadEntryPoint): Deleted.
+        * wtf/Threading.h:
+        * wtf/ThreadingPthreads.cpp:
+        (WTF::Thread::initializeCurrentThreadEvenIfNonWTFCreated):
+        (WTF::wtfThreadEntryPoint):
+        (WTF::Thread::establishHandle):
+        (WTF::Thread::initializeCurrentThreadInternal):
+        (WTF::Thread::current):
+        (WTF::Thread::establishPlatformSpecificHandle):
+        (WTF::Thread::createInternal): Deleted.
+        (WTF::Thread::establish): Deleted.
+        * wtf/ThreadingWin.cpp:
+        (WTF::Thread::initializeCurrentThreadEvenIfNonWTFCreated):
+        (WTF::Thread::initializeCurrentThreadInternal):
+        (WTF::wtfThreadEntryPoint):
+        (WTF::Thread::establishHandle):
+        (WTF::Thread::current):
+        (WTF::Thread::establishPlatformSpecificHandle):
+        (WTF::Thread::createInternal): Deleted.
+        (WTF::Thread::establish): Deleted.
+        * wtf/win/MainThreadWin.cpp:
+        (WTF::initializeMainThreadPlatform):
+
+2017-07-19  Yusuke Suzuki  <utatane.tea@gmail.com>
+
         [WTF] Implement WTF::ThreadGroup
         https://bugs.webkit.org/show_bug.cgi?id=174081
 
index 7886f16..98cd23d 100644 (file)
                A8A4732C151A825B004123FF /* TextPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TextPosition.h; sourceTree = "<group>"; };
                A8A4732D151A825B004123FF /* WTFString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WTFString.cpp; sourceTree = "<group>"; };
                A8A4732E151A825B004123FF /* WTFString.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WTFString.h; sourceTree = "<group>"; };
-               A8A4732F151A825B004123FF /* ThreadFunctionInvocation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadFunctionInvocation.h; sourceTree = "<group>"; };
                A8A47330151A825B004123FF /* ThreadHolderPthreads.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ThreadHolderPthreads.cpp; sourceTree = "<group>"; };
                A8A47332151A825B004123FF /* Threading.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Threading.cpp; sourceTree = "<group>"; };
                A8A47333151A825B004123FF /* Threading.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Threading.h; sourceTree = "<group>"; };
                                5597F82C1D94B9970066BC21 /* SynchronizedFixedQueue.h */,
                                E3E158251EADA53C004A079D /* SystemFree.h */,
                                0FB317C31C488001007E395A /* SystemTracing.h */,
-                               A8A4732F151A825B004123FF /* ThreadFunctionInvocation.h */,
                                E311FB151F0A568B003C08DE /* ThreadGroup.cpp */,
                                E311FB161F0A568B003C08DE /* ThreadGroup.h */,
                                E3200AB51E9A536D003B59D2 /* ThreadHolder.cpp */,
diff --git a/Source/WTF/wtf/ThreadFunctionInvocation.h b/Source/WTF/wtf/ThreadFunctionInvocation.h
deleted file mode 100644 (file)
index cb275f7..0000000
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer. 
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution. 
- * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
- *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission. 
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef ThreadFunctionInvocation_h
-#define ThreadFunctionInvocation_h
-
-#include "Threading.h"
-
-namespace WTF {
-
-typedef void (*ThreadFunction)(void* argument);
-
-struct ThreadFunctionInvocation {
-    WTF_MAKE_FAST_ALLOCATED;
-public:
-    ThreadFunctionInvocation(ThreadFunction function, RefPtr<Thread>&& thread, void* data)
-        : function(function)
-        , thread(WTFMove(thread))
-        , data(data)
-    {
-    }
-
-    ThreadFunction function;
-    RefPtr<Thread> thread;
-    void* data;
-};
-
-} // namespace WTF
-
-#endif // ThreadFunctionInvocation_h
index dcf8794..b2f8de6 100644 (file)
@@ -50,11 +50,7 @@ public:
     static void initializeOnce();
 
     // Creates and puts an instance of ThreadHolder into thread-specific storage.
-#if OS(WINDOWS)
-    static void initialize(Thread&, ThreadIdentifier);
-#else
     static void initialize(Thread&);
-#endif
 
     // Returns 0 if thread-specific storage was not initialized.
     static ThreadHolder* current();
index cedda65..f06b62f 100644 (file)
@@ -80,7 +80,7 @@ RefPtr<Thread> ThreadHolder::get(ThreadIdentifier id)
     return nullptr;
 }
 
-void ThreadHolder::initialize(Thread& thread, ThreadIdentifier id)
+void ThreadHolder::initialize(Thread& thread)
 {
     if (!current()) {
         // Ideally we'd have this as a release assert everywhere, but that would hurt performance.
@@ -90,11 +90,9 @@ void ThreadHolder::initialize(Thread& thread, ThreadIdentifier id)
         // FIXME: Remove this workaround code once <rdar://problem/31793213> is fixed.
         auto* holder = new ThreadHolder(thread);
         threadSpecificSet(m_key, holder);
-
-        // Since Thread is not established yet, we use the given id instead of thread->id().
         {
             std::lock_guard<std::mutex> locker(threadMapMutex());
-            threadMap().add(id, holder);
+            threadMap().add(thread.id(), holder);
         }
     }
 }
index ce1dd7e..2c20258 100644 (file)
 namespace WTF {
 
 enum class Stage {
-    Start, Initialized
+    Start, EstablishedHandle, Initialized
 };
 
-struct NewThreadContext {
+struct Thread::NewThreadContext {
     const char* name;
     Function<void()> entryPoint;
     Stage stage;
     Mutex mutex;
     ThreadCondition condition;
+    Thread& thread;
 };
 
 const char* Thread::normalizeThreadName(const char* threadName)
@@ -84,36 +85,39 @@ const char* Thread::normalizeThreadName(const char* threadName)
 #endif
 }
 
-static void threadEntryPoint(void* contextData)
+void Thread::entryPoint(NewThreadContext* context)
 {
-    NewThreadContext* context = static_cast<NewThreadContext*>(contextData);
-    Function<void()> entryPoint;
+    Function<void()> function;
     {
         // Block until our creating thread has completed any extra setup work, including establishing ThreadIdentifier.
         MutexLocker locker(context->mutex);
+        ASSERT(context->stage == Stage::EstablishedHandle);
+
+        // Initialize thread holder with established ID.
+        ThreadHolder::initialize(context->thread);
 
-        Thread::initializeCurrentThreadInternal(context->name);
-        entryPoint = WTFMove(context->entryPoint);
+        Thread::initializeCurrentThreadInternal(context->thread, context->name);
+        function = WTFMove(context->entryPoint);
 
         // Ack completion of initialization to the creating thread.
         context->stage = Stage::Initialized;
         context->condition.signal();
     }
-
-    entryPoint();
+    function();
 }
 
 RefPtr<Thread> Thread::create(const char* name, Function<void()>&& entryPoint)
 {
-    NewThreadContext context { name, WTFMove(entryPoint), Stage::Start, { }, { } };
-
+    Ref<Thread> thread = adoptRef(*new Thread());
+    NewThreadContext context { name, WTFMove(entryPoint), Stage::Start, { }, { }, thread.get() };
     MutexLocker locker(context.mutex);
-    RefPtr<Thread> result = Thread::createInternal(threadEntryPoint, &context, name);
+    if (!thread->establishHandle(&context))
+        return nullptr;
+    context.stage = Stage::EstablishedHandle;
     // After establishing Thread, release the mutex and wait for completion of initialization.
     while (context.stage != Stage::Initialized)
         context.condition.wait(context.mutex);
-
-    return result;
+    return WTFMove(thread);
 }
 
 Thread* Thread::currentMayBeNull()
index 883d78d..5b48f0a 100644 (file)
@@ -112,8 +112,8 @@ public:
 
     // Called in the thread during initialization.
     // Helpful for platforms where the thread name must be set from within the thread.
-    static void initializeCurrentThreadInternal(const char* threadName);
-    static void initializeCurrentThreadEvenIfNonWTFCreated();
+    static void initializeCurrentThreadInternal(Thread&, const char* threadName);
+    static void initializeCurrentThreadEvenIfNonWTFCreated(Thread&);
 
     WTF_EXPORT_PRIVATE void dump(PrintStream& out) const;
 
@@ -140,16 +140,18 @@ public:
     mach_port_t machThread() { return m_platformThread; }
 #endif
 
+    struct NewThreadContext;
+    static void entryPoint(NewThreadContext* data);
 protected:
     Thread();
 
-    // Internal platform-specific Thread::create implementation.
-    static RefPtr<Thread> createInternal(ThreadFunction, void*, const char* threadName);
+    // Internal platform-specific Thread establishment implementation.
+    bool establishHandle(NewThreadContext* data);
 
 #if USE(PTHREADS)
-    void establish(pthread_t);
+    void establishPlatformSpecificHandle(pthread_t);
 #else
-    void establish(HANDLE, ThreadIdentifier);
+    void establishPlatformSpecificHandle(HANDLE, ThreadIdentifier);
 #endif
     void initialize();
 
index 99aea08..55db3d6 100644 (file)
@@ -39,7 +39,6 @@
 #include <wtf/DataLog.h>
 #include <wtf/RawPointer.h>
 #include <wtf/StdLibExtras.h>
-#include <wtf/ThreadFunctionInvocation.h>
 #include <wtf/ThreadGroup.h>
 #include <wtf/ThreadHolder.h>
 #include <wtf/ThreadingPrimitives.h>
@@ -189,9 +188,9 @@ void Thread::initializePlatformThreading()
 #endif
 }
 
-void Thread::initializeCurrentThreadEvenIfNonWTFCreated()
+void Thread::initializeCurrentThreadEvenIfNonWTFCreated(Thread& thread)
 {
-    Thread::current().initialize();
+    thread.initialize();
 #if !OS(DARWIN)
     sigset_t mask;
     sigemptyset(&mask);
@@ -200,44 +199,31 @@ void Thread::initializeCurrentThreadEvenIfNonWTFCreated()
 #endif
 }
 
-static void* wtfThreadEntryPoint(void* param)
+static void* wtfThreadEntryPoint(void* data)
 {
-    // Balanced by .leakPtr() in Thread::createInternal.
-    auto invocation = std::unique_ptr<ThreadFunctionInvocation>(static_cast<ThreadFunctionInvocation*>(param));
-
-    ThreadHolder::initialize(*invocation->thread);
-    invocation->thread = nullptr;
-
-    invocation->function(invocation->data);
+    Thread::entryPoint(reinterpret_cast<Thread::NewThreadContext*>(data));
     return nullptr;
 }
 
-RefPtr<Thread> Thread::createInternal(ThreadFunction entryPoint, void* data, const char*)
+bool Thread::establishHandle(NewThreadContext* data)
 {
-    RefPtr<Thread> thread = adoptRef(new Thread());
-    auto invocation = std::make_unique<ThreadFunctionInvocation>(entryPoint, thread.get(), data);
     pthread_t threadHandle;
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 #if HAVE(QOS_CLASSES)
     pthread_attr_set_qos_class_np(&attr, adjustedQOSClass(QOS_CLASS_USER_INITIATED), 0);
 #endif
-    int error = pthread_create(&threadHandle, &attr, wtfThreadEntryPoint, invocation.get());
+    int error = pthread_create(&threadHandle, &attr, wtfThreadEntryPoint, data);
     pthread_attr_destroy(&attr);
     if (error) {
-        LOG_ERROR("Failed to create pthread at entry point %p with data %p", wtfThreadEntryPoint, invocation.get());
-        return nullptr;
+        LOG_ERROR("Failed to create pthread at entry point %p with data %p", wtfThreadEntryPoint, data);
+        return false;
     }
-
-    // Balanced by std::unique_ptr constructor in wtfThreadEntryPoint.
-    ThreadFunctionInvocation* leakedInvocation = invocation.release();
-    UNUSED_PARAM(leakedInvocation);
-
-    thread->establish(threadHandle);
-    return thread;
+    establishPlatformSpecificHandle(threadHandle);
+    return true;
 }
 
-void Thread::initializeCurrentThreadInternal(const char* threadName)
+void Thread::initializeCurrentThreadInternal(Thread& thread, const char* threadName)
 {
 #if HAVE(PTHREAD_SETNAME_NP)
     pthread_setname_np(normalizeThreadName(threadName));
@@ -246,7 +232,7 @@ void Thread::initializeCurrentThreadInternal(const char* threadName)
 #else
     UNUSED_PARAM(threadName);
 #endif
-    initializeCurrentThreadEvenIfNonWTFCreated();
+    initializeCurrentThreadEvenIfNonWTFCreated(thread);
 }
 
 void Thread::changePriority(int delta)
@@ -308,9 +294,9 @@ Thread& Thread::current()
 
     // Not a WTF-created thread, ThreadIdentifier is not established yet.
     Ref<Thread> thread = adoptRef(*new Thread());
-    thread->establish(pthread_self());
+    thread->establishPlatformSpecificHandle(pthread_self());
     ThreadHolder::initialize(thread.get());
-    initializeCurrentThreadEvenIfNonWTFCreated();
+    initializeCurrentThreadEvenIfNonWTFCreated(thread.get());
     return thread.get();
 }
 
@@ -443,7 +429,7 @@ size_t Thread::getRegisters(PlatformRegisters& registers)
 #endif
 }
 
-void Thread::establish(pthread_t handle)
+void Thread::establishPlatformSpecificHandle(pthread_t handle)
 {
     std::lock_guard<std::mutex> locker(m_mutex);
     m_handle = handle;
index 9ac18bd..f2304e6 100644 (file)
@@ -88,6 +88,7 @@
 
 #if OS(WINDOWS)
 
+#include <errno.h>
 #include <process.h>
 #include <windows.h>
 #include <wtf/CurrentTime.h>
 #include <wtf/MainThread.h>
 #include <wtf/MathExtras.h>
 #include <wtf/NeverDestroyed.h>
-#include <wtf/ThreadFunctionInvocation.h>
 #include <wtf/ThreadHolder.h>
 #include <wtf/ThreadingPrimitives.h>
 
-#if HAVE(ERRNO_H)
-#include <errno.h>
-#endif
-
 namespace WTF {
 
 static StaticLock globalSuspendLock;
@@ -119,9 +115,9 @@ Thread::~Thread()
         CloseHandle(m_handle);
 }
 
-void Thread::initializeCurrentThreadEvenIfNonWTFCreated()
+void Thread::initializeCurrentThreadEvenIfNonWTFCreated(Thread& thread)
 {
-    Thread::current().initialize();
+    thread.initialize();
 }
 
 // MS_VC_EXCEPTION, THREADNAME_INFO, and setThreadNameInternal all come from <http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx>.
@@ -136,7 +132,7 @@ typedef struct tagTHREADNAME_INFO {
 } THREADNAME_INFO;
 #pragma pack(pop)
 
-void Thread::initializeCurrentThreadInternal(const char* szThreadName)
+void Thread::initializeCurrentThreadInternal(Thread& thread, const char* szThreadName)
 {
 #if COMPILER(MINGW)
     // FIXME: Implement thread name setting with MingW.
@@ -153,49 +149,29 @@ void Thread::initializeCurrentThreadInternal(const char* szThreadName)
     } __except (EXCEPTION_CONTINUE_EXECUTION) {
     }
 #endif
-    initializeCurrentThreadEvenIfNonWTFCreated();
+    initializeCurrentThreadEvenIfNonWTFCreated(thread);
 }
 
 void Thread::initializePlatformThreading()
 {
 }
 
-static unsigned __stdcall wtfThreadEntryPoint(void* param)
+static unsigned __stdcall wtfThreadEntryPoint(void* data)
 {
-    // Balanced by .leakPtr() in Thread::createInternal.
-    auto invocation = std::unique_ptr<ThreadFunctionInvocation>(static_cast<ThreadFunctionInvocation*>(param));
-
-    ThreadHolder::initialize(*invocation->thread, Thread::currentID());
-    invocation->thread = nullptr;
-
-    invocation->function(invocation->data);
+    Thread::entryPoint(reinterpret_cast<Thread::NewThreadContext*>(data));
     return 0;
 }
 
-RefPtr<Thread> Thread::createInternal(ThreadFunction entryPoint, void* data, const char* threadName)
+bool Thread::establishHandle(NewThreadContext* data)
 {
-    Ref<Thread> thread = adoptRef(*new Thread());
     unsigned threadIdentifier = 0;
-    ThreadIdentifier threadID = 0;
-    auto invocation = std::make_unique<ThreadFunctionInvocation>(entryPoint, thread.ptr(), data);
-    HANDLE threadHandle = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, wtfThreadEntryPoint, invocation.get(), 0, &threadIdentifier));
+    HANDLE threadHandle = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, wtfThreadEntryPoint, data, 0, &threadIdentifier));
     if (!threadHandle) {
-#if !HAVE(ERRNO_H)
-        LOG_ERROR("Failed to create thread at entry point %p with data %p.", entryPoint, data);
-#else
-        LOG_ERROR("Failed to create thread at entry point %p with data %p: %ld", entryPoint, data, errno);
-#endif
-        return 0;
+        LOG_ERROR("Failed to create thread at entry point %p with data %p: %ld", wtfThreadEntryPoint, data, errno);
+        return false;
     }
-
-    // The thread will take ownership of invocation.
-    ThreadFunctionInvocation* leakedInvocation = invocation.release();
-    UNUSED_PARAM(leakedInvocation);
-
-    threadID = static_cast<ThreadIdentifier>(threadIdentifier);
-
-    thread->establish(threadHandle, threadIdentifier);
-    return thread;
+    establishPlatformSpecificHandle(threadHandle, threadIdentifier);
+    return true;
 }
 
 void Thread::changePriority(int delta)
@@ -280,9 +256,9 @@ Thread& Thread::current()
     bool isSuccessful = DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
     RELEASE_ASSERT(isSuccessful);
 
-    thread->establish(handle, currentID());
-    ThreadHolder::initialize(thread.get(), Thread::currentID());
-    initializeCurrentThreadEvenIfNonWTFCreated();
+    thread->establishPlatformSpecificHandle(handle, currentID());
+    ThreadHolder::initialize(thread.get());
+    initializeCurrentThreadEvenIfNonWTFCreated(thread.get());
     return thread.get();
 }
 
@@ -291,7 +267,7 @@ ThreadIdentifier Thread::currentID()
     return static_cast<ThreadIdentifier>(GetCurrentThreadId());
 }
 
-void Thread::establish(HANDLE handle, ThreadIdentifier threadID)
+void Thread::establishPlatformSpecificHandle(HANDLE handle, ThreadIdentifier threadID)
 {
     std::lock_guard<std::mutex> locker(m_mutex);
     m_handle = handle;
index a6473d0..ef549bf 100644 (file)
@@ -64,7 +64,7 @@ void initializeMainThreadPlatform()
         CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, HWND_MESSAGE, 0, 0, 0);
     threadingFiredMessage = RegisterWindowMessageW(L"com.apple.WebKit.MainThreadFired");
 
-    Thread::initializeCurrentThreadInternal("Main Thread");
+    Thread::initializeCurrentThreadInternal(Thread::current(), "Main Thread");
 }
 
 void scheduleDispatchFunctionsOnMainThread()