Migrate users of LinkedHashSet to NewLinkedHashSet

The migration is done by renaming LinkedHashSet->LegacyLinkedHashSet
and NewLinkedHashSet->LinkedHashSet. In case of OrderedTrackIndexSet
(in grid.h) adding custom hash traits is required too.

The CL results in a binary size increase due to inlined code related to
VectorBackedLinkedList, which does not exist in LegacyLinkedHashSet.

Co-author: keinakashima@chromium.org
Significant contributor: yukiy@chromium.org

Bug: 1100257
Change-Id: Ieefb3fa8cd27110872aba932370b84dcfe41c8a4
Binary-Size: Size increase is unavoidable (see above).
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2134039Reviewed-by: Omer Katz <omerkatz@chromium.org>
Reviewed-by: Yuki Yamada <yukiy@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Yuki Shiino <yukishiino@chromium.org>
Commit-Queue: Bartek Nowierski <bartekn@chromium.org>
Cr-Commit-Position: refs/heads/master@{#800903}

third_party/blink/renderer/core/layout/grid.h

@@ -17,9 +17,20 @@
 
 namespace blink {
 
+struct OrderedTrackIndexSetHashTraits : public HashTraits<size_t> {
+  static const bool kEmptyValueIsZero = false;
+  static size_t EmptyValue() { return UINT_MAX; }
+
+  static void ConstructDeletedValue(size_t& slot, bool) { slot = UINT_MAX - 1; }
+  static bool IsDeletedValue(const size_t& value) {
+    return value == UINT_MAX - 1;
+  }
+};
+
 // TODO(svillar): Perhaps we should use references here.
 typedef Vector<LayoutBox*, 1> GridItemList;
-typedef LinkedHashSet<size_t> OrderedTrackIndexSet;
+typedef LinkedHashSet<size_t, OrderedTrackIndexSetHashTraits>
+    OrderedTrackIndexSet;
 
 class LayoutGrid;
 class GridIterator;
@@ -62,7 +73,6 @@ class CORE_EXPORT Grid {
   size_t AutoRepeatTracks(GridTrackSizingDirection) const;
   void SetAutoRepeatTracks(size_t auto_repeat_rows, size_t auto_repeat_columns);
 
-  typedef LinkedHashSet<size_t> OrderedTrackIndexSet;
   void SetAutoRepeatEmptyColumns(std::unique_ptr<OrderedTrackIndexSet>);
   void SetAutoRepeatEmptyRows(std::unique_ptr<OrderedTrackIndexSet>);
 

third_party/blink/renderer/platform/heap/heap_allocator.h

@@ -474,79 +474,81 @@ template <typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashSet<T, U, V>>
     : public GCInfoTrait<HashSet<T, U, V, HeapAllocator>> {};
 
+// IMPORTANT! Do not use this class, unless you need to work around a
+// HeapLinkedHashSet issue. Contact chrome-memory-tok@ if you do.
+// TODO(bartekn): Remove once fully transitioned to LinkedHashSet.
 template <typename ValueArg,
           typename HashArg = typename DefaultHash<ValueArg>::Hash,
           typename TraitsArg = HashTraits<ValueArg>>
-class HeapLinkedHashSet
-    : public LinkedHashSet<ValueArg, HashArg, TraitsArg, HeapAllocator> {
+class HeapLegacyLinkedHashSet
+    : public LegacyLinkedHashSet<ValueArg, HashArg, TraitsArg, HeapAllocator> {
   IS_GARBAGE_COLLECTED_CONTAINER_TYPE();
   DISALLOW_NEW();
-  // HeapLinkedHashSet is using custom callbacks for compaction that rely on the
-  // fact that the container itself does not move.
+  // HeapLegacyLinkedHashSet is using custom callbacks for compaction that rely
+  // on the fact that the container itself does not move.
   DISALLOW_IN_CONTAINER();
 
   static void CheckType() {
-    static_assert(internal::IsMemberOrWeakMemberType<ValueArg>,
-                  "HeapLinkedHashSet supports only Member and WeakMember.");
+    static_assert(
+        internal::IsMemberOrWeakMemberType<ValueArg>,
+        "HeapLegacyLinkedHashSet supports only Member and WeakMember.");
     static_assert(
         IsAllowedInContainer<ValueArg>::value,
         "Not allowed to directly nest type. Use Member<> indirection instead.");
-    static_assert(WTF::IsTraceable<ValueArg>::value,
-                  "For sets without traceable elements, use LinkedHashSet<> "
-                  "instead of HeapLinkedHashSet<>.");
+    static_assert(
+        WTF::IsTraceable<ValueArg>::value,
+        "For sets without traceable elements, use LegacyLinkedHashSet<> "
+        "instead of HeapLegacyLinkedHashSet<>.");
   }
 
  public:
   template <typename>
   static void* AllocateObject(size_t size) {
     return ThreadHeap::Allocate<
-        HeapLinkedHashSet<ValueArg, HashArg, TraitsArg>>(size);
+        HeapLegacyLinkedHashSet<ValueArg, HashArg, TraitsArg>>(size);
   }
 
-  HeapLinkedHashSet() { CheckType(); }
+  HeapLegacyLinkedHashSet() { CheckType(); }
 };
 
+// TODO(bartekn): Remove once fully transitioned to LinkedHashSet.
 template <typename T, typename U, typename V>
-struct GCInfoTrait<HeapLinkedHashSet<T, U, V>>
-    : public GCInfoTrait<LinkedHashSet<T, U, V, HeapAllocator>> {};
+struct GCInfoTrait<HeapLegacyLinkedHashSet<T, U, V>>
+    : public GCInfoTrait<LegacyLinkedHashSet<T, U, V, HeapAllocator>> {};
 
-// This class is still experimental. Do not use this class.
 template <typename ValueArg, typename TraitsArg = HashTraits<ValueArg>>
-class HeapNewLinkedHashSet
-    : public NewLinkedHashSet<ValueArg, TraitsArg, HeapAllocator> {
+class HeapLinkedHashSet
+    : public LinkedHashSet<ValueArg, TraitsArg, HeapAllocator> {
   IS_GARBAGE_COLLECTED_CONTAINER_TYPE();
   DISALLOW_NEW();
 
   static void CheckType() {
     static_assert(internal::IsMemberOrWeakMemberType<ValueArg>,
-                  "HeapNewLinkedHashSet supports only Member and WeakMember.");
+                  "HeapLinkedHashSet supports only Member and WeakMember.");
     // If not trivially destructible, we have to add a destructor which will
     // hinder performance.
-    static_assert(std::is_trivially_destructible<HeapNewLinkedHashSet>::value,
-                  "HeapNewLinkedHashSet must be trivially destructible.");
+    static_assert(std::is_trivially_destructible<HeapLinkedHashSet>::value,
+                  "HeapLinkedHashSet must be trivially destructible.");
     static_assert(
         IsAllowedInContainer<ValueArg>::value,
         "Not allowed to directly nest type. Use Member<> indirection instead.");
     static_assert(WTF::IsTraceable<ValueArg>::value,
-                  "For sets without traceable elements, use NewLinkedHashSet<> "
-                  "instead of HeapNewLinkedHashSet<>.");
+                  "For sets without traceable elements, use LinkedHashSet<> "
+                  "instead of HeapLinkedHashSet<>.");
   }
 
  public:
   template <typename>
   static void* AllocateObject(size_t size) {
-    return ThreadHeap::Allocate<HeapNewLinkedHashSet<ValueArg, TraitsArg>>(
-        size);
+    return ThreadHeap::Allocate<HeapLinkedHashSet<ValueArg, TraitsArg>>(size);
   }
 
-  HeapNewLinkedHashSet() {
-    CheckType();
-  }
+  HeapLinkedHashSet() { CheckType(); }
 };
 
 template <typename T, typename U>
-struct GCInfoTrait<HeapNewLinkedHashSet<T, U>>
-    : public GCInfoTrait<NewLinkedHashSet<T, U, HeapAllocator>> {};
+struct GCInfoTrait<HeapLinkedHashSet<T, U>>
+    : public GCInfoTrait<LinkedHashSet<T, U, HeapAllocator>> {};
 
 template <typename ValueArg,
           wtf_size_t inlineCapacity =
@@ -751,7 +753,7 @@ struct VectorTraits<blink::Member<T>> : VectorTraitsBase<blink::Member<T>> {
 };
 
 // These traits are used in VectorBackedLinkedList to support WeakMember in
-// HeapNewLinkedHashSet though HeapVector<WeakMember> usage is still banned.
+// HeapLinkedHashSet though HeapVector<WeakMember> usage is still banned.
 // (See the discussion in https://crrev.com/c/2246014)
 template <typename T>
 struct VectorTraits<blink::WeakMember<T>>

third_party/blink/renderer/platform/heap/marking_visitor.h

@@ -53,8 +53,9 @@ class PLATFORM_EXPORT MarkingVisitorBase : public Visitor {
   // containing intra-object pointers, all of which must be relocated/rebased
   // with respect to the moved-to location.
   //
-  // For Blink, |HeapLinkedHashSet<>| is currently the only abstraction which
+  // |HeapLegacyLinkedHashSet<>| is currently the only abstraction which
   // relies on this feature.
+  // TODO(bartekn): Remove once fully transitioned to LinkedHashSet.
   void RegisterBackingStoreCallback(const void*, MovingObjectCallback) final;
 
   void RegisterMovableSlot(const void* const*) final;

third_party/blink/renderer/platform/heap/test/concurrent_marking_test.cc

@@ -192,6 +192,37 @@ TEST_F(ConcurrentMarkingTest, SwapHashSet) {
   SwapCollections<HeapHashSet<Member<IntegerObject>>>();
 }
 
+// HeapLegacyLinkedHashSet
+template <typename T>
+class HeapLegacyLinkedHashSetAdapter : public HeapLegacyLinkedHashSet<T> {
+ public:
+  ALWAYS_INLINE void swap(HeapLegacyLinkedHashSetAdapter<T>& other) {
+    HeapLegacyLinkedHashSet<T>::Swap(other);
+  }
+};
+
+TEST_F(ConcurrentMarkingTest, AddToLegacyLinkedHashSet) {
+  AddToCollection<HeapLegacyLinkedHashSetAdapter<Member<IntegerObject>>>();
+}
+TEST_F(ConcurrentMarkingTest, RemoveFromBeginningOfLegacyLinkedHashSet) {
+  RemoveFromBeginningOfCollection<
+      HeapLegacyLinkedHashSetAdapter<Member<IntegerObject>>>();
+}
+TEST_F(ConcurrentMarkingTest, RemoveFromMiddleOfLegacyLinkedHashSet) {
+  RemoveFromMiddleOfCollection<
+      HeapLegacyLinkedHashSetAdapter<Member<IntegerObject>>>();
+}
+TEST_F(ConcurrentMarkingTest, RemoveFromEndOfLegacyLinkedHashSet) {
+  RemoveFromEndOfCollection<
+      HeapLegacyLinkedHashSetAdapter<Member<IntegerObject>>>();
+}
+TEST_F(ConcurrentMarkingTest, ClearLegacyLinkedHashSet) {
+  ClearCollection<HeapLegacyLinkedHashSetAdapter<Member<IntegerObject>>>();
+}
+TEST_F(ConcurrentMarkingTest, SwapLegacyLinkedHashSet) {
+  SwapCollections<HeapLegacyLinkedHashSetAdapter<Member<IntegerObject>>>();
+}
+
 // HeapLinkedHashSet
 template <typename T>
 class HeapLinkedHashSetAdapter : public HeapLinkedHashSet<T> {
@@ -222,37 +253,6 @@ TEST_F(ConcurrentMarkingTest, SwapLinkedHashSet) {
   SwapCollections<HeapLinkedHashSetAdapter<Member<IntegerObject>>>();
 }
 
-// HeapNewLinkedHashSet
-template <typename T>
-class HeapNewLinkedHashSetAdapter : public HeapNewLinkedHashSet<T> {
- public:
-  ALWAYS_INLINE void swap(HeapNewLinkedHashSetAdapter<T>& other) {
-    HeapNewLinkedHashSet<T>::Swap(other);
-  }
-};
-
-TEST_F(ConcurrentMarkingTest, AddToNewLinkedHashSet) {
-  AddToCollection<HeapNewLinkedHashSetAdapter<Member<IntegerObject>>>();
-}
-TEST_F(ConcurrentMarkingTest, RemoveFromBeginningOfNewLinkedHashSet) {
-  RemoveFromBeginningOfCollection<
-      HeapNewLinkedHashSetAdapter<Member<IntegerObject>>>();
-}
-TEST_F(ConcurrentMarkingTest, RemoveFromMiddleOfNewLinkedHashSet) {
-  RemoveFromMiddleOfCollection<
-      HeapNewLinkedHashSetAdapter<Member<IntegerObject>>>();
-}
-TEST_F(ConcurrentMarkingTest, RemoveFromEndOfNewLinkedHashSet) {
-  RemoveFromEndOfCollection<
-      HeapNewLinkedHashSetAdapter<Member<IntegerObject>>>();
-}
-TEST_F(ConcurrentMarkingTest, ClearNewLinkedHashSet) {
-  ClearCollection<HeapNewLinkedHashSetAdapter<Member<IntegerObject>>>();
-}
-TEST_F(ConcurrentMarkingTest, SwapNewLinkedHashSet) {
-  SwapCollections<HeapNewLinkedHashSetAdapter<Member<IntegerObject>>>();
-}
-
 // HeapListHashSet
 
 template <typename T>

third_party/blink/renderer/platform/heap/test/heap_compact_test.cc

@@ -224,8 +224,8 @@ TEST_F(HeapCompactTest, CompactDeques) {
     EXPECT_EQ(static_cast<int>(7 - i), deque->at(i)->Value());
 }
 
-TEST_F(HeapCompactTest, CompactLinkedHashSet) {
-  using OrderedHashSet = HeapLinkedHashSet<Member<IntWrapper>>;
+TEST_F(HeapCompactTest, CompactLegacyLinkedHashSet) {
+  using OrderedHashSet = HeapLegacyLinkedHashSet<Member<IntWrapper>>;
   Persistent<OrderedHashSet> set = MakeGarbageCollected<OrderedHashSet>();
   for (int i = 0; i < 13; ++i) {
     IntWrapper* value = IntWrapper::Create(i, HashTablesAreCompacted);
@@ -249,8 +249,8 @@ TEST_F(HeapCompactTest, CompactLinkedHashSet) {
   }
 }
 
-TEST_F(HeapCompactTest, CompactLinkedHashSetVector) {
-  using OrderedHashSet = HeapLinkedHashSet<Member<IntVector>>;
+TEST_F(HeapCompactTest, CompactLegacyLinkedHashSetVector) {
+  using OrderedHashSet = HeapLegacyLinkedHashSet<Member<IntVector>>;
   Persistent<OrderedHashSet> set = MakeGarbageCollected<OrderedHashSet>();
   for (int i = 0; i < 13; ++i) {
     IntWrapper* value = IntWrapper::Create(i);
@@ -275,9 +275,9 @@ TEST_F(HeapCompactTest, CompactLinkedHashSetVector) {
   }
 }
 
-TEST_F(HeapCompactTest, CompactLinkedHashSetMap) {
+TEST_F(HeapCompactTest, CompactLegacyLinkedHashSetMap) {
   using Inner = HeapHashSet<Member<IntWrapper>>;
-  using OrderedHashSet = HeapLinkedHashSet<Member<Inner>>;
+  using OrderedHashSet = HeapLegacyLinkedHashSet<Member<Inner>>;
 
   Persistent<OrderedHashSet> set = MakeGarbageCollected<OrderedHashSet>();
   for (int i = 0; i < 13; ++i) {
@@ -306,9 +306,9 @@ TEST_F(HeapCompactTest, CompactLinkedHashSetMap) {
   }
 }
 
-TEST_F(HeapCompactTest, CompactLinkedHashSetNested) {
-  using Inner = HeapLinkedHashSet<Member<IntWrapper>>;
-  using OrderedHashSet = HeapLinkedHashSet<Member<Inner>>;
+TEST_F(HeapCompactTest, CompactLegacyLinkedHashSetNested) {
+  using Inner = HeapLegacyLinkedHashSet<Member<IntWrapper>>;
+  using OrderedHashSet = HeapLegacyLinkedHashSet<Member<Inner>>;
 
   Persistent<OrderedHashSet> set = MakeGarbageCollected<OrderedHashSet>();
   for (int i = 0; i < 13; ++i) {
@@ -337,8 +337,8 @@ TEST_F(HeapCompactTest, CompactLinkedHashSetNested) {
   }
 }
 
-TEST_F(HeapCompactTest, CompactNewLinkedHashSet) {
-  using OrderedHashSet = HeapNewLinkedHashSet<Member<IntWrapper>>;
+TEST_F(HeapCompactTest, CompactLinkedHashSet) {
+  using OrderedHashSet = HeapLinkedHashSet<Member<IntWrapper>>;
   Persistent<OrderedHashSet> set = MakeGarbageCollected<OrderedHashSet>();
   for (int i = 0; i < 13; ++i) {
     IntWrapper* value = IntWrapper::Create(i, HashTablesAreCompacted);
@@ -378,8 +378,8 @@ TEST_F(HeapCompactTest, CompactNewLinkedHashSet) {
   EXPECT_EQ(7u, set->size());
 }
 
-TEST_F(HeapCompactTest, CompactNewLinkedHashSetVector) {
-  using OrderedHashSet = HeapNewLinkedHashSet<Member<IntVector>>;
+TEST_F(HeapCompactTest, CompactLinkedHashSetVector) {
+  using OrderedHashSet = HeapLinkedHashSet<Member<IntVector>>;
   Persistent<OrderedHashSet> set = MakeGarbageCollected<OrderedHashSet>();
   for (int i = 0; i < 13; ++i) {
     IntWrapper* value = IntWrapper::Create(i);
@@ -404,9 +404,9 @@ TEST_F(HeapCompactTest, CompactNewLinkedHashSetVector) {
   }
 }
 
-TEST_F(HeapCompactTest, CompactNewLinkedHashSetMap) {
+TEST_F(HeapCompactTest, CompactLinkedHashSetMap) {
   using Inner = HeapHashSet<Member<IntWrapper>>;
-  using OrderedHashSet = HeapNewLinkedHashSet<Member<Inner>>;
+  using OrderedHashSet = HeapLinkedHashSet<Member<Inner>>;
 
   Persistent<OrderedHashSet> set = MakeGarbageCollected<OrderedHashSet>();
   for (int i = 0; i < 13; ++i) {
@@ -435,9 +435,9 @@ TEST_F(HeapCompactTest, CompactNewLinkedHashSetMap) {
   }
 }
 
-TEST_F(HeapCompactTest, CompactNewLinkedHashSetNested) {
-  using Inner = HeapNewLinkedHashSet<Member<IntWrapper>>;
-  using OrderedHashSet = HeapNewLinkedHashSet<Member<Inner>>;
+TEST_F(HeapCompactTest, CompactLinkedHashSetNested) {
+  using Inner = HeapLinkedHashSet<Member<IntWrapper>>;
+  using OrderedHashSet = HeapLinkedHashSet<Member<Inner>>;
 
   Persistent<OrderedHashSet> set = MakeGarbageCollected<OrderedHashSet>();
   for (int i = 0; i < 13; ++i) {

third_party/blink/renderer/platform/heap/test/incremental_marking_test.cc

@@ -904,59 +904,59 @@ TEST_F(IncrementalMarkingTest, HeapHashSetSwap) {
 }
 
 // =============================================================================
-// HeapLinkedHashSet support. ==================================================
+// HeapLegacyLinkedHashSet support. ============================================
 // =============================================================================
 
-TEST_F(IncrementalMarkingTest, HeapLinkedHashSetInsert) {
-  Insert<HeapLinkedHashSet<Member<Object>>>();
+TEST_F(IncrementalMarkingTest, HeapLegacyLinkedHashSetInsert) {
+  Insert<HeapLegacyLinkedHashSet<Member<Object>>>();
   // Weak references are strongified for the current cycle.
-  Insert<HeapLinkedHashSet<WeakMember<Object>>>();
+  Insert<HeapLegacyLinkedHashSet<WeakMember<Object>>>();
 }
 
-TEST_F(IncrementalMarkingTest, HeapLinkedHashSetCopy) {
-  Copy<HeapLinkedHashSet<Member<Object>>>();
+TEST_F(IncrementalMarkingTest, HeapLegacyLinkedHashSetCopy) {
+  Copy<HeapLegacyLinkedHashSet<Member<Object>>>();
   // Weak references are strongified for the current cycle.
-  Copy<HeapLinkedHashSet<WeakMember<Object>>>();
+  Copy<HeapLegacyLinkedHashSet<WeakMember<Object>>>();
 }
 
-TEST_F(IncrementalMarkingTest, HeapLinkedHashSetMove) {
-  Move<HeapLinkedHashSet<Member<Object>>>();
+TEST_F(IncrementalMarkingTest, HeapLegacyLinkedHashSetMove) {
+  Move<HeapLegacyLinkedHashSet<Member<Object>>>();
   // Weak references are strongified for the current cycle.
-  Move<HeapLinkedHashSet<WeakMember<Object>>>();
+  Move<HeapLegacyLinkedHashSet<WeakMember<Object>>>();
 }
 
-TEST_F(IncrementalMarkingTest, HeapLinkedHashSetSwap) {
-  Swap<HeapLinkedHashSet<Member<Object>>>();
+TEST_F(IncrementalMarkingTest, HeapLegacyLinkedHashSetSwap) {
+  Swap<HeapLegacyLinkedHashSet<Member<Object>>>();
   // Weak references are strongified for the current cycle.
-  Swap<HeapLinkedHashSet<WeakMember<Object>>>();
+  Swap<HeapLegacyLinkedHashSet<WeakMember<Object>>>();
 }
 
 // =============================================================================
-// HeapNewLinkedHashSet support. ===============================================
+// HeapLinkedHashSet support. ==================================================
 // =============================================================================
 
-TEST_F(IncrementalMarkingTest, HeapNewLinkedHashSetInsert) {
-  Insert<HeapNewLinkedHashSet<Member<Object>>>();
+TEST_F(IncrementalMarkingTest, HeapLinkedHashSetInsert) {
+  Insert<HeapLinkedHashSet<Member<Object>>>();
   // Weak references are strongified for the current cycle.
-  Insert<HeapNewLinkedHashSet<WeakMember<Object>>>();
+  Insert<HeapLinkedHashSet<WeakMember<Object>>>();
 }
 
-TEST_F(IncrementalMarkingTest, HeapNewLinkedHashSetCopy) {
-  Copy<HeapNewLinkedHashSet<Member<Object>>>();
+TEST_F(IncrementalMarkingTest, HeapLinkedHashSetCopy) {
+  Copy<HeapLinkedHashSet<Member<Object>>>();
   // Weak references are strongified for the current cycle.
-  Copy<HeapNewLinkedHashSet<WeakMember<Object>>>();
+  Copy<HeapLinkedHashSet<WeakMember<Object>>>();
 }
 
-TEST_F(IncrementalMarkingTest, HeapNewLinkedHashSetMove) {
-  Move<HeapNewLinkedHashSet<Member<Object>>>();
+TEST_F(IncrementalMarkingTest, HeapLinkedHashSetMove) {
+  Move<HeapLinkedHashSet<Member<Object>>>();
   // Weak references are strongified for the current cycle.
-  Move<HeapNewLinkedHashSet<WeakMember<Object>>>();
+  Move<HeapLinkedHashSet<WeakMember<Object>>>();
 }
 
-TEST_F(IncrementalMarkingTest, HeapNewLinkedHashSetSwap) {
-  Swap<HeapNewLinkedHashSet<Member<Object>>>();
+TEST_F(IncrementalMarkingTest, HeapLinkedHashSetSwap) {
+  Swap<HeapLinkedHashSet<Member<Object>>>();
   // Weak references are strongified for the current cycle.
-  Swap<HeapNewLinkedHashSet<WeakMember<Object>>>();
+  Swap<HeapLinkedHashSet<WeakMember<Object>>>();
 }
 
 // =============================================================================
@@ -1809,12 +1809,12 @@ class Destructed final : public GarbageCollected<Destructed> {
 
 size_t Destructed::n_destructed = 0;
 
-class LinkedHashSetWrapper final
-    : public GarbageCollected<LinkedHashSetWrapper> {
+class LegacyLinkedHashSetWrapper final
+    : public GarbageCollected<LegacyLinkedHashSetWrapper> {
  public:
-  using HashType = HeapLinkedHashSet<Member<Destructed>>;
+  using HashType = HeapLegacyLinkedHashSet<Member<Destructed>>;
 
-  LinkedHashSetWrapper() {
+  LegacyLinkedHashSetWrapper() {
     for (size_t i = 0; i < 10; ++i) {
       hash_set_.insert(MakeGarbageCollected<Destructed>());
     }
@@ -1830,7 +1830,7 @@ class LinkedHashSetWrapper final
   HashType hash_set_;
 };
 
-TEST_F(IncrementalMarkingTest, LinkedHashSetMovingCallback) {
+TEST_F(IncrementalMarkingTest, LegacyLinkedHashSetMovingCallback) {
   ClearOutOldGarbage();
 
   Destructed::n_destructed = 0;
@@ -1838,16 +1838,16 @@ TEST_F(IncrementalMarkingTest, LinkedHashSetMovingCallback) {
     HeapHashSet<Member<Destructed>> to_be_destroyed;
     to_be_destroyed.ReserveCapacityForSize(100);
   }
-  Persistent<LinkedHashSetWrapper> wrapper =
-      MakeGarbageCollected<LinkedHashSetWrapper>();
+  Persistent<LegacyLinkedHashSetWrapper> wrapper =
+      MakeGarbageCollected<LegacyLinkedHashSetWrapper>();
 
   IncrementalMarkingTestDriver driver(ThreadState::Current());
   ThreadState::Current()->EnableCompactionForNextGCForTesting();
   driver.Start();
   driver.FinishSteps();
 
-  // Destroy the link between original HeapLinkedHashSet object and its backing
-  // store.
+  // Destroy the link between original HeapLegacyLinkedHashSet object and its
+  // backing store.
   wrapper->Swap();
   DCHECK(wrapper->hash_set_.IsEmpty());
 
@@ -1856,12 +1856,12 @@ TEST_F(IncrementalMarkingTest, LinkedHashSetMovingCallback) {
   EXPECT_EQ(10u, Destructed::n_destructed);
 }
 
-class NewLinkedHashSetWrapper final
-    : public GarbageCollected<NewLinkedHashSetWrapper> {
+class LinkedHashSetWrapper final
+    : public GarbageCollected<LinkedHashSetWrapper> {
  public:
-  using HashType = HeapNewLinkedHashSet<Member<Destructed>>;
+  using HashType = HeapLinkedHashSet<Member<Destructed>>;
 
-  NewLinkedHashSetWrapper() {
+  LinkedHashSetWrapper() {
     for (size_t i = 0; i < 10; ++i) {
       hash_set_.insert(MakeGarbageCollected<Destructed>());
     }
@@ -1877,7 +1877,7 @@ class NewLinkedHashSetWrapper final
   HashType hash_set_;
 };
 
-TEST_F(IncrementalMarkingTest, NewLinkedHashSetMovingCallback) {
+TEST_F(IncrementalMarkingTest, LinkedHashSetMovingCallback) {
   ClearOutOldGarbage();
 
   Destructed::n_destructed = 0;
@@ -1885,16 +1885,16 @@ TEST_F(IncrementalMarkingTest, NewLinkedHashSetMovingCallback) {
     HeapHashSet<Member<Destructed>> to_be_destroyed;
     to_be_destroyed.ReserveCapacityForSize(100);
   }
-  Persistent<NewLinkedHashSetWrapper> wrapper =
-      MakeGarbageCollected<NewLinkedHashSetWrapper>();
+  Persistent<LinkedHashSetWrapper> wrapper =
+      MakeGarbageCollected<LinkedHashSetWrapper>();
 
   IncrementalMarkingTestDriver driver(ThreadState::Current());
   ThreadState::Current()->EnableCompactionForNextGCForTesting();
   driver.Start();
   driver.FinishSteps();
 
-  // Destroy the link between original NewHeapLinkedHashSet object and its
-  // backing store.
+  // Destroy the link between original HeapLinkedHashSet object and its backing
+  // store.
   wrapper->Swap();
   DCHECK(wrapper->hash_set_.IsEmpty());
 

third_party/blink/renderer/platform/heap/test/weakness_marking_test.cc

@@ -207,9 +207,12 @@ TEST_F(WeaknessMarkingTest, SwapIntoAlreadyProcessedWeakSet) {
   // Test ensures that an empty weak set that has already been marked sets up
   // weakness callbacks. This is important as another backing may be swapped in
   // at some point after marking it initially.
-  using WeakLinkedSet = HeapLinkedHashSet<WeakMember<IntegerObject>>;
-  Persistent<WeakLinkedSet> holder1(MakeGarbageCollected<WeakLinkedSet>());
-  Persistent<WeakLinkedSet> holder2(MakeGarbageCollected<WeakLinkedSet>());
+  using WeakLegacyLinkedSet =
+      HeapLegacyLinkedHashSet<WeakMember<IntegerObject>>;
+  Persistent<WeakLegacyLinkedSet> holder1(
+      MakeGarbageCollected<WeakLegacyLinkedSet>());
+  Persistent<WeakLegacyLinkedSet> holder2(
+      MakeGarbageCollected<WeakLegacyLinkedSet>());
   holder1->insert(MakeGarbageCollected<IntegerObject>(1));
   IncrementalMarkingTestDriver driver(ThreadState::Current());
   driver.Start();
@@ -217,11 +220,9 @@ TEST_F(WeaknessMarkingTest, SwapIntoAlreadyProcessedWeakSet) {
   holder1->Swap(*holder2.Get());
   driver.FinishGC();
 
-  using NewWeakLinkedSet = HeapNewLinkedHashSet<WeakMember<IntegerObject>>;
-  Persistent<NewWeakLinkedSet> holder3(
-      MakeGarbageCollected<NewWeakLinkedSet>());
-  Persistent<NewWeakLinkedSet> holder4(
-      MakeGarbageCollected<NewWeakLinkedSet>());
+  using WeakLinkedSet = HeapLinkedHashSet<WeakMember<IntegerObject>>;
+  Persistent<WeakLinkedSet> holder3(MakeGarbageCollected<WeakLinkedSet>());
+  Persistent<WeakLinkedSet> holder4(MakeGarbageCollected<WeakLinkedSet>());
   holder3->insert(MakeGarbageCollected<IntegerObject>(1));
   IncrementalMarkingTestDriver driver2(ThreadState::Current());
   driver2.Start();
@@ -257,9 +258,9 @@ TEST_F(WeaknessMarkingTest, ClearWeakHashTableAfterMarking) {
 
 TEST_F(WeaknessMarkingTest, StrongifyBackingOnStack) {
   // Test eunsures that conservative GC strongifies the backing store of
-  // on-stack NewLinkedHashSet.
-  using WeakSet = HeapNewLinkedHashSet<WeakMember<IntegerObject>>;
-  using StrongSet = HeapNewLinkedHashSet<Member<IntegerObject>>;
+  // on-stack HeapLinkedHashSet.
+  using WeakSet = HeapLinkedHashSet<WeakMember<IntegerObject>>;
+  using StrongSet = HeapLinkedHashSet<Member<IntegerObject>>;
   WeakSet weak_set_on_stack;
   weak_set_on_stack.insert(MakeGarbageCollected<IntegerObject>(1));
   StrongSet strong_set_on_stack;

third_party/blink/renderer/platform/heap/trace_traits.h

@@ -376,21 +376,22 @@ struct TraceInCollectionTrait<
   }
 };
 
-// Nodes used by LinkedHashSet.  Again we need two versions to disambiguate the
-// template.
+// Nodes used by LegacyLinkedHashSet.  Again we need two versions to
+// disambiguate the template.
+// TODO(bartekn): Remove once fully transitioned to LinkedHashSet.
 template <typename Value, typename Traits>
 struct TraceInCollectionTrait<kNoWeakHandling,
-                              LinkedHashSetNode<Value>,
+                              LegacyLinkedHashSetNode<Value>,
                               Traits> {
   static bool IsAlive(const blink::LivenessBroker& info,
-                      const LinkedHashSetNode<Value>& self) {
+                      const LegacyLinkedHashSetNode<Value>& self) {
     return TraceInCollectionTrait<
         kNoWeakHandling, Value,
         typename Traits::ValueTraits>::IsAlive(info, self.value_);
   }
 
   static void Trace(blink::Visitor* visitor,
-                    const LinkedHashSetNode<Value>& self) {
+                    const LegacyLinkedHashSetNode<Value>& self) {
     static_assert(
         IsTraceableInCollectionTrait<Traits>::value || IsWeak<Value>::value,
         "T should be traceable (or weak)");
@@ -401,16 +402,18 @@ struct TraceInCollectionTrait<kNoWeakHandling,
 };
 
 template <typename Value, typename Traits>
-struct TraceInCollectionTrait<kWeakHandling, LinkedHashSetNode<Value>, Traits> {
+struct TraceInCollectionTrait<kWeakHandling,
+                              LegacyLinkedHashSetNode<Value>,
+                              Traits> {
   static bool IsAlive(const blink::LivenessBroker& info,
-                      const LinkedHashSetNode<Value>& self) {
+                      const LegacyLinkedHashSetNode<Value>& self) {
     return TraceInCollectionTrait<
         kWeakHandling, Value,
         typename Traits::ValueTraits>::IsAlive(info, self.value_);
   }
 
   static void Trace(blink::Visitor* visitor,
-                    const LinkedHashSetNode<Value>& self) {
+                    const LegacyLinkedHashSetNode<Value>& self) {
     TraceInCollectionTrait<kWeakHandling, Value,
                            typename Traits::ValueTraits>::Trace(visitor,
                                                                 self.value_);

third_party/blink/renderer/platform/wtf/hash_table.h

@@ -219,11 +219,12 @@ template <typename Key,
           typename KeyTraits,
           typename Allocator>
 class HashTableConstIterator;
+// TODO(bartekn): Remove once fully transitioned to LinkedHashSet.
 template <typename Value,
           typename HashFunctions,
           typename HashTraits,
           typename Allocator>
-class LinkedHashSet;
+class LegacyLinkedHashSet;
 template <WeakHandlingFlag x,
           typename T,
           typename U,
@@ -1018,8 +1019,9 @@ class HashTable final
             typename Y,
             typename Z>
   friend struct WeakProcessingHashTableHelper;
+  // TODO(bartekn): Remove once fully transitioned to LinkedHashSet.
   template <typename T, typename U, typename V, typename W>
-  friend class LinkedHashSet;
+  friend class LegacyLinkedHashSet;
   template <typename T, size_t, typename U, typename V>
   friend class ListHashSet;
 };

third_party/blink/renderer/platform/wtf/hash_traits.h

@@ -99,9 +99,10 @@ struct GenericHashTraitsBase<false, T> {
   static constexpr bool kCanHaveDeletedValue = true;
 
   // The kHasMovingCallback value is only used for HashTable backing stores.
-  // Currently it is needed for LinkedHashSet to register moving callback on
-  // write barrier. Users of this value have to provide RegisterMovingCallback
-  // function.
+  // Currently it is needed for LegacyLinkedHashSet to register moving callback
+  // on write barrier. Users of this value have to provide
+  // RegisterMovingCallback function.
+  // TODO(bartekn): Remove once fully transitioned to LinkedHashSet.
   static constexpr bool kHasMovingCallback = false;
 
   // The kCanTraceConcurrently value is used by Oilpan concurrent marking. Only

third_party/blink/renderer/platform/wtf/linked_hash_set_test.cc

@@ -11,12 +11,17 @@
 
 namespace WTF {
 
+static_assert(!WTF::IsTraceable<LinkedHashSet<int>>::value,
+              "LinkedHashSet must not be traceable.");
+static_assert(!WTF::IsTraceable<LinkedHashSet<String>>::value,
+              "LinkedHashSet must not be traceable.");
+
 template <typename T>
 int* const ValueInstanceCount<T>::kDeletedValue =
     reinterpret_cast<int*>(static_cast<uintptr_t>(-1));
 
-TEST(NewLinkedHashSetTest, CopyConstructAndAssignInt) {
-  using Set = NewLinkedHashSet<ValueInstanceCount<int>>;
+TEST(LinkedHashSetTest, CopyConstructAndAssignInt) {
+  using Set = LinkedHashSet<ValueInstanceCount<int>>;
   // Declare the counters before the set, because they have to outlive teh set.
   int counter1 = 0;
   int counter2 = 0;
@@ -53,8 +58,8 @@ TEST(NewLinkedHashSetTest, CopyConstructAndAssignInt) {
   EXPECT_EQ(counter3, 6);
 }
 
-TEST(NewLinkedHashSetTest, CopyConstructAndAssignIntPtr) {
-  using Set = NewLinkedHashSet<int*>;
+TEST(LinkedHashSetTest, CopyConstructAndAssignIntPtr) {
+  using Set = LinkedHashSet<int*>;
   Set set1;
   EXPECT_EQ(set1.size(), 0u);
   EXPECT_TRUE(set1.IsEmpty());
@@ -99,8 +104,8 @@ TEST(NewLinkedHashSetTest, CopyConstructAndAssignIntPtr) {
   }
 }
 
-TEST(NewLinkedHashSetTest, CopyConstructAndAssignString) {
-  using Set = NewLinkedHashSet<String>;
+TEST(LinkedHashSetTest, CopyConstructAndAssignString) {
+  using Set = LinkedHashSet<String>;
   Set set1;
   EXPECT_EQ(set1.size(), 0u);
   EXPECT_TRUE(set1.IsEmpty());
@@ -144,8 +149,8 @@ TEST(NewLinkedHashSetTest, CopyConstructAndAssignString) {
   }
 }
 
-TEST(NewLinkedHashSetTest, MoveConstructAndAssignInt) {
-  using Set = NewLinkedHashSet<ValueInstanceCount<int>>;
+TEST(LinkedHashSetTest, MoveConstructAndAssignInt) {
+  using Set = LinkedHashSet<ValueInstanceCount<int>>;
   int counter1 = 0;
   int counter2 = 0;
   int counter3 = 0;
@@ -181,8 +186,8 @@ TEST(NewLinkedHashSetTest, MoveConstructAndAssignInt) {
   EXPECT_EQ(counter3, 4);
 }
 
-TEST(NewLinkedHashSetTest, MoveConstructAndAssignString) {
-  using Set = NewLinkedHashSet<ValueInstanceCount<String>>;
+TEST(LinkedHashSetTest, MoveConstructAndAssignString) {
+  using Set = LinkedHashSet<ValueInstanceCount<String>>;
   int counter1 = 0;
   int counter2 = 0;
   int counter3 = 0;
@@ -218,15 +223,15 @@ TEST(NewLinkedHashSetTest, MoveConstructAndAssignString) {
   EXPECT_EQ(counter3, 4);
 }
 
-TEST(NewLinkedHashSetTest, Iterator) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, Iterator) {
+  using Set = LinkedHashSet<int>;
   Set set;
   EXPECT_TRUE(set.begin() == set.end());
   EXPECT_TRUE(set.rbegin() == set.rend());
 }
 
-TEST(NewLinkedHashSetTest, FrontAndBack) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, FrontAndBack) {
+  using Set = LinkedHashSet<int>;
   Set set;
   EXPECT_EQ(set.size(), 0u);
   EXPECT_TRUE(set.IsEmpty());
@@ -252,8 +257,8 @@ TEST(NewLinkedHashSetTest, FrontAndBack) {
   EXPECT_EQ(set.back(), 1);
 }
 
-TEST(NewLinkedHashSetTest, FindAndContains) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, FindAndContains) {
+  using Set = LinkedHashSet<int>;
   Set set;
   set.insert(2);
   set.AppendOrMoveToLast(2);
@@ -284,8 +289,8 @@ TEST(NewLinkedHashSetTest, FindAndContains) {
   EXPECT_FALSE(set.Contains(10));
 }
 
-TEST(NewLinkedHashSetTest, Insert) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, Insert) {
+  using Set = LinkedHashSet<int>;
   Set set;
   Set::AddResult result = set.insert(1);
   EXPECT_TRUE(result.is_new_entry);
@@ -317,8 +322,8 @@ TEST(NewLinkedHashSetTest, Insert) {
   EXPECT_TRUE(it == set.end());
 }
 
-TEST(NewLinkedHashSetTest, InsertBefore) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, InsertBefore) {
+  using Set = LinkedHashSet<int>;
   Set set;
 
   set.InsertBefore(set.begin(), 1);
@@ -344,8 +349,8 @@ TEST(NewLinkedHashSetTest, InsertBefore) {
   EXPECT_TRUE(it == set.end());
 }
 
-TEST(NewLinkedHashSetTest, AppendOrMoveToLast) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, AppendOrMoveToLast) {
+  using Set = LinkedHashSet<int>;
   Set set;
   Set::AddResult result = set.AppendOrMoveToLast(1);
   EXPECT_TRUE(result.is_new_entry);
@@ -371,8 +376,8 @@ TEST(NewLinkedHashSetTest, AppendOrMoveToLast) {
   EXPECT_EQ(*it, 3);
 }
 
-TEST(NewLinkedHashSetTest, PrependOrMoveToFirst) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, PrependOrMoveToFirst) {
+  using Set = LinkedHashSet<int>;
   Set set;
   Set::AddResult result = set.PrependOrMoveToFirst(1);
   EXPECT_TRUE(result.is_new_entry);
@@ -398,8 +403,8 @@ TEST(NewLinkedHashSetTest, PrependOrMoveToFirst) {
   EXPECT_EQ(*it, 2);
 }
 
-TEST(NewLinkedHashSetTest, Erase) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, Erase) {
+  using Set = LinkedHashSet<int>;
   Set set;
   set.insert(1);
   set.insert(2);
@@ -442,8 +447,8 @@ TEST(NewLinkedHashSetTest, Erase) {
   EXPECT_EQ(*it, 6);
 }
 
-TEST(NewLinkedHashSetTest, RemoveFirst) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, RemoveFirst) {
+  using Set = LinkedHashSet<int>;
   Set set;
   set.insert(1);
   set.insert(2);
@@ -463,8 +468,8 @@ TEST(NewLinkedHashSetTest, RemoveFirst) {
   EXPECT_TRUE(set.begin() == set.end());
 }
 
-TEST(NewLinkedHashSetTest, pop_back) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, pop_back) {
+  using Set = LinkedHashSet<int>;
   Set set;
   set.insert(1);
   set.insert(2);
@@ -484,8 +489,8 @@ TEST(NewLinkedHashSetTest, pop_back) {
   EXPECT_TRUE(set.begin() == set.end());
 }
 
-TEST(NewLinkedHashSetTest, Clear) {
-  using Set = NewLinkedHashSet<int>;
+TEST(LinkedHashSetTest, Clear) {
+  using Set = LinkedHashSet<int>;
   Set set;
   set.insert(1);
   set.insert(2);
@@ -544,13 +549,13 @@ struct DefaultHash<EmptyString> {
   };
 };
 
-// This ensures that NewLinkedHashSet can store a struct that needs
+// This ensures that LinkedHashSet can store a struct that needs
 // HashTraits<>::kEmptyValueIsZero set to false. The default EmptyValue() of
 // SimpleClassHashTraits<> returns a value created with the default constructor,
 // so a custom HashTraits that sets kEmptyValueIsZero to false and also
 // overrides EmptyValue() to provide another empty value is needed.
-TEST(NewLinkedHashSetEmptyTest, EmptyString) {
-  using Set = NewLinkedHashSet<EmptyString>;
+TEST(LinkedHashSetEmptyTest, EmptyString) {
+  using Set = LinkedHashSet<EmptyString>;
   Set set;
   set.insert(EmptyString());
 }

third_party/blink/renderer/platform/wtf/list_hash_set_test.cc

@@ -41,7 +41,7 @@ namespace {
 template <typename Set>
 class ListOrLinkedHashSetTest : public testing::Test {};
 
-// These custom traits affect only NewLinkedHashSet tests.
+// These custom traits affect only LinkedHashSet tests.
 struct CustomHashTraitsForInt : public HashTraits<int> {
   static const bool kEmptyValueIsZero = false;
   static int EmptyValue() { return INT_MAX; }
@@ -52,8 +52,8 @@ struct CustomHashTraitsForInt : public HashTraits<int> {
 
 using SetTypes = testing::Types<ListHashSet<int>,
                                 ListHashSet<int, 1>,
-                                LinkedHashSet<int>,
-                                NewLinkedHashSet<int, CustomHashTraitsForInt>>;
+                                LegacyLinkedHashSet<int>,
+                                LinkedHashSet<int, CustomHashTraitsForInt>>;
 TYPED_TEST_SUITE(ListOrLinkedHashSetTest, SetTypes);
 
 TYPED_TEST(ListOrLinkedHashSetTest, RemoveFirst) {
@@ -240,8 +240,8 @@ TYPED_TEST(ListOrLinkedHashSetTest, Find) {
 TYPED_TEST(ListOrLinkedHashSetTest, InsertBefore) {
   using Set = TypeParam;
   bool can_modify_while_iterating =
-      !std::is_same<Set, LinkedHashSet<int>>::value &&
-      !std::is_same<Set, NewLinkedHashSet<int, CustomHashTraitsForInt>>::value;
+      !std::is_same<Set, LegacyLinkedHashSet<int>>::value &&
+      !std::is_same<Set, LinkedHashSet<int, CustomHashTraitsForInt>>::value;
   Set set;
   set.insert(-1);
   set.insert(0);
@@ -373,16 +373,15 @@ class ListOrLinkedHashSetRefPtrTest : public testing::Test {};
 using RefPtrSetTypes =
     testing::Types<ListHashSet<scoped_refptr<DummyRefCounted>>,
                    ListHashSet<scoped_refptr<DummyRefCounted>, 1>,
-                   LinkedHashSet<scoped_refptr<DummyRefCounted>>,
-                   NewLinkedHashSet<scoped_refptr<DummyRefCounted>>>;
+                   LegacyLinkedHashSet<scoped_refptr<DummyRefCounted>>,
+                   LinkedHashSet<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)
+  // LinkedHashSet stores each object twice.
+  if (std::is_same<Set, LinkedHashSet<scoped_refptr<DummyRefCounted>>>::value)
     expected = 2;
   bool is_deleted = false;
   DummyRefCounted::ref_invokes_count_ = 0;
@@ -485,11 +484,11 @@ struct ComplexityTranslator {
 template <typename Set>
 class ListOrLinkedHashSetTranslatorTest : public testing::Test {};
 
-// TODO(bartekn): Add NewLinkedHashSet once it supports custom hash function.
+// TODO(bartekn): Add LinkedHashSet once it supports custom hash function.
 using TranslatorSetTypes =
     testing::Types<ListHashSet<Complicated, 256, ComplicatedHashFunctions>,
                    ListHashSet<Complicated, 1, ComplicatedHashFunctions>,
-                   LinkedHashSet<Complicated, ComplicatedHashFunctions>>;
+                   LegacyLinkedHashSet<Complicated, ComplicatedHashFunctions>>;
 TYPED_TEST_SUITE(ListOrLinkedHashSetTranslatorTest, TranslatorSetTypes);
 
 TYPED_TEST(ListOrLinkedHashSetTranslatorTest, ComplexityTranslator) {
@@ -595,8 +594,8 @@ class ListOrLinkedHashSetCountCopyTest : public testing::Test {};
 
 using CountCopySetTypes = testing::Types<ListHashSet<CountCopy>,
                                          ListHashSet<CountCopy, 1>,
-                                         LinkedHashSet<CountCopy>,
-                                         NewLinkedHashSet<CountCopy>>;
+                                         LegacyLinkedHashSet<CountCopy>,
+                                         LinkedHashSet<CountCopy>>;
 TYPED_TEST_SUITE(ListOrLinkedHashSetCountCopyTest, CountCopySetTypes);
 
 TYPED_TEST(ListOrLinkedHashSetCountCopyTest,
@@ -626,10 +625,10 @@ TYPED_TEST(ListOrLinkedHashSetCountCopyTest, MoveAssignmentShouldNotMakeACopy) {
 template <typename Set>
 class ListOrLinkedHashSetMoveOnlyTest : public testing::Test {};
 
-// TODO(bartekn): Add NewLinkedHashSet once it supports move-only type.
+// TODO(bartekn): Add LinkedHashSet once it supports move-only type.
 using MoveOnlySetTypes = testing::Types<ListHashSet<MoveOnlyHashValue>,
                                         ListHashSet<MoveOnlyHashValue, 1>,
-                                        LinkedHashSet<MoveOnlyHashValue>>;
+                                        LegacyLinkedHashSet<MoveOnlyHashValue>>;
 TYPED_TEST_SUITE(ListOrLinkedHashSetMoveOnlyTest, MoveOnlySetTypes);
 
 TYPED_TEST(ListOrLinkedHashSetMoveOnlyTest, MoveOnlyValue) {
@@ -722,11 +721,11 @@ struct DefaultHash<InvalidZeroValue> {
 template <typename Set>
 class ListOrLinkedHashSetInvalidZeroTest : public testing::Test {};
 
-// NewLinkedHashSet is tested in NewLinkedHashSetEmptyTest.EmptyString
+// LinkedHashSet is tested in LinkedHashSetEmptyTest.EmptyString
 using InvalidZeroValueSetTypes =
     testing::Types<ListHashSet<InvalidZeroValue>,
                    ListHashSet<InvalidZeroValue, 1>,
-                   LinkedHashSet<InvalidZeroValue>>;
+                   LegacyLinkedHashSet<InvalidZeroValue>>;
 TYPED_TEST_SUITE(ListOrLinkedHashSetInvalidZeroTest, InvalidZeroValueSetTypes);
 
 TYPED_TEST(ListOrLinkedHashSetInvalidZeroTest, InvalidZeroValue) {

third_party/blink/renderer/platform/wtf/vector_backed_linked_list.h

@@ -155,6 +155,10 @@ class VectorBackedLinkedList {
 
  private:
   using Node = VectorBackedLinkedListNode<ValueType, Allocator>;
+  // Using Vector like this (instead of HeapVector for garbage collected types)
+  // skips the checks for HeapVector in heap_allocator.h. This is necessary
+  // because HeapVector doesn't allow WeakMember, but we need to support
+  // VectorBackedLinkedList<WeakMember>.
   using VectorType = Vector<Node, 0, Allocator>;
 
  public:
@@ -168,15 +172,6 @@ class VectorBackedLinkedList {
   using const_reverse_iterator =
       VectorBackedLinkedListConstReverseIterator<VectorBackedLinkedList>;
 
-  VectorBackedLinkedList();
-
-  VectorBackedLinkedList(const VectorBackedLinkedList&) = default;
-  VectorBackedLinkedList(VectorBackedLinkedList&&) = default;
-  VectorBackedLinkedList& operator=(const VectorBackedLinkedList&) = default;
-  VectorBackedLinkedList& operator=(VectorBackedLinkedList&&) = default;
-
-  ~VectorBackedLinkedList() = default;
-
   void swap(VectorBackedLinkedList&);
 
   bool empty() const { return size_ == 0; }
@@ -273,6 +268,22 @@ class VectorBackedLinkedList {
 #endif
 
  private:
+  // The constructors are private, because the class is used only by
+  // LinkedHashSet and we don't want it to be instantiated directly otherwise.
+  // There are a couple resonts for that:
+  // 1. We know that usage of VectorBackedLinkedList in LinkedHashSet is safe,
+  //    since it is limited to Member and WeakMember for GCed sets. Other
+  //    potential usages might not be safe.
+  // 2. LinkedHashSet relies on indices inside VectorBackedLinkedList not
+  //    changing. Usage of VectorBackedLinkedList outside of LinkedHashSet may
+  //    encourage code optimizations that may break that assumption.
+  VectorBackedLinkedList();
+  VectorBackedLinkedList(const VectorBackedLinkedList&) = default;
+  VectorBackedLinkedList(VectorBackedLinkedList&&) = default;
+  VectorBackedLinkedList& operator=(const VectorBackedLinkedList&) = default;
+  VectorBackedLinkedList& operator=(VectorBackedLinkedList&&) = default;
+  ~VectorBackedLinkedList() = default;
+
   bool IsFreeListEmpty() const { return free_head_index_ == anchor_index_; }
 
   wtf_size_t UsedFirstIndex() const {
@@ -328,7 +339,19 @@ class VectorBackedLinkedList {
 #endif
 
   template <typename T, typename U, typename V>
-  friend class NewLinkedHashSet;
+  friend class LinkedHashSet;
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, Insert);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, PushFront);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, PushBack);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, MoveTo);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, Erase);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, PopFront);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, PopBack);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, Clear);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, Iterator);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, ConstIterator);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, String);
+  FRIEND_TEST_ALL_PREFIXES(VectorBackedLinkedListTest, UniquePtr);
 };
 
 template <typename VectorBackedLinkedListType>

third_party/blink/renderer/platform/wtf/vector_backed_linked_list_test.cc

@@ -43,7 +43,7 @@ TEST(VectorBackedLinkedListTest, Insert) {
   }
 }
 
-TEST(VectorBackedLinkedList, PushFront) {
+TEST(VectorBackedLinkedListTest, PushFront) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -62,7 +62,7 @@ TEST(VectorBackedLinkedList, PushFront) {
   }
 }
 
-TEST(VectorBackedLinkedList, PushBack) {
+TEST(VectorBackedLinkedListTest, PushBack) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -81,7 +81,7 @@ TEST(VectorBackedLinkedList, PushBack) {
   }
 }
 
-TEST(VectorBackedLinkedList, MoveTo) {
+TEST(VectorBackedLinkedListTest, MoveTo) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -140,7 +140,7 @@ TEST(VectorBackedLinkedList, MoveTo) {
   EXPECT_EQ(*it, 2);
 }
 
-TEST(VectorBackedLinkedList, Erase) {
+TEST(VectorBackedLinkedListTest, Erase) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -183,7 +183,7 @@ TEST(VectorBackedLinkedList, Erase) {
   EXPECT_EQ(list.back(), 6);
 }
 
-TEST(VectorBackedLinkedList, PopFront) {
+TEST(VectorBackedLinkedListTest, PopFront) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -211,7 +211,7 @@ TEST(VectorBackedLinkedList, PopFront) {
   EXPECT_TRUE(list.empty());
 }
 
-TEST(VectorBackedLinkedList, PopBack) {
+TEST(VectorBackedLinkedListTest, PopBack) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -233,7 +233,7 @@ TEST(VectorBackedLinkedList, PopBack) {
   EXPECT_TRUE(list.empty());
 }
 
-TEST(VectorBackedLinkedList, Clear) {
+TEST(VectorBackedLinkedListTest, Clear) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -254,7 +254,7 @@ TEST(VectorBackedLinkedList, Clear) {
   EXPECT_EQ(list.size(), 1u);
 }
 
-TEST(VectorBackedLinkedList, Iterator) {
+TEST(VectorBackedLinkedListTest, Iterator) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -297,7 +297,7 @@ TEST(VectorBackedLinkedList, Iterator) {
   EXPECT_EQ(*rit, 1);
 }
 
-TEST(VectorBackedLinkedList, ConstIterator) {
+TEST(VectorBackedLinkedListTest, ConstIterator) {
   using List = VectorBackedLinkedList<int>;
   List list;
 
@@ -333,7 +333,7 @@ TEST(VectorBackedLinkedList, ConstIterator) {
   EXPECT_EQ(*crit, 1);
 }
 
-TEST(VectorBackedLinkedList, String) {
+TEST(VectorBackedLinkedListTest, String) {
   using List = VectorBackedLinkedList<String>;
   List list;
 
@@ -394,7 +394,7 @@ TEST(VectorBackedLinkedList, String) {
   EXPECT_TRUE(list.empty());
 }
 
-TEST(VectorBackedLinkedList, UniquePtr) {
+TEST(VectorBackedLinkedListTest, UniquePtr) {
   using List = VectorBackedLinkedList<std::unique_ptr<Dummy>>;
   List list;