Changeset 43663 in webkit


Ignore:
Timestamp:
May 13, 2009 3:09:21 PM (15 years ago)
Author:
dimich@chromium.org
Message:

JavaScriptCore:

2009-05-13 Dmitry Titov <​dimich@chromium.org>

Rubber-stamped by Mark Rowe.

​https://bugs.webkit.org/show_bug.cgi?id=25746
Revert ​http://trac.webkit.org/changeset/43507 which caused crash in PPC nightlies with Safari 4.

  • JavaScriptCore.exp:
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
  • bytecode/SamplingTool.cpp: (JSC::SamplingThread::start): (JSC::SamplingThread::stop):
  • bytecode/SamplingTool.h:
  • wtf/CrossThreadRefCounted.h: (WTF::CrossThreadRefCounted::CrossThreadRefCounted): (WTF::::ref): (WTF::::deref):
  • wtf/Threading.h:
  • wtf/ThreadingNone.cpp:
  • wtf/ThreadingPthreads.cpp: (WTF::threadMapMutex): (WTF::initializeThreading): (WTF::threadMap): (WTF::identifierByPthreadHandle): (WTF::establishIdentifierForPthreadHandle): (WTF::pthreadHandleForIdentifier): (WTF::clearPthreadHandleForIdentifier): (WTF::createThreadInternal): (WTF::waitForThreadCompletion): (WTF::detachThread): (WTF::currentThread):
  • wtf/ThreadingWin.cpp: (WTF::threadMapMutex): (WTF::initializeThreading): (WTF::threadMap): (WTF::storeThreadHandleByIdentifier): (WTF::threadHandleForIdentifier): (WTF::clearThreadHandleForIdentifier): (WTF::createThreadInternal): (WTF::waitForThreadCompletion): (WTF::detachThread): (WTF::currentThread):
  • wtf/gtk/ThreadingGtk.cpp: (WTF::threadMapMutex): (WTF::initializeThreading): (WTF::threadMap): (WTF::identifierByGthreadHandle): (WTF::establishIdentifierForThread): (WTF::threadForIdentifier): (WTF::clearThreadForIdentifier): (WTF::createThreadInternal): (WTF::waitForThreadCompletion): (WTF::currentThread):
  • wtf/qt/ThreadingQt.cpp: (WTF::threadMapMutex): (WTF::threadMap): (WTF::identifierByQthreadHandle): (WTF::establishIdentifierForThread): (WTF::clearThreadForIdentifier): (WTF::threadForIdentifier): (WTF::initializeThreading): (WTF::createThreadInternal): (WTF::waitForThreadCompletion): (WTF::currentThread):

WebCore:

2009-05-13 Dmitry Titov <​dimich@chromium.org>

Rubber-stamped by Mark Rowe.

​https://bugs.webkit.org/show_bug.cgi?id=25746
Revert ​http://trac.webkit.org/changeset/43507 which caused crash in PPC nightlies with Safari 4.

  • dom/XMLTokenizerLibxml2.cpp: (WebCore::matchFunc): (WebCore::openFunc): (WebCore::createStringParser): (WebCore::createMemoryParser):
  • loader/icon/IconDatabase.cpp: (WebCore::IconDatabase::open):
  • platform/sql/SQLiteDatabase.cpp: (WebCore::SQLiteDatabase::SQLiteDatabase): (WebCore::SQLiteDatabase::close):
  • storage/DatabaseThread.cpp: (WebCore::DatabaseThread::DatabaseThread): (WebCore::DatabaseThread::start): (WebCore::DatabaseThread::databaseThread):
  • storage/LocalStorageThread.cpp: (WebCore::LocalStorageThread::LocalStorageThread): (WebCore::LocalStorageThread::start): (WebCore::LocalStorageThread::localStorageThread): (WebCore::LocalStorageThread::scheduleImport): (WebCore::LocalStorageThread::scheduleSync): (WebCore::LocalStorageThread::terminate):
  • workers/WorkerThread.cpp: (WebCore::WorkerThread::WorkerThread): (WebCore::WorkerThread::start):

WebKit/win:

2009-05-13 Dmitry Titov <​dimich@chromium.org>

Rubber-stamped by Mark Rowe.

​https://bugs.webkit.org/show_bug.cgi?id=25746
Revert ​http://trac.webkit.org/changeset/43507 which caused crash in PPC nightlies with Safari 4.

  • WebKit.vcproj/WebKit.def:
  • WebKit.vcproj/WebKit_debug.def:
Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r43661 r43663  
     12009-05-13  Dmitry Titov  <dimich@chromium.org>
     2
     3        Rubber-stamped by Mark Rowe.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=25746
     6        Revert http://trac.webkit.org/changeset/43507 which caused crash in PPC nightlies with Safari 4.
     7
     8        * JavaScriptCore.exp:
     9        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
     10        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
     11        * bytecode/SamplingTool.cpp:
     12        (JSC::SamplingThread::start):
     13        (JSC::SamplingThread::stop):
     14        * bytecode/SamplingTool.h:
     15        * wtf/CrossThreadRefCounted.h:
     16        (WTF::CrossThreadRefCounted::CrossThreadRefCounted):
     17        (WTF::::ref):
     18        (WTF::::deref):
     19        * wtf/Threading.h:
     20        * wtf/ThreadingNone.cpp:
     21        * wtf/ThreadingPthreads.cpp:
     22        (WTF::threadMapMutex):
     23        (WTF::initializeThreading):
     24        (WTF::threadMap):
     25        (WTF::identifierByPthreadHandle):
     26        (WTF::establishIdentifierForPthreadHandle):
     27        (WTF::pthreadHandleForIdentifier):
     28        (WTF::clearPthreadHandleForIdentifier):
     29        (WTF::createThreadInternal):
     30        (WTF::waitForThreadCompletion):
     31        (WTF::detachThread):
     32        (WTF::currentThread):
     33        * wtf/ThreadingWin.cpp:
     34        (WTF::threadMapMutex):
     35        (WTF::initializeThreading):
     36        (WTF::threadMap):
     37        (WTF::storeThreadHandleByIdentifier):
     38        (WTF::threadHandleForIdentifier):
     39        (WTF::clearThreadHandleForIdentifier):
     40        (WTF::createThreadInternal):
     41        (WTF::waitForThreadCompletion):
     42        (WTF::detachThread):
     43        (WTF::currentThread):
     44        * wtf/gtk/ThreadingGtk.cpp:
     45        (WTF::threadMapMutex):
     46        (WTF::initializeThreading):
     47        (WTF::threadMap):
     48        (WTF::identifierByGthreadHandle):
     49        (WTF::establishIdentifierForThread):
     50        (WTF::threadForIdentifier):
     51        (WTF::clearThreadForIdentifier):
     52        (WTF::createThreadInternal):
     53        (WTF::waitForThreadCompletion):
     54        (WTF::currentThread):
     55        * wtf/qt/ThreadingQt.cpp:
     56        (WTF::threadMapMutex):
     57        (WTF::threadMap):
     58        (WTF::identifierByQthreadHandle):
     59        (WTF::establishIdentifierForThread):
     60        (WTF::clearThreadForIdentifier):
     61        (WTF::threadForIdentifier):
     62        (WTF::initializeThreading):
     63        (WTF::createThreadInternal):
     64        (WTF::waitForThreadCompletion):
     65        (WTF::currentThread):
     66
    1672009-05-13  Darin Adler  <darin@apple.com>
    268

  • trunk/JavaScriptCore/JavaScriptCore.exp

    r43661 r43663  
    281281__ZN3WTF12createThreadEPFPvS0_ES0_
    282282__ZN3WTF12createThreadEPFPvS0_ES0_PKc
    283 __ZN3WTF12detachThreadENS_16ThreadIdentifierE
     283__ZN3WTF12detachThreadEj
    284284__ZN3WTF12isMainThreadEv
    285285__ZN3WTF12randomNumberEv
    … …  
    302302__ZN3WTF21RefCountedLeakCounterC1EPKc
    303303__ZN3WTF21RefCountedLeakCounterD1Ev
    304 __ZN3WTF23waitForThreadCompletionENS_16ThreadIdentifierEPPv
     304__ZN3WTF23waitForThreadCompletionEjPPv
    305305__ZN3WTF27releaseFastMallocFreeMemoryEv
    306306__ZN3WTF28setMainThreadCallbacksPausedEb
    … …  
    364364__ZNK3JSC9HashTable11deleteTableEv
    365365__ZNK3WTF8Collator7collateEPKtmS2_m
    366 __ZNK3WTF16ThreadIdentifiereqERKS0_
    367 __ZNK3WTF16ThreadIdentifierneERKS0_
    368366__ZTVN3JSC12StringObjectE
    369367__ZTVN3JSC14JSGlobalObjectE

  • trunk/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def

    r43661 r43663  
    3333    ??4UString@JSC@@QAEAAV01@PBD@Z
    3434    ??8JSC@@YA_NABVUString@0@0@Z
    35     ??8ThreadIdentifier@WTF@@QBE_NABV01@@Z
    3635    ?UTF8String@UString@JSC@@QBE?AVCString@2@_N@Z
    3736    ?add@Identifier@JSC@@SA?AV?$PassRefPtr@URep@UString@JSC@@@WTF@@PAVExecState@2@PBD@Z
    … …  
    7675    ?createStructure@JSByteArray@JSC@@SA?AV?$PassRefPtr@VStructure@JSC@@@WTF@@VJSValue@2@@Z
    7776    ?createTable@HashTable@JSC@@ABEXPAVJSGlobalData@2@@Z
    78     ?createThread@WTF@@YA?AVThreadIdentifier@1@P6APAXPAX@Z0PBD@Z
    79     ?currentThread@WTF@@YA?AVThreadIdentifier@1@XZ
     77    ?createThread@WTF@@YAIP6APAXPAX@Z0@Z
     78    ?createThread@WTF@@YAIP6APAXPAX@Z0PBD@Z
     79    ?currentThread@WTF@@YAIXZ
    8080    ?currentTime@WTF@@YANXZ
    8181    ?decrement@RefCountedLeakCounter@WTF@@QAEXXZ
    … …  
    9797    ?destroy@Rep@UString@JSC@@QAEXXZ
    9898    ?detach@Debugger@JSC@@QAEXPAVJSGlobalObject@2@@Z
    99     ?detachThread@WTF@@YAXVThreadIdentifier@1@@Z
     99    ?detachThread@WTF@@YAXI@Z
    100100    ?equal@Identifier@JSC@@SA_NPBURep@UString@2@PBD@Z
    101101    ?equal@JSC@@YA_NPBURep@UString@1@0@Z
    … …  
    255255    ?unwrappedObject@JSObject@JSC@@UAEPAV12@XZ
    256256    ?wait@ThreadCondition@WTF@@QAEXAAVMutex@2@@Z
    257     ?waitForThreadCompletion@WTF@@YAHVThreadIdentifier@1@PAPAX@Z
     257    ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z
    258258    WTFLog
    259259    WTFLogVerbose
    … …  
    266266    ?setDumpsGeneratedCode@BytecodeGenerator@JSC@@SAX_N@Z
    267267    ?putDirectFunction@JSObject@JSC@@QAEXPAVExecState@2@PAVInternalFunction@2@I@Z
    268     ?createThreadDeprecated@WTF@@YAIP6APAXPAX@Z0PBD@Z
    269     ?currentThreadDeprecated@WTF@@YAIXZ
    270     ?detachThreadDeprecated@WTF@@YAXI@Z
    271     ?waitForThreadCompletionDeprecated@WTF@@YAHIPAPAX@Z

  • trunk/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def

    r43661 r43663  
    3333    ??4UString@JSC@@QAEAAV01@PBD@Z
    3434    ??8JSC@@YA_NABVUString@0@0@Z
    35     ??8ThreadIdentifier@WTF@@QBE_NABV01@@Z
    3635    ?UTF8String@UString@JSC@@QBE?AVCString@2@_N@Z
    3736    ?add@Identifier@JSC@@SA?AV?$PassRefPtr@URep@UString@JSC@@@WTF@@PAVExecState@2@PBD@Z
    … …  
    7675    ?createStructure@JSByteArray@JSC@@SA?AV?$PassRefPtr@VStructure@JSC@@@WTF@@VJSValue@2@@Z
    7776    ?createTable@HashTable@JSC@@ABEXPAVJSGlobalData@2@@Z
    78     ?createThread@WTF@@YA?AVThreadIdentifier@1@P6APAXPAX@Z0PBD@Z
    79     ?currentThread@WTF@@YA?AVThreadIdentifier@1@XZ
     77    ?createThread@WTF@@YAIP6APAXPAX@Z0@Z
     78    ?createThread@WTF@@YAIP6APAXPAX@Z0PBD@Z
     79    ?currentThread@WTF@@YAIXZ
    8080    ?currentTime@WTF@@YANXZ
    8181    ?decrement@RefCountedLeakCounter@WTF@@QAEXXZ
    … …  
    9797    ?destroy@Rep@UString@JSC@@QAEXXZ
    9898    ?detach@Debugger@JSC@@QAEXPAVJSGlobalObject@2@@Z
    99     ?detachThread@WTF@@YAXVThreadIdentifier@1@@Z
     99    ?detachThread@WTF@@YAXI@Z
    100100    ?equal@Identifier@JSC@@SA_NPBURep@UString@2@PBD@Z
    101101    ?equal@JSC@@YA_NPBURep@UString@1@0@Z
    … …  
    255255    ?unwrappedObject@JSObject@JSC@@UAEPAV12@XZ
    256256    ?wait@ThreadCondition@WTF@@QAEXAAVMutex@2@@Z
    257     ?waitForThreadCompletion@WTF@@YAHVThreadIdentifier@1@PAPAX@Z
     257    ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z
    258258    WTFLog
    259259    WTFLogVerbose
    … …  
    266266    ?setDumpsGeneratedCode@BytecodeGenerator@JSC@@SAX_N@Z
    267267    ?putDirectFunction@JSObject@JSC@@QAEXPAVExecState@2@PAVInternalFunction@2@I@Z
    268     ?createThreadDeprecated@WTF@@YAIP6APAXPAX@Z0PBD@Z
    269     ?currentThreadDeprecated@WTF@@YAIXZ
    270     ?detachThreadDeprecated@WTF@@YAXI@Z
    271     ?waitForThreadCompletionDeprecated@WTF@@YAHIPAPAX@Z

  • trunk/JavaScriptCore/bytecode/SamplingTool.cpp

    r43619 r43663  
    122122bool SamplingThread::s_running = false;
    123123unsigned SamplingThread::s_hertz = 10000;
    124 
    125 ThreadIdentifier& SamplingThread::samplingThread() {
    126     DEFINE_STATIC_LOCAL(ThreadIdentifier, staticSamplingThread, ());
    127     return staticSamplingThread;
    128 }
     124ThreadIdentifier SamplingThread::s_samplingThread;
    129125
    130126void* SamplingThread::threadStartFunc(void*)
    … …  
    151147    s_hertz = hertz;
    152148
    153     samplingThread() = createThread(threadStartFunc, 0, "JavaScriptCore::Sampler");
     149    s_samplingThread = createThread(threadStartFunc, 0, "JavaScriptCore::Sampler");
    154150}
    155151
    … …  
    158154    ASSERT(s_running);
    159155    s_running = false;
    160     waitForThreadCompletion(samplingThread(), 0);
     156    waitForThreadCompletion(s_samplingThread, 0);
    161157}
    162158

  • trunk/JavaScriptCore/bytecode/SamplingTool.h

    r43619 r43663  
    127127        static bool s_running;
    128128        static unsigned s_hertz;
    129 
    130         static ThreadIdentifier& samplingThread();
     129        static ThreadIdentifier s_samplingThread;
    131130
    132131        static void start(unsigned hertz=10000);

  • trunk/JavaScriptCore/wtf/CrossThreadRefCounted.h

    r43507 r43663  
    7575            : m_threadSafeRefCounter(threadedCounter)
    7676            , m_data(data)
     77#ifndef NDEBUG
     78            , m_threadId(0)
     79#endif
    7780        {
    7881        }
    … …  
    97100    void CrossThreadRefCounted<T>::ref()
    98101    {
    99         ASSERT(!m_threadId.isValid() || m_threadId == currentThread());
     102        ASSERT(!m_threadId || m_threadId == currentThread());
    100103        m_refCounter.ref();
    101104#ifndef NDEBUG
    … …  
    105108        // is a heuristic but it seems to always work and has helped
    106109        // find some bugs.
    107         if (!m_threadId.isValid() && m_refCounter.refCount() == 2)
     110        if (!m_threadId && m_refCounter.refCount() == 2)
    108111            m_threadId = currentThread();
    109112#endif
    … …  
    113116    void CrossThreadRefCounted<T>::deref()
    114117    {
    115         ASSERT(!m_threadId.isValid() || m_threadId == currentThread());
     118        ASSERT(!m_threadId || m_threadId == currentThread());
    116119        if (m_refCounter.derefBase()) {
    117120            threadSafeDeref();
    … …  
    122125            // is safe to be passed to another thread at this point.
    123126            if (m_threadId && m_refCounter.refCount() == 1)
    124                 m_threadId.invalidate();
     127                m_threadId = 0;
    125128#endif
    126129        }

  • trunk/JavaScriptCore/wtf/Threading.h

    r43507 r43663  
    8686typedef struct _GMutex GMutex;
    8787typedef struct _GCond GCond;
    88 typedef struct _GThread GThread;
    8988#endif
    9089
    … …  
    9392QT_BEGIN_NAMESPACE
    9493class QMutex;
    95 class QThread;
    9694class QWaitCondition;
    9795QT_END_NAMESPACE
    … …  
    108106namespace WTF {
    109107
     108typedef uint32_t ThreadIdentifier;
     109typedef void* (*ThreadFunction)(void* argument);
     110
     111// Returns 0 if thread creation failed.
     112// The thread name must be a literal since on some platforms it's passed in to the thread.
     113ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
     114
     115// Internal platform-specific createThread implementation.
     116ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
     117
     118// Called in the thread during initialization.
     119// Helpful for platforms where the thread name must be set from within the thread.
     120void setThreadNameInternal(const char* threadName);
     121
     122ThreadIdentifier currentThread();
     123bool isMainThread();
     124int waitForThreadCompletion(ThreadIdentifier, void**);
     125void detachThread(ThreadIdentifier);
     126
    110127#if USE(PTHREADS)
    111128typedef pthread_mutex_t PlatformMutex;
    112129typedef pthread_cond_t PlatformCondition;
    113 typedef pthread_t PlatformThreadIdentifier;
    114130#elif PLATFORM(GTK)
    115131typedef GOwnPtr<GMutex> PlatformMutex;
    116132typedef GOwnPtr<GCond> PlatformCondition;
    117 typedef GThread* PlatformThreadIdentifier;
    118133#elif PLATFORM(QT)
    119134typedef QT_PREPEND_NAMESPACE(QMutex)* PlatformMutex;
    120135typedef QT_PREPEND_NAMESPACE(QWaitCondition)* PlatformCondition;
    121 typedef QT_PREPEND_NAMESPACE(QThread)* PlatformThreadIdentifier;
    122136#elif PLATFORM(WIN_OS)
    123137struct PlatformMutex {
    … …  
    136150    void signal(bool unblockAll);
    137151};
    138 typedef unsigned PlatformThreadIdentifier;
    139152#else
    140153typedef void* PlatformMutex;
    … …  
    142155#endif
    143156   
    144 // Platform-independent wrapper for thread id. Assignable and copyable.
    145 // A valid ThreadIdentifier is usually returned from createThread(...) or currentThread() functions.
    146 // ThreadIdentifier remains valid for as long as its thread is alive and is not automatically invalidated
    147 // when thread terminates. Since platform-dependent thread ids can be recycled, stale ThreadIdentifier
    148 // may reference a completely unrelated thread after its original thread terminates.
    149 class ThreadIdentifier {
    150 public:
    151     ThreadIdentifier()
    152         : m_platformId(0)
    153     {
    154         ASSERT(!isValid());
    155     }
    156 
    157     explicit ThreadIdentifier(PlatformThreadIdentifier platformId)
    158         : m_platformId(platformId)
    159     {
    160         ASSERT(isValid());
    161     }
    162 
    163     bool isValid() const  { return m_platformId; }
    164     void invalidate() { m_platformId = 0; }
    165 
    166     bool operator==(const ThreadIdentifier&) const;
    167     bool operator!=(const ThreadIdentifier&) const;
    168 
    169     PlatformThreadIdentifier platformId() const { return m_platformId;  }
    170 
    171 private:
    172     PlatformThreadIdentifier m_platformId;
    173 };
    174 
    175 typedef void* (*ThreadFunction)(void* argument);
    176 
    177 // Returns invalid identifier if thread creation failed.
    178 // The thread name must be a literal since on some platforms it's passed in to the thread.
    179 ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
    180 
    181 // Internal platform-specific createThread implementation.
    182 ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
    183 
    184 // Called in the thread during initialization.
    185 // Helpful for platforms where the thread name must be set from within the thread.
    186 void setThreadNameInternal(const char* threadName);
    187 
    188 ThreadIdentifier currentThread();
    189 bool isMainThread();
    190 int waitForThreadCompletion(ThreadIdentifier, void**);
    191 void detachThread(ThreadIdentifier);
    192 
    193157class Mutex : Noncopyable {
    194158public:

  • trunk/JavaScriptCore/wtf/ThreadingNone.cpp

    r43507 r43663  
    3333namespace WTF {
    3434
    35 bool ThreadIdentifier::operator==(const ThreadIdentifier&) const { return true; }
    36 bool ThreadIdentifier::operator!=(const ThreadIdentifier&) const { return false; }
    37 
    3835void initializeThreading() { }
    3936ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char*) { return ThreadIdentifier(); }

  • trunk/JavaScriptCore/wtf/ThreadingPthreads.cpp

    r43510 r43663  
    4949namespace WTF {
    5050
    51 bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
    52 {
    53     return pthread_equal(m_platformId, another.m_platformId);
    54 }
    55 
    56 bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
    57 {
    58     return !pthread_equal(m_platformId, another.m_platformId);
    59 }
     51typedef HashMap<ThreadIdentifier, pthread_t> ThreadMap;
    6052
    6153static Mutex* atomicallyInitializedStaticMutex;
    … …  
    6557#endif
    6658
     59static Mutex& threadMapMutex()
     60{
     61    DEFINE_STATIC_LOCAL(Mutex, mutex, ());
     62    return mutex;
     63}
     64
    6765void initializeThreading()
    6866{
    6967    if (!atomicallyInitializedStaticMutex) {
    7068        atomicallyInitializedStaticMutex = new Mutex;
     69        threadMapMutex();
    7170        initializeRandomNumberGenerator();
    7271#if !PLATFORM(DARWIN) || PLATFORM(CHROMIUM)
    … …  
    8685{
    8786    atomicallyInitializedStaticMutex->unlock();
     87}
     88
     89static ThreadMap& threadMap()
     90{
     91    DEFINE_STATIC_LOCAL(ThreadMap, map, ());
     92    return map;
     93}
     94
     95static ThreadIdentifier identifierByPthreadHandle(const pthread_t& pthreadHandle)
     96{
     97    MutexLocker locker(threadMapMutex());
     98
     99    ThreadMap::iterator i = threadMap().begin();
     100    for (; i != threadMap().end(); ++i) {
     101        if (pthread_equal(i->second, pthreadHandle))
     102            return i->first;
     103    }
     104
     105    return 0;
     106}
     107
     108static ThreadIdentifier establishIdentifierForPthreadHandle(pthread_t& pthreadHandle)
     109{
     110    ASSERT(!identifierByPthreadHandle(pthreadHandle));
     111
     112    MutexLocker locker(threadMapMutex());
     113
     114    static ThreadIdentifier identifierCount = 1;
     115
     116    threadMap().add(identifierCount, pthreadHandle);
     117
     118    return identifierCount++;
     119}
     120
     121static pthread_t pthreadHandleForIdentifier(ThreadIdentifier id)
     122{
     123    MutexLocker locker(threadMapMutex());
     124
     125    return threadMap().get(id);
     126}
     127
     128static void clearPthreadHandleForIdentifier(ThreadIdentifier id)
     129{
     130    MutexLocker locker(threadMapMutex());
     131
     132    ASSERT(threadMap().contains(id));
     133
     134    threadMap().remove(id);
    88135}
    89136
    … …  
    118165    if (pthread_create(&threadHandle, 0, runThreadWithRegistration, static_cast<void*>(threadData))) {
    119166        LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);
    120         return ThreadIdentifier();
    121     }
    122     return ThreadIdentifier(threadHandle);
     167        return 0;
     168    }
     169    return establishIdentifierForPthreadHandle(threadHandle);
    123170}
    124171#else
    … …  
    128175    if (pthread_create(&threadHandle, 0, entryPoint, data)) {
    129176        LOG_ERROR("Failed to create pthread at entry point %p with data %p", entryPoint, data);
    130         return ThreadIdentifier();
    131     }
    132 
    133     return ThreadIdentifier(threadHandle);
     177        return 0;
     178    }
     179
     180    return establishIdentifierForPthreadHandle(threadHandle);
    134181}
    135182#endif
    … …  
    146193int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
    147194{
    148     ASSERT(threadID.isValid());
    149    
    150     pthread_t pthreadHandle = threadID.platformId();
    151  
     195    ASSERT(threadID);
     196
     197    pthread_t pthreadHandle = pthreadHandleForIdentifier(threadID);
     198
    152199    int joinResult = pthread_join(pthreadHandle, result);
    153200    if (joinResult == EDEADLK)
    154         LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", pthreadHandle);
    155        
     201        LOG_ERROR("ThreadIdentifier %u was found to be deadlocked trying to quit", threadID);
     202
     203    clearPthreadHandleForIdentifier(threadID);
    156204    return joinResult;
    157205}
    … …  
    159207void detachThread(ThreadIdentifier threadID)
    160208{
    161     ASSERT(threadID.isValid());
    162    
    163     pthread_t pthreadHandle = threadID.platformId();
    164    
     209    ASSERT(threadID);
     210
     211    pthread_t pthreadHandle = pthreadHandleForIdentifier(threadID);
     212
    165213    pthread_detach(pthreadHandle);
     214
     215    clearPthreadHandleForIdentifier(threadID);
    166216}
    167217
    168218ThreadIdentifier currentThread()
    169219{
    170     return ThreadIdentifier(pthread_self());
     220    pthread_t currentThread = pthread_self();
     221    if (ThreadIdentifier id = identifierByPthreadHandle(currentThread))
     222        return id;
     223    return establishIdentifierForPthreadHandle(currentThread);
    171224}
    172225
    … …  
    195248    ASSERT_UNUSED(result, !result);
    196249}
    197    
     250
    198251bool Mutex::tryLock()
    199252{
    200253    int result = pthread_mutex_trylock(&m_mutex);
    201    
     254
    202255    if (result == 0)
    203256        return true;
    … …  
    263316}
    264317
    265 #if PLATFORM(DARWIN)
    266 // Derecated function. Safari 4 beta, until recompiled next time, uses ThreadIdentifier as uint32_t.
    267 // pthread_t is a pointer. So they get a pointer casted into uint32_t from CurrentThread()
    268 // and then pass it here. We cast it back to pointer. This is an ugly hack which is very temporary
    269 // and will be removed once next public build of Safari 4 is released.
    270 // Some versions of GCC require a prototype before a function with external linkage, so we have to
    271 // add a declaration here before defining the function.
    272 int waitForThreadCompletion(uint32_t, void**);
    273 int waitForThreadCompletion(uint32_t threadID, void** result)
    274 {
    275     pthread_t pthreadHandle = reinterpret_cast<pthread_t>(threadID);
    276 
    277     int joinResult = pthread_join(pthreadHandle, result);
    278     if (joinResult == EDEADLK)
    279         LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", pthreadHandle);
    280 
    281     return joinResult;
    282 }
    283 #endif
    284 
    285318} // namespace WTF
    286319

  • trunk/JavaScriptCore/wtf/ThreadingWin.cpp

    r43507 r43663  
    9999namespace WTF {
    100100
    101 bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
    102 {
    103     return m_platformId == another.m_platformId;
    104 }
    105 
    106 bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
    107 {
    108     return m_platformId != another.m_platformId;
    109 }
    110 
    111101// MS_VC_EXCEPTION, THREADNAME_INFO, and setThreadNameInternal all come from <http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx>.
    112102static const DWORD MS_VC_EXCEPTION = 0x406D1388;
    … …  
    150140static ThreadIdentifier mainThreadIdentifier;
    151141
     142static Mutex& threadMapMutex()
     143{
     144    static Mutex mutex;
     145    return mutex;
     146}
     147
    152148void initializeThreading()
    153149{
    154150    if (!atomicallyInitializedStaticMutex) {
    155151        atomicallyInitializedStaticMutex = new Mutex;
     152        threadMapMutex();
    156153        initializeRandomNumberGenerator();
    157154        initializeMainThread();
    … …  
    161158}
    162159
     160static HashMap<DWORD, HANDLE>& threadMap()
     161{
     162    static HashMap<DWORD, HANDLE> map;
     163    return map;
     164}
     165
     166static void storeThreadHandleByIdentifier(DWORD threadID, HANDLE threadHandle)
     167{
     168    MutexLocker locker(threadMapMutex());
     169    ASSERT(!threadMap().contains(threadID));
     170    threadMap().add(threadID, threadHandle);
     171}
     172
     173static HANDLE threadHandleForIdentifier(ThreadIdentifier id)
     174{
     175    MutexLocker locker(threadMapMutex());
     176    return threadMap().get(id);
     177}
     178
     179static void clearThreadHandleForIdentifier(ThreadIdentifier id)
     180{
     181    MutexLocker locker(threadMapMutex());
     182    ASSERT(threadMap().contains(id));
     183    threadMap().remove(id);
     184}
     185
    163186struct ThreadFunctionInvocation {
    164187    ThreadFunctionInvocation(ThreadFunction function, void* data) : function(function), data(data) {}
    … …  
    186209{
    187210    unsigned threadIdentifier = 0;
     211    ThreadIdentifier threadID = 0;
    188212    ThreadFunctionInvocation* invocation = new ThreadFunctionInvocation(entryPoint, data);
    189213    HANDLE threadHandle = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, wtfThreadEntryPoint, invocation, 0, &threadIdentifier));
    190214    if (!threadHandle) {
    191215        LOG_ERROR("Failed to create thread at entry point %p with data %p: %ld", entryPoint, data, errno);
    192         return ThreadIdentifier();
    193     }
    194     // Closes handle only, since we don't need it. The new thread runs until it exits.
    195     CloseHandle(threadHandle);
    196 
    197     return ThreadIdentifier(threadIdentifier);
     216        return 0;
     217    }
     218
     219    threadID = static_cast<ThreadIdentifier>(threadIdentifier);
     220    storeThreadHandleByIdentifier(threadIdentifier, threadHandle);
     221
     222    return threadID;
    198223}
    199224
    200225int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
    201226{
    202     ASSERT(threadID.isValid());
     227    ASSERT(threadID);
    203228   
    204     unsigned threadIdentifier = threadID.platformId();
    205     HANDLE threadHandle = OpenThread(SYNCHRONIZE, FALSE, threadIdentifier);
    206     // If thread already exited, return immediately.
     229    HANDLE threadHandle = threadHandleForIdentifier(threadID);
    207230    if (!threadHandle)
    208         return WAIT_OBJECT_0;
     231        LOG_ERROR("ThreadIdentifier %u did not correspond to an active thread when trying to quit", threadID);
    209232 
    210233    DWORD joinResult = WaitForSingleObject(threadHandle, INFINITE);
    211234    if (joinResult == WAIT_FAILED)
    212         LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", threadHandle);
     235        LOG_ERROR("ThreadIdentifier %u was found to be deadlocked trying to quit", threadID);
    213236
    214237    CloseHandle(threadHandle);
     238    clearThreadHandleForIdentifier(threadID);
    215239
    216240    return joinResult;
    217241}
    218242
    219 void detachThread(ThreadIdentifier)
    220 {
     243void detachThread(ThreadIdentifier threadID)
     244{
     245    ASSERT(threadID);
     246
     247    HANDLE threadHandle = threadHandleForIdentifier(threadID);
     248    if (threadHandle)
     249        CloseHandle(threadHandle);
     250    clearThreadHandleForIdentifier(threadID);
    221251}
    222252
    223253ThreadIdentifier currentThread()
    224254{
    225     return ThreadIdentifier(GetCurrentThreadId());
     255    return static_cast<ThreadIdentifier>(GetCurrentThreadId());
    226256}
    227257
    … …  
    441471}
    442472
    443 // Deprecated functions. The current build of Safari 4 beta is linked with them so we need to provide
    444 // the implementation taking PlatformThreadIdentifier instead of ThreadIdentifier. These are not declared
    445 // in .h file so the next time Safari is built it will 'automatically' switch to new functions.
    446 // Then deprecated ones can be removed from this file and from JavaScriptCore.def and WebKit.def files.
    447 // In WebKit.def file, these functions are 'renamed' so their name does not have 'Deprecated' part - this
    448 // is to avoid having 2 functions with only different type of return value.
    449 void detachThreadDeprecated(PlatformThreadIdentifier)
    450 {
    451 }
    452 
    453 int waitForThreadCompletionDeprecated(PlatformThreadIdentifier threadID, void** result)
    454 {
    455     ASSERT(threadID);
    456 
    457     unsigned threadIdentifier = static_cast<unsigned>(threadID);
    458     HANDLE threadHandle = OpenThread(SYNCHRONIZE, FALSE, threadIdentifier);
    459     // If thread already exited, return immediately.
    460     if (!threadHandle)
    461         return WAIT_OBJECT_0;
    462 
    463     DWORD joinResult = WaitForSingleObject(threadHandle, INFINITE);
    464     if (joinResult == WAIT_FAILED)
    465         LOG_ERROR("ThreadIdentifier %p was found to be deadlocked trying to quit", threadHandle);
    466 
    467     CloseHandle(threadHandle);
    468 
    469     return joinResult;
    470 }
    471 
    472 PlatformThreadIdentifier currentThreadDeprecated()
    473 {
    474     return static_cast<PlatformThreadIdentifier>(GetCurrentThreadId());
    475 }
    476 
    477 PlatformThreadIdentifier createThreadDeprecated(ThreadFunction entryPoint, void* data, const char* name)
    478 {
    479     ThreadIdentifier threadID = createThread(entryPoint, data, name);
    480     return static_cast<PlatformThreadIdentifier>(threadID.platformId());
    481 }
    482 
    483473} // namespace WTF

  • trunk/JavaScriptCore/wtf/gtk/ThreadingGtk.cpp

    r43507 r43663  
    4343namespace WTF {
    4444
    45 bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
    46 {
    47     return m_platformId == another.m_platformId;
    48 }
    49 
    50 bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
    51 {
    52     return m_platformId != another.m_platformId;
    53 }
    54 
    5545static Mutex* atomicallyInitializedStaticMutex;
    5646
    5747static ThreadIdentifier mainThreadIdentifier;
     48
     49static Mutex& threadMapMutex()
     50{
     51    static Mutex mutex;
     52    return mutex;
     53}
    5854
    5955void initializeThreading()
    … …  
    6561    if (!atomicallyInitializedStaticMutex) {
    6662        atomicallyInitializedStaticMutex = new Mutex;
     63        threadMapMutex();
    6764        initializeRandomNumberGenerator();
    6865        mainThreadIdentifier = currentThread();
    … …  
    8279}
    8380
     81static HashMap<ThreadIdentifier, GThread*>& threadMap()
     82{
     83    static HashMap<ThreadIdentifier, GThread*> map;
     84    return map;
     85}
     86
     87static ThreadIdentifier identifierByGthreadHandle(GThread*& thread)
     88{
     89    MutexLocker locker(threadMapMutex());
     90
     91    HashMap<ThreadIdentifier, GThread*>::iterator i = threadMap().begin();
     92    for (; i != threadMap().end(); ++i) {
     93        if (i->second == thread)
     94            return i->first;
     95    }
     96
     97    return 0;
     98}
     99
     100static ThreadIdentifier establishIdentifierForThread(GThread*& thread)
     101{
     102    ASSERT(!identifierByGthreadHandle(thread));
     103
     104    MutexLocker locker(threadMapMutex());
     105
     106    static ThreadIdentifier identifierCount = 1;
     107
     108    threadMap().add(identifierCount, thread);
     109
     110    return identifierCount++;
     111}
     112
     113static GThread* threadForIdentifier(ThreadIdentifier id)
     114{
     115    MutexLocker locker(threadMapMutex());
     116
     117    return threadMap().get(id);
     118}
     119
     120static void clearThreadForIdentifier(ThreadIdentifier id)
     121{
     122    MutexLocker locker(threadMapMutex());
     123
     124    ASSERT(threadMap().contains(id));
     125
     126    threadMap().remove(id);
     127}
     128
    84129ThreadIdentifier createThreadInternal(ThreadFunction entryPoint, void* data, const char*)
    85130{
    … …  
    87132    if (!(thread = g_thread_create(entryPoint, data, TRUE, 0))) {
    88133        LOG_ERROR("Failed to create thread at entry point %p with data %p", entryPoint, data);
    89         return ThreadIdentifier();
    90     }
    91 
    92     return ThreadIdentifier(thread);
     134        return 0;
     135    }
     136
     137    ThreadIdentifier threadID = establishIdentifierForThread(thread);
     138    return threadID;
    93139}
    94140
    … …  
    99145int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
    100146{
    101     ASSERT(threadID.isValid());
    102 
    103     GThread* thread = threadID.platformId();
     147    ASSERT(threadID);
     148
     149    GThread* thread = threadForIdentifier(threadID);
    104150
    105151    void* joinResult = g_thread_join(thread);
    … …  
    107153        *result = joinResult;
    108154
     155    clearThreadForIdentifier(threadID);
    109156    return 0;
    110157}
    … …  
    116163ThreadIdentifier currentThread()
    117164{
    118     return ThreadIdentifier(g_thread_self());
     165    GThread* currentThread = g_thread_self();
     166    if (ThreadIdentifier id = identifierByGthreadHandle(currentThread))
     167        return id;
     168    return establishIdentifierForThread(currentThread);
    119169}
    120170

  • trunk/JavaScriptCore/wtf/qt/ThreadingQt.cpp

    r43637 r43663  
    4242namespace WTF {
    4343
    44 bool ThreadIdentifier::operator==(const ThreadIdentifier& another) const
    45 {
    46     return m_platformId == another.m_platformId;
    47 }
    48 
    49 bool ThreadIdentifier::operator!=(const ThreadIdentifier& another) const
    50 {
    51     return m_platformId != another.m_platformId;
    52 }
    53 
    5444class ThreadPrivate : public QThread {
    5545public:
    … …  
    8070static ThreadIdentifier mainThreadIdentifier;
    8171
     72static Mutex& threadMapMutex()
     73{
     74    static Mutex mutex;
     75    return mutex;
     76}
     77
     78static HashMap<ThreadIdentifier, QThread*>& threadMap()
     79{
     80    static HashMap<ThreadIdentifier, QThread*> map;
     81    return map;
     82}
     83
     84static ThreadIdentifier identifierByQthreadHandle(QThread*& thread)
     85{
     86    MutexLocker locker(threadMapMutex());
     87
     88    HashMap<ThreadIdentifier, QThread*>::iterator i = threadMap().begin();
     89    for (; i != threadMap().end(); ++i) {
     90        if (i->second == thread)
     91            return i->first;
     92    }
     93
     94    return 0;
     95}
     96
     97static ThreadIdentifier establishIdentifierForThread(QThread*& thread)
     98{
     99    ASSERT(!identifierByQthreadHandle(thread));
     100
     101    MutexLocker locker(threadMapMutex());
     102
     103    static ThreadIdentifier identifierCount = 1;
     104
     105    threadMap().add(identifierCount, thread);
     106
     107    return identifierCount++;
     108}
     109
     110static void clearThreadForIdentifier(ThreadIdentifier id)
     111{
     112    MutexLocker locker(threadMapMutex());
     113
     114    ASSERT(threadMap().contains(id));
     115
     116    threadMap().remove(id);
     117}
     118
     119static QThread* threadForIdentifier(ThreadIdentifier id)
     120{
     121    MutexLocker locker(threadMapMutex());
     122
     123    return threadMap().get(id);
     124}
     125
    82126void initializeThreading()
    83127{
    84128    if (!atomicallyInitializedStaticMutex) {
    85129        atomicallyInitializedStaticMutex = new Mutex;
     130        threadMapMutex();
    86131        initializeRandomNumberGenerator();
    87         mainThreadIdentifier = ThreadIdentifier(QCoreApplication::instance()->thread());
     132        QThread* mainThread = QCoreApplication::instance()->thread();
     133        mainThreadIdentifier = identifierByQthreadHandle(mainThread);
     134        if (!mainThreadIdentifier)
     135            mainThreadIdentifier = establishIdentifierForThread(mainThread);
    88136        initializeMainThread();
    89137    }
    … …  
    106154    if (!thread) {
    107155        LOG_ERROR("Failed to create thread at entry point %p with data %p", entryPoint, data);
    108         return ThreadIdentifier();
     156        return 0;
    109157    }
    110158    thread->start();
    … …  
    112160    QThread* threadRef = static_cast<QThread*>(thread);
    113161
    114     return ThreadIdentifier(threadRef);
     162    return establishIdentifierForThread(threadRef);
    115163}
    116164
    … …  
    121169int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
    122170{
    123     ASSERT(threadID.isValid());
    124 
    125     QThread* thread = threadID.platformId();
     171    ASSERT(threadID);
     172
     173    QThread* thread = threadForIdentifier(threadID);
    126174
    127175    bool res = thread->wait();
    128176
     177    clearThreadForIdentifier(threadID);
    129178    if (result)
    130179        *result = static_cast<ThreadPrivate*>(thread)->getReturnValue();
    … …  
    139188ThreadIdentifier currentThread()
    140189{
    141     return ThreadIdentifier(QThread::currentThread());
     190    QThread* currentThread = QThread::currentThread();
     191    if (ThreadIdentifier id = identifierByQthreadHandle(currentThread))
     192        return id;
     193    return establishIdentifierForThread(currentThread);
    142194}
    143195

  • trunk/WebCore/ChangeLog

    r43662 r43663  
     12009-05-13  Dmitry Titov  <dimich@chromium.org>
     2
     3        Rubber-stamped by Mark Rowe.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=25746
     6        Revert http://trac.webkit.org/changeset/43507 which caused crash in PPC nightlies with Safari 4.
     7
     8        * dom/XMLTokenizerLibxml2.cpp:
     9        (WebCore::matchFunc):
     10        (WebCore::openFunc):
     11        (WebCore::createStringParser):
     12        (WebCore::createMemoryParser):
     13        * loader/icon/IconDatabase.cpp:
     14        (WebCore::IconDatabase::open):
     15        * platform/sql/SQLiteDatabase.cpp:
     16        (WebCore::SQLiteDatabase::SQLiteDatabase):
     17        (WebCore::SQLiteDatabase::close):
     18        * storage/DatabaseThread.cpp:
     19        (WebCore::DatabaseThread::DatabaseThread):
     20        (WebCore::DatabaseThread::start):
     21        (WebCore::DatabaseThread::databaseThread):
     22        * storage/LocalStorageThread.cpp:
     23        (WebCore::LocalStorageThread::LocalStorageThread):
     24        (WebCore::LocalStorageThread::start):
     25        (WebCore::LocalStorageThread::localStorageThread):
     26        (WebCore::LocalStorageThread::scheduleImport):
     27        (WebCore::LocalStorageThread::scheduleSync):
     28        (WebCore::LocalStorageThread::terminate):
     29        * workers/WorkerThread.cpp:
     30        (WebCore::WorkerThread::WorkerThread):
     31        (WebCore::WorkerThread::start):
     32
    1332009-05-13  David Hyatt  <hyatt@apple.com>
    234

  • trunk/WebCore/dom/XMLTokenizerLibxml2.cpp

    r43507 r43663  
    327327
    328328static int globalDescriptor = 0;
    329 
    330 static ThreadIdentifier& libxmlLoaderThread() {
    331     DEFINE_STATIC_LOCAL(ThreadIdentifier, staticLibxmlLoaderThread, ());
    332     return staticLibxmlLoaderThread;
    333 }
     329static ThreadIdentifier libxmlLoaderThread = 0;
    334330
    335331static int matchFunc(const char*)
    … …  
    337333    // Only match loads initiated due to uses of libxml2 from within XMLTokenizer to avoid
    338334    // interfering with client applications that also use libxml2.  http://bugs.webkit.org/show_bug.cgi?id=17353
    339     return XMLTokenizerScope::currentDocLoader && currentThread() == libxmlLoaderThread();
     335    return XMLTokenizerScope::currentDocLoader && currentThread() == libxmlLoaderThread;
    340336}
    341337
    … …  
    398394{
    399395    ASSERT(XMLTokenizerScope::currentDocLoader);
    400     ASSERT(currentThread() == libxmlLoaderThread());
     396    ASSERT(currentThread() == libxmlLoaderThread);
    401397
    402398    KURL url(KURL(), uri);
    … …  
    467463        xmlRegisterInputCallbacks(matchFunc, openFunc, readFunc, closeFunc);
    468464        xmlRegisterOutputCallbacks(matchFunc, openFunc, writeFunc, closeFunc);
    469         libxmlLoaderThread() = currentThread();
     465        libxmlLoaderThread = currentThread();
    470466        didInit = true;
    471467    }
    … …  
    489485        xmlRegisterInputCallbacks(matchFunc, openFunc, readFunc, closeFunc);
    490486        xmlRegisterOutputCallbacks(matchFunc, openFunc, writeFunc, closeFunc);
    491         libxmlLoaderThread() = currentThread();
     487        libxmlLoaderThread = currentThread();
    492488        didInit = true;
    493489    }

  • trunk/WebCore/loader/icon/IconDatabase.cpp

    r43507 r43663  
    136136    m_syncLock.lock();
    137137    m_syncThread = createThread(IconDatabase::iconDatabaseSyncThreadStart, this, "WebCore: IconDatabase");
    138     m_syncThreadRunning = m_syncThread.isValid();
     138    m_syncThreadRunning = m_syncThread;
    139139    m_syncLock.unlock();
    140 
    141     return m_syncThreadRunning;
     140    if (!m_syncThread)
     141        return false;
     142    return true;
    142143}
    143144

  • trunk/WebCore/platform/sql/SQLiteDatabase.cpp

    r43507 r43663  
    4848    , m_pageSize(-1)
    4949    , m_transactionInProgress(false)
     50    , m_openingThread(0)
    5051{
    5152}
    … …  
    8990    }
    9091
    91     m_openingThread.invalidate();
     92    m_openingThread = 0;
    9293}
    9394

  • trunk/WebCore/storage/DatabaseThread.cpp

    r43507 r43663  
    4040
    4141DatabaseThread::DatabaseThread()
     42    : m_threadID(0)
    4243{
    4344    m_selfRef = this;
    … …  
    5354    MutexLocker lock(m_threadCreationMutex);
    5455
    55     if (m_threadID.isValid())
     56    if (m_threadID)
    5657        return true;
    5758
    5859    m_threadID = createThread(DatabaseThread::databaseThreadStart, this, "WebCore: Database");
    5960
    60     return m_threadID.isValid();
     61    return m_threadID;
    6162}
    6263
    … …  
    9798    }
    9899
    99     LOG(StorageAPI, "About to detach thread and clear the ref to DatabaseThread %p, which currently has %i ref(s)", this, refCount());
     100    LOG(StorageAPI, "About to detach thread %i and clear the ref to DatabaseThread %p, which currently has %i ref(s)", m_threadID, this, refCount());
    100101
    101102    // Detach the thread so its resources are no longer of any concern to anyone else

  • trunk/WebCore/storage/LocalStorageThread.cpp

    r43507 r43663  
    3939
    4040LocalStorageThread::LocalStorageThread()
     41    : m_threadID(0)
    4142{
    4243    m_selfRef = this;
    … …  
    4748    MutexLocker lock(m_threadCreationMutex);
    4849
    49     if (!m_threadID.isValid())
    50         m_threadID = createThread(LocalStorageThread::localStorageThreadStart, this, "WebCore: LocalStorage");
     50    if (m_threadID)
     51        return true;
    5152
    52     return m_threadID.isValid();
     53    m_threadID = createThread(LocalStorageThread::localStorageThreadStart, this, "WebCore: LocalStorage");
     54
     55    return m_threadID;
    5356}
    5457
    … …  
    7578    // Detach the thread so its resources are no longer of any concern to anyone else
    7679    detachThread(m_threadID);
    77     m_threadID.invalidate();
     80    m_threadID = 0;
    7881
    7982    // Clear the self refptr, possibly resulting in deletion
    … …  
    8588void LocalStorageThread::scheduleImport(PassRefPtr<LocalStorage> storage)
    8689{
    87     ASSERT(!m_queue.killed() && m_threadID.isValid());
     90    ASSERT(!m_queue.killed() && m_threadID);
    8891    m_queue.append(LocalStorageTask::createImport(storage));
    8992}
    … …  
    9194void LocalStorageThread::scheduleSync(PassRefPtr<LocalStorage> storage)
    9295{
    93     ASSERT(!m_queue.killed() && m_threadID.isValid());
     96    ASSERT(!m_queue.killed() && m_threadID);
    9497    m_queue.append(LocalStorageTask::createSync(storage));
    9598}
    … …  
    97100void LocalStorageThread::scheduleImport(PassRefPtr<LocalStorageArea> area)
    98101{
    99     ASSERT(!m_queue.killed() && m_threadID.isValid());
     102    ASSERT(!m_queue.killed() && m_threadID);
    100103    m_queue.append(LocalStorageTask::createImport(area));
    101104}
    … …  
    103106void LocalStorageThread::scheduleSync(PassRefPtr<LocalStorageArea> area)
    104107{
    105     ASSERT(!m_queue.killed() && m_threadID.isValid());
     108    ASSERT(!m_queue.killed() && m_threadID);
    106109    m_queue.append(LocalStorageTask::createSync(area));
    107110}
    … …  
    113116    // Ideally we'd never be killing a thread that wasn't live, so ASSERT it.
    114117    // But if we do in a release build, make sure to not wait on a condition that will never get signalled
    115     ASSERT(!m_queue.killed() && m_threadID.isValid());
    116     if (!m_threadID.isValid())
     118    ASSERT(!m_queue.killed() && m_threadID);
     119    if (!m_threadID)
    117120        return;
    118121

  • trunk/WebCore/workers/WorkerThread.cpp

    r43507 r43663  
    6969
    7070WorkerThread::WorkerThread(const KURL& scriptURL, const String& userAgent, const String& sourceCode, WorkerObjectProxy* workerObjectProxy)
    71     : m_workerObjectProxy(workerObjectProxy)
     71    : m_threadID(0)
     72    , m_workerObjectProxy(workerObjectProxy)
    7273    , m_startupData(WorkerThreadStartupData::create(scriptURL, userAgent, sourceCode))
    7374{
    … …  
    8384    MutexLocker lock(m_threadCreationMutex);
    8485
    85     if (!m_threadID.isValid())
    86         m_threadID = createThread(WorkerThread::workerThreadStart, this, "WebCore: Worker");
     86    if (m_threadID)
     87        return true;
    8788
    88     return m_threadID.isValid();
     89    m_threadID = createThread(WorkerThread::workerThreadStart, this, "WebCore: Worker");
     90
     91    return m_threadID;
    8992}
    9093

  • trunk/WebKit/win/ChangeLog

    r43569 r43663  
     12009-05-13  Dmitry Titov  <dimich@chromium.org>
     2
     3        Rubber-stamped by Mark Rowe.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=25746
     6        Revert http://trac.webkit.org/changeset/43507 which caused crash in PPC nightlies with Safari 4.
     7
     8        * WebKit.vcproj/WebKit.def:
     9        * WebKit.vcproj/WebKit_debug.def:
     10
    1112009-05-12  Steve Falkenburg  <sfalken@apple.com>
    212

  • trunk/WebKit/win/WebKit.vcproj/WebKit.def

    r43507 r43663  
    115115        ??1Mutex@WTF@@QAE@XZ
    116116        ??1ThreadCondition@WTF@@QAE@XZ
    117         ??8ThreadIdentifier@WTF@@QBE_NABV01@@Z
    118117        ?broadcast@ThreadCondition@WTF@@QAEXXZ
    119118        ?callOnMainThread@WTF@@YAXP6AXPAX@Z0@Z
    120         ?createThread@WTF@@YA?AVThreadIdentifier@1@P6APAXPAX@Z0PBD@Z
    121         ?currentThread@WTF@@YA?AVThreadIdentifier@1@XZ
    122         ?detachThread@WTF@@YAXVThreadIdentifier@1@@Z
     119        ?createThread@WTF@@YAIP6APAXPAX@Z0PBD@Z
     120        ?currentThread@WTF@@YAIXZ
     121        ?detachThread@WTF@@YAXI@Z
    123122        ?initializeMainThread@WTF@@YAXXZ
    124123        ?initializeThreading@WTF@@YAXXZ
    … …  
    134133        ?unlockAtomicallyInitializedStaticMutex@WTF@@YAXXZ
    135134        ?wait@ThreadCondition@WTF@@QAEXAAVMutex@2@@Z
    136         ?waitForThreadCompletion@WTF@@YAHVThreadIdentifier@1@PAPAX@Z
    137         ?createThread@WTF@@YAIP6APAXPAX@Z0PBD@Z=?createThreadDeprecated@WTF@@YAIP6APAXPAX@Z0PBD@Z
    138         ?currentThread@WTF@@YAIXZ=?currentThreadDeprecated@WTF@@YAIXZ
    139         ?detachThread@WTF@@YAXI@Z=?detachThreadDeprecated@WTF@@YAXI@Z
    140         ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z=?waitForThreadCompletionDeprecated@WTF@@YAHIPAPAX@Z
     135        ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z
     136        ?createThread@WTF@@YAIP6APAXPAX@Z0@Z

  • trunk/WebKit/win/WebKit.vcproj/WebKit_debug.def

    r43507 r43663  
    115115        ??1Mutex@WTF@@QAE@XZ
    116116        ??1ThreadCondition@WTF@@QAE@XZ
    117         ??8ThreadIdentifier@WTF@@QBE_NABV01@@Z
    118117        ?broadcast@ThreadCondition@WTF@@QAEXXZ
    119118        ?callOnMainThread@WTF@@YAXP6AXPAX@Z0@Z
    120         ?createThread@WTF@@YA?AVThreadIdentifier@1@P6APAXPAX@Z0PBD@Z
    121         ?currentThread@WTF@@YA?AVThreadIdentifier@1@XZ
    122         ?detachThread@WTF@@YAXVThreadIdentifier@1@@Z
     119        ?createThread@WTF@@YAIP6APAXPAX@Z0PBD@Z
     120        ?currentThread@WTF@@YAIXZ
     121        ?detachThread@WTF@@YAXI@Z
    123122        ?initializeMainThread@WTF@@YAXXZ
    124123        ?initializeThreading@WTF@@YAXXZ
    … …  
    134133        ?unlockAtomicallyInitializedStaticMutex@WTF@@YAXXZ
    135134        ?wait@ThreadCondition@WTF@@QAEXAAVMutex@2@@Z
    136         ?waitForThreadCompletion@WTF@@YAHVThreadIdentifier@1@PAPAX@Z
    137         ?createThread@WTF@@YAIP6APAXPAX@Z0PBD@Z=?createThreadDeprecated@WTF@@YAIP6APAXPAX@Z0PBD@Z
    138         ?currentThread@WTF@@YAIXZ=?currentThreadDeprecated@WTF@@YAIXZ
    139         ?detachThread@WTF@@YAXI@Z=?detachThreadDeprecated@WTF@@YAXI@Z
    140         ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z=?waitForThreadCompletionDeprecated@WTF@@YAHIPAPAX@Z
     135        ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z
     136        ?createThread@WTF@@YAIP6APAXPAX@Z0@Z
Note: See TracChangeset for help on using the changeset viewer.