Oilpan: handle thread-local weak tracing slightly better.

Source/platform/heap/StackFrameDepth.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef StackFrameDepth_h
 #define StackFrameDepth_h
 
 #include "platform/PlatformExport.h"
 #include "wtf/Assertions.h"
 #include <stdint.h>
 
 namespace blink {
 
 // StackFrameDepth keeps track of current call stack frame depth.
 // Use isSafeToRecurse() to query if there is a room in current
 // call stack for more recursive call.
 class PLATFORM_EXPORT StackFrameDepth final {
 public:
     inline static bool isSafeToRecurse()
     {
-        ASSERT(s_stackFrameLimit);
+        ASSERT(s_stackFrameLimit || !s_isActive);
 
         // Asssume that the stack grows towards lower addresses, which
         // all the ABIs currently supported do.
         //
         // A unit test checks that the assumption holds for a target
         // (HeapTest.StackGrowthDirection.)
         return currentStackFrame() > s_stackFrameLimit;
     }
     static void configureStackLimit();
     static size_t getUnderestimatedStackSize();
     static void* getStackStart();
 
+    static void clearStackLimit()

[haraken, 2015/05/04 23:11:32]

configureStackLimit => enableStackLimit
clearStackLimit => disableStackLimit
m_isActive => m_enabled

?

[sof, 2015/05/06 10:39:57]

Renamed so.

+    {
+        s_stackFrameLimit = 0;
+#if ENABLE(ASSERT)
+        s_isActive = false;
+#endif
+    }
+
+#if ENABLE(ASSERT)
+    inline static bool isActive() { return s_isActive; }
+#endif
+
 #if COMPILER(MSVC)
 // Ignore C4172: returning address of local variable or temporary: dummy. This
 // warning suppression has to go outside of the function to take effect.
 #pragma warning(push)
 #pragma warning(disable: 4172)
 #endif
     static uintptr_t currentStackFrame(const char* dummy = nullptr)
     {
 #if COMPILER(GCC)
         return reinterpret_cast<uintptr_t>(__builtin_frame_address(0));
 #elif COMPILER(MSVC)
         return reinterpret_cast<uintptr_t>(&dummy) - sizeof(void*);
 #else
 #error "Stack frame pointer estimation not supported on this platform."
         return 0;
 #endif
     }
 #if COMPILER(MSVC)
 #pragma warning(pop)
 #endif
 
 private:
     // The maximum depth of eager, unrolled trace() calls that is
     // considered safe and allowed.
     static const int kSafeStackFrameSize = 32 * 1024;
 
     static uintptr_t s_stackFrameLimit;
+#if ENABLE(ASSERT)
+    static bool s_isActive;
+#endif
+};
+
+class StackFrameDepthScope {

[haraken, 2015/05/04 23:11:32]

Add STACK_ALLOCATED.

[sof, 2015/05/06 10:39:57]

Not done, that would be an unnecessary restriction.

+public:
+    StackFrameDepthScope()
+    {
+        StackFrameDepth::configureStackLimit();
+        ASSERT(StackFrameDepth::isSafeToRecurse());
+    }
+
+    ~StackFrameDepthScope()
+    {
+        StackFrameDepth::clearStackLimit();
+    }
 };
 
 } // namespace blink
 
 #endif // StackFrameDepth_h