Stop calling blink::shutdown

third_party/WebKit/Source/wtf/ThreadSpecific.h

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Jian Li <jianli@chromium.org>
  * Copyright (C) 2012 Patrick Gansterer <paroga@paroga.com>
  *
  * 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
@@ skipping 24 matching lines @@
  *     repeatedly if there is still non-NULL value associated with the function.
  *   @ In Windows native implementation, the destructor function will be called
  *     only once.
  * This semantic discrepancy does not impose any problem because nowhere in
  * WebKit the repeated call bahavior is utilized.
  */
 
 #ifndef WTF_ThreadSpecific_h
 #define WTF_ThreadSpecific_h
 
+#include "wtf/AddressSanitizer.h"
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/WTF.h"
 #include "wtf/WTFExport.h"
 #include "wtf/allocator/Partitions.h"
 
 #if OS(POSIX)
 #include <pthread.h>
 #elif OS(WIN)
@@ skipping 93 matching lines @@
 {
     Data* data = static_cast<Data*>(pthread_getspecific(m_key));
     return data ? data->value : 0;
 }
 
 template<typename T>
 inline void ThreadSpecific<T>::set(T* ptr)
 {
     ASSERT(!get());
     pthread_setspecific(m_key, new Data(ptr, this));
+    __lsan_register_root_region(ptr, sizeof(Data));
 }
 
 #elif OS(WIN)
 
 // TLS_OUT_OF_INDEXES is not defined on WinCE.
 #ifndef TLS_OUT_OF_INDEXES
 #define TLS_OUT_OF_INDEXES 0xffffffff
 #endif
 
 // The maximum number of TLS keys that can be created. For simplification, we assume that:
@@ skipping 38 matching lines @@
 {
     Data* data = static_cast<Data*>(TlsGetValue(tlsKeys()[m_index]));
     return data ? data->value : 0;
 }
 
 template<typename T>
 inline void ThreadSpecific<T>::set(T* ptr)
 {
     ASSERT(!get());
     Data* data = new Data(ptr, this);
+    __lsan_register_root_region(ptr, sizeof(Data));
     data->destructor = &ThreadSpecific<T>::destroy;
     TlsSetValue(tlsKeys()[m_index], data);
 }
 
 #else
 #error ThreadSpecific is not implemented for this platform.
 #endif
 
 template<typename T>
 inline void ThreadSpecific<T>::destroy(void* ptr)
 {
-    if (isShutdown())
+    // Never call destructors on the main thread.
+    // This is fine because Blink no longer has a graceful shutdown sequence.
+    if (isMainThread())
         return;
 
     Data* data = static_cast<Data*>(ptr);
 
 #if OS(POSIX)
     // We want get() to keep working while data destructor works, because it can be called indirectly by the destructor.
     // Some pthreads implementations zero out the pointer before calling destroy(), so we temporarily reset it.
     pthread_setspecific(data->owner->m_key, ptr);
 #endif
 
@@ skipping 20 matching lines @@
 template<typename T>
 inline ThreadSpecific<T>::operator T*()
 {
     T* ptr = static_cast<T*>(get());
     if (!ptr) {
         // Set up thread-specific value's memory pointer before invoking constructor, in case any function it calls
         // needs to access the value, to avoid recursion.
         ptr = static_cast<T*>(Partitions::fastZeroedMalloc(sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T)));
         set(ptr);
         new (NotNull, ptr) T;
+        __lsan_register_root_region(ptr, sizeof(T));
     }
     return ptr;
 }
 
 template<typename T>
 inline T* ThreadSpecific<T>::operator->()
 {
     return operator T*();
 }
 
 template<typename T>
 inline T& ThreadSpecific<T>::operator*()
 {
     return *operator T*();
 }
 
 } // namespace WTF
 
 using WTF::ThreadSpecific;
 
 #endif // WTF_ThreadSpecific_h