Replace ASSERTs in platform/heap/ with DCHECKs

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 138 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 (m_persistentNode) {
-      ASSERT(ThreadState::current());
+      DCHECK(ThreadState::current());
       ThreadState::current()->registerStaticPersistentNode(m_persistentNode,
                                                            nullptr);
       LEAK_SANITIZER_IGNORE_OBJECT(this);
     }
     return this;
   }
 
  protected:
   NO_SANITIZE_ADDRESS
   T* atomicGet() {
@@ skipping 32 matching lines @@
                                               handleWeakPersistent);
       else
         visitor->registerWeakMembers(this, m_raw, handleWeakPersistent);
     } else {
       visitor->mark(m_raw);
     }
   }
 
   NO_SANITIZE_ADDRESS
   void initialize() {
-    ASSERT(!m_persistentNode);
+    DCHECK(!m_persistentNode);
     if (!m_raw || isHashTableDeletedValue())
       return;
 
     TraceCallback traceCallback =
         TraceMethodDelegate<PersistentBase,
                             &PersistentBase::tracePersistent>::trampoline;
     if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
       ProcessHeap::crossThreadPersistentRegion().allocatePersistentNode(
           m_persistentNode, this, traceCallback);
       return;
     }
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
-    ASSERT(state->checkThread());
+    DCHECK(state->checkThread());
     m_persistentNode = state->getPersistentRegion()->allocatePersistentNode(
         this, traceCallback);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     m_state = state;
 #endif
   }
 
   void uninitialize() {
     // TODO(haraken): This is a short-term hack to prevent use-after-frees
     // during a shutdown sequence.
     // 1) blink::shutdown() frees the underlying storage for persistent nodes.
     // 2) ~MessageLoop() destructs some Chromium-side objects that hold
     //    Persistent. It touches the underlying storage and crashes.
     if (WTF::isShutdown())
       return;
 
     if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
       if (acquireLoad(reinterpret_cast<void* volatile*>(&m_persistentNode)))
         ProcessHeap::crossThreadPersistentRegion().freePersistentNode(
             m_persistentNode);
       return;
     }
 
     if (!m_persistentNode)
       return;
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
-    ASSERT(state->checkThread());
+    DCHECK(state->checkThread());
     // Persistent handle must be created and destructed in the same thread.
-    ASSERT(m_state == state);
+    DCHECK(m_state == state);
     state->freePersistentNode(m_persistentNode);
     m_persistentNode = nullptr;
   }
 
   void checkPointer() {
 #if DCHECK_IS_ON()
     if (!m_raw || isHashTableDeletedValue())
       return;
 
     if (crossThreadnessConfiguration != CrossThreadPersistentConfiguration) {
@@ skipping 42 matching lines @@
                        weaknessConfiguration, crossThreadnessConfiguration>;
     Base* persistent = reinterpret_cast<Base*>(persistentPointer);
     T* object = persistent->get();
     if (object && !ObjectAliveTrait<T>::isHeapObjectAlive(object))
       persistent->clear();
   }
 
   // m_raw is accessed most, so put it at the first field.
   T* m_raw;
   PersistentNode* m_persistentNode = nullptr;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   ThreadState* m_state = nullptr;
 #endif
 #if DCHECK_IS_ON()
   const ThreadState* m_creationThreadState;
 #endif
 };
 
 // Persistent is a way to create a strong pointer from an off-heap object
 // to another on-heap object. As long as the Persistent handle is alive
 // the GC will keep the object pointed to alive. The Persistent handle is
@@ skipping 247 matching lines @@
   PersistentHeapCollectionBase(const OtherCollection& other)
       : Collection(other) {
     initialize();
   }
 
   ~PersistentHeapCollectionBase() { uninitialize(); }
 
   // See PersistentBase::registerAsStaticReference() comment.
   PersistentHeapCollectionBase* registerAsStaticReference() {
     if (m_persistentNode) {
-      ASSERT(ThreadState::current());
+      DCHECK(ThreadState::current());
       ThreadState::current()->registerStaticPersistentNode(
           m_persistentNode,
           &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());
     m_persistentNode = state->getPersistentRegion()->allocatePersistentNode(
         this,
         TraceMethodDelegate<PersistentHeapCollectionBase<Collection>,
                             &PersistentHeapCollectionBase<
                                 Collection>::tracePersistent>::trampoline);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     m_state = state;
 #endif
   }
 
   void uninitialize() {
     if (!m_persistentNode)
       return;
     ThreadState* state = ThreadState::current();
-    ASSERT(state->checkThread());
+    DCHECK(state->checkThread());
     // Persistent handle must be created and destructed in the same thread.
-    ASSERT(m_state == state);
+    DCHECK(m_state == state);
     state->freePersistentNode(m_persistentNode);
     m_persistentNode = nullptr;
   }
 
   PersistentNode* m_persistentNode;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   ThreadState* m_state;
 #endif
 };
 
 template <typename KeyArg,
           typename MappedArg,
           typename HashArg = typename DefaultHash<KeyArg>::Hash,
           typename KeyTraitsArg = HashTraits<KeyArg>,
           typename MappedTraitsArg = HashTraits<MappedArg>>
 class PersistentHeapHashMap
@@ skipping 172 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