DEFINE_STATIC_LOCAL(): assert against illegal use of GCed types.

third_party/WebKit/Source/wtf/StdLibExtras.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 41 matching lines @@
         // AtomicallyInitializedStatic (i.e. with a lock held).
         return m_safelyInitialized || m_thread == WTF::currentThread() || WTF::isAtomicallyInitializedStaticMutexLockHeld();
     }
 
 private:
     bool m_safelyInitialized;
     ThreadIdentifier m_thread;
 };
 #endif
 
+// A direct static local to a Blink garbage collected objects isn't allowed;
+// must be wrapped up with a persistent reference.
+#define STATIC_ASSERT_FOR_LOCAL_WITH_GARBAGE_COLLECTED_TYPE(Name, Type) \
+    using Name##NoConstType = std::remove_const<Type>::type; \
+    using Name##NoPointerType = std::remove_pointer<Name##NoConstType>::type; \
+    using Name##NoReferenceType = std::remove_reference<Name##NoPointerType>::type; \
+    static_assert(!WTF::IsGarbageCollectedType<Name##NoReferenceType>::value || WTF::IsPersistentReferenceType<Name##NoReferenceType>::value, "Garbage collected static local needs to be wrapped up with a persistent reference")
+
 // Use DEFINE_STATIC_LOCAL() to declare and define a static local variable (static T;)
 // so that it is leaked and its destructors are not called at exit.
 //
 // To cooperate with leak detection, the objects held onto by these local statics
 // will in some cases have to be finalized prior to leak checking. This only applies
 // to static references to Oilpan heap objects and what they transitively hold on to.
 // LEAK_SANITIZER_REGISTER_STATIC_LOCAL() takes care of the details.
 //
 #if ENABLE(ASSERT)
-#define DEFINE_STATIC_LOCAL(type, name, arguments)        \
-    static StaticLocalVerifier name##StaticLocalVerifier; \
-    ASSERT(name##StaticLocalVerifier.isNotRacy());        \
-    static type& name = *LEAK_SANITIZER_REGISTER_STATIC_LOCAL(type, new type arguments)
+#define DEFINE_STATIC_LOCAL(Type, Name, Arguments)        \
+    STATIC_ASSERT_FOR_LOCAL_WITH_GARBAGE_COLLECTED_TYPE(Name, Type); \
+    static StaticLocalVerifier Name##StaticLocalVerifier; \
+    ASSERT(Name##StaticLocalVerifier.isNotRacy());        \
+    static Type& Name = *LEAK_SANITIZER_REGISTER_STATIC_LOCAL(Type, new Type Arguments)
 #else
-#define DEFINE_STATIC_LOCAL(type, name, arguments) \
-    static type& name = *LEAK_SANITIZER_REGISTER_STATIC_LOCAL(type, new type arguments)
+#define DEFINE_STATIC_LOCAL(Type, Name, Arguments) \
+    STATIC_ASSERT_FOR_LOCAL_WITH_GARBAGE_COLLECTED_TYPE(Name, Type); \
+    static Type& Name = *LEAK_SANITIZER_REGISTER_STATIC_LOCAL(Type, new Type Arguments)
 #endif
 
 // Use this to declare and define a static local pointer to a ref-counted object so that
 // it is leaked so that the object's destructors are not called at exit.
 // This macro should be used with ref-counted objects rather than DEFINE_STATIC_LOCAL macro,
 // as this macro does not lead to an extra memory allocation.
 #define DEFINE_STATIC_REF(type, name, arguments) \
     static type* name = PassRefPtr<type>(arguments).leakRef();
 
 /*
@@ skipping 74 matching lines @@
 inline void* operator new(size_t, NotNullTag, void* location)
 {
     ASSERT(location);
     return location;
 }
 
 using WTF::bitwise_cast;
 using WTF::safeCast;
 
 #endif // WTF_StdLibExtras_h