StackFrameDepth should be managed per ThreadHeap

third_party/WebKit/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/Allocator.h"
 #include "wtf/Assertions.h"
 #include <cstddef>
 #include <stdint.h>
 
 namespace blink {
 
 // StackFrameDepth keeps track of current call stack frame depth.
 // It is specifically used to control stack usage while tracing
 // the object graph during a GC.
 //
 // Use isSafeToRecurse() to determine if it is safe to consume
 // more stack by invoking another recursive call.
-class PLATFORM_EXPORT StackFrameDepth final {
-    STATIC_ONLY(StackFrameDepth);
+class PLATFORM_EXPORT StackFrameDepth {
 public:
-    inline static bool isSafeToRecurse()
+    void enableStackLimit();
+    void disableStackLimit()
     {
-        // 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;
+        m_stackFrameLimit = kMinimumStackLimit;
     }
 
-    static void enableStackLimit();
-    static void disableStackLimit()
-    {
-        s_stackFrameLimit = kMinimumStackLimit;
-    }
-
-#if ENABLE(ASSERT)
-    inline static bool isEnabled() { return s_stackFrameLimit != kMinimumStackLimit; }
-    inline static bool isAcceptableStackUse()
+    bool isEnabled() { return m_stackFrameLimit != kMinimumStackLimit; }
+    bool isAcceptableStackUse()
     {
 #if defined(ADDRESS_SANITIZER)
         // ASan adds extra stack usage leading to too noisy asserts.
         return true;
 #else
         return !isEnabled() || isSafeToRecurse();
 #endif
     }
-#endif
 
     static size_t getUnderestimatedStackSize();
     static void* getStackStart();
 
 #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
 
+protected:
+    StackFrameDepth() : m_stackFrameLimit(kMinimumStackLimit) {}
+
 private:
+    bool isSafeToRecurse()
+    {
+        // 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() > m_stackFrameLimit;
+    }
+
     // The maximum depth of eager, unrolled trace() calls that is
     // considered safe and allowed for targets with an unknown
     // thread stack size.
     static const int kSafeStackFrameSize = 32 * 1024;
 
     // The stack pointer is assumed to grow towards lower addresses;
     // |kMinimumStackLimit| then being the limit that a stack
     // pointer will always exceed.
     static const uintptr_t kMinimumStackLimit = ~0ul;
 
     static uintptr_t getFallbackStackLimit();
 
     // The (pointer-valued) stack limit.
-    static uintptr_t s_stackFrameLimit;
+    uintptr_t m_stackFrameLimit;
 };
 
 class StackFrameDepthScope {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(StackFrameDepthScope);
 public:
-    StackFrameDepthScope()
+    explicit StackFrameDepthScope(StackFrameDepth* depth): m_depth(depth)
     {
-        StackFrameDepth::enableStackLimit();
+        m_depth->enableStackLimit();
         // Enabled unless under stack pressure.
-        ASSERT(StackFrameDepth::isSafeToRecurse() || !StackFrameDepth::isEnabled());
+        DCHECK(m_depth->isSafeToRecurse() || !m_depth->isEnabled());
     }
 
     ~StackFrameDepthScope()
     {
-        StackFrameDepth::disableStackLimit();
+        m_depth->disableStackLimit();
     }
+
+private:
+    StackFrameDepth* m_depth;
 };
 
 } // namespace blink
 
 #endif // StackFrameDepth_h