Replace ASSERTs in platform/heap/ with DCHECKs

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"
 #include "wtf/Assertions.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/ThreadingPrimitives.h"
 #include <memory>
 
 namespace blink {
 
 class CrossThreadPersistentRegion;
 
 class PersistentNode final {
   DISALLOW_NEW();
 
  public:
-  PersistentNode() : m_self(nullptr), m_trace(nullptr) { ASSERT(isUnused()); }
+  PersistentNode() : m_self(nullptr), m_trace(nullptr) { DCHECK(isUnused()); }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   ~PersistentNode() {
     // If you hit this assert, it means that the thread finished
     // without clearing persistent handles that the thread created.
     // We don't enable the assert for the main thread because the
     // main thread finishes without clearing all persistent handles.
-    ASSERT(isMainThread() || isUnused());
+    DCHECK(isMainThread() || isUnused());
   }
 #endif
 
   // It is dangerous to copy the PersistentNode because it breaks the
   // free list.
   PersistentNode& operator=(const PersistentNode& otherref) = delete;
 
   // Ideally the trace method should be virtual and automatically dispatch
   // to the most specific implementation. However having a virtual method
   // on PersistentNode leads to too eager template instantiation with MSVC
   // which leads to include cycles.
   // Instead we call the constructor with a TraceCallback which knows the
   // type of the most specific child and calls trace directly. See
   // TraceMethodDelegate in Visitor.h for how this is done.
   void tracePersistentNode(Visitor* visitor) {
-    ASSERT(!isUnused());
-    ASSERT(m_trace);
+    DCHECK(!isUnused());
+    DCHECK(m_trace);
     m_trace(visitor, m_self);
   }
 
   void initialize(void* self, TraceCallback trace) {
-    ASSERT(isUnused());
+    DCHECK(isUnused());
     m_self = self;
     m_trace = trace;
   }
 
   void setFreeListNext(PersistentNode* node) {
-    ASSERT(!node || node->isUnused());
+    DCHECK(!node || node->isUnused());
     m_self = node;
     m_trace = nullptr;
-    ASSERT(isUnused());
+    DCHECK(isUnused());
   }
 
   PersistentNode* freeListNext() {
-    ASSERT(isUnused());
+    DCHECK(isUnused());
     PersistentNode* node = reinterpret_cast<PersistentNode*>(m_self);
-    ASSERT(!node || node->isUnused());
+    DCHECK(!node || node->isUnused());
     return node;
   }
 
   bool isUnused() const { return !m_trace; }
 
   void* self() const { return m_self; }
 
  private:
   // If this PersistentNode is in use:
   //   - m_self points to the corresponding Persistent handle.
@@ skipping 34 matching lines @@
   {
   }
   ~PersistentRegion();
 
   PersistentNode* allocatePersistentNode(void* self, TraceCallback trace) {
 #if DCHECK_IS_ON()
     ++m_persistentCount;
 #endif
     if (UNLIKELY(!m_freeListHead))
       ensurePersistentNodeSlots(self, trace);
-    ASSERT(m_freeListHead);
+    DCHECK(m_freeListHead);
     PersistentNode* node = m_freeListHead;
     m_freeListHead = m_freeListHead->freeListNext();
     node->initialize(self, trace);
-    ASSERT(!node->isUnused());
+    DCHECK(!node->isUnused());
     return node;
   }
 
   void freePersistentNode(PersistentNode* persistentNode) {
 #if DCHECK_IS_ON()
     DCHECK_GT(m_persistentCount, 0);
 #endif
     persistentNode->setFreeListNext(m_freeListHead);
     m_freeListHead = persistentNode;
 #if DCHECK_IS_ON()
@@ skipping 68 matching lines @@
       m_persistentRegion.lock();
     }
     ~LockScope() { m_persistentRegion.unlock(); }
 
    private:
     CrossThreadPersistentRegion& m_persistentRegion;
   };
 
   void tracePersistentNodes(Visitor* visitor) {
 // If this assert triggers, you're tracing without being in a LockScope.
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     DCHECK(m_mutex.locked());
 #endif
     m_persistentRegion->tracePersistentNodes(
         visitor, CrossThreadPersistentRegion::shouldTracePersistentNode);
   }
 
   void prepareForThreadStateTermination(ThreadState*);
 
   NO_SANITIZE_ADDRESS
   static bool shouldTracePersistentNode(Visitor*, PersistentNode*);
@@ skipping 17 matching lines @@
   // 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