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 5127 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