Simplify StackFrameDepth's handling of stack limits.

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.
-// Use isSafeToRecurse() to query if there is a room in current
-// call stack for more recursive call.
+// 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);
 public:
     inline static bool isSafeToRecurse()
     {
-        ASSERT(s_stackFrameLimit || !s_isEnabled);
-
         // 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 enableStackLimit();
     static void disableStackLimit()
     {
-        s_stackFrameLimit = 0;
-#if ENABLE(ASSERT)
-        s_isEnabled = false;
-#endif
+        s_stackFrameLimit = kMinimumStackLimit;
     }
 
 #if ENABLE(ASSERT)
-    inline static bool isEnabled() { return s_isEnabled; }
+    inline static bool isEnabled() { return s_stackFrameLimit != kMinimumStackLimit; }
     inline static bool isAcceptableStackUse()
     {
+#if defined(ADDRESS_SANITIZER)
         // ASan adds extra stack usage leading to too noisy asserts.
-#if defined(ADDRESS_SANITIZER)
         return true;
 #else
-        // If a conservative fallback stack size is in effect, use
-        // a larger stack limit so as to avoid false positives.
-        if (!s_isEnabled || isSafeToRecurse())
-            return true;
-        if (s_isUsingFallbackStackSize)
-            return (s_stackFrameLimit - currentStackFrame()) < 3 * kSafeStackFrameSize;
-        return false;
+        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.
@@ skipping 10 matching lines @@
 #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.
+    // 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;
-#if ENABLE(ASSERT)
-    static bool s_isEnabled;
-    static bool s_isUsingFallbackStackSize;
-#endif
 };
 
 class StackFrameDepthScope {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(StackFrameDepthScope);
 public:
     StackFrameDepthScope()
     {
         StackFrameDepth::enableStackLimit();
         // Enabled unless under stack pressure.
         ASSERT(StackFrameDepth::isSafeToRecurse() || !StackFrameDepth::isEnabled());
     }
 
     ~StackFrameDepthScope()
     {
         StackFrameDepth::disableStackLimit();
     }
 };
 
 } // namespace blink
 
 #endif // StackFrameDepth_h