Call elements' destructors in HashTable

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 69 matching lines @@
 
   IntWrapper(int x) : x_(x) {}
 
  private:
   IntWrapper();
   int x_;
 };
 static_assert(WTF::IsTraceable<IntWrapper>::value,
               "IsTraceable<> template failed to recognize trace method.");
 
+class KeyWithCopyingMoveConstructor final {
+ public:
+  struct Hash final {
+    STATIC_ONLY(Hash);
+
+   public:
+    static unsigned GetHash(const KeyWithCopyingMoveConstructor& key) {
+      return key.hash_;
+    }
+
+    static bool Equal(const KeyWithCopyingMoveConstructor& x,
+                      const KeyWithCopyingMoveConstructor& y) {
+      return x.hash_ == y.hash_;
+    }
+
+    static constexpr bool safe_to_compare_to_empty_or_deleted = true;
+  };
+
+  KeyWithCopyingMoveConstructor() = default;
+  KeyWithCopyingMoveConstructor(WTF::HashTableDeletedValueType) : hash_(-1) {}
+  ~KeyWithCopyingMoveConstructor() = default;
+  KeyWithCopyingMoveConstructor(unsigned hash, const String& string)
+      : hash_(hash), string_(string) {
+    DCHECK_NE(hash_, 0);
+    DCHECK_NE(hash_, -1);
+  }
+  KeyWithCopyingMoveConstructor(const KeyWithCopyingMoveConstructor&) = default;
+  // The move constructor delegates to the copy constructor intentionally.
+  KeyWithCopyingMoveConstructor(KeyWithCopyingMoveConstructor&& x)
+      : KeyWithCopyingMoveConstructor(x) {}
+  KeyWithCopyingMoveConstructor& operator=(
+      const KeyWithCopyingMoveConstructor&) = default;
+  bool operator==(const KeyWithCopyingMoveConstructor& x) const {
+    return hash_ == x.hash_;
+  }
+
+  bool IsHashTableDeletedValue() const { return hash_ == -1; }
+
+ private:
+  int hash_ = 0;
+  String string_;
+};
+
 struct SameSizeAsPersistent {
   void* pointer_[4];
 };
 
 static_assert(sizeof(Persistent<IntWrapper>) <= sizeof(SameSizeAsPersistent),
               "Persistent handle should stay small");
 
 class ThreadMarker {
  public:
   ThreadMarker()
@@ skipping 165 matching lines @@
   static bool IsDeletedValue(const blink::PairWithWeakHandling& value) {
     return value.IsHashTableDeletedValue();
   }
 };
 
 template <>
 struct IsTraceable<blink::PairWithWeakHandling> {
   static const bool value = IsTraceable<blink::StrongWeakPair>::value;
 };
 
+template <>
+struct DefaultHash<blink::KeyWithCopyingMoveConstructor> {
+  using Hash = blink::KeyWithCopyingMoveConstructor::Hash;
+};
+
+template <>
+struct HashTraits<blink::KeyWithCopyingMoveConstructor>
+    : public SimpleClassHashTraits<blink::KeyWithCopyingMoveConstructor> {};
+
 }  // namespace WTF
 
 namespace blink {
 
 class TestGCScope {
  public:
   explicit TestGCScope(BlinkGC::StackState state)
       : state_(ThreadState::Current()), safe_point_scope_(state) {
     ASSERT(state_->CheckThread());
     state_->PreGC();
@@ skipping 6199 matching lines @@
       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");
 }
 
+TEST(HeapTest, HeapHashMapCallsDestructor) {
+  String string = "string";
+  EXPECT_TRUE(string.Impl()->HasOneRef());
+
+  HeapHashMap<KeyWithCopyingMoveConstructor, Member<IntWrapper>> map;
+
+  EXPECT_TRUE(string.Impl()->HasOneRef());
+
+  for (int i = 1; i <= 100; ++i) {
+    KeyWithCopyingMoveConstructor key(i, string);
+    map.insert(key, IntWrapper::Create(i));
+  }
+
+  EXPECT_FALSE(string.Impl()->HasOneRef());
+  map.Clear();
+
+  EXPECT_TRUE(string.Impl()->HasOneRef());
+}
+
 }  // namespace blink