Oilpan: handle thread-local weak tracing slightly better.

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 226 matching lines @@
     {                                                                      \
         return ensureMarked(objectPointer);                                \
     }
 
 class CountingVisitor : public Visitor {
 public:
     CountingVisitor()
         : Visitor(Visitor::ThreadLocalMarking)
         , m_count(0)
     {
-        StackFrameDepth::configureStackLimit();
     }
 
     virtual void mark(const void* object, TraceCallback) override
     {
         if (object)
             m_count++;
     }
 
     virtual void markHeader(HeapObjectHeader* header, TraceCallback callback) override
     {
@@ skipping 17 matching lines @@
         if (!objectPointer || isMarked(objectPointer))
             return false;
         markNoTracing(objectPointer);
         return true;
     }
 
     size_t count() { return m_count; }
     void reset() { m_count = 0; }
 
 private:
+    StackFrameDepthScope m_scope;
     size_t m_count;
 };
 
 #undef DEFINE_VISITOR_METHODS
 
 class SimpleObject : public GarbageCollected<SimpleObject> {
 public:
     static SimpleObject* create() { return new SimpleObject(); }
     DEFINE_INLINE_TRACE() { }
     char getPayload(int i) { return payload[i]; }
@@ skipping 4843 matching lines @@
 
         // Wait for the worker thread to sweep its heaps before checking.
         {
             SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             parkMainThread();
         }
     }
 
 private:
 
-    static HeapHashSet<WeakMember<IntWrapper>>* allocateCollection()
+    using WeakCollectionType = HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>>;
+
+    static WeakCollectionType* allocateCollection()
     {
         // Create a weak collection that is kept alive by a persistent
         // and keep the contents alive with a persistents as
         // well.
         Persistent<IntWrapper> wrapper1 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper2 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper3 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper4 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper5 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper6 = IntWrapper::create(32);
-        Persistent<HeapHashSet<WeakMember<IntWrapper>>> weakCollection = new HeapHashSet<WeakMember<IntWrapper>>;
-        weakCollection->add(wrapper1);
-        weakCollection->add(wrapper2);
-        weakCollection->add(wrapper3);
-        weakCollection->add(wrapper4);
-        weakCollection->add(wrapper5);
-        weakCollection->add(wrapper6);
+        Persistent<WeakCollectionType> weakCollection = new WeakCollectionType;
+        weakCollection->add(wrapper1, wrapper1);
+        weakCollection->add(wrapper2, wrapper2);
+        weakCollection->add(wrapper3, wrapper3);
+        weakCollection->add(wrapper4, wrapper4);
+        weakCollection->add(wrapper5, wrapper5);
+        weakCollection->add(wrapper6, wrapper6);
 
         // Signal the main thread that the worker is done with its allocation.
         wakeMainThread();
 
         {
             // Wait for the main thread to do two GCs without sweeping
             // this thread heap. The worker waits within a safepoint,
             // but there is no sweeping until leaving the safepoint
             // scope. If the weak collection backing is marked dead
             // because of this we will not get strongification in the
             // GC we force when we continue.
             SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             parkWorkerThread();
         }
 
         return weakCollection;
     }
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
         ThreadState::attach();
 
         {
-            Persistent<HeapHashSet<WeakMember<IntWrapper>>> collection = allocateCollection();
+            Persistent<WeakCollectionType> collection = allocateCollection();
             {
                 // Prevent weak processing with an iterator and GC.
-                HeapHashSet<WeakMember<IntWrapper>>::iterator it = collection->begin();
+                WeakCollectionType::iterator it = collection->begin();
                 Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
 
                 // The backing should be strongified because of the iterator.
                 EXPECT_EQ(6u, collection->size());
-                EXPECT_EQ(32, (*it)->value());
+                EXPECT_EQ(32, it->value->value());
             }
 
             // Disregarding the iterator but keeping the collection alive
             // with a persistent should lead to weak processing.
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
             EXPECT_EQ(0u, collection->size());
         }
 
         wakeMainThread();
         ThreadState::detach();
@@ skipping 793 matching lines @@
 {
     Persistent<ClassWithMember> object = ClassWithMember::create();
     EXPECT_EQ(0, object->traceCount());
     TestMixinAllocatingObject* mixin = TestMixinAllocatingObject::create(object.get());
     EXPECT_TRUE(mixin);
     EXPECT_GT(object->traceCount(), 0);
     EXPECT_GT(mixin->traceCount(), 0);
 }
 
 } // namespace blink