Replace ASSERT with DHCECK_op in platform/heap

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 <memory>
 #include "platform/PlatformExport.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/wtf/Allocator.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/ThreadingPrimitives.h"
 
 namespace blink {
 
 class CrossThreadPersistentRegion;
 
 class PersistentNode final {
   DISALLOW_NEW();
 
  public:
-  PersistentNode() : self_(nullptr), trace_(nullptr) { ASSERT(IsUnused()); }
+  PersistentNode() : self_(nullptr), trace_(nullptr) { DCHECK(IsUnused()); }
 
 #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(trace_);
+    DCHECK(!IsUnused());
+    DCHECK(trace_);
     trace_(visitor, self_);
   }
 
   void Initialize(void* self, TraceCallback trace) {
-    ASSERT(IsUnused());
+    DCHECK(IsUnused());
     self_ = self;
     trace_ = trace;
   }
 
   void SetFreeListNext(PersistentNode* node) {
-    ASSERT(!node || node->IsUnused());
+    DCHECK(!node || node->IsUnused());
     self_ = node;
     trace_ = nullptr;
-    ASSERT(IsUnused());
+    DCHECK(IsUnused());
   }
 
   PersistentNode* FreeListNext() {
-    ASSERT(IsUnused());
+    DCHECK(IsUnused());
     PersistentNode* node = reinterpret_cast<PersistentNode*>(self_);
-    ASSERT(!node || node->IsUnused());
+    DCHECK(!node || node->IsUnused());
     return node;
   }
 
   bool IsUnused() const { return !trace_; }
 
   void* Self() const { return 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()
     ++persistent_count_;
 #endif
     if (UNLIKELY(!free_list_head_))
       EnsurePersistentNodeSlots(self, trace);
-    ASSERT(free_list_head_);
+    DCHECK(free_list_head_);
     PersistentNode* node = free_list_head_;
     free_list_head_ = free_list_head_->FreeListNext();
     node->Initialize(self, trace);
-    ASSERT(!node->IsUnused());
+    DCHECK(!node->IsUnused());
     return node;
   }
 
   void FreePersistentNode(PersistentNode* persistent_node) {
 #if DCHECK_IS_ON()
     DCHECK_GT(persistent_count_, 0);
 #endif
     persistent_node->SetFreeListNext(free_list_head_);
     free_list_head_ = persistent_node;
 #if DCHECK_IS_ON()
@@ skipping 106 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 mutex_;
 };
 
 }  // namespace blink
 
 #endif