[oilpan]: fix deadlock when leaving a safepoint and sweeping.

Source/wtf/ThreadingPrimitives.h

 /*
  * Copyright (C) 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
  *
  * 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.
@@ skipping 30 matching lines @@
 #include <windows.h>
 #endif
 
 #if USE(PTHREADS)
 #include <pthread.h>
 #endif
 
 namespace WTF {
 
 #if USE(PTHREADS)
-typedef pthread_mutex_t PlatformMutex;
+struct PlatformMutex {
+    pthread_mutex_t m_internalMutex;
+#if ENABLE(ASSERT)
+    size_t m_recursionCount;
+#endif
+};
 typedef pthread_cond_t PlatformCondition;
 #elif OS(WIN)
 struct PlatformMutex {
     CRITICAL_SECTION m_internalMutex;
     size_t m_recursionCount;
 };
 struct PlatformCondition {
     size_t m_waitersGone;
     size_t m_waitersBlocked;
     size_t m_waitersToUnblock;
     HANDLE m_blockLock;
     HANDLE m_blockQueue;
     HANDLE m_unblockLock;
 
     bool timedWait(PlatformMutex&, DWORD durationMilliseconds);
     void signal(bool unblockAll);
 };
 #else
 typedef void* PlatformMutex;
 typedef void* PlatformCondition;
 #endif
 
-class WTF_EXPORT Mutex {
-    WTF_MAKE_NONCOPYABLE(Mutex); WTF_MAKE_FAST_ALLOCATED;
+class WTF_EXPORT MutexBase {
+    WTF_MAKE_NONCOPYABLE(MutexBase); WTF_MAKE_FAST_ALLOCATED;
 public:
-    Mutex();
-    ~Mutex();
+    ~MutexBase();
 
     void lock();
-    bool tryLock();
     void unlock();
+#if ENABLE(ASSERT)
+    bool locked() { return m_mutex.m_recursionCount > 0; }
+#endif
 
 public:
     PlatformMutex& impl() { return m_mutex; }
-private:
+
+protected:
+    MutexBase(bool recursive);
+
     PlatformMutex m_mutex;
 };
 
-typedef Locker<Mutex> MutexLocker;
+class WTF_EXPORT Mutex : public MutexBase {
+public:
+    Mutex() : MutexBase(false) { }
+    bool tryLock();
+};
+
+class WTF_EXPORT RecursiveMutex : public MutexBase {
+public:
+    RecursiveMutex() : MutexBase(true) { }
+    bool tryLock();
+};
+
+typedef Locker<MutexBase> MutexLocker;
 
 class MutexTryLocker {
     WTF_MAKE_NONCOPYABLE(MutexTryLocker);
 public:
     MutexTryLocker(Mutex& mutex) : m_mutex(mutex), m_locked(mutex.tryLock()) { }
     ~MutexTryLocker()
     {
         if (m_locked)
             m_mutex.unlock();
     }
 
     bool locked() const { return m_locked; }
 
 private:
     Mutex& m_mutex;
     bool m_locked;
 };
 
 class WTF_EXPORT ThreadCondition {
     WTF_MAKE_NONCOPYABLE(ThreadCondition);
 public:
     ThreadCondition();
     ~ThreadCondition();
 
-    void wait(Mutex&);
+    void wait(MutexBase&);
     // Returns true if the condition was signaled before absoluteTime, false if the absoluteTime was reached or is in the past.
     // The absoluteTime is in seconds, starting on January 1, 1970. The time is assumed to use the same time zone as WTF::currentTime().
-    bool timedWait(Mutex&, double absoluteTime);
+    bool timedWait(MutexBase&, double absoluteTime);
     void signal();
     void broadcast();
 
 private:
     PlatformCondition m_condition;
 };
 
 #if OS(WIN)
 // The absoluteTime is in seconds, starting on January 1, 1970. The time is assumed to use the same time zone as WTF::currentTime().
 // Returns an interval in milliseconds suitable for passing to one of the Win32 wait functions (e.g., ::WaitForSingleObject).
 DWORD absoluteTimeToWaitTimeoutInterval(double absoluteTime);
 #endif
 
 } // namespace WTF
 
+using WTF::MutexBase;
 using WTF::Mutex;
+using WTF::RecursiveMutex;
 using WTF::MutexLocker;
 using WTF::MutexTryLocker;
 using WTF::ThreadCondition;
 
 #if OS(WIN)
 using WTF::absoluteTimeToWaitTimeoutInterval;
 #endif
 
 #endif // ThreadingPrimitives_h