Changeset 74975 in webkit

Timestamp:

Jan 4, 2011 10:56:18 AM (13 years ago)

Author:

dbates@webkit.org

Message:

2011-01-04 Daniel Bates <​dbates@rim.com>

Reviewed by Adam Roben.

Extract ThreadFunctionInvocation into separate file and share between Apple Windows and Android
​https://bugs.webkit.org/show_bug.cgi?id=51855

Both the Apple Windows and Android ports implement a similar adapter structure,
called ThreadFunctionInvocation and ThreadData respectively, as part of
their thread creation process. Instead, we should share such an adapter
structure and remove duplicate code.

• JavaScriptCore.gypi: Added header wtf/ThreadFunctionInvocation.h.
• wtf/ThreadFunctionInvocation.h: Added. (WTF::ThreadFunctionInvocation::ThreadFunctionInvocation):
• wtf/ThreadingPthreads.cpp: Removed Android-specific structure ThreadData; Instead, use ThreadFunctionInvocation. (WTF::runThreadWithRegistration): (WTF::createThreadInternal):
• wtf/ThreadingWin.cpp: Moved structure ThreadFunctionInvocation to its own file so that it can be shared with the Android implementation of createThreadInternal(). (WTF::wtfThreadEntryPoint): Use OwnPtr to hold passed instance of ThreadFunctionInvocation.

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• JavaScriptCore.gypi (modified) (1 diff)
• wtf/ThreadFunctionInvocation.h (added)
• wtf/ThreadingPthreads.cpp (modified) (3 diffs)
• wtf/ThreadingWin.cpp (modified) (3 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2011-01-04  Daniel Bates  <dbates@rim.com>
+
+        Reviewed by Adam Roben.
+
+        Extract ThreadFunctionInvocation into separate file and share between Apple Windows and Android
+        https://bugs.webkit.org/show_bug.cgi?id=51855
+
+        Both the Apple Windows and Android ports implement a similar adapter structure,
+        called ThreadFunctionInvocation and ThreadData respectively, as part of
+        their thread creation process. Instead, we should share such an adapter
+        structure and remove duplicate code.
+
+        * JavaScriptCore.gypi: Added header wtf/ThreadFunctionInvocation.h.
+        * wtf/ThreadFunctionInvocation.h: Added.
+        (WTF::ThreadFunctionInvocation::ThreadFunctionInvocation):
+        * wtf/ThreadingPthreads.cpp: Removed Android-specific structure ThreadData; Instead, use ThreadFunctionInvocation.
+        (WTF::runThreadWithRegistration):
+        (WTF::createThreadInternal): 
+        * wtf/ThreadingWin.cpp: Moved structure ThreadFunctionInvocation to its own file so that
+        it can be shared with the Android implementation of createThreadInternal().
+        (WTF::wtfThreadEntryPoint): Use OwnPtr to hold passed instance of ThreadFunctionInvocation.
+
 2011-01-03  Daniel Bates  <dbates@rim.com>
 

trunk/Source/JavaScriptCore/JavaScriptCore.gypi

@@ -441 +441 @@
             'wtf/TCSystemAlloc.cpp',
             'wtf/TCSystemAlloc.h',
+            'wtf/ThreadFunctionInvocation.h',
             'wtf/ThreadIdentifierDataPthreads.cpp',
             'wtf/ThreadIdentifierDataPthreads.h',

trunk/Source/JavaScriptCore/wtf/ThreadingPthreads.cpp

@@ -51 +51 @@
 #if OS(ANDROID)
 #include "JNIUtility.h"
+#include "ThreadFunctionInvocation.h"
+#include <wtf/OwnPtr.h>
 #endif
 
@@ -137 +139 @@
 
 #if OS(ANDROID)
-// On the Android platform, threads must be registered with the VM before they run.
-struct ThreadData {
-    ThreadFunction entryPoint;
-    void* arg;
-};
-
 static void* runThreadWithRegistration(void* arg)
 {
-    ThreadData* data = static_cast<ThreadData*>(arg);
+    OwnPtr<ThreadFunctionInvocation> invocation = adoptPtr(static_cast<ThreadFunctionInvocation*>(arg));
     JavaVM* vm = JSC::Bindings::getJavaVM();
     JNIEnv* env;
     void* ret = 0;
     if (vm->AttachCurrentThread(&env, 0) == JNI_OK) {
-        ret = data->entryPoint(data->arg);
+        ret = invocation->function(invocation.data);
         vm->DetachCurrentThread();
     }
-    delete data;
     return ret;
 }
@@ -160 +155 @@
 {
     pthread_t threadHandle;
-    ThreadData* threadData = new ThreadData();
-    threadData->entryPoint = entryPoint;
-    threadData->arg = data;
-
-    if (pthread_create(&threadHandle, 0, runThreadWithRegistration, static_cast<void*>(threadData))) {
+
+    // On the Android platform, threads must be registered with the VM before they run.
+    OwnPtr<ThreadFunctionInvocation> invocation = adoptPtr(new ThreadFunctionInvocation(entryPoint, data));
+
+    if (pthread_create(&threadHandle, 0, runThreadWithRegistration, invocation.get())) {
         LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);
-        delete threadData;
         return 0;
     }
+
+    // The thread will take ownership of invocation.
+    invocation.leakPtr();
+
     return establishIdentifierForPthreadHandle(threadHandle);
 }

trunk/Source/JavaScriptCore/wtf/ThreadingWin.cpp

@@ -88 +88 @@
 
 #include "MainThread.h"
+#include "ThreadFunctionInvocation.h"
 #if !USE(PTHREADS) && OS(WINDOWS)
 #include "ThreadSpecific.h"
@@ -103 +104 @@
 #include <wtf/HashMap.h>
 #include <wtf/MathExtras.h>
+#include <wtf/OwnPtr.h>
 #include <wtf/RandomNumberSeed.h>
 
@@ -188 +190 @@
 }
 
-struct ThreadFunctionInvocation {
-    ThreadFunctionInvocation(ThreadFunction function, void* data) : function(function), data(data) {}
-
-    ThreadFunction function;
-    void* data;
-};
-
 static unsigned __stdcall wtfThreadEntryPoint(void* param)
 {
-    ThreadFunctionInvocation invocation = *static_cast<ThreadFunctionInvocation*>(param);
-    delete static_cast<ThreadFunctionInvocation*>(param);
-
-    void* result = invocation.function(invocation.data);
+    OwnPtr<ThreadFunctionInvocation> invocation = adoptPtr(static_cast<ThreadFunctionInvocation*>(param));
+    void* result = invocation->function(invocation.data);
 
 #if !USE(PTHREADS) && OS(WINDOWS)