StackFrameDepth should be managed per ThreadHeap

third_party/WebKit/Source/platform/heap/StackFrameDepth.cpp

 // 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.
 
 #include "platform/heap/StackFrameDepth.h"
 
 #include "public/platform/Platform.h"
 
 #if OS(WIN)
 #include <stddef.h>
 #include <windows.h>
 #include <winnt.h>
 #elif defined(__GLIBC__)
 extern "C" void* __libc_stack_end;  // NOLINT
 #endif
 
 namespace blink {
 
 static const char* s_avoidOptimization = nullptr;
 
-uintptr_t StackFrameDepth::s_stackFrameLimit = kMinimumStackLimit;
-
 // NEVER_INLINE ensures that |dummy| array on configureLimit() is not optimized away,
 // and the stack frame base register is adjusted |kSafeStackFrameSize|.
 NEVER_INLINE static uintptr_t currentStackFrameBaseOnCallee(const char* dummy)
 {
     s_avoidOptimization = dummy;
     return StackFrameDepth::currentStackFrame();
 }
 
 uintptr_t StackFrameDepth::getFallbackStackLimit()
 {
     // Allocate an |kSafeStackFrameSize|-sized object on stack and query
     // stack frame base after it.
     char dummy[kSafeStackFrameSize];
 
     // Check that the stack frame can be used.
     dummy[sizeof(dummy) - 1] = 0;
     return currentStackFrameBaseOnCallee(dummy);
 }
 
 void StackFrameDepth::enableStackLimit()
 {
     // All supported platforms will currently return a non-zero estimate,
     // except if ASan is enabled.
     size_t stackSize = getUnderestimatedStackSize();
     if (!stackSize) {
-        s_stackFrameLimit = getFallbackStackLimit();
+        m_stackFrameLimit = getFallbackStackLimit();
         return;
     }
 
     static const int kStackRoomSize = 1024;
 
     Address stackBase = reinterpret_cast<Address>(getStackStart());
-    RELEASE_ASSERT(stackSize > static_cast<const size_t>(kStackRoomSize));
+    CHECK_GT(stackSize, static_cast<const size_t>(kStackRoomSize));
     size_t stackRoom = stackSize - kStackRoomSize;
-    RELEASE_ASSERT(stackBase > reinterpret_cast<Address>(stackRoom));
-    s_stackFrameLimit = reinterpret_cast<uintptr_t>(stackBase - stackRoom);
+    CHECK_GT(stackBase, reinterpret_cast<Address>(stackRoom));
+    m_stackFrameLimit = reinterpret_cast<uintptr_t>(stackBase - stackRoom);
 
     // If current stack use is already exceeding estimated limit, mark as disabled.
     if (!isSafeToRecurse())
         disableStackLimit();
 }
 
 size_t StackFrameDepth::getUnderestimatedStackSize()
 {
     // FIXME: ASAN bot uses a fake stack as a thread stack frame,
     // and its size is different from the value which APIs tells us.
@@ skipping 14 matching lines @@
 #if OS(FREEBSD)
     pthread_attr_init(&attr);
     error = pthread_attr_get_np(pthread_self(), &attr);
 #else
     error = pthread_getattr_np(pthread_self(), &attr);
 #endif
     if (!error) {
         void* base;
         size_t size;
         error = pthread_attr_getstack(&attr, &base, &size);
-        RELEASE_ASSERT(!error);
+        CHECK(!error);
         pthread_attr_destroy(&attr);
         return size;
     }
 #if OS(FREEBSD)
     pthread_attr_destroy(&attr);
 #endif
 
     // Return a 512k stack size, (conservatively) assuming the following:
     //  - that size is much lower than the pthreads default (x86 pthreads has a 2M default.)
     //  - no one is running Blink with an RLIMIT_STACK override, let alone as
@@ skipping 37 matching lines @@
 #if OS(FREEBSD)
     pthread_attr_init(&attr);
     error = pthread_attr_get_np(pthread_self(), &attr);
 #else
     error = pthread_getattr_np(pthread_self(), &attr);
 #endif
     if (!error) {
         void* base;
         size_t size;
         error = pthread_attr_getstack(&attr, &base, &size);
-        RELEASE_ASSERT(!error);
+        CHECK(!error);
         pthread_attr_destroy(&attr);
         return reinterpret_cast<uint8_t*>(base) + size;
     }
 #if OS(FREEBSD)
     pthread_attr_destroy(&attr);
 #endif
 #if defined(__GLIBC__)
     // pthread_getattr_np can fail for the main thread. In this case
     // just like NaCl we rely on the __libc_stack_end to give us
     // the start of the stack.
@@ skipping 13 matching lines @@
     return reinterpret_cast<void*>(__readgsqword(offsetof(NT_TIB64, StackBase)));
 #else
     return reinterpret_cast<void*>(__readfsdword(offsetof(NT_TIB, StackBase)));
 #endif
 #else
 #error Unsupported getStackStart on this platform.
 #endif
 }
 
 } // namespace blink