Revert of Release 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/LeakAnnotations.h"
 #include <cstddef>
 
 #if ENABLE(ASSERT)
 #include "wtf/Noncopyable.h"
 #include "wtf/Threading.h"
 
 class WTF_EXPORT StaticLocalVerifier {
     WTF_MAKE_NONCOPYABLE(StaticLocalVerifier);
 public:
     StaticLocalVerifier()
         : m_safelyInitialized(WTF::isBeforeThreadCreated())
         , m_thread(WTF::currentThread())
     {
     }
 
     bool isNotRacy()
     {
         // Make sure that this 1) is safely initialized, 2) keeps being called
         // on the same thread, or 3) is called within
         // AtomicallyInitializedStatic (i.e. with a lock held).
         return m_safelyInitialized || m_thread == WTF::currentThread() || WTF::isAtomicallyInitializedStaticMutexLockHeld();
     }
 
 private:
     bool m_safelyInitialized;
     ThreadIdentifier m_thread;
 };
 #endif
 
-// 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.
-//
+// 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.
+#ifndef DEFINE_STATIC_LOCAL
+
 #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)
+    ASSERT(name##StaticLocalVerifier.isNotRacy()); \
+    static type& name = *new type arguments
 #else
 #define DEFINE_STATIC_LOCAL(type, name, arguments) \
-    static type& name = *LEAK_SANITIZER_REGISTER_STATIC_LOCAL(type, new type arguments)
+    static type& name = *new type arguments
 #endif
 
+#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.
+#ifndef DEFINE_STATIC_REF
 #define DEFINE_STATIC_REF(type, name, arguments) \
     static type* name = PassRefPtr<type>(arguments).leakRef();
+#endif
 
 /*
  * The reinterpret_cast<Type1*>([pointer to Type2]) expressions - where
  * sizeof(Type1) > sizeof(Type2) - cause the following warning on ARM with GCC:
  * increases required alignment of target type.
  *
  * An implicit or an extra static_cast<void*> bypasses the warning.
  * For more info see the following bugzilla entries:
  * - https://bugs.webkit.org/show_bug.cgi?id=38045
  * - http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43976
@@ skipping 66 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