Oilpan: Query stack frame register instead of manual bookkeeping

Source/platform/heap/Visitor.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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Visitor_h
 #define Visitor_h
 
 #include "platform/PlatformExport.h"
+#include "platform/heap/StackFrameDepth.h"
 #include "platform/heap/ThreadState.h"
 #include "wtf/Assertions.h"
 #include "wtf/Deque.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashTraits.h"
 #include "wtf/InstanceCounter.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/TypeTraits.h"
@@ skipping 562 matching lines @@
     virtual bool ensureMarked(const void*) = 0;
 
 #if ENABLE(GC_PROFILE_MARKING)
     void setHostInfo(void* object, const String& name)
     {
         m_hostObject = object;
         m_hostName = name;
     }
 #endif
 
-    inline bool canTraceEagerly() const { return m_traceDepth < kMaxEagerTraceDepth; }
-    inline void incrementTraceDepth() { m_traceDepth++; }
-    inline void decrementTraceDepth() { ASSERT(m_traceDepth > 0); m_traceDepth--; }
+    inline bool canTraceEagerly() const
+    {
+        ASSERT(m_traceDepth);
+        return m_traceDepth->isSafeToRecurse();
+    }
+
+    inline void incrementTraceDepth()
+    {
+        ASSERT(m_traceDepth);
+        m_traceDepth->increment();
+    }
+
+    inline void decrementTraceDepth()
+    {
+        ASSERT(m_traceDepth);
+        m_traceDepth->decrement();
+    }
+
+    inline void configureEagerTraceLimit()
+    {
+        if (!m_traceDepth)
+            m_traceDepth = new StackFrameDepth;
+        m_traceDepth->configureLimit();
+    }
 
     inline bool isGlobalMarkingVisitor() const { return m_isGlobalMarkingVisitor; }
 
 protected:
     explicit Visitor(VisitorType type)
         : m_isGlobalMarkingVisitor(type == GlobalMarkingVisitorType)
-    {
-        m_traceDepth = 0;
-    }
+    { }
 
     virtual void registerWeakCellWithCallback(void**, WeakPointerCallback) = 0;
 #if ENABLE(GC_PROFILE_MARKING)
     virtual void recordObjectGraphEdge(const void*)
     {
         ASSERT_NOT_REACHED();
     }
 
     void* m_hostObject;
     String m_hostName;
 #endif
 
 private:
-    // The maximum depth of eager, unrolled trace() calls that is
-    // considered safe and allowed.
-    const int kMaxEagerTraceDepth = 100;
-
-    static int m_traceDepth;
+    static StackFrameDepth* m_traceDepth;
     bool m_isGlobalMarkingVisitor;
 };
 
 // We trace vectors by using the trace trait on each element, which means you
 // can have vectors of general objects (not just pointers to objects) that can
 // be traced.
 template<typename T, size_t N>
 struct OffHeapCollectionTraceTrait<WTF::Vector<T, N, WTF::DefaultAllocator> > {
     typedef WTF::Vector<T, N, WTF::DefaultAllocator> Vector;
 
@@ skipping 233 matching lines @@
 struct GCInfoTrait {
     static size_t index()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::index();
     }
 };
 
 }
 
 #endif