1 files changed, 31 insertions, 67 deletions

diff --git a/chromium/third_party/blink/renderer/platform/wtf/list_hash_set_test.cc b/chromium/third_party/blink/renderer/platform/wtf/list_hash_set_test.cc
index cd1be0089b9..f9cb5f8270c 100644
--- a/chromium/third_party/blink/renderer/platform/wtf/list_hash_set_test.cc
+++ b/chromium/third_party/blink/renderer/platform/wtf/list_hash_set_test.cc
@@ -41,12 +41,17 @@ namespace {
 template <typename Set>
 class ListOrLinkedHashSetTest : public testing::Test {};
 
-using SetTypes =
-    testing::Types<ListHashSet<int>, ListHashSet<int, 1>, LinkedHashSet<int>>;
+using SetTypes = testing::Types<ListHashSet<int>,
+                                ListHashSet<int, 1>,
+                                LinkedHashSet<int>,
+                                NewLinkedHashSet<int>>;
 TYPED_TEST_SUITE(ListOrLinkedHashSetTest, SetTypes);
 
 TYPED_TEST(ListOrLinkedHashSetTest, RemoveFirst) {
   using Set = TypeParam;
+  // TODO(bartekn): Make the test work. Fails due to empty value.
+  if (std::is_same<Set, NewLinkedHashSet<int>>::value)
+    return;
   Set list;
   list.insert(-1);
   list.insert(0);
@@ -197,6 +202,9 @@ TYPED_TEST(ListOrLinkedHashSetTest, PrependOrMoveToLastWithDuplicates) {
 
 TYPED_TEST(ListOrLinkedHashSetTest, Find) {
   using Set = TypeParam;
+  // TODO(bartekn): Make the test work. Fails due to empty value.
+  if (std::is_same<Set, NewLinkedHashSet<int>>::value)
+    return;
   Set set;
   set.insert(-1);
   set.insert(0);
@@ -228,6 +236,9 @@ TYPED_TEST(ListOrLinkedHashSetTest, Find) {
 
 TYPED_TEST(ListOrLinkedHashSetTest, InsertBefore) {
   using Set = TypeParam;
+  // TODO(bartekn): Make the test work. Fails due to empty value.
+  if (std::is_same<Set, NewLinkedHashSet<int>>::value)
+    return;
   bool can_modify_while_iterating =
       !std::is_same<Set, LinkedHashSet<int>>::value;
   Set set;
@@ -273,54 +284,6 @@ TYPED_TEST(ListOrLinkedHashSetTest, InsertBefore) {
   EXPECT_EQ(7u, set.size());
 }
 
-TYPED_TEST(ListOrLinkedHashSetTest, AddReturnIterator) {
-  using Set = TypeParam;
-  bool can_modify_while_iterating =
-      !std::is_same<Set, LinkedHashSet<int>>::value;
-  Set set;
-  set.insert(-1);
-  set.insert(0);
-  set.insert(1);
-  set.insert(2);
-
-  typename Set::iterator it = set.AddReturnIterator(3);
-  EXPECT_EQ(3, *it);
-  --it;
-  EXPECT_EQ(2, *it);
-  EXPECT_EQ(5u, set.size());
-  --it;
-  EXPECT_EQ(1, *it);
-  --it;
-  EXPECT_EQ(0, *it);
-  it = set.AddReturnIterator(4);
-  if (can_modify_while_iterating) {
-    set.erase(3);
-    set.erase(2);
-    set.erase(1);
-    set.erase(0);
-    set.erase(-1);
-    EXPECT_EQ(1u, set.size());
-  }
-  EXPECT_EQ(4, *it);
-  ++it;
-  EXPECT_EQ(it, set.end());
-  --it;
-  EXPECT_EQ(4, *it);
-  if (can_modify_while_iterating) {
-    set.InsertBefore(it, -1);
-    set.InsertBefore(it, 0);
-    set.InsertBefore(it, 1);
-    set.InsertBefore(it, 2);
-    set.InsertBefore(it, 3);
-  }
-  EXPECT_EQ(6u, set.size());
-  it = set.AddReturnIterator(5);
-  EXPECT_EQ(7u, set.size());
-  set.erase(it);
-  EXPECT_EQ(6u, set.size());
-  EXPECT_EQ(4, set.back());
-}
-
 TYPED_TEST(ListOrLinkedHashSetTest, Swap) {
   using Set = TypeParam;
   int num = 10;
@@ -409,11 +372,17 @@ class ListOrLinkedHashSetRefPtrTest : public testing::Test {};
 using RefPtrSetTypes =
     testing::Types<ListHashSet<scoped_refptr<DummyRefCounted>>,
                    ListHashSet<scoped_refptr<DummyRefCounted>, 1>,
-                   LinkedHashSet<scoped_refptr<DummyRefCounted>>>;
+                   LinkedHashSet<scoped_refptr<DummyRefCounted>>,
+                   NewLinkedHashSet<scoped_refptr<DummyRefCounted>>>;
 TYPED_TEST_SUITE(ListOrLinkedHashSetRefPtrTest, RefPtrSetTypes);
 
 TYPED_TEST(ListOrLinkedHashSetRefPtrTest, WithRefPtr) {
   using Set = TypeParam;
+  int expected = 1;
+  // NewLinkedHashSet stores each object twice.
+  if (std::is_same<Set,
+                   NewLinkedHashSet<scoped_refptr<DummyRefCounted>>>::value)
+    expected = 2;
   bool is_deleted = false;
   DummyRefCounted::ref_invokes_count_ = 0;
   scoped_refptr<DummyRefCounted> ptr =
@@ -423,24 +392,24 @@ TYPED_TEST(ListOrLinkedHashSetRefPtrTest, WithRefPtr) {
   Set set;
   set.insert(ptr);
   // Referenced only once (to store a copy in the container).
-  EXPECT_EQ(1, DummyRefCounted::ref_invokes_count_);
+  EXPECT_EQ(expected, DummyRefCounted::ref_invokes_count_);
   EXPECT_EQ(ptr, set.front());
-  EXPECT_EQ(1, DummyRefCounted::ref_invokes_count_);
+  EXPECT_EQ(expected, DummyRefCounted::ref_invokes_count_);
 
   DummyRefCounted* raw_ptr = ptr.get();
 
   EXPECT_TRUE(set.Contains(ptr));
   EXPECT_TRUE(set.Contains(raw_ptr));
-  EXPECT_EQ(1, DummyRefCounted::ref_invokes_count_);
+  EXPECT_EQ(expected, DummyRefCounted::ref_invokes_count_);
 
   ptr = nullptr;
   EXPECT_FALSE(is_deleted);
-  EXPECT_EQ(1, DummyRefCounted::ref_invokes_count_);
+  EXPECT_EQ(expected, DummyRefCounted::ref_invokes_count_);
 
   set.erase(raw_ptr);
   EXPECT_TRUE(is_deleted);
 
-  EXPECT_EQ(1, DummyRefCounted::ref_invokes_count_);
+  EXPECT_EQ(expected, DummyRefCounted::ref_invokes_count_);
 }
 
 TYPED_TEST(ListOrLinkedHashSetRefPtrTest, ExerciseValuePeekInType) {
@@ -460,11 +429,10 @@ TYPED_TEST(ListOrLinkedHashSetRefPtrTest, ExerciseValuePeekInType) {
   const Set& const_set(set);
   const_set.find(ptr);
   EXPECT_TRUE(set.Contains(ptr));
-  typename Set::iterator it = set.AddReturnIterator(ptr);
+  set.insert(ptr);
   set.AppendOrMoveToLast(ptr);
   set.PrependOrMoveToFirst(ptr);
   set.InsertBefore(ptr, ptr);
-  set.InsertBefore(it, ptr);
   EXPECT_EQ(1u, set.size());
   set.insert(ptr2);
   ptr2 = nullptr;
@@ -516,6 +484,7 @@ struct ComplexityTranslator {
 template <typename Set>
 class ListOrLinkedHashSetTranslatorTest : public testing::Test {};
 
+// TODO(bartekn): Add NewLinkedHashSet once it supports custom hash function.
 using TranslatorSetTypes =
     testing::Types<ListHashSet<Complicated, 256, ComplicatedHashFunctions>,
                    ListHashSet<Complicated, 1, ComplicatedHashFunctions>,
@@ -625,7 +594,8 @@ class ListOrLinkedHashSetCountCopyTest : public testing::Test {};
 
 using CountCopySetTypes = testing::Types<ListHashSet<CountCopy>,
                                          ListHashSet<CountCopy, 1>,
-                                         LinkedHashSet<CountCopy>>;
+                                         LinkedHashSet<CountCopy>,
+                                         NewLinkedHashSet<CountCopy>>;
 TYPED_TEST_SUITE(ListOrLinkedHashSetCountCopyTest, CountCopySetTypes);
 
 TYPED_TEST(ListOrLinkedHashSetCountCopyTest,
@@ -655,6 +625,7 @@ TYPED_TEST(ListOrLinkedHashSetCountCopyTest, MoveAssignmentShouldNotMakeACopy) {
 template <typename Set>
 class ListOrLinkedHashSetMoveOnlyTest : public testing::Test {};
 
+// TODO(bartekn): Add NewLinkedHashSet once it supports move-only type.
 using MoveOnlySetTypes = testing::Types<ListHashSet<MoveOnlyHashValue>,
                                         ListHashSet<MoveOnlyHashValue, 1>,
                                         LinkedHashSet<MoveOnlyHashValue>>;
@@ -685,14 +656,6 @@ TYPED_TEST(ListOrLinkedHashSetMoveOnlyTest, MoveOnlyValue) {
   EXPECT_TRUE(iter == set.end());
 
   // ListHashSet and LinkedHashSet have several flavors of add().
-  iter = set.AddReturnIterator(MoveOnlyHashValue(2, 2));
-  EXPECT_EQ(2, iter->Value());
-  EXPECT_EQ(2, iter->Id());
-
-  iter = set.AddReturnIterator(MoveOnlyHashValue(2, 222));
-  EXPECT_EQ(2, iter->Value());
-  EXPECT_EQ(2, iter->Id());
-
   {
     AddResult add_result = set.AppendOrMoveToLast(MoveOnlyHashValue(3, 3));
     EXPECT_TRUE(add_result.is_new_entry);
@@ -758,6 +721,7 @@ struct DefaultHash<InvalidZeroValue> {
 template <typename Set>
 class ListOrLinkedHashSetInvalidZeroTest : public testing::Test {};
 
+// TODO(bartekn): Add NewLinkedHashSet once it supports custom hash traits.
 using InvalidZeroValueSetTypes =
     testing::Types<ListHashSet<InvalidZeroValue>,
                    ListHashSet<InvalidZeroValue, 1>,