Replace ENABLE(ASSERT) with DCHECK_IS_ON().

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 207 matching lines @@
                             &PersistentBase::tracePersistent>::trampoline;
     if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
       ProcessHeap::crossThreadPersistentRegion().allocatePersistentNode(
           m_persistentNode, this, traceCallback);
       return;
     }
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
     ASSERT(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.
@@ skipping 68 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
 // always a GC root from the point of view of the GC.
 //
 // We have to construct and destruct Persistent in the same thread.
@@ skipping 279 matching lines @@
   NO_SANITIZE_ADDRESS
   void initialize() {
     // FIXME: Derive affinity based on the collection.
     ThreadState* state = ThreadState::current();
     ASSERT(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());
     // Persistent handle must be created and destructed in the same thread.
     ASSERT(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