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

Source/platform/heap/ThreadState.h

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 600 matching lines @@
 };
 
 // The SafePointAwareMutexLocker is used to enter a safepoint while waiting for
 // a mutex lock. It also ensures that the lock is not held while waiting for a GC
 // to complete in the leaveSafePoint method, by releasing the lock if the
 // leaveSafePoint method cannot complete without blocking, see
 // SafePointBarrier::checkAndPark.
 class SafePointAwareMutexLocker {
     WTF_MAKE_NONCOPYABLE(SafePointAwareMutexLocker);
 public:
-    explicit SafePointAwareMutexLocker(Mutex& mutex, ThreadState::StackState stackState = ThreadState::HeapPointersOnStack)
+    explicit SafePointAwareMutexLocker(MutexBase& mutex, ThreadState::StackState stackState = ThreadState::HeapPointersOnStack)
         : m_mutex(mutex)
         , m_locked(false)
     {
         ThreadState* state = ThreadState::current();
         do {
             bool leaveSafePoint = false;
             // We cannot enter a safepoint if we are currently sweeping. In that
             // case we just try to acquire the lock without being at a safepoint.
             // If another thread tries to do a GC at that time it might time out
             // due to this thread not being at a safepoint and waiting on the lock.
@@ skipping 22 matching lines @@
 private:
     friend class SafePointBarrier;
 
     void reset()
     {
         ASSERT(m_locked);
         m_mutex.unlock();
         m_locked = false;
     }
 
-    Mutex& m_mutex;
+    MutexBase& m_mutex;
     bool m_locked;
 };
 
 // Common header for heap pages. Needs to be defined before class Visitor.
 class BaseHeapPage {
 public:
     BaseHeapPage(PageMemory*, const GCInfo*, ThreadState*);
     virtual ~BaseHeapPage() { }
 
     // Check if the given address points to an object in this
@@ skipping 37 matching lines @@
     // HeapPage header. We use some of the bits to determine
     // whether the page is part of a terminting thread or
     // if the page is traced after being terminated (orphaned).
     uintptr_t m_terminating : 1;
     uintptr_t m_tracedAfterOrphaned : 1;
 };
 
 }
 
 #endif // ThreadState_h