[oilpan]: Add SafePointAwareMutexLocker to allow GC when waiting for lock.

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 34 matching lines @@
 
 class BaseHeap;
 class BaseHeapPage;
 class FinalizedHeapObjectHeader;
 struct GCInfo;
 class HeapContainsCache;
 class HeapObjectHeader;
 class PersistentNode;
 class Visitor;
 class SafePointBarrier;
+class SafePointAwareMutexLocker;
 template<typename Header> class ThreadHeap;
 class CallbackStack;
 
 typedef uint8_t* Address;
 
 typedef void (*FinalizationCallback)(void*);
 typedef void (*VisitorCallback)(Visitor*, void* self);
 typedef VisitorCallback TraceCallback;
 typedef VisitorCallback WeakPointerCallback;
 
@@ skipping 297 matching lines @@
     static bool stopThreads();
     static void resumeThreads();
 
     // Check if GC is requested by another thread and pause this thread if this is the case.
     // Can only be called when current thread is in a consistent state.
     void safePoint(StackState);
 
     // Mark current thread as running inside safepoint.
     void enterSafePointWithoutPointers() { enterSafePoint(NoHeapPointersOnStack, 0); }
     void enterSafePointWithPointers(void* scopeMarker) { enterSafePoint(HeapPointersOnStack, scopeMarker); }
-    void leaveSafePoint();
+    void leaveSafePoint(SafePointAwareMutexLocker* = 0);
     bool isAtSafePoint() const { return m_atSafePoint; }
 
     class SafePointScope {
     public:
         enum ScopeNesting {
             NoNesting,
             AllowNesting
         };
 
         explicit SafePointScope(StackState stackState, ScopeNesting nesting = NoNesting)
@@ skipping 120 matching lines @@
 
     void getStats(HeapStats&);
     HeapStats& stats() { return m_stats; }
     HeapStats& statsAfterLastGC() { return m_statsAfterLastGC; }
 
 private:
     explicit ThreadState();
     ~ThreadState();
 
     friend class SafePointBarrier;
+    friend class SafePointAwareMutexLocker;
 
     void enterSafePoint(StackState, void*);
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
     void clearSafePointScopeMarker()
     {
         m_safePointStackCopy.clear();
         m_safePointScopeMarker = 0;
     }
 
     void performPendingGC(StackState);
@@ skipping 71 matching lines @@
         ASSERT(ThreadState::current()->isMainThread());
         return ThreadState::mainThreadState();
     }
 };
 
 template<> class ThreadStateFor<AnyThread> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
+// 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) : m_mutex(mutex), m_locked(false)
+    {
+        ThreadState* state = ThreadState::current();
+        do {
+            bool leaveSafePoint = false;
+            if (!state->isAtSafePoint()) {
+                state->enterSafePoint(ThreadState::HeapPointersOnStack, this);
+                leaveSafePoint = true;
+            }
+            m_mutex.lock();
+            m_locked = true;
+            if (leaveSafePoint) {
+                // When leaving the safepoint we might end up release the mutex
+                // if another thread is requesting a GC, see
+                // SafePointBarrier::checkAndPark. This is the case where we
+                // loop around to reacquire the lock.
+                state->leaveSafePoint(this);
+            }
+        } while (!m_locked);
+    }
+
+    ~SafePointAwareMutexLocker()
+    {
+        ASSERT(m_locked);
+        m_mutex.unlock();
+    }
+
+private:
+    friend class SafePointBarrier;
+
+    void reset()
+    {
+        ASSERT(m_locked);
+        m_mutex.unlock();
+        m_locked = false;
+    }
+
+    Mutex& m_mutex;
+    bool m_locked;
+};
+
 }
 
 #endif // ThreadState_h