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

Source/wtf/ThreadingWin.cpp

 /*
  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile, 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
@@ skipping 246 matching lines @@
 void yield()
 {
     ::Sleep(1);
 }
 
 ThreadIdentifier currentThread()
 {
     return static_cast<ThreadIdentifier>(GetCurrentThreadId());
 }
 
-Mutex::Mutex()
+MutexBase::MutexBase(bool recursive)
 {
     m_mutex.m_recursionCount = 0;
     InitializeCriticalSection(&m_mutex.m_internalMutex);
 }
 
-Mutex::~Mutex()
+MutexBase::~MutexBase()
 {
     DeleteCriticalSection(&m_mutex.m_internalMutex);
 }
 
-void Mutex::lock()
+void MutexBase::lock()
 {
     EnterCriticalSection(&m_mutex.m_internalMutex);
     ++m_mutex.m_recursionCount;
 }
 
+void MutexBase::unlock()
+{
+    ASSERT(m_mutex.m_recursionCount);
+    --m_mutex.m_recursionCount;
+    LeaveCriticalSection(&m_mutex.m_internalMutex);
+}
+
 bool Mutex::tryLock()
 {
     // This method is modeled after the behavior of pthread_mutex_trylock,
     // which will return an error if the lock is already owned by the
     // current thread.  Since the primitive Win32 'TryEnterCriticalSection'
     // treats this as a successful case, it changes the behavior of several
     // tests in WebKit that check to see if the current thread already
     // owned this mutex (see e.g., IconDatabase::getOrCreateIconRecord)
     DWORD result = TryEnterCriticalSection(&m_mutex.m_internalMutex);
 
     if (result != 0) {       // We got the lock
-        // If this thread already had the lock, we must unlock and
-        // return false so that we mimic the behavior of POSIX's
-        // pthread_mutex_trylock:
+        // If this thread already had the lock, we must unlock and return
+        // false since this is a non-recursive mutex. This is to mimic the
+        // behavior of POSIX's pthread_mutex_trylock. We don't do this
+        // check in the lock method (presumably due to performance?). This
+        // means lock() will succeed even if the current thread has already
+        // entered the critical section.
         if (m_mutex.m_recursionCount > 0) {
             LeaveCriticalSection(&m_mutex.m_internalMutex);
             return false;
         }
-
         ++m_mutex.m_recursionCount;
         return true;
     }
 
     return false;
 }
 
-void Mutex::unlock()
+bool RecursiveMutex::tryLock()
 {
-    ASSERT(m_mutex.m_recursionCount);
-    --m_mutex.m_recursionCount;
-    LeaveCriticalSection(&m_mutex.m_internalMutex);
+    // CRITICAL_SECTION is recursive/reentrant so TryEnterCriticalSection will
+    // succeed if the current thread is already in the critical section.
+    DWORD result = TryEnterCriticalSection(&m_mutex.m_internalMutex);
+    if (result == 0) { // We didn't get the lock.
+        return false;
+    }
+    ++m_mutex.m_recursionCount;
+    return true;
 }
 
 bool PlatformCondition::timedWait(PlatformMutex& mutex, DWORD durationMilliseconds)
 {
     // Enter the wait state.
     DWORD res = WaitForSingleObject(m_blockLock, INFINITE);
     ASSERT_UNUSED(res, res == WAIT_OBJECT_0);
     ++m_waitersBlocked;
     res = ReleaseSemaphore(m_blockLock, 1, 0);
     ASSERT_UNUSED(res, res);
@@ skipping 112 matching lines @@
     }
 }
 
 ThreadCondition::~ThreadCondition()
 {
     CloseHandle(m_condition.m_blockLock);
     CloseHandle(m_condition.m_blockQueue);
     CloseHandle(m_condition.m_unblockLock);
 }
 
-void ThreadCondition::wait(Mutex& mutex)
+void ThreadCondition::wait(MutexBase& mutex)
 {
     m_condition.timedWait(mutex.impl(), INFINITE);
 }
 
-bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
+bool ThreadCondition::timedWait(MutexBase& mutex, double absoluteTime)
 {
     DWORD interval = absoluteTimeToWaitTimeoutInterval(absoluteTime);
 
     if (!interval) {
         // Consider the wait to have timed out, even if our condition has already been signaled, to
         // match the pthreads implementation.
         return false;
     }
 
     return m_condition.timedWait(mutex.impl(), interval);
@@ skipping 20 matching lines @@
     // Time is too far in the future (and would overflow unsigned long) - wait forever.
     if (absoluteTime - currentTime > static_cast<double>(INT_MAX) / 1000.0)
         return INFINITE;
 
     return static_cast<DWORD>((absoluteTime - currentTime) * 1000.0);
 }
 
 } // namespace WTF
 
 #endif // OS(WIN)