Oilpan: add eager tracing stack depth checks.

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 493 matching lines @@
 #undef DECLARE_VISITOR_METHODS
 
 #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--; }
+
 protected:
+    Visitor()
+        : m_traceDepth(0)
+    {
+    }
+
     virtual void registerWeakCell(void**, WeakPointerCallback) = 0;
 #if ENABLE(GC_PROFILE_MARKING)
     void* m_hostObject;
     String m_hostName;
 #endif
 
 private:
     template<typename T>
     static void handleWeakCell(Visitor* self, void* obj)
     {
         T** cell = reinterpret_cast<T**>(obj);
         if (*cell && !self->isAlive(*cell))
             *cell = 0;
     }
+
+    // The maximum depth of eager, unrolled trace() calls that is
+    // considered safe and allowed.
+    const int kMaxEagerTraceDepth = 100;
+
+    int m_traceDepth;
 };
 
 // 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;
 
     static void trace(Visitor* visitor, const Vector& vector)
@@ skipping 33 matching lines @@
     static void mark(Visitor* visitor, const T* t)
     {
         // Default mark method of the trait just calls the two-argument mark
         // method on the visitor. The second argument is the static trace method
         // of the trait, which by default calls the instance method
         // trace(Visitor*) on the object.
         //
         // If the trait allows it, invoke the trace callback right here on the
         // not-yet-marked object.
         if (!DISABLE_ALL_EAGER_TRACING && TraceEagerlyTrait<T>::value) {
-            if (visitor->ensureMarked(t))
-                TraceTrait<T>::trace(visitor, const_cast<T*>(t));
-            return;
+            // Protect against too deep trace call chains, and the
+            // unbounded system stack usage they can bring about.
+            //
+            // Assert against deep stacks so as to flush them out,
+            // but test and appropriately handle them should they occur
+            // in release builds.
+            ASSERT(visitor->canTraceEagerly());
+            if (LIKELY(visitor->canTraceEagerly())) {
+                if (visitor->ensureMarked(t)) {
+                    visitor->incrementTraceDepth();
+                    TraceTrait<T>::trace(visitor, const_cast<T*>(t));
+                    visitor->decrementTraceDepth();
+                }
+                return;
+            }
         }
         visitor->mark(const_cast<T*>(t), &TraceTrait<T>::trace);
     }
 
 #if ENABLE(ASSERT)
     static void checkGCInfo(Visitor* visitor, const T* t)
     {
         visitor->checkGCInfo(const_cast<T*>(t), GCInfoTrait<T>::get());
     }
 #endif
@@ skipping 146 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif