Replace ASSERT with DHCECK_op in platform/heap

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 148 matching lines @@
   // Register the persistent node as a 'static reference',
   // 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 (persistent_node_) {
-      ASSERT(ThreadState::Current());
+      DCHECK(ThreadState::Current());
       ThreadState::Current()->RegisterStaticPersistentNode(persistent_node_,
                                                            nullptr);
       LEAK_SANITIZER_IGNORE_OBJECT(this);
     }
     return this;
   }
 
  protected:
   NO_SANITIZE_ADDRESS
   T* AtomicGet() {
@@ skipping 27 matching lines @@
                   "T needs to be a garbage collected object");
     if (weaknessConfiguration == kWeakPersistentConfiguration) {
       visitor->RegisterWeakCallback(this, HandleWeakPersistent);
     } else {
       visitor->Mark(raw_);
     }
   }
 
   NO_SANITIZE_ADDRESS
   void Initialize() {
-    ASSERT(!persistent_node_);
+    DCHECK(!persistent_node_);
     if (!raw_ || IsHashTableDeletedValue())
       return;
 
     TraceCallback trace_callback =
         TraceMethodDelegate<PersistentBase,
                             &PersistentBase::TracePersistent>::Trampoline;
     if (crossThreadnessConfiguration == kCrossThreadPersistentConfiguration) {
       ProcessHeap::GetCrossThreadPersistentRegion().AllocatePersistentNode(
           persistent_node_, this, trace_callback);
       return;
     }
     ThreadState* state =
         ThreadStateFor<ThreadingTrait<T>::kAffinity>::GetState();
-    ASSERT(state->CheckThread());
+    DCHECK(state->CheckThread());
     persistent_node_ = state->GetPersistentRegion()->AllocatePersistentNode(
         this, trace_callback);
 #if DCHECK_IS_ON()
     state_ = state;
 #endif
   }
 
   void Uninitialize() {
     if (crossThreadnessConfiguration == kCrossThreadPersistentConfiguration) {
       if (AcquireLoad(reinterpret_cast<void* volatile*>(&persistent_node_)))
         ProcessHeap::GetCrossThreadPersistentRegion().FreePersistentNode(
             persistent_node_);
       return;
     }
 
     if (!persistent_node_)
       return;
     ThreadState* state =
         ThreadStateFor<ThreadingTrait<T>::kAffinity>::GetState();
-    ASSERT(state->CheckThread());
+    DCHECK(state->CheckThread());
     // Persistent handle must be created and destructed in the same thread.
-    ASSERT(state_ == state);
+#if DCHECK_IS_ON()
+    DCHECK_EQ(state_, state);
+#endif
     state->FreePersistentNode(persistent_node_);
     persistent_node_ = nullptr;
   }
 
   void CheckPointer() const {
 #if DCHECK_IS_ON()
     if (!raw_ || IsHashTableDeletedValue())
       return;
 
     if (crossThreadnessConfiguration != kCrossThreadPersistentConfiguration) {
@@ skipping 296 matching lines @@
   PersistentHeapCollectionBase(const OtherCollection& other)
       : Collection(other) {
     Initialize();
   }
 
   ~PersistentHeapCollectionBase() { Uninitialize(); }
 
   // See PersistentBase::registerAsStaticReference() comment.
   PersistentHeapCollectionBase* RegisterAsStaticReference() {
     if (persistent_node_) {
-      ASSERT(ThreadState::Current());
+      DCHECK(ThreadState::Current());
       ThreadState::Current()->RegisterStaticPersistentNode(
           persistent_node_,
           &PersistentHeapCollectionBase<Collection>::ClearPersistentNode);
       LEAK_SANITIZER_IGNORE_OBJECT(this);
     }
     return this;
   }
 
  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) {
     PersistentHeapCollectionBase<Collection>* collection =
         (reinterpret_cast<PersistentHeapCollectionBase<Collection>*>(self));
     collection->Uninitialize();
     collection->Clear();
   }
 
   NO_SANITIZE_ADDRESS
   void Initialize() {
     // FIXME: Derive affinity based on the collection.
     ThreadState* state = ThreadState::Current();
-    ASSERT(state->CheckThread());
+    DCHECK(state->CheckThread());
     persistent_node_ = state->GetPersistentRegion()->AllocatePersistentNode(
         this,
         TraceMethodDelegate<PersistentHeapCollectionBase<Collection>,
                             &PersistentHeapCollectionBase<
                                 Collection>::TracePersistent>::Trampoline);
 #if DCHECK_IS_ON()
     state_ = state;
 #endif
   }
 
   void Uninitialize() {
     if (!persistent_node_)
       return;
     ThreadState* state = ThreadState::Current();
-    ASSERT(state->CheckThread());
+    DCHECK(state->CheckThread());
     // Persistent handle must be created and destructed in the same thread.
-    ASSERT(state_ == state);
+#if DCHECK_IS_ON()
+    DCHECK_EQ(state_, state);
+#endif
     state->FreePersistentNode(persistent_node_);
     persistent_node_ = nullptr;
   }
 
   PersistentNode* persistent_node_;
 #if DCHECK_IS_ON()
   ThreadState* state_;
 #endif
 };
 
@@ skipping 178 matching lines @@
   static blink::CrossThreadPersistent<T> Unwrap(
       const blink::CrossThreadWeakPersistent<T>& wrapped) {
     blink::CrossThreadPersistentRegion::LockScope persistentLock(
         blink::ProcessHeap::GetCrossThreadPersistentRegion());
     return blink::CrossThreadPersistent<T>(wrapped.Get());
   }
 };
 }
 
 #endif  // Persistent_h