Allow assertions to be enabled in Blink Release builds.

Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 185 matching lines @@
         ASSERT(isAlive());
         ASSERT(m_next->isAlive());
         ASSERT(m_prev->isAlive());
         m_next->m_prev = m_prev;
         m_prev->m_next = m_next;
     }
 
 protected:
     inline PersistentBase()
         : PersistentNode(TraceMethodDelegate<Owner, &Owner::trace>::trampoline)
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         , m_roots(RootsAccessor::roots())
 #endif
     {
         typename RootsAccessor::Lock lock;
         m_prev = RootsAccessor::roots();
         m_next = m_prev->m_next;
         m_prev->m_next = this;
         m_next->m_prev = this;
     }
 
     inline explicit PersistentBase(const PersistentBase& otherref)
         : PersistentNode(otherref.m_trace)
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         , m_roots(RootsAccessor::roots())
 #endif
     {
         // We don't support allocation of thread local Persistents while doing
         // thread shutdown/cleanup.
         ASSERT(!ThreadState::current()->isTerminating());
         typename RootsAccessor::Lock lock;
         ASSERT(otherref.m_roots == m_roots); // Handles must belong to the same list.
         PersistentBase* other = const_cast<PersistentBase*>(&otherref);
         m_prev = other;
         m_next = other->m_next;
         other->m_next = this;
         m_next->m_prev = this;
     }
 
     inline PersistentBase& operator=(const PersistentBase& otherref) { return *this; }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 private:
     PersistentNode* m_roots;
 #endif
 };
 
 // A dummy Persistent handle that ensures the list of persistents is never null.
 // This removes a test from a hot path.
 class PersistentAnchor : public PersistentNode {
 public:
     void trace(Visitor* visitor)
@@ skipping 21 matching lines @@
 private:
     PersistentAnchor() : PersistentNode(TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
     {
         m_next = this;
         m_prev = this;
     }
 
     friend class ThreadState;
 };
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     // For global persistent handles we cannot check that the
     // pointer is in the heap because that would involve
     // inspecting the heap of running threads.
 #define ASSERT_IS_VALID_PERSISTENT_POINTER(pointer) \
     bool isGlobalPersistent = WTF::IsSubclass<RootsAccessor, GlobalPersistents>::value; \
     ASSERT(!pointer || isGlobalPersistent || ThreadStateFor<ThreadingTrait<T>::Affinity>::state()->contains(pointer))
 #else
 #define ASSERT_IS_VALID_PERSISTENT_POINTER(pointer)
 #endif
 
@@ skipping 900 matching lines @@
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 template<typename T>
 struct ParamStorageTraits<RawPtr<T> > : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 } // namespace WTF
 
 #endif