Replace ASSERT with DHCECK_op in platform/heap

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 164 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 129 matching lines @@
     : public SimpleClassHashTraits<blink::KeyWithCopyingMoveConstructor> {};
 
 }  // namespace WTF
 
 namespace blink {
 
 class TestGCScope {
  public:
   explicit TestGCScope(BlinkGC::StackState state)
       : state_(ThreadState::Current()), safe_point_scope_(state) {
-    ASSERT(state_->CheckThread());
+    DCHECK(state_->CheckThread());
     state_->PreGC();
   }
 
   ~TestGCScope() {
     state_->PostGC(BlinkGC::kGCWithSweep);
     state_->PreSweep(BlinkGC::kGCWithSweep);
   }
 
  private:
   ThreadState* state_;
@@ skipping 165 matching lines @@
 const int ThreadedTesterBase::kNumberOfThreads;
 
 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& global_int_wrapper : cross_persistents_) {
-      ASSERT(global_int_wrapper.get());
+      DCHECK(global_int_wrapper.get());
       EXPECT_FALSE(global_int_wrapper.get()->Get());
     }
   }
 
  protected:
   using GlobalIntWrapperPersistent = CrossThreadPersistent<IntWrapper>;
 
   Mutex mutex_;
   Vector<std::unique_ptr<GlobalIntWrapperPersistent>> cross_persistents_;
 
@@ skipping 398 matching lines @@
     : public GarbageCollectedFinalized<RefCountedAndGarbageCollected> {
  public:
   static RefCountedAndGarbageCollected* Create() {
     return new RefCountedAndGarbageCollected;
   }
 
   ~RefCountedAndGarbageCollected() { ++destructor_calls_; }
 
   void Ref() {
     if (UNLIKELY(!ref_count_)) {
-      ASSERT(ThreadState::Current()->FindPageFromAddress(
+#if DCHECK_IS_ON()
+      DCHECK(ThreadState::Current()->FindPageFromAddress(
           reinterpret_cast<Address>(this)));
+#endif
       keep_alive_ = this;
     }
     ++ref_count_;
   }
 
   void Deref() {
-    ASSERT(ref_count_ > 0);
+    DCHECK_GT(ref_count_, 0);
     if (!--ref_count_)
       keep_alive_.Clear();
   }
 
   DEFINE_INLINE_TRACE() {}
 
   static int destructor_calls_;
 
  private:
   RefCountedAndGarbageCollected() : ref_count_(0) {}
 
   int ref_count_;
   SelfKeepAlive<RefCountedAndGarbageCollected> keep_alive_;
 };
 
 int RefCountedAndGarbageCollected::destructor_calls_ = 0;
 
 class RefCountedAndGarbageCollected2
     : public HeapTestOtherSuperClass,
       public GarbageCollectedFinalized<RefCountedAndGarbageCollected2> {
  public:
   static RefCountedAndGarbageCollected2* Create() {
     return new RefCountedAndGarbageCollected2;
   }
 
   ~RefCountedAndGarbageCollected2() { ++destructor_calls_; }
 
   void Ref() {
     if (UNLIKELY(!ref_count_)) {
-      ASSERT(ThreadState::Current()->FindPageFromAddress(
+#if DCHECK_IS_ON()
+      DCHECK(ThreadState::Current()->FindPageFromAddress(
           reinterpret_cast<Address>(this)));
+#endif
       keep_alive_ = this;
     }
     ++ref_count_;
   }
 
   void Deref() {
-    ASSERT(ref_count_ > 0);
+    DCHECK_GT(ref_count_, 0);
     if (!--ref_count_)
       keep_alive_.Clear();
   }
 
   DEFINE_INLINE_TRACE() {}
 
   static int destructor_calls_;
 
  private:
   RefCountedAndGarbageCollected2() : ref_count_(0) {}
@@ skipping 211 matching lines @@
     did_call_will_finalize_ = true;
   }
 
   static ObserverMap& Observe(Observable& target) {
     ObserverMap& map = Observers();
     ObserverMap::AddResult result = map.insert(&target, nullptr);
     if (result.is_new_entry) {
       result.stored_value->value =
           WTF::MakeUnique<FinalizationObserverWithHashMap>(target);
     } else {
-      ASSERT(result.stored_value->value);
+      DCHECK(result.stored_value->value);
     }
     return map;
   }
 
   static void ClearObservers() {
     delete observer_map_;
     observer_map_ = nullptr;
   }
 
   static bool did_call_will_finalize_;
@@ skipping 855 matching lines @@
     EXPECT_EQ(1u, Bar::live_);
   }
   PreciselyCollectGarbage();
   EXPECT_EQ(0u, Bar::live_);
 }
 
 TEST(HeapTest, MarkTest) {
   {
     Bar::live_ = 0;
     Persistent<Bar> bar = Bar::Create();
-    ASSERT(ThreadState::Current()->FindPageFromAddress(bar));
+#if DCHECK_IS_ON()
+    DCHECK(ThreadState::Current()->FindPageFromAddress(bar));
+#endif
     EXPECT_EQ(1u, Bar::live_);
     {
       Foo* foo = Foo::Create(bar);
-      ASSERT(ThreadState::Current()->FindPageFromAddress(foo));
+#if DCHECK_IS_ON()
+      DCHECK(ThreadState::Current()->FindPageFromAddress(foo));
+#endif
       EXPECT_EQ(2u, Bar::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::live_);
     }
     PreciselyCollectGarbage();
     EXPECT_EQ(1u, Bar::live_);
   }
   PreciselyCollectGarbage();
   EXPECT_EQ(0u, Bar::live_);
 }
 
 TEST(HeapTest, DeepTest) {
   const unsigned kDepth = 100000;
   Bar::live_ = 0;
   {
     Bar* bar = Bar::Create();
-    ASSERT(ThreadState::Current()->FindPageFromAddress(bar));
+#if DCHECK_IS_ON()
+    DCHECK(ThreadState::Current()->FindPageFromAddress(bar));
+#endif
     Foo* foo = Foo::Create(bar);
-    ASSERT(ThreadState::Current()->FindPageFromAddress(foo));
+#if DCHECK_IS_ON()
+    DCHECK(ThreadState::Current()->FindPageFromAddress(foo));
+#endif
     EXPECT_EQ(2u, Bar::live_);
     for (unsigned i = 0; i < kDepth; i++) {
       Foo* foo2 = Foo::Create(foo);
       foo = foo2;
-      ASSERT(ThreadState::Current()->FindPageFromAddress(foo));
+#if DCHECK_IS_ON()
+      DCHECK(ThreadState::Current()->FindPageFromAddress(foo));
+#endif
     }
     EXPECT_EQ(kDepth + 2, Bar::live_);
     ConservativelyCollectGarbage();
     EXPECT_TRUE(foo != bar);  // To make sure foo and bar are kept alive.
     EXPECT_EQ(kDepth + 2, Bar::live_);
   }
   PreciselyCollectGarbage();
   EXPECT_EQ(0u, Bar::live_);
 }
 
@@ skipping 122 matching lines @@
   ThreadHeap& heap = ThreadState::Current()->Heap();
   ClearOutOldGarbage();
   size_t initial_object_payload_size = heap.ObjectPayloadSizeForTesting();
   size_t initial_allocated_space = heap.HeapStats().AllocatedSpace();
   IntWrapper::destructor_calls_ = 0;
   LargeHeapObject::destructor_calls_ = 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(
+#if DCHECK_IS_ON()
+    DCHECK(ThreadState::Current()->FindPageFromAddress(object));
+    DCHECK(ThreadState::Current()->FindPageFromAddress(
         reinterpret_cast<char*>(object.Get()) + sizeof(LargeHeapObject) - 1));
+#endif
     ClearOutOldGarbage();
     size_t after_allocation = 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 expected_large_heap_object_payload_size =
           ThreadHeap::AllocationSizeFromSize(sizeof(LargeHeapObject));
       size_t expected_object_payload_size =
@@ skipping 3369 matching lines @@
 }
 #endif
 #endif
 
 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() : dummy_(CheckGCForbidden()) {}
 
  private:
   bool dummy_;
 };
@@ skipping 533 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 ? kGrowsTowardsLower : kGrowsTowardsHigher;
 }
 
 }  // 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(kGrowsTowardsLower, 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()
       : 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(a_);
     TestMixinAllocationA::Trace(visitor);
   }
 
  private:
   Member<TestMixinAllocationA> 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 number_of_large_objects_to_allocate,
       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 < number_of_large_objects_to_allocate; i++) {
       LargeHeapObject* large_object = LargeHeapObject::Create();
       EXPECT_TRUE(large_object);
       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(trace_counter_);
     TestMixinAllocationB::Trace(visitor);
   }
 
   int TraceCount() const { return trace_counter_->TraceCount(); }
 
  private:
   TestMixinAllocatingObject(ClassWithMember* member)
       : ObjectWithLargeAmountsOfAllocationInConstructor(600, member),
         trace_counter_(TraceCounter::Create()) {
-    ASSERT(!ThreadState::Current()->IsGCForbidden());
+    DCHECK(!ThreadState::Current()->IsGCForbidden());
     ConservativelyCollectGarbage();
     EXPECT_GT(member->TraceCount(), 0);
     EXPECT_GT(TraceCount(), 0);
   }
 
   Member<TraceCounter> trace_counter_;
 };
 
 TEST(HeapTest, MixinConstructionNoGC) {
   Persistent<ClassWithMember> object = ClassWithMember::Create();
@@ skipping 355 matching lines @@
     map.insert(key, IntWrapper::Create(i));
   }
 
   EXPECT_FALSE(string.Impl()->HasOneRef());
   map.Clear();
 
   EXPECT_TRUE(string.Impl()->HasOneRef());
 }
 
 }  // namespace blink