Catch illegal hash table modifications when they happen.

third_party/WebKit/Source/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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 85 matching lines @@
 class HashTable;
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 class HashTableIterator;
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 class HashTableConstIterator;
 template <typename Value, typename HashFunctions, typename HashTraits, typename Allocator>
 class LinkedHashSet;
 template <WeakHandlingFlag x, typename T, typename U, typename V, typename W, typename X, typename Y, typename Z>
 struct WeakProcessingHashTableHelper;
 
+#if ENABLE(ASSERT)
+// HashTable and collections that build on it do not support modifications
+// while there is an iterator or HashTableAddResult on the stack.
+// The exception is ListHashSet, which has its own iterators that tolerate modification
+// of the underlying set.
+//
+// Constraint enforced by this scope object.
+template <typename HashTableType>
+class HashTableModificationForbiddenScope {
+public:
+    HashTableModificationForbiddenScope();
+    explicit HashTableModificationForbiddenScope(const HashTableType*);
+    HashTableModificationForbiddenScope(const HashTableModificationForbiddenScope&);
+
+    ~HashTableModificationForbiddenScope();
+
+    void leaveScope();
+
+private:
+    HashTableType* m_container;
+};
+#endif
+
 typedef enum { HashItemKnownGood } HashItemKnownGoodTag;
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 class HashTableConstIterator final {
     DISALLOW_NEW();
 private:
     typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> HashTableType;
     typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> iterator;
     typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> const_iterator;
     typedef Value ValueType;
     typedef typename Traits::IteratorConstGetType GetType;
     typedef const ValueType* PointerType;
 
     friend class HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>;
     friend class HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>;
 
     void skipEmptyBuckets()
     {
         while (m_position != m_endPosition && HashTableType::isEmptyOrDeletedBucket(*m_position))
             ++m_position;
     }
 
     HashTableConstIterator(PointerType position, PointerType endPosition, const HashTableType* container)
         : m_position(position)
         , m_endPosition(endPosition)
 #if ENABLE(ASSERT)
-        , m_container(container)
-        , m_containerModifications(container->modifications())
+        , m_modificationForbiddenScope(position != endPosition ? container : nullptr)
 #endif
     {
         skipEmptyBuckets();
     }
 
     HashTableConstIterator(PointerType position, PointerType endPosition, const HashTableType* container, HashItemKnownGoodTag)
         : m_position(position)
         , m_endPosition(endPosition)
 #if ENABLE(ASSERT)
-        , m_container(container)
-        , m_containerModifications(container->modifications())
+        , m_modificationForbiddenScope(position != endPosition ? container : nullptr)
 #endif
     {
-        ASSERT(m_containerModifications == m_container->modifications());
-    }
-
-    void checkModifications() const
-    {
-        // 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.
-        ASSERT(m_containerModifications == m_container->modifications());
-        ASSERT(!m_container->accessForbidden());
     }
 
 public:
     HashTableConstIterator() {}
 
     GetType get() const
     {
-        checkModifications();
         return m_position;
     }
     typename Traits::IteratorConstReferenceType operator*() const { return Traits::getToReferenceConstConversion(get()); }
     GetType operator->() const { return get(); }
 
     const_iterator& operator++()
     {
         ASSERT(m_position != m_endPosition);
-        checkModifications();
         ++m_position;
         skipEmptyBuckets();
+#if ENABLE(ASSERT)
+        // If now at the end, leave the forbidden scope. Waiting until
+        // the iterator goes out of (stack) scope disallows perfectly valid
+        // code idioms.
+        if (m_position == m_endPosition)
+            m_modificationForbiddenScope.leaveScope();
+#endif
         return *this;
     }
 
     // postfix ++ intentionally omitted
 
     // Comparison.
     bool operator==(const const_iterator& other) const
     {
         return m_position == other.m_position;
     }
     bool operator!=(const const_iterator& other) const
     {
         return m_position != other.m_position;
     }
     bool operator==(const iterator& other) const
     {
         return *this == static_cast<const_iterator>(other);
     }
     bool operator!=(const iterator& other) const
     {
         return *this != static_cast<const_iterator>(other);
     }
 
 private:
     PointerType m_position;
     PointerType m_endPosition;
 #if ENABLE(ASSERT)
-    const HashTableType* m_container;
-    int64_t m_containerModifications;
+    HashTableModificationForbiddenScope<HashTableType> m_modificationForbiddenScope;
 #endif
 };
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 class HashTableIterator final {
     DISALLOW_NEW();
 private:
     typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> HashTableType;
     typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> iterator;
     typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> const_iterator;
@@ skipping 54 matching lines @@
 };
 
 template <typename HashFunctions> class IdentityHashTranslator {
     STATIC_ONLY(IdentityHashTranslator);
 public:
     template <typename T> static unsigned hash(const T& key) { return HashFunctions::hash(key); }
     template <typename T, typename U> static bool equal(const T& a, const U& b) { return HashFunctions::equal(a, b); }
     template <typename T, typename U, typename V> static void translate(T& location, U&&, V&& value) { location = std::forward<V>(value); }
 };
 
-template <typename HashTableType, typename ValueType> struct HashTableAddResult final {
+template <typename HashTableType, typename ValueType>
+struct HashTableAddResult final {
     STACK_ALLOCATED();
     HashTableAddResult(const HashTableType* container, ValueType* storedValue, bool isNewEntry)
         : storedValue(storedValue)
         , isNewEntry(isNewEntry)
 #if ENABLE(SECURITY_ASSERT)
-        , m_container(container)
-        , m_containerModifications(container->modifications())
+        , m_modificationForbiddenScope(container)
 #endif
     {
         ALLOW_UNUSED_LOCAL(container);
         DCHECK(container);
     }
 
     ValueType* storedValue;
     bool isNewEntry;
 
 #if ENABLE(SECURITY_ASSERT)
     ~HashTableAddResult()
     {
         // If rehash happened before accessing storedValue, it's
-        // use-after-free. Any modification may cause a rehash, so we check for
-        // modifications here.
-
-        // Rehash after accessing storedValue is harmless but will assert if the
-        // AddResult destructor takes place after a modification. You may need
-        // to limit the scope of the AddResult.
-        ASSERT_WITH_SECURITY_IMPLICATION(m_containerModifications == m_container->modifications());
+        // use-after-free. Any modification may cause a rehash, so we enter
+        // a modification forbidden scope for the lifetime of this value.
     }
 
 private:
-    const HashTableType* m_container;
-    const int64_t m_containerModifications;
+    HashTableModificationForbiddenScope<HashTableType> m_modificationForbiddenScope;
 #endif
 };
 
 template <typename Value, typename Extractor, typename KeyTraits>
 struct HashTableHelper {
     STATIC_ONLY(HashTableHelper);
     static bool isEmptyBucket(const Value& value) { return isHashTraitsEmptyValue<KeyTraits>(Extractor::extract(value)); }
     static bool isDeletedBucket(const Value& value) { return KeyTraits::isDeletedValue(Extractor::extract(value)); }
     static bool isEmptyOrDeletedBucket(const Value& value) { return isEmptyBucket(value) || isDeletedBucket(value); }
 };
@@ skipping 83 matching lines @@
         }
     };
 #endif
 
     HashTable();
     void finalize()
     {
         ASSERT(!Allocator::isGarbageCollected);
         if (LIKELY(!m_table))
             return;
-        ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-        m_accessForbidden = true;
-#endif
         deleteAllBucketsAndDeallocate(m_table, m_tableSize);
-#if ENABLE(ASSERT)
-        m_accessForbidden = false;
-#endif
         m_table = nullptr;
     }
 
     HashTable(const HashTable&);
     HashTable(HashTable&&);
     void swap(HashTable&);
     HashTable& operator=(const HashTable&);
     HashTable& operator=(HashTable&&);
 
     // When the hash table is empty, just return the same iterator for end as
     // for begin.  This is more efficient because we don't have to skip all the
     // empty and deleted buckets, and iterating an empty table is a common case
     // that's worth optimizing.
     iterator begin() { return isEmpty() ? end() : makeIterator(m_table); }
     iterator end() { return makeKnownGoodIterator(m_table + m_tableSize); }
     const_iterator begin() const { return isEmpty() ? end() : makeConstIterator(m_table); }
     const_iterator end() const { return makeKnownGoodConstIterator(m_table + m_tableSize); }
 
     unsigned size() const
     {
-        ASSERT(!m_accessForbidden);
         return m_keyCount;
     }
     unsigned capacity() const
     {
-        ASSERT(!m_accessForbidden);
         return m_tableSize;
     }
     bool isEmpty() const
     {
-        ASSERT(!m_accessForbidden);
         return !m_keyCount;
     }
 
     void reserveCapacityForSize(unsigned size);
 
     template <typename IncomingValueType>
     AddResult add(IncomingValueType&& value)
     {
         return add<IdentityTranslatorType>(Extractor::extract(value), std::forward<IncomingValueType>(value));
     }
@@ skipping 21 matching lines @@
     static bool isDeletedBucket(const ValueType& value) { return KeyTraits::isDeletedValue(Extractor::extract(value)); }
     static bool isEmptyOrDeletedBucket(const ValueType& value) { return HashTableHelper<ValueType, Extractor, KeyTraits>:: isEmptyOrDeletedBucket(value); }
 
     ValueType* lookup(KeyPeekInType key) { return lookup<IdentityTranslatorType, KeyPeekInType>(key); }
     template <typename HashTranslator, typename T> ValueType* lookup(const T&);
     template <typename HashTranslator, typename T> const ValueType* lookup(const T&) const;
 
     template <typename VisitorDispatcher> void trace(VisitorDispatcher);
 
 #if ENABLE(ASSERT)
-    bool accessForbidden() const { return m_accessForbidden; }
-    int64_t modifications() const { return m_modifications; }
-    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 { ASSERT(mods == m_modifications); }
+    void enterModificationForbiddenScope() { m_modificationForbidden++; }
+    void leaveModificationForbiddenScope()
+    {
+        ASSERT(m_modificationForbidden > 0);
+        m_modificationForbidden--;
+    }
+
+    void registerModification()
+    {
+        ASSERT(!m_modificationForbidden);
+    }
 #else
-    int64_t modifications() const { return 0; }
-    void registerModification() {}
-    void checkModifications(int64_t mods) const {}
+    void registerModification() { }
 #endif
 
 private:
     static ValueType* allocateTable(unsigned size);
     static void deleteAllBucketsAndDeallocate(ValueType* table, unsigned size);
 
     typedef std::pair<ValueType*, bool> LookupType;
     typedef std::pair<LookupType, unsigned> FullLookupType;
 
     LookupType lookupForWriting(const Key& key) { return lookupForWriting<IdentityTranslatorType>(key); }
@@ skipping 45 matching lines @@
         return mask;
     }
 
     void setEnqueued() { m_queueFlag = true; }
     void clearEnqueued() { m_queueFlag = false; }
     bool enqueued() { return m_queueFlag; }
 
     ValueType* m_table;
     unsigned m_tableSize;
     unsigned m_keyCount;
-#if ENABLE(ASSERT)
-    unsigned m_deletedCount:30;
-    unsigned m_queueFlag:1;
-    unsigned m_accessForbidden:1;
-    unsigned m_modifications;
-#else
     unsigned m_deletedCount:31;
     unsigned m_queueFlag:1;
+#if ENABLE(ASSERT)
+    unsigned m_modificationForbidden;
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
 public:
     mutable OwnPtr<Stats> m_stats;
 #endif
 
     template <WeakHandlingFlag x, typename T, typename U, typename V, typename W, typename X, typename Y, typename Z> friend struct WeakProcessingHashTableHelper;
     template <typename T, typename U, typename V, typename W> friend class LinkedHashSet;
 };
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 inline HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::HashTable()
     : m_table(nullptr)
     , m_tableSize(0)
     , m_keyCount(0)
     , m_deletedCount(0)
     , m_queueFlag(false)
 #if ENABLE(ASSERT)
-    , m_accessForbidden(false)
-    , m_modifications(0)
+    , m_modificationForbidden(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
     , m_stats(adoptPtr(new Stats))
 #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)
 {
@@ skipping 29 matching lines @@
 template <typename HashTranslator, typename T>
 inline Value* HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::lookup(const T& key)
 {
     return const_cast<Value*>(const_cast<const HashTable*>(this)->lookup<HashTranslator>(key));
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 template <typename HashTranslator, typename T>
 inline const Value* HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::lookup(const T& key) const
 {
-    ASSERT(!m_accessForbidden);
     ASSERT((HashTableKeyChecker<HashTranslator, KeyTraits, HashFunctions::safeToCompareToEmptyOrDeleted>::checkKey(key)));
     const ValueType* table = m_table;
     if (!table)
         return nullptr;
 
     size_t k = 0;
     size_t sizeMask = tableSizeMask();
     unsigned h = HashTranslator::hash(key);
     size_t i = h & sizeMask;
 
@@ skipping 19 matching lines @@
         if (!k)
             k = 1 | doubleHash(h);
         i = (i + k) & sizeMask;
     }
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 template <typename HashTranslator, typename T>
 inline typename HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::LookupType HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::lookupForWriting(const T& key)
 {
-    ASSERT(!m_accessForbidden);
     ASSERT(m_table);
     registerModification();
 
     ValueType* table = m_table;
     size_t k = 0;
     size_t sizeMask = tableSizeMask();
     unsigned h = HashTranslator::hash(key);
     size_t i = h & sizeMask;
 
     UPDATE_ACCESS_COUNTS();
@@ skipping 22 matching lines @@
         if (!k)
             k = 1 | doubleHash(h);
         i = (i + k) & sizeMask;
     }
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 template <typename HashTranslator, typename T>
 inline typename HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::FullLookupType HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::fullLookupForWriting(const T& key)
 {
-    ASSERT(!m_accessForbidden);
     ASSERT(m_table);
     registerModification();
 
     ValueType* table = m_table;
     size_t k = 0;
     size_t sizeMask = tableSizeMask();
     unsigned h = HashTranslator::hash(key);
     size_t i = h & sizeMask;
 
     UPDATE_ACCESS_COUNTS();
@@ skipping 50 matching lines @@
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::initializeBucket(ValueType& bucket)
 {
     HashTableBucketInitializer<Traits::emptyValueIsZero>::template initialize<Traits>(bucket);
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 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)
 {
-    ASSERT(!m_accessForbidden);
     ASSERT(Allocator::isAllocationAllowed());
     if (!m_table)
         expand();
 
     ASSERT(m_table);
 
     ValueType* table = m_table;
     size_t k = 0;
     size_t sizeMask = tableSizeMask();
     unsigned h = HashTranslator::hash(key);
@@ skipping 45 matching lines @@
     if (shouldExpand())
         entry = expand(entry);
 
     return AddResult(this, entry, true);
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 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>::addPassingHashCode(T&& key, Extra&& extra)
 {
-    ASSERT(!m_accessForbidden);
     ASSERT(Allocator::isAllocationAllowed());
     if (!m_table)
         expand();
 
     FullLookupType lookupResult = fullLookupForWriting<HashTranslator>(key);
 
     ValueType* entry = lookupResult.first.first;
     bool found = lookupResult.first.second;
     unsigned h = lookupResult.second;
 
@@ skipping 69 matching lines @@
 void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::remove(ValueType* pos)
 {
     registerModification();
 #if DUMP_HASHTABLE_STATS
     atomicIncrement(&HashTableStats::numRemoves);
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
     ++m_stats->numRemoves;
 #endif
 
-    ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-    m_accessForbidden = true;
-#endif
     deleteBucket(*pos);
-#if ENABLE(ASSERT)
-    m_accessForbidden = false;
-#endif
     ++m_deletedCount;
     --m_keyCount;
 
     if (shouldShrink())
         shrink();
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::remove(iterator it)
 {
@@ skipping 115 matching lines @@
     m_table = temporaryTable;
 
     if (Traits::emptyValueIsZero) {
         memset(originalTable, 0, newTableSize * sizeof(ValueType));
     } else {
         for (unsigned i = 0; i < newTableSize; i++)
             initializeBucket(originalTable[i]);
     }
     newEntry = rehashTo(originalTable, newTableSize, newEntry);
 
-    ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-    m_accessForbidden = true;
-#endif
     deleteAllBucketsAndDeallocate(temporaryTable, oldTableSize);
-#if ENABLE(ASSERT)
-    m_accessForbidden = false;
-#endif
-
     return newEntry;
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 Value* HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::rehashTo(ValueType* newTable, unsigned newTableSize, Value* entry)
 {
     unsigned oldTableSize = m_tableSize;
     ValueType* oldTable = m_table;
 
 #if DUMP_HASHTABLE_STATS
@@ skipping 49 matching lines @@
     if (Allocator::isGarbageCollected && newTableSize > oldTableSize) {
         bool success;
         Value* newEntry = expandBuffer(newTableSize, entry, success);
         if (success)
             return newEntry;
     }
 
     ValueType* newTable = allocateTable(newTableSize);
     Value* newEntry = rehashTo(newTable, newTableSize, entry);
 
-    ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-    m_accessForbidden = true;
-#endif
     deleteAllBucketsAndDeallocate(oldTable, oldTableSize);
-#if ENABLE(ASSERT)
-    m_accessForbidden = false;
-#endif
-
     return newEntry;
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::clear()
 {
     registerModification();
     if (!m_table)
         return;
 
-    ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-    m_accessForbidden = true;
-#endif
     deleteAllBucketsAndDeallocate(m_table, m_tableSize);
-#if ENABLE(ASSERT)
-    m_accessForbidden = false;
-#endif
     m_table = nullptr;
     m_tableSize = 0;
     m_keyCount = 0;
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::HashTable(const HashTable& other)
     : m_table(nullptr)
     , m_tableSize(0)
     , m_keyCount(0)
     , m_deletedCount(0)
     , m_queueFlag(false)
 #if ENABLE(ASSERT)
-    , m_accessForbidden(false)
-    , m_modifications(0)
+    , m_modificationForbidden(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
     , m_stats(adoptPtr(new Stats(*other.m_stats)))
 #endif
 {
     // 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.
     const_iterator end = other.end();
     for (const_iterator it = other.begin(); it != end; ++it)
         add(*it);
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::HashTable(HashTable&& other)
     : m_table(nullptr)
     , m_tableSize(0)
     , m_keyCount(0)
     , m_deletedCount(0)
     , m_queueFlag(false)
 #if ENABLE(ASSERT)
-    , m_accessForbidden(false)
-    , m_modifications(0)
+    , m_modificationForbidden(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
     , m_stats(adoptPtr(new Stats(*other.m_stats)))
 #endif
 {
     swap(other);
 }
 
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::swap(HashTable& other)
 {
-    ASSERT(!m_accessForbidden);
+    registerModification();
     std::swap(m_table, other.m_table);
     std::swap(m_tableSize, other.m_tableSize);
     std::swap(m_keyCount, other.m_keyCount);
     // std::swap does not work for bit fields.
     unsigned deleted = m_deletedCount;
     m_deletedCount = other.m_deletedCount;
     other.m_deletedCount = deleted;
     ASSERT(!m_queueFlag);
     ASSERT(!other.m_queueFlag);
 
 #if ENABLE(ASSERT)
-    std::swap(m_modifications, other.m_modifications);
+    std::swap(m_modificationForbidden, other.m_modificationForbidden);
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
     m_stats.swap(other.m_stats);
 #endif
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>& HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::operator=(const HashTable& other)
 {
     HashTable tmp(other);
     swap(tmp);
     return *this;
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>& HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::operator=(HashTable&& other)
 {
     swap(other);
     return *this;
 }
 
+#if ENABLE(ASSERT)
+template <typename HashTableType>
+HashTableModificationForbiddenScope<HashTableType>::HashTableModificationForbiddenScope()
+    : m_container(nullptr)
+{
+}
+
+template <typename HashTableType>
+HashTableModificationForbiddenScope<HashTableType>::HashTableModificationForbiddenScope(const HashTableType* container)
+    : m_container(const_cast<HashTableType*>(container))
+{
+    if (m_container)
+        m_container->enterModificationForbiddenScope();
+}
+
+template <typename HashTableType>
+HashTableModificationForbiddenScope<HashTableType>::HashTableModificationForbiddenScope(const HashTableModificationForbiddenScope& other)
+    : m_container(other.m_container)
+{
+    if (m_container)
+        m_container->enterModificationForbiddenScope();
+}
+
+template <typename HashTableType>
+HashTableModificationForbiddenScope<HashTableType>::~HashTableModificationForbiddenScope()
+{
+    leaveScope();
+}
+
+template <typename HashTableType>
+void HashTableModificationForbiddenScope<HashTableType>::leaveScope()
+{
+    if (!m_container)
+        return;
+    m_container->leaveModificationForbiddenScope();
+    m_container = nullptr;
+}
+#endif
+
 template <WeakHandlingFlag weakHandlingFlag, typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 struct WeakProcessingHashTableHelper;
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 struct WeakProcessingHashTableHelper<NoWeakHandlingInCollections, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> {
     STATIC_ONLY(WeakProcessingHashTableHelper);
     static void process(typename Allocator::Visitor* visitor, void* closure) {}
     static void ephemeronIteration(typename Allocator::Visitor* visitor, void* closure) {}
     static void ephemeronIterationDone(typename Allocator::Visitor* visitor, void* closure) {}
 };
@@ skipping 219 matching lines @@
     CollectionIterator end(toBeRemoved.end());
     for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
         collection.remove(*it);
 }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h