Disallow static locals of ScriptWrappable-derived objects.

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 45 matching lines @@
 
  private:
   bool m_safelyInitialized;
   ThreadIdentifier m_thread;
 };
 #endif
 
 namespace blink {
 template <typename T>
 class Persistent;
+
+class ScriptWrappable;
 };
 
 template <typename T,
           bool = WTF::IsGarbageCollectedType<T>::value &&
                  !WTF::IsPersistentReferenceType<T>::value>
 class StaticLocalWrapper {
  public:
   using WrapType = T;
 
   static T& unwrap(T* singleton) { return *singleton; }
@@ skipping 29 matching lines @@
 // wrapped up by an off-heap Persistent<T> reference to the object, keeping
 // it alive across GCs.
 //
 // To cooperate with leak detection(LSan) for Blink garbage collected objects,
 // the objects owned by persistent local statics will in some cases have to be
 // finalized prior to leak checking. This only applies to static references to
 // Blink heap objects and what they transitively hold on to. Hence the
 // LEAK_SANITIZER_REGISTER_STATIC_LOCAL() use, it taking care of the grungy
 // details.
 //
-#define DEFINE_STATIC_LOCAL(Type, Name, Arguments)                   \
-  DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name);                 \
-  using WrappedTypeFor##Name = StaticLocalWrapper<Type>::WrapType;   \
-  static WrappedTypeFor##Name* WrappedInstanceFor##Name =            \
-      LEAK_SANITIZER_REGISTER_STATIC_LOCAL(                          \
-          WrappedTypeFor##Name, new WrappedTypeFor##Name Arguments); \
+#define DEFINE_STATIC_LOCAL(Type, Name, Arguments)                       \
+  DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name);                     \
+  using WrappedTypeFor##Name = StaticLocalWrapper<Type>::WrapType;       \
+  static_assert(                                                         \
+      !WTF::IsPersistentReferenceType<WrappedTypeFor##Name>::value ||    \
+          !WTF::IsSubclass<WTF::RemoveTemplate<WrappedTypeFor##Name,     \
+                                               blink::Persistent>::type, \
+                           blink::ScriptWrappable>::value,               \
+      "It is unsafe to keep a static local singleton to a "              \
+      "ScriptWrappable-derived object");                                 \
+  static WrappedTypeFor##Name* WrappedInstanceFor##Name =                \
+      LEAK_SANITIZER_REGISTER_STATIC_LOCAL(                              \
+          WrappedTypeFor##Name, new WrappedTypeFor##Name Arguments);     \
   Type& Name = StaticLocalWrapper<Type>::unwrap(WrappedInstanceFor##Name);
 
 // 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 108 matching lines @@
 enum NotNullTag { NotNull };
 inline void* operator new(size_t, NotNullTag, void* location) {
   DCHECK(location);
   return location;
 }
 
 using WTF::bitwiseCast;
 using WTF::safeCast;
 
 #endif  // WTF_StdLibExtras_h