Allow CrossThreadPersistent in collections

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 2879 matching lines @@
     EXPECT_EQ(3u, vectorUW->size());
     EXPECT_EQ(1u, vectorUW2->size());
     EXPECT_EQ(2u, deque->size());
     EXPECT_EQ(1u, deque2->size());
     EXPECT_EQ(3u, dequeWU->size());
     EXPECT_EQ(1u, dequeWU2->size());
     EXPECT_EQ(3u, dequeUW->size());
     EXPECT_EQ(1u, dequeUW2->size());
 }
 
+TEST(HeapTest, PersistentVector)
+{
+    IntWrapper::s_destructorCalls = 0;
+
+    typedef Vector<Persistent<IntWrapper>> PersistentVector;
+
+    Persistent<IntWrapper> one(IntWrapper::create(1));
+    Persistent<IntWrapper> two(IntWrapper::create(2));
+    Persistent<IntWrapper> three(IntWrapper::create(3));
+    Persistent<IntWrapper> four(IntWrapper::create(4));
+    Persistent<IntWrapper> five(IntWrapper::create(5));
+    Persistent<IntWrapper> six(IntWrapper::create(6));
+    {
+        PersistentVector vector;
+        vector.append(one);
+        vector.append(two);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector.contains(one));
+        EXPECT_TRUE(vector.contains(two));
+
+        vector.append(three);
+        vector.append(four);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector.contains(one));
+        EXPECT_TRUE(vector.contains(two));
+        EXPECT_TRUE(vector.contains(three));
+        EXPECT_TRUE(vector.contains(four));
+
+        vector.shrink(1);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector.contains(one));
+        EXPECT_FALSE(vector.contains(two));
+        EXPECT_FALSE(vector.contains(three));
+        EXPECT_FALSE(vector.contains(four));
+    }
+    {
+        PersistentVector vector1;
+        PersistentVector vector2;
+
+        vector1.append(one);
+        vector2.append(two);
+        vector1.swap(vector2);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector1.contains(two));
+        EXPECT_TRUE(vector2.contains(one));
+    }
+    {
+        PersistentVector vector1;
+        PersistentVector vector2;
+
+        vector1.append(one);
+        vector1.append(two);
+        vector2.append(three);
+        vector2.append(four);
+        vector2.append(five);
+        vector2.append(six);
+        vector1.swap(vector2);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector1.contains(three));
+        EXPECT_TRUE(vector1.contains(four));
+        EXPECT_TRUE(vector1.contains(five));
+        EXPECT_TRUE(vector1.contains(six));
+        EXPECT_TRUE(vector2.contains(one));
+        EXPECT_TRUE(vector2.contains(two));
+    }
+}
+
+TEST(HeapTest, CrossThreadPersistentVector)
+{
+    IntWrapper::s_destructorCalls = 0;
+
+    typedef Vector<CrossThreadPersistent<IntWrapper>> CrossThreadPersistentVector;
+
+    CrossThreadPersistent<IntWrapper> one(IntWrapper::create(1));
+    CrossThreadPersistent<IntWrapper> two(IntWrapper::create(2));
+    CrossThreadPersistent<IntWrapper> three(IntWrapper::create(3));
+    CrossThreadPersistent<IntWrapper> four(IntWrapper::create(4));
+    CrossThreadPersistent<IntWrapper> five(IntWrapper::create(5));
+    CrossThreadPersistent<IntWrapper> six(IntWrapper::create(6));
+    {
+        CrossThreadPersistentVector vector;
+        vector.append(one);
+        vector.append(two);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector.contains(one));
+        EXPECT_TRUE(vector.contains(two));
+
+        vector.append(three);
+        vector.append(four);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector.contains(one));
+        EXPECT_TRUE(vector.contains(two));
+        EXPECT_TRUE(vector.contains(three));
+        EXPECT_TRUE(vector.contains(four));
+
+        vector.shrink(1);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector.contains(one));
+        EXPECT_FALSE(vector.contains(two));
+        EXPECT_FALSE(vector.contains(three));
+        EXPECT_FALSE(vector.contains(four));
+    }
+    {
+        CrossThreadPersistentVector vector1;
+        CrossThreadPersistentVector vector2;
+
+        vector1.append(one);
+        vector2.append(two);
+        vector1.swap(vector2);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector1.contains(two));
+        EXPECT_TRUE(vector2.contains(one));
+    }
+    {
+        CrossThreadPersistentVector vector1;
+        CrossThreadPersistentVector vector2;
+
+        vector1.append(one);
+        vector1.append(two);
+        vector2.append(three);
+        vector2.append(four);
+        vector2.append(five);
+        vector2.append(six);
+        vector1.swap(vector2);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(vector1.contains(three));
+        EXPECT_TRUE(vector1.contains(four));
+        EXPECT_TRUE(vector1.contains(five));
+        EXPECT_TRUE(vector1.contains(six));
+        EXPECT_TRUE(vector2.contains(one));
+        EXPECT_TRUE(vector2.contains(two));
+    }
+}
+
+TEST(HeapTest, PersistentSet)
+{
+    IntWrapper::s_destructorCalls = 0;
+
+    typedef HashSet<Persistent<IntWrapper>> PersistentSet;
+
+    IntWrapper* oneRaw = IntWrapper::create(1);
+    Persistent<IntWrapper> one(oneRaw);
+    Persistent<IntWrapper> one2(oneRaw);
+    Persistent<IntWrapper> two(IntWrapper::create(2));
+    Persistent<IntWrapper> three(IntWrapper::create(3));
+    Persistent<IntWrapper> four(IntWrapper::create(4));
+    Persistent<IntWrapper> five(IntWrapper::create(5));
+    Persistent<IntWrapper> six(IntWrapper::create(6));
+    {
+        PersistentSet set;
+        set.add(one);
+        set.add(two);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(set.contains(one));
+        EXPECT_TRUE(set.contains(one2));
+        EXPECT_TRUE(set.contains(two));
+
+        set.add(three);
+        set.add(four);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(set.contains(one));
+        EXPECT_TRUE(set.contains(two));
+        EXPECT_TRUE(set.contains(three));
+        EXPECT_TRUE(set.contains(four));
+
+        set.clear();
+        conservativelyCollectGarbage();
+        EXPECT_FALSE(set.contains(one));
+        EXPECT_FALSE(set.contains(two));
+        EXPECT_FALSE(set.contains(three));
+        EXPECT_FALSE(set.contains(four));
+    }
+    {
+        PersistentSet set1;
+        PersistentSet set2;
+
+        set1.add(one);
+        set2.add(two);
+        set1.swap(set2);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(set1.contains(two));
+        EXPECT_TRUE(set2.contains(one));
+        EXPECT_TRUE(set2.contains(one2));
+    }
+}
+
+TEST(HeapTest, CrossThreadPersistentSet)
+{
+    IntWrapper::s_destructorCalls = 0;
+
+    typedef HashSet<CrossThreadPersistent<IntWrapper>> CrossThreadPersistentSet;
+
+    IntWrapper* oneRaw = IntWrapper::create(1);
+    CrossThreadPersistent<IntWrapper> one(oneRaw);
+    CrossThreadPersistent<IntWrapper> one2(oneRaw);
+    CrossThreadPersistent<IntWrapper> two(IntWrapper::create(2));
+    CrossThreadPersistent<IntWrapper> three(IntWrapper::create(3));
+    CrossThreadPersistent<IntWrapper> four(IntWrapper::create(4));
+    CrossThreadPersistent<IntWrapper> five(IntWrapper::create(5));
+    CrossThreadPersistent<IntWrapper> six(IntWrapper::create(6));
+    {
+        CrossThreadPersistentSet set;
+        set.add(one);
+        set.add(two);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(set.contains(one));
+        EXPECT_TRUE(set.contains(one2));
+        EXPECT_TRUE(set.contains(two));
+
+        set.add(three);
+        set.add(four);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(set.contains(one));
+        EXPECT_TRUE(set.contains(two));
+        EXPECT_TRUE(set.contains(three));
+        EXPECT_TRUE(set.contains(four));
+
+        set.clear();
+        conservativelyCollectGarbage();
+        EXPECT_FALSE(set.contains(one));
+        EXPECT_FALSE(set.contains(two));
+        EXPECT_FALSE(set.contains(three));
+        EXPECT_FALSE(set.contains(four));
+    }
+    {
+        CrossThreadPersistentSet set1;
+        CrossThreadPersistentSet set2;
+
+        set1.add(one);
+        set2.add(two);
+        set1.swap(set2);
+        conservativelyCollectGarbage();
+        EXPECT_TRUE(set1.contains(two));
+        EXPECT_TRUE(set2.contains(one));
+        EXPECT_TRUE(set2.contains(one2));
+    }
+}
+
 class NonTrivialObject final {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     NonTrivialObject()
     {
     }
     explicit NonTrivialObject(int num)
     {
         m_deque.append(IntWrapper::create(num));
         m_vector.append(IntWrapper::create(num));
@@ skipping 3774 matching lines @@
     static_assert(WTF::IsGarbageCollectedType<HeapLinkedHashSet<Member<IntWrapper>>>::value, "HeapLinkedHashSet");
     static_assert(WTF::IsGarbageCollectedType<HeapListHashSet<Member<IntWrapper>>>::value, "HeapListHashSet");
     static_assert(WTF::IsGarbageCollectedType<HeapHashCountedSet<Member<IntWrapper>>>::value, "HeapHashCountedSet");
     static_assert(WTF::IsGarbageCollectedType<HeapHashMap<int, Member<IntWrapper>>>::value, "HeapHashMap");
     static_assert(WTF::IsGarbageCollectedType<HeapVector<Member<IntWrapper>>>::value, "HeapVector");
     static_assert(WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value, "HeapDeque");
     static_assert(WTF::IsGarbageCollectedType<HeapTerminatedArray<Member<IntWrapper>>>::value, "HeapTerminatedArray");
 }
 
 } // namespace blink