Added erase-related functions to NewLinkedHashSet

Implemented |erase|, |RemoveFirst|, |pop_back|, |clear| in NewLinkedHashSet.
Also added tests for those functions.

Change-Id: I434409a3f1ad0a6bffd60ddfbd79f4cdeaf22d94
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2103994Reviewed-by: Bartek Nowierski <bartekn@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Yuki Shiino <yukishiino@chromium.org>
Commit-Queue: Kei Nakashima <keinakashima@google.com>
Cr-Commit-Position: refs/heads/master@{#750538}

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

@@ -1102,9 +1102,16 @@ class NewLinkedHashSet {
   template <typename IncomingValueType>
   AddResult PrependOrMoveToFirst(IncomingValueType&&);
 
-  // TODO(keinakashima): implement functions related to erase
+  void erase(ValuePeekInType);
+  void erase(const_iterator);
+  void RemoveFirst();
+  void pop_back();
 
-  // TODO(keinakashima): implement clear (,RemoveAll, Trace)
+  void clear() {
+    value_to_index_.clear();
+    list_.clear();
+  }
+  // TODO(keinakashima): implement Trace
 
  private:
   template <typename IncomingValueType>
@@ -1195,6 +1202,31 @@ NewLinkedHashSet<T>::PrependOrMoveToFirst(IncomingValueType&& value) {
   return InsertOrMoveBefore(begin(), std::forward<IncomingValueType>(value));
 }
 
+template <typename T>
+inline void NewLinkedHashSet<T>::erase(ValuePeekInType value) {
+  erase(find(value));
+}
+
+template <typename T>
+inline void NewLinkedHashSet<T>::erase(const_iterator it) {
+  if (it == end())
+    return;
+  value_to_index_.erase(*it);
+  list_.erase(it);
+}
+
+template <typename T>
+inline void NewLinkedHashSet<T>::RemoveFirst() {
+  DCHECK(!IsEmpty());
+  erase(begin());
+}
+
+template <typename T>
+inline void NewLinkedHashSet<T>::pop_back() {
+  DCHECK(!IsEmpty());
+  erase(--end());
+}
+
 template <typename T>
 template <typename IncomingValueType>
 typename NewLinkedHashSet<T>::AddResult NewLinkedHashSet<T>::InsertOrMoveBefore(

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

@@ -50,6 +50,38 @@ TEST(NewLinkedHashSetTest, FrontAndBack) {
   EXPECT_EQ(set.back(), 1);
 }
 
+TEST(NewLinkedHashSetTest, FindAndContains) {
+  using Set = NewLinkedHashSet<int>;
+  Set set;
+  set.insert(2);
+  set.AppendOrMoveToLast(2);
+  set.PrependOrMoveToFirst(1);
+  set.insert(3);
+  set.AppendOrMoveToLast(4);
+  set.insert(5);
+
+  int i = 1;
+  for (auto element : set) {
+    EXPECT_EQ(element, i);
+    i++;
+  }
+
+  Set::const_iterator it = set.find(2);
+  EXPECT_EQ(*it, 2);
+  it = set.find(3);
+  EXPECT_EQ(*it, 3);
+  it = set.find(10);
+  EXPECT_TRUE(it == set.end());
+
+  EXPECT_TRUE(set.Contains(1));
+  EXPECT_TRUE(set.Contains(2));
+  EXPECT_TRUE(set.Contains(3));
+  EXPECT_TRUE(set.Contains(4));
+  EXPECT_TRUE(set.Contains(5));
+
+  EXPECT_FALSE(set.Contains(10));
+}
+
 TEST(NewLinkedHashSetTest, Insert) {
   using Set = NewLinkedHashSet<int>;
   Set set;
@@ -137,36 +169,103 @@ TEST(NewLinkedHashSetTest, PrependOrMoveToFirst) {
   EXPECT_EQ(*it, 2);
 }
 
-TEST(NewLinkedHashSetTest, FindAndContains) {
+TEST(NewLinkedHashSetTest, Erase) {
   using Set = NewLinkedHashSet<int>;
   Set set;
+  set.insert(1);
   set.insert(2);
-  set.AppendOrMoveToLast(2);
-  set.PrependOrMoveToFirst(1);
   set.insert(3);
-  set.AppendOrMoveToLast(4);
+  set.insert(4);
   set.insert(5);
 
-  int i = 1;
-  for (auto element : set) {
-    EXPECT_EQ(element, i);
-    i++;
-  }
+  Set::const_iterator it = set.begin();
+  ++it;
+  set.erase(it);
+  it = set.begin();
+  EXPECT_EQ(*it, 1);
+  ++it;
+  EXPECT_EQ(*it, 3);
+  ++it;
+  EXPECT_EQ(*it, 4);
+  ++it;
+  EXPECT_EQ(*it, 5);
 
-  Set::const_iterator it = set.find(2);
+  set.erase(3);
+  it = set.begin();
+  EXPECT_EQ(*it, 1);
+  ++it;
+  EXPECT_EQ(*it, 4);
+  ++it;
+  EXPECT_EQ(*it, 5);
+
+  set.insert(6);
+  it = set.begin();
+  EXPECT_EQ(*it, 1);
+  ++it;
+  EXPECT_EQ(*it, 4);
+  ++it;
+  EXPECT_EQ(*it, 5);
+  ++it;
+  EXPECT_EQ(*it, 6);
+}
+
+TEST(NewLinkedHashSetTest, RemoveFirst) {
+  using Set = NewLinkedHashSet<int>;
+  Set set;
+  set.insert(1);
+  set.insert(2);
+  set.insert(3);
+
+  set.RemoveFirst();
+  Set::const_iterator it = set.begin();
   EXPECT_EQ(*it, 2);
-  it = set.find(3);
+  ++it;
   EXPECT_EQ(*it, 3);
-  it = set.find(10);
-  EXPECT_TRUE(it == set.end());
 
-  EXPECT_TRUE(set.Contains(1));
-  EXPECT_TRUE(set.Contains(2));
-  EXPECT_TRUE(set.Contains(3));
-  EXPECT_TRUE(set.Contains(4));
-  EXPECT_TRUE(set.Contains(5));
+  set.RemoveFirst();
+  it = set.begin();
+  EXPECT_EQ(*it, 3);
 
-  EXPECT_FALSE(set.Contains(10));
+  set.RemoveFirst();
+  EXPECT_TRUE(set.begin() == set.end());
+}
+
+TEST(NewLinkedHashSetTest, pop_back) {
+  using Set = NewLinkedHashSet<int>;
+  Set set;
+  set.insert(1);
+  set.insert(2);
+  set.insert(3);
+
+  set.pop_back();
+  Set::const_iterator it = set.begin();
+  EXPECT_EQ(*it, 1);
+  ++it;
+  EXPECT_EQ(*it, 2);
+
+  set.pop_back();
+  it = set.begin();
+  EXPECT_EQ(*it, 1);
+
+  set.pop_back();
+  EXPECT_TRUE(set.begin() == set.end());
+}
+
+TEST(NewLinkedHashSetTest, Clear) {
+  using Set = NewLinkedHashSet<int>;
+  Set set;
+  set.insert(1);
+  set.insert(2);
+  set.insert(3);
+
+  set.clear();
+  EXPECT_TRUE(set.begin() == set.end());
+
+  set.insert(1);
+  Set::const_iterator it = set.begin();
+  EXPECT_EQ(*it, 1);
+  ++it;
+  EXPECT_TRUE(it == set.end());
 }
 
 }  // namespace WTF