Tidy DEFINE_(THREAD_SAFE_)STATIC_LOCAL() implementations.

third_party/WebKit/Source/platform/heap/Member.h

 // Copyright 2016 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 Member_h
 #define Member_h
 
 #include "wtf/Allocator.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/HashTraits.h"
 
 namespace blink {
 
 template <typename T>
 class Persistent;
+class ScriptWrappable;
 template <typename T>
 class TraceWrapperMember;
 
 enum class TracenessMemberConfiguration {
   Traced,
   Untraced,
 };
 
 template <typename T,
           TracenessMemberConfiguration tracenessConfiguration =
@@ skipping 139 matching lines @@
 #if DCHECK_IS_ON()
     if (tracenessConfiguration == TracenessMemberConfiguration::Untraced) {
       m_creationThreadState = nullptr;
     } else {
       m_creationThreadState = ThreadState::current();
       // Members should be created in an attached thread. But an empty
       // value Member may be created on an unattached thread by a heap
       // collection iterator.
       DCHECK(m_creationThreadState || !m_raw);
     }
+
+    // If this DCHECK() triggers, you're attempting to embed a ScriptWrappable
+    // inside a static local singleton, which is unsafe.
+    // See |DEFINE_STATIC_LOCAL()| documentation for further details.
+    if (WTF::IsSubclass<T, blink::ScriptWrappable>::value) {
+      if (m_creationThreadState)
+        DCHECK(m_creationThreadState->canAllocateScriptWrappable());

[haraken, 2017/02/11 10:25:20]

Would you help me understand why we need to have the check here? i.e., why is
the check in ScriptWrappable's constructor not enough?

[sof, 2017/02/11 12:09:11]

Good question to raise -- the "no ScriptWrappable" scope is something we set up
while the singleton is constructed. So, in order to detect the fields referring
to ScriptWrappables that aren't eagerly initialized, we fall back to the
MemberBase<> check above for the *Member<> fields that are default initialized.

Which is of course only an approximation, as ScriptWrappables may reside deeper
within the object type. I should document that more clearly, if we end up taking
this on..

The other original suggestion of using the type information that GC plugin has
to do this detection, would be accurate. But that might generate false negatives
while computing ScriptWrappable reachability (e.g., should we trace through a
LocalFrame* reference or not.)

+    }
 #endif
   }
 
   T* m_raw;
 #if DCHECK_IS_ON()
   const ThreadState* m_creationThreadState;
 #endif
 
   template <bool x,
             WTF::WeakHandlingFlag y,
@@ skipping 381 matching lines @@
 
 template <typename T>
 struct IsTraceable<blink::TraceWrapperMember<T>> {
   STATIC_ONLY(IsTraceable);
   static const bool value = true;
 };
 
 }  // namespace WTF
 
 #endif  // Member_h