If pthread stack size can't be determined, make a conservative guess.

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>
@@ skipping 38 matching lines @@
     return currentStackFrameBaseOnCallee(dummy);
 }
 
 void StackFrameDepth::enableStackLimit()
 {
 #if ENABLE(ASSERT)
     s_isEnabled = true;
     s_isUsingFallbackStackSize = false;
 #endif
 
-    // Windows and OSX platforms will always return a non-zero estimate.
+    // All supported platforms will currently return a non-zero estimate,
+    // except if ASan is enabled.
     size_t stackSize = getUnderestimatedStackSize();
     if (!stackSize) {
         s_stackFrameLimit = getFallbackStackLimit();
         return;
     }
 
     static const int kStackRoomSize = 1024;
 
     Address stackBase = reinterpret_cast<Address>(getStackStart());
     RELEASE_ASSERT(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);
 }
 
 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.
 #if defined(ADDRESS_SANITIZER)
     return 0;
 #endif
 
     // FIXME: On Mac OSX and Linux, this method cannot estimate stack size
     // correctly for the main thread.
 
 #if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
     // pthread_getattr_np() can fail if the thread is not invoked by
     // pthread_create() (e.g., the main thread of webkit_unit_tests).
-    // In this case, this method returns 0 and the caller must handle it.
+    // If so, a conservative size estimate is returned.
 
     pthread_attr_t attr;
     int error;
 #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);
         pthread_attr_destroy(&attr);
         return size;
     }
 #if OS(FREEBSD)
     pthread_attr_destroy(&attr);
 #endif
 
-    return 0;
+    // 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
+    //    low as 512k.
+    //
+    return 512 * 1024;
 #elif OS(MACOSX)
     // pthread_get_stacksize_np() returns too low a value for the main thread on
     // OSX 10.9, http://mail.openjdk.java.net/pipermail/hotspot-dev/2013-October/011369.html
     //
     // Multiple workarounds possible, adopt the one made by https://github.com/robovm/robovm/issues/274
     // (cf. https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Multithreading/CreatingThreads/CreatingThreads.html
     // on why hardcoding sizes is reasonable.)
     if (pthread_main_np()) {
 #if defined(IOS)
         pthread_attr_t attr;
@@ skipping 58 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