Require that heap collections are used over traceable elements.

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 214 matching lines @@
 // SimpleClassHashTraits allow empty slots in the table to be initialzed with
 // memset to zero, and we use -1 in the first part of the pair to represent
 // deleted slots.
 template<> struct HashTraits<blink::PairWithWeakHandling> : blink::WeakHandlingHashTraits<blink::PairWithWeakHandling> {
     static const bool hasIsEmptyValueFunction = true;
     static bool isEmptyValue(const blink::PairWithWeakHandling& value) { return !value.first; }
     static void constructDeletedValue(blink::PairWithWeakHandling& slot, bool) { new (NotNull, &slot) blink::PairWithWeakHandling(HashTableDeletedValue); }
     static bool isDeletedValue(const blink::PairWithWeakHandling& value) { return value.isHashTableDeletedValue(); }
 };
 
+template<>
+struct NeedsTracing<blink::PairWithWeakHandling> {
+    static const bool value = NeedsTracing<blink::StrongWeakPair>::value;
+};
+
 } // namespace WTF
 
 namespace blink {
 
 class TestGCScope {
 public:
     explicit TestGCScope(BlinkGC::StackState state)
         : m_state(ThreadState::current())
         , m_safePointScope(state)
         , m_parkedAllThreads(false)
@@ skipping 3807 matching lines @@
         outlineVector.append(o2);
 
         PersistentHeapVector<VectorObjectInheritedTrace> vectorInheritedTrace;
         VectorObjectInheritedTrace it1, it2;
         vectorInheritedTrace.append(it1);
         vectorInheritedTrace.append(it2);
 
         preciselyCollectGarbage();
         EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
 
-        // Since VectorObjectNoTrace has no trace method it will
-        // not be traced and hence be collected when doing GC.
-        // We trace items in a collection braced on the item's
-        // having a trace method. This is determined via the
-        // NeedsTracing trait in wtf/TypeTraits.h.
-        PersistentHeapVector<VectorObjectNoTrace> vectorNoTrace;
-        VectorObjectNoTrace n1, n2;
-        vectorNoTrace.append(n1);
-        vectorNoTrace.append(n2);
-        preciselyCollectGarbage();
-        EXPECT_EQ(2, SimpleFinalizedObject::s_destructorCalls);
     }
     preciselyCollectGarbage();
-    EXPECT_EQ(8, SimpleFinalizedObject::s_destructorCalls);
+    EXPECT_EQ(6, SimpleFinalizedObject::s_destructorCalls);
 }
 
 TEST(HeapTest, EmbeddedInDeque)
 {
     clearOutOldGarbage();
     SimpleFinalizedObject::s_destructorCalls = 0;
     {
         PersistentHeapDeque<VectorObject, 2> inlineDeque;
         PersistentHeapDeque<VectorObject> outlineDeque;
         VectorObject i1, i2;
         inlineDeque.append(i1);
         inlineDeque.append(i2);
 
         VectorObject o1, o2;
         outlineDeque.append(o1);
         outlineDeque.append(o2);
 
         PersistentHeapDeque<VectorObjectInheritedTrace> dequeInheritedTrace;
         VectorObjectInheritedTrace it1, it2;
         dequeInheritedTrace.append(it1);
         dequeInheritedTrace.append(it2);
 
         preciselyCollectGarbage();
         EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
-
-        // Since VectorObjectNoTrace has no trace method it will
-        // not be traced and hence be collected when doing GC.
-        // We trace items in a collection braced on the item's
-        // having a trace method. This is determined via the
-        // NeedsTracing trait in wtf/TypeTraits.h.
-        PersistentHeapDeque<VectorObjectNoTrace> dequeNoTrace;
-        VectorObjectNoTrace n1, n2;
-        dequeNoTrace.append(n1);
-        dequeNoTrace.append(n2);
-        preciselyCollectGarbage();
-        EXPECT_EQ(2, SimpleFinalizedObject::s_destructorCalls);
     }
     preciselyCollectGarbage();
-    EXPECT_EQ(8, SimpleFinalizedObject::s_destructorCalls);
+    EXPECT_EQ(6, SimpleFinalizedObject::s_destructorCalls);
 }
 
 class InlinedVectorObject {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     InlinedVectorObject()
     {
     }
     ~InlinedVectorObject()
     {
@@ skipping 396 matching lines @@
         }
     }
 
     EXPECT_FALSE(RefCountedWithDestructor::s_wasDestructed);
     set.clear();
     EXPECT_TRUE(RefCountedWithDestructor::s_wasDestructed);
 }
 
 TEST(HeapTest, DestructorsCalled)
 {
-    HeapHashMap<SimpleClassWithDestructor*, OwnPtr<SimpleClassWithDestructor>> map;
+    HeapHashMap<Member<IntWrapper>, OwnPtr<SimpleClassWithDestructor>> map;
     SimpleClassWithDestructor* hasDestructor = new SimpleClassWithDestructor();
-    map.add(hasDestructor, adoptPtr(hasDestructor));
+    map.add(IntWrapper::create(1), adoptPtr(hasDestructor));
     SimpleClassWithDestructor::s_wasDestructed = false;
     map.clear();
     EXPECT_TRUE(SimpleClassWithDestructor::s_wasDestructed);
-
-    destructorsCalledOnClear<HeapHashSet<RefPtr<RefCountedWithDestructor>>>(false);
-    destructorsCalledOnClear<HeapListHashSet<RefPtr<RefCountedWithDestructor>>>(false);
-    destructorsCalledOnClear<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor>>>(false);
-    destructorsCalledOnClear<HeapHashSet<RefPtr<RefCountedWithDestructor>>>(true);
-    destructorsCalledOnClear<HeapListHashSet<RefPtr<RefCountedWithDestructor>>>(true);
-    destructorsCalledOnClear<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor>>>(true);
-
-    destructorsCalledOnGC<HeapHashSet<RefPtr<RefCountedWithDestructor>>>(false);
-    destructorsCalledOnGC<HeapListHashSet<RefPtr<RefCountedWithDestructor>>>(false);
-    destructorsCalledOnGC<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor>>>(false);
-    destructorsCalledOnGC<HeapHashSet<RefPtr<RefCountedWithDestructor>>>(true);
-    destructorsCalledOnGC<HeapListHashSet<RefPtr<RefCountedWithDestructor>>>(true);
-    destructorsCalledOnGC<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor>>>(true);
 }
 
 class MixinA : public GarbageCollectedMixin {
 public:
     MixinA() : m_obj(IntWrapper::create(100)) { }
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         s_traceCount++;
         visitor->trace(m_obj);
     }
@@ skipping 1534 matching lines @@
 };
 
 class PartObjectWithRef {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     PartObjectWithRef(int i)
         : m_value(SimpleRefValue::create(i))
     {
     }
 
+    DEFINE_INLINE_TRACE() { }
+
     int value() const { return m_value->value(); }
 
 private:
     RefPtr<SimpleRefValue> m_value;
 };
 
 } // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::PartObjectWithRef);
 
@@ skipping 407 matching lines @@
 };
 
 } // namespace
 
 TEST(HeapTest, TestClearOnShutdown)
 {
     ThreadedClearOnShutdownTester::test();
 }
 
 } // namespace blink