Revert of Simple BlinkGC heap compaction.

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 331 matching lines @@
 #endif
   void registerWeakCellWithCallback(void**, WeakCallback) override {}
   bool ensureMarked(const void* objectPointer) override {
     if (!objectPointer ||
         HeapObjectHeader::fromPayload(objectPointer)->isMarked())
       return false;
     markNoTracing(objectPointer);
     return true;
   }
 
-  void registerMovingObjectReference(MovableReference*) override {}
-
-  void registerMovingObjectCallback(MovableReference,
-                                    MovingObjectCallback,
-                                    void*) override {}
-
   size_t count() { return m_count; }
   void reset() { m_count = 0; }
 
  private:
   StackFrameDepthScope m_scope;
   size_t m_count;
 };
 
 #undef DEFINE_VISITOR_METHODS
 
@@ skipping 3396 matching lines @@
     RefCountedAndGarbageCollected* pointer1 = 0;
     RefCountedAndGarbageCollected2* pointer2 = 0;
     {
       Persistent<RefCountedAndGarbageCollected> object1 =
           RefCountedAndGarbageCollected::create();
       Persistent<RefCountedAndGarbageCollected2> object2 =
           RefCountedAndGarbageCollected2::create();
       pointer1 = object1.get();
       pointer2 = object2.get();
       void* objects[2] = {object1.get(), object2.get()};
-      ThreadState::GCForbiddenScope gcScope(ThreadState::current());
       RefCountedGarbageCollectedVisitor visitor(ThreadState::current(), 2,
                                                 objects);
       ThreadState::current()->visitPersistents(&visitor);
       EXPECT_TRUE(visitor.validate());
     }
     conservativelyCollectGarbage();
     EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
     EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
     conservativelyCollectGarbage();
     EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
     EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
     {
       // At this point, the reference counts of object1 and object2 are 0.
       // Only pointer1 and pointer2 keep references to object1 and object2.
       void* objects[] = {0};
-      ThreadState::GCForbiddenScope gcScope(ThreadState::current());
       RefCountedGarbageCollectedVisitor visitor(ThreadState::current(), 0,
                                                 objects);
       ThreadState::current()->visitPersistents(&visitor);
       EXPECT_TRUE(visitor.validate());
     }
 
     {
       Persistent<RefCountedAndGarbageCollected> object1(pointer1);
       Persistent<RefCountedAndGarbageCollected2> object2(pointer2);
       void* objects[2] = {object1.get(), object2.get()};
-      ThreadState::GCForbiddenScope gcScope(ThreadState::current());
       RefCountedGarbageCollectedVisitor visitor(ThreadState::current(), 2,
                                                 objects);
       ThreadState::current()->visitPersistents(&visitor);
       EXPECT_TRUE(visitor.validate());
     }
     conservativelyCollectGarbage();
     EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
     EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
     conservativelyCollectGarbage();
@@ skipping 143 matching lines @@
 
   // This is a low-level test where we call checkAndMarkPointer. This method
   // causes the object start bitmap to be computed which requires the heap
   // to be in a consistent state (e.g. the free allocation area must be put
   // into a free list header). However when we call makeConsistentForGC it
   // also clears out the freelists so we have to rebuild those before trying
   // to allocate anything again. We do this by forcing a GC after doing the
   // checkAndMarkPointer tests.
   {
     TestGCScope scope(BlinkGC::HeapPointersOnStack);
-    ThreadState::GCForbiddenScope gcScope(ThreadState::current());
     CountingVisitor visitor(ThreadState::current());
     EXPECT_TRUE(scope.allThreadsParked());  // Fail the test if we could not
                                             // park all threads.
     heap.flushHeapDoesNotContainCache();
     for (size_t i = 0; i < objectAddresses.size(); i++) {
       EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, objectAddresses[i]));
       EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, endAddresses[i]));
     }
     EXPECT_EQ(objectAddresses.size() * 2, visitor.count());
     visitor.reset();
     EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, largeObjectAddress));
     EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, largeObjectEndAddress));
     EXPECT_EQ(2ul, visitor.count());
     visitor.reset();
   }
   // This forces a GC without stack scanning which results in the objects
   // being collected. This will also rebuild the above mentioned freelists,
   // however we don't rely on that below since we don't have any allocations.
   clearOutOldGarbage();
   {
     TestGCScope scope(BlinkGC::HeapPointersOnStack);
-    ThreadState::GCForbiddenScope gcScope(ThreadState::current());
     CountingVisitor visitor(ThreadState::current());
     EXPECT_TRUE(scope.allThreadsParked());
     heap.flushHeapDoesNotContainCache();
     for (size_t i = 0; i < objectAddresses.size(); i++) {
       // We would like to assert that checkAndMarkPointer returned false
       // here because the pointers no longer point into a valid object
       // (it's been freed by the GCs. But checkAndMarkPointer will return
       // true for any pointer that points into a heap page, regardless of
       // whether it points at a valid object (this ensures the
       // correctness of the page-based on-heap address caches), so we
@@ skipping 1878 matching lines @@
 
  public:
   PartObject() : m_obj(SimpleObject::create()) {}
   DEFINE_INLINE_TRACE() { visitor->trace(m_obj); }
 
  private:
   Member<SimpleObject> m_obj;
 };
 
 TEST(HeapTest, TraceIfNeeded) {
-  ThreadState::GCForbiddenScope scope(ThreadState::current());
   CountingVisitor visitor(ThreadState::current());
 
   {
     TraceIfNeededTester<RefPtr<OffHeapInt>>* m_offHeap =
         TraceIfNeededTester<RefPtr<OffHeapInt>>::create(OffHeapInt::create(42));
     visitor.reset();
     m_offHeap->trace(&visitor);
     EXPECT_EQ(0u, visitor.count());
   }
 
@@ skipping 920 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink