Lend LSan a hand and clear out singleton static persistents first.

third_party/WebKit/Source/platform/heap/Persistent.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef Persistent_h
 #define Persistent_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/Member.h"
 #include "platform/heap/PersistentNode.h"
@@ skipping 15 matching lines @@
 enum WeaknessPersistentConfiguration {
   NonWeakPersistentConfiguration,
   WeakPersistentConfiguration
 };
 
 enum CrossThreadnessPersistentConfiguration {
   SingleThreadPersistentConfiguration,
   CrossThreadPersistentConfiguration
 };
 
+// Auxillary template, probing if |void T::clear()| exists and is accessible.
+// Used to conditionally clear the contents of a static persistent.
+template <typename T>
+class CanClearPersistentReference {
+  typedef char YesType;
+  typedef struct NoType { char padding[8]; } NoType;
+
+  // Check if class T has public method "void clear()".
+  template <typename V>
+  static YesType checkHasClearMethod(
+      V* p,
+      typename std::enable_if<
+      std::is_same<decltype(p->clear()), void>::value>::type* = nullptr);
+  template <typename V>
+  static NoType checkHasClearMethod(...);
+
+ public:
+  static const bool value =
+      sizeof(YesType) + sizeof(T) ==
+      sizeof(checkHasClearMethod<T>(nullptr)) + sizeof(T);
+};
+
+template <typename T, bool = CanClearPersistentReference<T>::value>
+class ClearStaticPersistentReference {
+ public:
+  static void clear(T*) {}
+};
+
+template <typename T>
+class ClearStaticPersistentReference<T, true> {
+ public:
+  static void clear(T* ptr) { ptr->clear(); }
+};
+
 template <typename T,
           WeaknessPersistentConfiguration weaknessConfiguration,
           CrossThreadnessPersistentConfiguration crossThreadnessConfiguration>
 class PersistentBase {
   USING_FAST_MALLOC(PersistentBase);
   IS_PERSISTENT_REFERENCE_TYPE();
 
  public:
   PersistentBase() : m_raw(nullptr) {
     saveCreationThreadHeap();
@@ skipping 104 matching lines @@
   // belonging to the current thread and a persistent that must
   // be cleared when the ThreadState itself is cleared out and
   // destructed.
   //
   // Static singletons arrange for this to happen, either to ensure
   // clean LSan leak reports or to register a thread-local persistent
   // needing to be cleared out before the thread is terminated.
   PersistentBase* registerAsStaticReference() {
     if (m_persistentNode) {
       ASSERT(ThreadState::current());
-      ThreadState::current()->registerStaticPersistentNode(m_persistentNode,
-                                                           nullptr);
+      ThreadState::current()->registerStaticPersistentNode(
+          m_persistentNode, &PersistentBase::clearPersistentNode);
       LEAK_SANITIZER_IGNORE_OBJECT(this);
     }
     return this;
   }
 
  protected:
   NO_SANITIZE_ADDRESS
   T* atomicGet() {
     return reinterpret_cast<T*>(acquireLoad(reinterpret_cast<void* volatile*>(
         const_cast<typename std::remove_const<T>::type**>(&m_raw))));
@@ skipping 12 matching lines @@
     }
     checkPointer();
     if (m_raw) {
       if (!m_persistentNode)
         initialize();
       return;
     }
     uninitialize();
   }
 
+  // Used when the registered PersistentNode of this object is
+  // released during ThreadState shutdown, clearing the association.
+  static void clearPersistentNode(void* self,
+                                  ThreadState::ReleasePersistentMode mode) {
+    PersistentBase* persistent =
+        (reinterpret_cast<PersistentBase*>(self));
+    ClearStaticPersistentReference<T>::clear(persistent->get());
+    if (mode == ThreadState::ReleasePersistent)
+      persistent->uninitialize();
+  }
+
   template <typename VisitorDispatcher>
   void tracePersistent(VisitorDispatcher visitor) {
     static_assert(sizeof(T), "T must be fully defined");
     static_assert(IsGarbageCollectedType<T>::value,
                   "T needs to be a garbage collected object");
     if (weaknessConfiguration == WeakPersistentConfiguration) {
       if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration)
         visitor->registerWeakCellWithCallback(reinterpret_cast<void**>(this),
                                               handleWeakPersistent);
       else
@@ skipping 389 matching lines @@
 
  private:
   template <typename VisitorDispatcher>
   void tracePersistent(VisitorDispatcher visitor) {
     static_assert(sizeof(Collection), "Collection must be fully defined");
     visitor->trace(*static_cast<Collection*>(this));
   }
 
   // Used when the registered PersistentNode of this object is
   // released during ThreadState shutdown, clearing the association.
-  static void clearPersistentNode(void* self) {
+  static void clearPersistentNode(void* self,
+                                  ThreadState::ReleasePersistentMode mode) {
     PersistentHeapCollectionBase<Collection>* collection =
         (reinterpret_cast<PersistentHeapCollectionBase<Collection>*>(self));
-    collection->uninitialize();
     collection->clear();
+    if (mode == ThreadState::ReleasePersistent)
+      collection->uninitialize();
   }
 
   NO_SANITIZE_ADDRESS
   void initialize() {
     // FIXME: Derive affinity based on the collection.
     ThreadState* state = ThreadState::current();
     ASSERT(state->checkThread());
     m_persistentNode = state->getPersistentRegion()->allocatePersistentNode(
         this,
         TraceMethodDelegate<PersistentHeapCollectionBase<Collection>,
@@ skipping 202 matching lines @@
   static blink::CrossThreadPersistent<T> Unwrap(
       const blink::CrossThreadWeakPersistent<T>& wrapped) {
     blink::CrossThreadPersistentRegion::LockScope persistentLock(
         blink::ProcessHeap::crossThreadPersistentRegion());
     return blink::CrossThreadPersistent<T>(wrapped.get());
   }
 };
 }
 
 #endif  // Persistent_h