Experiment: Release static Oilpan heap singletons prior to LSan leak detection.

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 11 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WTF_StdLibExtras_h
 #define WTF_StdLibExtras_h
 
 #include "wtf/Assertions.h"
 #include "wtf/CPU.h"
 #include "wtf/CheckedArithmetic.h"
+#include "wtf/TypeTraits.h"
 #include <cstddef>
 
 #if ENABLE(ASSERT)
 #include "wtf/Noncopyable.h"
 #include "wtf/Threading.h"
 
 class WTF_EXPORT StaticLocalVerifier {
     WTF_MAKE_NONCOPYABLE(StaticLocalVerifier);
 public:
     StaticLocalVerifier()
@@ skipping 10 matching lines @@
         return m_safelyInitialized || m_thread == WTF::currentThread() || WTF::isAtomicallyInitializedStaticMutexLockHeld();
     }
 
 private:
     bool m_safelyInitialized;
     ThreadIdentifier m_thread;
 };
 #endif
 
 // Use this to declare and define a static local variable (static T;) so that
-//  it is leaked so that its destructors are not called at exit.
+// it is leaked so that its destructors are not called at exit.
+//
+// If the object pointed to by the static local is on the Oilpan heap, a strong
+// Persistent<> is created to keep the pointed-to heap object alive. This makes
+// both the Persistent<> and the heap object reachable by LeakSanitizer's leak
+// detection pass. We do not want these intentional leaks to be reported by LSan,
+// hence the static local is registered with Oilpan
+// (see RegisterStaticLocalReference<> below.)
+//
+// Upon Blink shutdown, we release all these statics and perform a final round
+// of GCs to sweep out their now-unreachable object graphs. The end result being
+// a tidied heap that the LeakSanitizer can then scan to report real leaks.
+//
+// Should you not want to register a static reference to an Oilpan object for
+// finalization upon shutdown, DEFINE_STATIC_LOCAL_NO_REGISTER() is provided.
 #ifndef DEFINE_STATIC_LOCAL
 
+template<typename T>
+class CanRegisterStaticLocalReference {
+    typedef char YesType;
+    typedef struct NoType {
+        char padding[8];
+    } NoType;
+
+    // Check if class T has public method "T* registerAsStaticReference()".
+    template<typename V> static YesType checkHasRegisterAsStaticReferenceMethod(V* p, typename WTF::EnableIf<WTF::IsSubclass<V, typename std::remove_pointer<decltype(p->registerAsStaticReference())>::type>::value>::Type* = 0);
+    template<typename V> static NoType checkHasRegisterAsStaticReferenceMethod(...);
+public:
+
+    static const bool value = sizeof(YesType) + sizeof(T) == sizeof(checkHasRegisterAsStaticReferenceMethod<T>(nullptr)) + sizeof(T);
+};
+
+template<typename T, bool = CanRegisterStaticLocalReference<T>::value>
+class RegisterStaticLocalReference {
+public:
+    static T* registerStatic(T* ptr)
+    {
+        return ptr;
+    }
+};
+
+template<typename T>
+class RegisterStaticLocalReference<T, true> {
+public:
+    static T* registerStatic(T* ptr)
+    {
+        return static_cast<T*>(ptr->registerAsStaticReference());
+    }
+};
+
 #if ENABLE(ASSERT)
 #define DEFINE_STATIC_LOCAL(type, name, arguments)        \
     static StaticLocalVerifier name##StaticLocalVerifier; \
-    ASSERT(name##StaticLocalVerifier.isNotRacy()); \
+    ASSERT(name##StaticLocalVerifier.isNotRacy());        \
+    static type& name = *RegisterStaticLocalReference<type>::registerStatic(new type arguments)
+#define DEFINE_STATIC_LOCAL_NO_REGISTER(type, name, arguments)        \
+    static StaticLocalVerifier name##StaticLocalVerifier; \
+    ASSERT(name##StaticLocalVerifier.isNotRacy());        \
     static type& name = *new type arguments
 #else
 #define DEFINE_STATIC_LOCAL(type, name, arguments) \
+    static type& name = *RegisterStaticLocalReference<type>::registerStatic(new type arguments)
+#define DEFINE_STATIC_LOCAL_NO_REGISTER(type, name, arguments) \
     static type& name = *new type arguments
 #endif
 
-#endif
-
+#endif // DEFINE_STATIC_LOCAL
 
 // 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.
 #ifndef DEFINE_STATIC_REF
 #define DEFINE_STATIC_REF(type, name, arguments) \
     static type* name = PassRefPtr<type>(arguments).leakRef();
 #endif
 
@@ skipping 75 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