WTF: Initialize main-thread stack estimates when WTF starts up.

third_party/WebKit/Source/wtf/ThreadSpecific.h

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Jian Li <jianli@chromium.org>
  * Copyright (C) 2012 Patrick Gansterer <paroga@paroga.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 250 matching lines @@
 inline bool ThreadSpecific<T>::isSet() {
   return !!get();
 }
 
 template <typename T>
 inline ThreadSpecific<T>::operator T*() {
   T* offThreadPtr;
 #if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
   // TLS is fast on these platforms.
   // TODO(csharrison): Qualify this statement for Android.
+  const bool mainThreadAlwaysChecksTLS = true;
   T** ptr = &offThreadPtr;
   offThreadPtr = static_cast<T*>(get());
 #else
+  const bool mainThreadAlwaysChecksTLS = false;
   T** ptr = &m_mainThreadStorage;
-  if (UNLIKELY(internal::mayNotBeMainThread())) {
+  if (UNLIKELY(mayNotBeMainThread())) {
     offThreadPtr = static_cast<T*>(get());
     ptr = &offThreadPtr;
   }
 #endif
   // Set up thread-specific value's memory pointer before invoking constructor,
   // in case any function it calls needs to access the value, to avoid
   // recursion.
   if (UNLIKELY(!*ptr)) {
     *ptr = static_cast<T*>(Partitions::fastZeroedMalloc(
         sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T)));
+
+    // Even if we didn't realize we're on the main thread, we might still be.
+    // We need to double-check so that |m_mainThreadStorage| is populated.
+    if (!mainThreadAlwaysChecksTLS && UNLIKELY(ptr != &m_mainThreadStorage) &&

[haraken, 2017/03/06 01:44:03]

This code is in a slow path. So I'm okay with dropping the
mainThreadAlwaysChecksTLS check for simplicity.

[jbroman, 2017/03/06 16:14:03]

Even though |m_mainThreadStorage| will never be read?

+        isMainThread()) {
+      m_mainThreadStorage = *ptr;

[haraken, 2017/03/06 01:44:03]

Just to confirm: |*ptr| populates the thread-local storage, right?

[jbroman, 2017/03/06 16:14:03]

|ptr| either points to |offThreadPtr| (in this stack frame) or to
|m_mainThreadStorage| (a member of ThreadSpecific<T>). In this branch it always
points to |offThreadPtr|, so I could equivalently have written
"m_mainThreadStorage = offThreadPtr;", but this seemed to me to make the intent
clearer.

The thread-local storage is populated by the call to ThreadSpecific::set, below.

+    }
+
     set(*ptr);
     new (NotNull, *ptr) T;
   }
   return *ptr;
 }
 
 template <typename T>
 inline T* ThreadSpecific<T>::operator->() {
   return operator T*();
 }
 
 template <typename T>
 inline T& ThreadSpecific<T>::operator*() {
   return *operator T*();
 }
 
 }  // namespace WTF
 
 using WTF::ThreadSpecific;
 
 #endif  // WTF_ThreadSpecific_h