Replace ASSERTs in platform/heap/ with DCHECKs

third_party/WebKit/Source/platform/heap/HeapTest.cpp

 /*
  * Copyright (C) 2013 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 120 matching lines @@
 
 typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper>> StrongWeakPair;
 
 struct PairWithWeakHandling : public StrongWeakPair {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   // Regular constructor.
   PairWithWeakHandling(IntWrapper* one, IntWrapper* two)
       : StrongWeakPair(one, two) {
-    ASSERT(one);  // We use null first field to indicate empty slots in the hash
+    DCHECK(one);  // We use null first field to indicate empty slots in the hash
                   // table.
   }
 
   // The HashTable (via the HashTrait) calls this constructor with a
   // placement new to mark slots in the hash table as being deleted. We will
   // never call trace or the destructor on these slots. We mark ourselves
   // deleted
   // with a pointer to -1 in the first field.
   PairWithWeakHandling(WTF::HashTableDeletedValueType)
       : StrongWeakPair(reinterpret_cast<IntWrapper*>(-1), nullptr) {}
@@ skipping 122 matching lines @@
 }  // namespace WTF
 
 namespace blink {
 
 class TestGCScope {
  public:
   explicit TestGCScope(BlinkGC::StackState state)
       : m_state(ThreadState::current()),
         m_safePointScope(state),
         m_parkedAllThreads(false) {
-    ASSERT(m_state->checkThread());
+    DCHECK(m_state->checkThread());
     if (LIKELY(m_state->heap().park())) {
       m_state->heap().preGC();
       m_parkedAllThreads = true;
     }
   }
 
   bool allThreadsParked() { return m_parkedAllThreads; }
 
   ~TestGCScope() {
     // Only cleanup if we parked all threads in which case the GC happened
@@ skipping 26 matching lines @@
       : Visitor(state, Visitor::ThreadLocalMarking),
         m_scope(&state->heap().stackFrameDepth()),
         m_count(0) {}
 
   void mark(const void* object, TraceCallback) override {
     if (object)
       m_count++;
   }
 
   void markHeader(HeapObjectHeader* header, TraceCallback callback) override {
-    ASSERT(header->payload());
+    DCHECK(header->payload());
     m_count++;
   }
 
   void registerDelayedMarkNoTracing(const void*) override {}
   void registerWeakMembers(const void*, const void*, WeakCallback) override {}
   void registerWeakTable(const void*,
                          EphemeronCallback,
                          EphemeronCallback) override {}
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   bool weakTableRegistered(const void*) override { return false; }
 #endif
   void registerWeakCellWithCallback(void**, WeakCallback) override {}
   bool ensureMarked(const void* objectPointer) override {
     if (!objectPointer ||
         HeapObjectHeader::fromPayload(objectPointer)->isMarked())
       return false;
     markNoTracing(objectPointer);
     return true;
   }
@@ skipping 180 matching lines @@
 const int ThreadedTesterBase::numberOfThreads;
 
 class ThreadedHeapTester : public ThreadedTesterBase {
  public:
   static void test() { ThreadedTesterBase::test(new ThreadedHeapTester); }
 
   ~ThreadedHeapTester() override {
     // Verify that the threads cleared their CTPs when
     // terminating, preventing access to a finalized heap.
     for (auto& globalIntWrapper : m_crossPersistents) {
-      ASSERT(globalIntWrapper.get());
+      DCHECK(globalIntWrapper.get());
       EXPECT_FALSE(globalIntWrapper.get()->get());
     }
   }
 
  protected:
   using GlobalIntWrapperPersistent = CrossThreadPersistent<IntWrapper>;
 
   Mutex m_mutex;
   Vector<std::unique_ptr<GlobalIntWrapperPersistent>> m_crossPersistents;
 
@@ skipping 403 matching lines @@
     : public GarbageCollectedFinalized<RefCountedAndGarbageCollected> {
  public:
   static RefCountedAndGarbageCollected* create() {
     return new RefCountedAndGarbageCollected;
   }
 
   ~RefCountedAndGarbageCollected() { ++s_destructorCalls; }
 
   void ref() {
     if (UNLIKELY(!m_refCount)) {
-      ASSERT(ThreadState::current()->findPageFromAddress(
+      DCHECK(ThreadState::current()->findPageFromAddress(
           reinterpret_cast<Address>(this)));
       m_keepAlive = this;
     }
     ++m_refCount;
   }
 
   void deref() {
-    ASSERT(m_refCount > 0);
+    DCHECK_GT(m_refCount, 0);
     if (!--m_refCount)
       m_keepAlive.clear();
   }
 
   DEFINE_INLINE_TRACE() {}
 
   static int s_destructorCalls;
 
  private:
   RefCountedAndGarbageCollected() : m_refCount(0) {}
 
   int m_refCount;
   SelfKeepAlive<RefCountedAndGarbageCollected> m_keepAlive;
 };
 
 int RefCountedAndGarbageCollected::s_destructorCalls = 0;
 
 class RefCountedAndGarbageCollected2
     : public HeapTestOtherSuperClass,
       public GarbageCollectedFinalized<RefCountedAndGarbageCollected2> {
  public:
   static RefCountedAndGarbageCollected2* create() {
     return new RefCountedAndGarbageCollected2;
   }
 
   ~RefCountedAndGarbageCollected2() { ++s_destructorCalls; }
 
   void ref() {
     if (UNLIKELY(!m_refCount)) {
-      ASSERT(ThreadState::current()->findPageFromAddress(
+      DCHECK(ThreadState::current()->findPageFromAddress(
           reinterpret_cast<Address>(this)));
       m_keepAlive = this;
     }
     ++m_refCount;
   }
 
   void deref() {
-    ASSERT(m_refCount > 0);
+    DCHECK_GT(m_refCount, 0);
     if (!--m_refCount)
       m_keepAlive.clear();
   }
 
   DEFINE_INLINE_TRACE() {}
 
   static int s_destructorCalls;
 
  private:
   RefCountedAndGarbageCollected2() : m_refCount(0) {}
@@ skipping 267 matching lines @@
     s_didCallWillFinalize = true;
   }
 
   static ObserverMap& observe(Observable& target) {
     ObserverMap& map = observers();
     ObserverMap::AddResult result = map.add(&target, nullptr);
     if (result.isNewEntry) {
       result.storedValue->value =
           WTF::makeUnique<FinalizationObserverWithHashMap>(target);
     } else {
-      ASSERT(result.storedValue->value);
+      DCHECK(result.storedValue->value);
     }
     return map;
   }
 
   static void clearObservers() {
     delete s_observerMap;
     s_observerMap = nullptr;
   }
 
   static bool s_didCallWillFinalize;
@@ skipping 515 matching lines @@
         SimpleFinalizedObject::create();
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
     preciselyCollectGarbage();
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
   }
 
   preciselyCollectGarbage();
   EXPECT_EQ(1, SimpleFinalizedObject::s_destructorCalls);
 }
 
-#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
+#if DCHECK_IS_ON() || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
 TEST(HeapTest, FreelistReuse) {
   clearOutOldGarbage();
 
   for (int i = 0; i < 100; i++)
     new IntWrapper(i);
   IntWrapper* p1 = new IntWrapper(100);
   preciselyCollectGarbage();
   // In non-production builds, we delay reusing freed memory for at least
   // one GC cycle.
   for (int i = 0; i < 100; i++) {
@@ skipping 204 matching lines @@
     EXPECT_EQ(1u, Bar::s_live);
   }
   preciselyCollectGarbage();
   EXPECT_EQ(0u, Bar::s_live);
 }
 
 TEST(HeapTest, MarkTest) {
   {
     Bar::s_live = 0;
     Persistent<Bar> bar = Bar::create();
-    ASSERT(ThreadState::current()->findPageFromAddress(bar));
+    DCHECK(ThreadState::current()->findPageFromAddress(bar));
     EXPECT_EQ(1u, Bar::s_live);
     {
       Foo* foo = Foo::create(bar);
-      ASSERT(ThreadState::current()->findPageFromAddress(foo));
+      DCHECK(ThreadState::current()->findPageFromAddress(foo));
       EXPECT_EQ(2u, Bar::s_live);
       EXPECT_TRUE(reinterpret_cast<Address>(foo) !=
                   reinterpret_cast<Address>(bar.get()));
       conservativelyCollectGarbage();
       EXPECT_TRUE(foo != bar);  // To make sure foo is kept alive.
       EXPECT_EQ(2u, Bar::s_live);
     }
     preciselyCollectGarbage();
     EXPECT_EQ(1u, Bar::s_live);
   }
   preciselyCollectGarbage();
   EXPECT_EQ(0u, Bar::s_live);
 }
 
 TEST(HeapTest, DeepTest) {
   const unsigned depth = 100000;
   Bar::s_live = 0;
   {
     Bar* bar = Bar::create();
-    ASSERT(ThreadState::current()->findPageFromAddress(bar));
+    DCHECK(ThreadState::current()->findPageFromAddress(bar));
     Foo* foo = Foo::create(bar);
-    ASSERT(ThreadState::current()->findPageFromAddress(foo));
+    DCHECK(ThreadState::current()->findPageFromAddress(foo));
     EXPECT_EQ(2u, Bar::s_live);
     for (unsigned i = 0; i < depth; i++) {
       Foo* foo2 = Foo::create(foo);
       foo = foo2;
-      ASSERT(ThreadState::current()->findPageFromAddress(foo));
+      DCHECK(ThreadState::current()->findPageFromAddress(foo));
     }
     EXPECT_EQ(depth + 2, Bar::s_live);
     conservativelyCollectGarbage();
     EXPECT_TRUE(foo != bar);  // To make sure foo and bar are kept alive.
     EXPECT_EQ(depth + 2, Bar::s_live);
   }
   preciselyCollectGarbage();
   EXPECT_EQ(0u, Bar::s_live);
 }
 
@@ skipping 122 matching lines @@
   ThreadHeap& heap = ThreadState::current()->heap();
   clearOutOldGarbage();
   size_t initialObjectPayloadSize = heap.objectPayloadSizeForTesting();
   size_t initialAllocatedSpace = heap.heapStats().allocatedSpace();
   IntWrapper::s_destructorCalls = 0;
   LargeHeapObject::s_destructorCalls = 0;
   {
     int slack =
         8;  // LargeHeapObject points to an IntWrapper that is also allocated.
     Persistent<LargeHeapObject> object = LargeHeapObject::create();
-    ASSERT(ThreadState::current()->findPageFromAddress(object));
-    ASSERT(ThreadState::current()->findPageFromAddress(
+    DCHECK(ThreadState::current()->findPageFromAddress(object));
+    DCHECK(ThreadState::current()->findPageFromAddress(
         reinterpret_cast<char*>(object.get()) + sizeof(LargeHeapObject) - 1));
     clearOutOldGarbage();
     size_t afterAllocation = heap.heapStats().allocatedSpace();
     {
       object->set(0, 'a');
       EXPECT_EQ('a', object->get(0));
       object->set(object->length() - 1, 'b');
       EXPECT_EQ('b', object->get(object->length() - 1));
       size_t expectedLargeHeapObjectPayloadSize =
           ThreadHeap::allocationSizeFromSize(sizeof(LargeHeapObject));
@@ skipping 1366 matching lines @@
               if (deleteAfterwards)
                 EXPECT_EQ(i,
                           strongWeak->take(keepNumbersAlive[i + 1])->value());
             } else if (collectionNumber == weakWeakIndex) {
               if (deleteAfterwards)
                 EXPECT_EQ(i + 1, weakWeak->take(keepNumbersAlive[i])->value());
             }
             if (!deleteAfterwards)
               count++;
           } else if (collectionNumber == weakSetIndex && firstAlive) {
-            ASSERT_TRUE(weakSet->contains(keepNumbersAlive[i]));
+            DCHECK(weakSet->contains(keepNumbersAlive[i]));
             if (deleteAfterwards)
               weakSet->remove(keepNumbersAlive[i]);
             else
               count++;
           } else if (collectionNumber == weakOrderedSetIndex && firstAlive) {
-            ASSERT_TRUE(weakOrderedSet->contains(keepNumbersAlive[i]));
+            DCHECK(weakOrderedSet->contains(keepNumbersAlive[i]));
             if (deleteAfterwards)
               weakOrderedSet->remove(keepNumbersAlive[i]);
             else
               count++;
           }
         }
         if (addAfterwards) {
           for (int i = 1000; i < 1100; i++) {
             IntWrapper* wrapped = IntWrapper::create(i);
             keepNumbersAlive.append(wrapped);
@@ skipping 54 matching lines @@
   set.add(new IntWrapper(1));
   set.add(new IntWrapper(2));
 
   copyToVector(set, vector);
   EXPECT_EQ(3u, vector.size());
 
   Vector<int> intVector;
   for (const auto& i : vector)
     intVector.append(i->value());
   std::sort(intVector.begin(), intVector.end());
-  ASSERT_EQ(3u, intVector.size());
+  DCHECK_EQ(3u, intVector.size());
   EXPECT_EQ(1, intVector[0]);
   EXPECT_EQ(1, intVector[1]);
   EXPECT_EQ(2, intVector[2]);
 }
 
 TEST(HeapTest, WeakHeapHashCountedSetToVector) {
   HeapHashCountedSet<WeakMember<IntWrapper>> set;
   HeapVector<Member<IntWrapper>> vector;
   set.add(new IntWrapper(1));
   set.add(new IntWrapper(1));
@@ skipping 100 matching lines @@
   EXPECT_EQ(1, RefCountedAndGarbageCollected2::s_destructorCalls);
 }
 
 TEST(HeapTest, WeakMembers) {
   Bar::s_live = 0;
   {
     Persistent<Bar> h1 = Bar::create();
     Persistent<Weak> h4;
     Persistent<WithWeakMember> h5;
     preciselyCollectGarbage();
-    ASSERT_EQ(1u, Bar::s_live);  // h1 is live.
+    DCHECK_EQ(1u, Bar::s_live);  // h1 is live.
     {
       Bar* h2 = Bar::create();
       Bar* h3 = Bar::create();
       h4 = Weak::create(h2, h3);
       h5 = WithWeakMember::create(h2, h3);
       conservativelyCollectGarbage();
       EXPECT_EQ(5u, Bar::s_live);  // The on-stack pointer keeps h3 alive.
       EXPECT_FALSE(h3->hasBeenFinalized());
       EXPECT_TRUE(h4->strongIsThere());
       EXPECT_TRUE(h4->weakIsThere());
@@ skipping 1843 matching lines @@
 TEST(HeapTest, ThreadedStrongification) {
   ThreadedStrongificationTester::test();
 }
 
 static bool allocateAndReturnBool() {
   conservativelyCollectGarbage();
   return true;
 }
 
 static bool checkGCForbidden() {
-  ASSERT(ThreadState::current()->isGCForbidden());
+  DCHECK(ThreadState::current()->isGCForbidden());
   return true;
 }
 
 class MixinClass : public GarbageCollectedMixin {
  public:
   MixinClass() : m_dummy(checkGCForbidden()) {}
 
  private:
   bool m_dummy;
 };
@@ skipping 438 matching lines @@
   static int sTraceLazy;
 };
 
 int DeepEagerly::sTraceCalls = 0;
 int DeepEagerly::sTraceLazy = 0;
 
 TEST(HeapTest, TraceDeepEagerly) {
 // The allocation & GC overhead is considerable for this test,
 // straining debug builds and lower-end targets too much to be
 // worth running.
-#if !ENABLE(ASSERT) && !OS(ANDROID)
+#if !DCHECK_IS_ON() && !OS(ANDROID)
   DeepEagerly* obj = nullptr;
   for (int i = 0; i < 10000000; i++)
     obj = new DeepEagerly(obj);
 
   Persistent<DeepEagerly> persistent(obj);
   preciselyCollectGarbage();
 
   // Verify that the DeepEagerly chain isn't completely unravelled
   // by performing eager trace() calls, but the explicit mark
   // stack is switched once some nesting limit is exceeded.
@@ skipping 189 matching lines @@
   // Disable ASan, otherwise its stack checking (use-after-return) will
   // confuse the direction check.
   static char* previous = nullptr;
   char dummy;
   if (!previous) {
     previous = &dummy;
     GrowthDirection result = stackGrowthDirection();
     previous = nullptr;
     return result;
   }
-  ASSERT(&dummy != previous);
+  DCHECK_NE(&dummy, previous);
   return &dummy < previous ? GrowsTowardsLower : GrowsTowardsHigher;
 }
 
 }  // namespace
 
 TEST(HeapTest, StackGrowthDirection) {
   // The implementation of marking probes stack usage as it runs,
   // and has a builtin assumption that the stack grows towards
   // lower addresses.
   EXPECT_EQ(GrowsTowardsLower, stackGrowthDirection());
 }
 
 class TestMixinAllocationA : public GarbageCollected<TestMixinAllocationA>,
                              public GarbageCollectedMixin {
   USING_GARBAGE_COLLECTED_MIXIN(TestMixinAllocationA);
 
  public:
   TestMixinAllocationA() {
     // Completely wrong in general, but test only
     // runs this constructor while constructing another mixin.
-    ASSERT(ThreadState::current()->isGCForbidden());
+    DCHECK(ThreadState::current()->isGCForbidden());
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {}
 };
 
 class TestMixinAllocationB : public TestMixinAllocationA {
   USING_GARBAGE_COLLECTED_MIXIN(TestMixinAllocationB);
 
  public:
   TestMixinAllocationB()
       : m_a(new TestMixinAllocationA())  // Construct object during a mixin
                                          // construction.
   {
     // Completely wrong in general, but test only
     // runs this constructor while constructing another mixin.
-    ASSERT(ThreadState::current()->isGCForbidden());
+    DCHECK(ThreadState::current()->isGCForbidden());
   }
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_a);
     TestMixinAllocationA::trace(visitor);
   }
 
  private:
   Member<TestMixinAllocationA> m_a;
 };
 
 class TestMixinAllocationC final : public TestMixinAllocationB {
   USING_GARBAGE_COLLECTED_MIXIN(TestMixinAllocationC);
 
  public:
-  TestMixinAllocationC() { ASSERT(!ThreadState::current()->isGCForbidden()); }
+  TestMixinAllocationC() { DCHECK(!ThreadState::current()->isGCForbidden()); }
 
   DEFINE_INLINE_TRACE() { TestMixinAllocationB::trace(visitor); }
 };
 
 TEST(HeapTest, NestedMixinConstruction) {
   TestMixinAllocationC* object = new TestMixinAllocationC();
   EXPECT_TRUE(object);
 }
 
 class ObjectWithLargeAmountsOfAllocationInConstructor {
  public:
   ObjectWithLargeAmountsOfAllocationInConstructor(
       size_t numberOfLargeObjectsToAllocate,
       ClassWithMember* member) {
     // Should a constructor allocate plenty in its constructor,
     // and it is a base of GC mixin, GCs will remain locked out
     // regardless, as we cannot safely trace the leftmost GC
     // mixin base.
-    ASSERT(ThreadState::current()->isGCForbidden());
+    DCHECK(ThreadState::current()->isGCForbidden());
     for (size_t i = 0; i < numberOfLargeObjectsToAllocate; i++) {
       LargeHeapObject* largeObject = LargeHeapObject::create();
       EXPECT_TRUE(largeObject);
       EXPECT_EQ(0, member->traceCount());
     }
   }
 };
 
 class TestMixinAllocatingObject final
     : public TestMixinAllocationB,
       public ObjectWithLargeAmountsOfAllocationInConstructor {
   USING_GARBAGE_COLLECTED_MIXIN(TestMixinAllocatingObject);
 
  public:
   static TestMixinAllocatingObject* create(ClassWithMember* member) {
     return new TestMixinAllocatingObject(member);
   }
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_traceCounter);
     TestMixinAllocationB::trace(visitor);
   }
 
   int traceCount() const { return m_traceCounter->traceCount(); }
 
  private:
   TestMixinAllocatingObject(ClassWithMember* member)
       : ObjectWithLargeAmountsOfAllocationInConstructor(600, member),
         m_traceCounter(TraceCounter::create()) {
-    ASSERT(!ThreadState::current()->isGCForbidden());
+    DCHECK(!ThreadState::current()->isGCForbidden());
     conservativelyCollectGarbage();
     EXPECT_GT(member->traceCount(), 0);
     EXPECT_GT(traceCount(), 0);
   }
 
   Member<TraceCounter> m_traceCounter;
 };
 
 TEST(HeapTest, MixinConstructionNoGC) {
   Persistent<ClassWithMember> object = ClassWithMember::create();
@@ skipping 63 matching lines @@
   std::unique_ptr<WebThread> workerThread =
       WTF::wrapUnique(Platform::current()->createThread("Test Worker Thread"));
   DestructorLockingObject* object = nullptr;
   workerThread->getWebTaskRunner()->postTask(
       BLINK_FROM_HERE,
       crossThreadBind(workerThreadMainForCrossThreadWeakPersistentTest,
                       crossThreadUnretained(&object)));
   parkMainThread();
 
   // Step 3: Set up a CrossThreadWeakPersistent.
-  ASSERT_TRUE(object);
+  DCHECK(object);
   CrossThreadWeakPersistent<DestructorLockingObject> crossThreadWeakPersistent(
       object);
   object = nullptr;
   {
     SafePointAwareMutexLocker recursiveMutexLocker(recursiveMutex());
     EXPECT_EQ(0, DestructorLockingObject::s_destructorCalls);
   }
 
   {
     // Pretend we have no pointers on stack during the step 4.
@@ skipping 251 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink