Remove unused parameters from WTF threading API
[WebKit-https.git] / Source / JavaScriptCore / wtf / Threading.cpp
1 /*
2  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "Threading.h"
28 #include <wtf/OwnPtr.h>
29 #include <wtf/PassOwnPtr.h>
30
31 #include <string.h>
32
33 namespace WTF {
34
35 struct NewThreadContext {
36     WTF_MAKE_FAST_ALLOCATED;
37 public:
38     NewThreadContext(ThreadFunction entryPoint, void* data, const char* name)
39         : entryPoint(entryPoint)
40         , data(data)
41         , name(name)
42     {
43     }
44
45     ThreadFunction entryPoint;
46     void* data;
47     const char* name;
48
49     Mutex creationMutex;
50 };
51
52 static void threadEntryPoint(void* contextData)
53 {
54     NewThreadContext* context = reinterpret_cast<NewThreadContext*>(contextData);
55
56     // Block until our creating thread has completed any extra setup work, including
57     // establishing ThreadIdentifier.
58     {
59         MutexLocker locker(context->creationMutex);
60     }
61
62     initializeCurrentThreadInternal(context->name);
63
64     // Grab the info that we need out of the context, then deallocate it.
65     ThreadFunction entryPoint = context->entryPoint;
66     void* data = context->data;
67     delete context;
68
69     entryPoint(data);
70 }
71
72 ThreadIdentifier createThread(ThreadFunction entryPoint, void* data, const char* name)
73 {
74     // Visual Studio has a 31-character limit on thread names. Longer names will
75     // be truncated silently, but we'd like callers to know about the limit.
76 #if !LOG_DISABLED
77     if (strlen(name) > 31)
78         LOG_ERROR("Thread name \"%s\" is longer than 31 characters and will be truncated by Visual Studio", name);
79 #endif
80
81     NewThreadContext* context = new NewThreadContext(entryPoint, data, name);
82
83     // Prevent the thread body from executing until we've established the thread identifier.
84     MutexLocker locker(context->creationMutex);
85
86     return createThreadInternal(threadEntryPoint, context, name);
87 }
88
89 #if PLATFORM(MAC) || PLATFORM(WIN)
90
91 // For ABI compatibility with Safari on Mac / Windows: Safari uses the private
92 // createThread() and waitForThreadCompletion() functions directly and we need
93 // to keep the old ABI compatibility until it's been rebuilt.
94
95 typedef void* (*ThreadFunctionWithReturnValue)(void* argument);
96
97 WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunctionWithReturnValue entryPoint, void* data, const char* name);
98
99 struct ThreadFunctionWithReturnValueInvocation {
100     ThreadFunctionWithReturnValueInvocation(ThreadFunctionWithReturnValue function, void* data)
101         : function(function)
102         , data(data)
103     {
104     }
105
106     ThreadFunctionWithReturnValue function;
107     void* data;
108 };
109
110 static void compatEntryPoint(void* param)
111 {
112     // Balanced by .leakPtr() in createThread.
113     OwnPtr<ThreadFunctionWithReturnValueInvocation> invocation = adoptPtr(static_cast<ThreadFunctionWithReturnValueInvocation*>(param));
114     invocation->function(invocation->data);
115 }
116
117 ThreadIdentifier createThread(ThreadFunctionWithReturnValue entryPoint, void* data, const char* name)
118 {
119     OwnPtr<ThreadFunctionWithReturnValueInvocation> invocation = adoptPtr(new ThreadFunctionWithReturnValueInvocation(entryPoint, data));
120
121     // Balanced by adoptPtr() in compatEntryPoint.
122     return createThread(compatEntryPoint, invocation.leakPtr(), name);
123 }
124
125 WTF_EXPORT_PRIVATE int waitForThreadCompletion(ThreadIdentifier, void**);
126
127 int waitForThreadCompletion(ThreadIdentifier threadID, void**)
128 {
129     return waitForThreadCompletion(threadID);
130 }
131
132 // This function is deprecated but needs to be kept around for backward
133 // compatibility. Use the 3-argument version of createThread above.
134
135 WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunctionWithReturnValue entryPoint, void* data);
136
137 ThreadIdentifier createThread(ThreadFunctionWithReturnValue entryPoint, void* data)
138 {
139     OwnPtr<ThreadFunctionWithReturnValueInvocation> invocation = adoptPtr(new ThreadFunctionWithReturnValueInvocation(entryPoint, data));
140
141     // Balanced by adoptPtr() in compatEntryPoint.
142     return createThread(compatEntryPoint, invocation.leakPtr(), 0);
143 }
144 #endif
145
146 } // namespace WTF