Allow CrossThreadPersistent in collections

third_party/WebKit/Source/platform/heap/HeapTest.cpp

Index: third_party/WebKit/Source/platform/heap/HeapTest.cpp
diff --git a/third_party/WebKit/Source/platform/heap/HeapTest.cpp b/third_party/WebKit/Source/platform/heap/HeapTest.cpp
index b85821351ad4395d839078e29b4ba6f28e86be1d..27a498edce9cdc4dfa94d15e165dd3f81ff74d5a 100644
--- a/third_party/WebKit/Source/platform/heap/HeapTest.cpp
+++ b/third_party/WebKit/Source/platform/heap/HeapTest.cpp
@@ -2897,6 +2897,192 @@ TEST(HeapTest, HeapCollectionTypes)
     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, 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: