Unpoison CrossThreadPersistents

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

 // Copyright 2015 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 PersistentNode_h
 #define PersistentNode_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/ThreadState.h"
 #include "wtf/Allocator.h"
@@ skipping 89 matching lines @@
 // holds a linked list of PersistentNodeSlots, each of which stores
 // a predefined number of PersistentNodes. You can call allocatePersistentNode/
 // freePersistentNode to allocate/free a PersistentNode on the region.
 class PLATFORM_EXPORT PersistentRegion final {
   USING_FAST_MALLOC(PersistentRegion);
 
  public:
   PersistentRegion()
       : m_freeListHead(nullptr),
         m_slots(nullptr)
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
         ,
         m_persistentCount(0)
 #endif
   {
   }
   ~PersistentRegion();
 
   PersistentNode* allocatePersistentNode(void* self, TraceCallback trace) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     ++m_persistentCount;
 #endif
     if (UNLIKELY(!m_freeListHead))
       ensurePersistentNodeSlots(self, trace);
     ASSERT(m_freeListHead);
     PersistentNode* node = m_freeListHead;
     m_freeListHead = m_freeListHead->freeListNext();
     node->initialize(self, trace);
     ASSERT(!node->isUnused());
     return node;
   }
 
   void freePersistentNode(PersistentNode* persistentNode) {
     ASSERT(m_persistentCount > 0);
     persistentNode->setFreeListNext(m_freeListHead);
     m_freeListHead = persistentNode;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     --m_persistentCount;
 #endif
   }
 
   static bool shouldTracePersistentNode(Visitor*, PersistentNode*) {
     return true;
   }
 
   void releasePersistentNode(PersistentNode*,
                              ThreadState::PersistentClearCallback);
   using ShouldTraceCallback = bool (*)(Visitor*, PersistentNode*);
   void tracePersistentNodes(
       Visitor*,
       ShouldTraceCallback = PersistentRegion::shouldTracePersistentNode);
   int numberOfPersistents();
 
  private:
   friend CrossThreadPersistentRegion;
 
   void ensurePersistentNodeSlots(void*, TraceCallback);
 
   PersistentNode* m_freeListHead;
   PersistentNodeSlots* m_slots;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   int m_persistentCount;
 #endif
 };
 
 class CrossThreadPersistentRegion final {
   USING_FAST_MALLOC(CrossThreadPersistentRegion);
 
  public:
   CrossThreadPersistentRegion()
       : m_persistentRegion(wrapUnique(new PersistentRegion)) {}
@@ skipping 46 matching lines @@
 #endif
     m_persistentRegion->tracePersistentNodes(
         visitor, CrossThreadPersistentRegion::shouldTracePersistentNode);
   }
 
   void prepareForThreadStateTermination(ThreadState*);
 
   NO_SANITIZE_ADDRESS
   static bool shouldTracePersistentNode(Visitor*, PersistentNode*);
 
+#if defined(ADDRESS_SANITIZER)
+  void unpoisonCrossThreadPersistents();
+#endif
+
  private:
   friend class LockScope;
 
   void lock() { m_mutex.lock(); }
 
   void unlock() { m_mutex.unlock(); }
 
   // We don't make CrossThreadPersistentRegion inherit from PersistentRegion
   // because we don't want to virtualize performance-sensitive methods
   // such as PersistentRegion::allocate/freePersistentNode.
   std::unique_ptr<PersistentRegion> m_persistentRegion;
 
   // Recursive as prepareForThreadStateTermination() clears a PersistentNode's
   // associated Persistent<> -- it in turn freeing the PersistentNode. And both
   // CrossThreadPersistentRegion operations need a lock on the region before
   // mutating.
   RecursiveMutex m_mutex;
 };
 
 }  // namespace blink
 
 #endif