HashTable check

third_party/WebKit/Source/platform/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 774 matching lines @@
   void trace(VisitorDispatcher);
 
 #if DCHECK_IS_ON()
   void enterAccessForbiddenScope() {
     DCHECK(!m_accessForbidden);
     m_accessForbidden = true;
   }
   void leaveAccessForbiddenScope() { m_accessForbidden = false; }
   bool accessForbidden() const { return m_accessForbidden; }
   int64_t modifications() const { return m_modifications; }
+  void checkCreationThread() const {
+    DCHECK(!Allocator::isGarbageCollected ||
+           m_creationThread == currentThread());
+  }
   void registerModification() { m_modifications++; }
   // HashTable and collections that build on it do not support modifications
   // while there is an iterator in use. The exception is ListHashSet, which
   // has its own iterators that tolerate modification of the underlying set.
   void checkModifications(int64_t mods) const {
     DCHECK_EQ(mods, m_modifications);
   }
 #else
   ALWAYS_INLINE void enterAccessForbiddenScope() {}
   ALWAYS_INLINE void leaveAccessForbiddenScope() {}
@@ skipping 82 matching lines @@
   bool enqueued() { return m_queueFlag; }
 
   ValueType* m_table;
   unsigned m_tableSize;
   unsigned m_keyCount;
 #if DCHECK_IS_ON()
   unsigned m_deletedCount : 30;
   unsigned m_queueFlag : 1;
   unsigned m_accessForbidden : 1;
   unsigned m_modifications;
+  ThreadIdentifier m_creationThread;
 #else
   unsigned m_deletedCount : 31;
   unsigned m_queueFlag : 1;
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
  public:
   mutable
       typename std::conditional<Allocator::isGarbageCollected,
                                 HashTableStats*,
@@ skipping 35 matching lines @@
 #if DCHECK_IS_ON()
       ,
       m_accessForbidden(false),
       m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
       m_stats(nullptr)
 #endif
 {
+#if DCHECK_IS_ON()
+  if (Allocator::isGarbageCollected)
+    m_creationThread = currentThread();
+#endif
   static_assert(Allocator::isGarbageCollected ||
                     (!IsPointerToGarbageCollectedType<Key>::value &&
                      !IsPointerToGarbageCollectedType<Value>::value),
                 "Cannot put raw pointers to garbage-collected classes into an "
                 "off-heap collection.");
 }
 
 inline unsigned doubleHash(unsigned key) {
   key = ~key + (key >> 23);
   key ^= (key << 12);
@@ skipping 261 matching lines @@
 template <typename HashTranslator, typename T, typename Extra>
 typename HashTable<Key,
                    Value,
                    Extractor,
                    HashFunctions,
                    Traits,
                    KeyTraits,
                    Allocator>::AddResult
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     add(T&& key, Extra&& extra) {
+  checkCreationThread();
   DCHECK(!accessForbidden());
   DCHECK(Allocator::isAllocationAllowed());
   if (!m_table)
     expand();
 
   DCHECK(m_table);
 
   ValueType* table = m_table;
   size_t k = 0;
   size_t sizeMask = tableSizeMask();
@@ skipping 577 matching lines @@
 #if DCHECK_IS_ON()
       ,
       m_accessForbidden(false),
       m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
       m_stats(HashTableStatsPtr<Allocator>::copy(other.m_stats))
 #endif
 {
+#if DCHECK_IS_ON()
+  if (Allocator::isGarbageCollected)
+    m_creationThread = currentThread();
+#endif
   if (other.size())
     reserveCapacityForSize(other.size());
   // Copy the hash table the dumb way, by adding each element to the new
   // table.  It might be more efficient to copy the table slots, but it's not
   // clear that efficiency is needed.
   for (const auto& element : other)
     add(element);
 }
 
 template <typename Key,
@@ skipping 13 matching lines @@
 #if DCHECK_IS_ON()
       ,
       m_accessForbidden(false),
       m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
       m_stats(HashTableStatsPtr<Allocator>::copy(other.m_stats))
 #endif
 {
+#if DCHECK_IS_ON()
+  if (Allocator::isGarbageCollected)
+    m_creationThread = currentThread();
+#endif
   swap(other);
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
@@ skipping 398 matching lines @@
   CollectionIterator end(toBeRemoved.end());
   for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
     collection.erase(*it);
 }
 
 }  // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif  // WTF_HashTable_h