Merge VisitorScope to Visitor

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 264 matching lines @@
             m_count++;                                             \
     }                                                              \
     bool isMarked(const Type*) override { return false; }          \
     bool ensureMarked(const Type* objectPointer) override          \
     {                                                              \
         return ensureMarked(objectPointer);                        \
     }
 
 class CountingVisitor : public Visitor {
 public:
-    CountingVisitor()
-        : Visitor(Visitor::ThreadLocalMarking)
+    explicit CountingVisitor(ThreadState* state)
+        : Visitor(state, Visitor::ThreadLocalMarking)
         , m_count(0)
     {
     }
 
     void mark(const void* object, TraceCallback) override
     {
         if (object)
             m_count++;
     }
 
@@ skipping 729 matching lines @@
 int RefCountedAndGarbageCollected2::s_destructorCalls = 0;
 
 #define DEFINE_VISITOR_METHODS(Type)                               \
     void mark(const Type* object, TraceCallback callback) override \
     {                                                              \
         mark(object);                                              \
     }                                                              \
 
 class RefCountedGarbageCollectedVisitor : public CountingVisitor {
 public:
-    RefCountedGarbageCollectedVisitor(int expected, void** objects)
-        : m_count(0)
+    RefCountedGarbageCollectedVisitor(ThreadState* state, int expected, void** objects)
+        : CountingVisitor(state)
+        , m_count(0)
         , m_expectedCount(expected)
         , m_expectedObjects(objects)
     {
     }
 
     void mark(const void* ptr) { markNoTrace(ptr); }
 
     virtual void markNoTrace(const void* ptr)
     {
         if (!ptr)
@@ skipping 2541 matching lines @@
     RefCountedAndGarbageCollected2::s_destructorCalls = 0;
     {
         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() };
-            RefCountedGarbageCollectedVisitor visitor(2, objects);
+            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 };
-        RefCountedGarbageCollectedVisitor visitor(0, objects);
-        ThreadState::current()->visitPersistents(&visitor);
-        EXPECT_TRUE(visitor.validate());
+        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 };
+            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() };
-            RefCountedGarbageCollectedVisitor visitor(2, objects);
+            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);
 
         conservativelyCollectGarbage();
         EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
         EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
     }
 
     preciselyCollectGarbage();
     EXPECT_EQ(1, RefCountedAndGarbageCollected::s_destructorCalls);
     EXPECT_EQ(1, RefCountedAndGarbageCollected2::s_destructorCalls);
 }
@@ skipping 122 matching lines @@
 }
 
 TEST(HeapTest, CheckAndMarkPointer)
 {
     clearOutOldGarbage();
 
     Vector<Address> objectAddresses;
     Vector<Address> endAddresses;
     Address largeObjectAddress;
     Address largeObjectEndAddress;
-    CountingVisitor visitor;
     for (int i = 0; i < 10; i++) {
         SimpleObject* object = SimpleObject::create();
         Address objectAddress = reinterpret_cast<Address>(object);
         objectAddresses.append(objectAddress);
         endAddresses.append(objectAddress + sizeof(SimpleObject) - 1);
     }
     LargeHeapObject* largeObject = LargeHeapObject::create();
     largeObjectAddress = reinterpret_cast<Address>(largeObject);
     largeObjectEndAddress = largeObjectAddress + sizeof(LargeHeapObject) - 1;
 
     // 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);
+        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);
+        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
             // can't make that assert.
@@ skipping 1992 matching lines @@
     DISALLOW_NEW();
 public:
     PartObject() : m_obj(SimpleObject::create()) { }
     DEFINE_INLINE_TRACE() { visitor->trace(m_obj); }
 private:
     Member<SimpleObject> m_obj;
 };
 
 TEST(HeapTest, TraceIfNeeded)
 {
-    CountingVisitor visitor;
+    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());
     }
 
     {
         TraceIfNeededTester<PartObject>* m_part = TraceIfNeededTester<PartObject>::create();
@@ skipping 692 matching lines @@
     EXPECT_EQ(1u, vector2.size());
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, remove.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
     EXPECT_EQ(16u, vector1.capacity());
     EXPECT_EQ(16u, vector2.capacity());
 #endif
 }
 
 } // namespace blink