Catch illegal hash table modifications when they happen.

third_party/WebKit/Source/wtf/LinkedHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * 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 261 matching lines @@
 
     void remove(ValuePeekInType);
     void remove(iterator);
     void clear() { m_impl.clear(); }
     template<typename Collection>
     void removeAll(const Collection& other) { WTF::removeAll(*this, other); }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor) { m_impl.trace(visitor); }
 
-    int64_t modifications() const { return m_impl.modifications(); }
-    void checkModifications(int64_t mods) const { m_impl.checkModifications(mods); }
+#if ENABLE(ASSERT)
+    void enterModificationForbiddenScope() { m_impl.enterModificationForbiddenScope(); }
+    void leaveModificationForbiddenScope() { m_impl.leaveModificationForbiddenScope(); }
+#endif
 
 private:
     Node* anchor() { return reinterpret_cast<Node*>(&m_anchor); }
     const Node* anchor() const { return reinterpret_cast<const Node*>(&m_anchor); }
     Node* firstNode() { return reinterpret_cast<Node*>(m_anchor.m_next); }
     const Node* firstNode() const { return reinterpret_cast<const Node*>(m_anchor.m_next); }
     Node* lastNode() { return reinterpret_cast<Node*>(m_anchor.m_prev); }
     const Node* lastNode() const { return reinterpret_cast<const Node*>(m_anchor.m_prev); }
 
     iterator makeIterator(const Node* position) { return iterator(position, this); }
@@ skipping 115 matching lines @@
 
     typedef const typename LinkedHashSetType::Value& ReferenceType;
     typedef const typename LinkedHashSetType::Value* PointerType;
 
     const Node* getNode() const { return static_cast<const Node*>(m_position); }
 
 protected:
     LinkedHashSetConstIterator(const LinkedHashSetNodeBase* position, const LinkedHashSetType* container)
         : m_position(position)
 #if ENABLE(ASSERT)
-        , m_container(container)
-        , m_containerModifications(container->modifications())
+        , m_modificationForbiddenScope(position ? container : nullptr)
 #endif
     {
     }
 
 public:
     PointerType get() const
     {
-        checkModifications();
         return &static_cast<const Node*>(m_position)->m_value;
     }
     ReferenceType operator*() const { return *get(); }
     PointerType operator->() const { return get(); }
 
     LinkedHashSetConstIterator& operator++()
     {
         ASSERT(m_position);
-        checkModifications();
         m_position = m_position->m_next;
+#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_modificationForbiddenScope.leaveScope();
+#endif
         return *this;
     }
 
     LinkedHashSetConstIterator& operator--()
     {
         ASSERT(m_position);
-        checkModifications();
         m_position = m_position->m_prev;
+#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_modificationForbiddenScope.leaveScope();
+#endif
         return *this;
     }
 
     // Postfix ++ and -- intentionally omitted.
 
     // Comparison.
     bool operator==(const LinkedHashSetConstIterator& other) const
     {
         return m_position == other.m_position;
     }
     bool operator!=(const LinkedHashSetConstIterator& other) const
     {
         return m_position != other.m_position;
     }
 
 private:
+    template<typename T, typename U, typename V, typename W> friend class LinkedHashSet;
+    friend class LinkedHashSetIterator<LinkedHashSetType>;
+
     const LinkedHashSetNodeBase* m_position;
 #if ENABLE(ASSERT)
-    void checkModifications() const { m_container->checkModifications(m_containerModifications); }
-    const LinkedHashSetType* m_container;
-    int64_t m_containerModifications;
-#else
-    void checkModifications() const { }
+    HashTableModificationForbiddenScope<LinkedHashSetType> m_modificationForbiddenScope;
 #endif
-    template<typename T, typename U, typename V, typename W> friend class LinkedHashSet;
-    friend class LinkedHashSetIterator<LinkedHashSetType>;
 };
 
 template<typename LinkedHashSetType>
 class LinkedHashSetReverseIterator : public LinkedHashSetIterator<LinkedHashSetType> {
     typedef LinkedHashSetIterator<LinkedHashSetType> Superclass;
     typedef LinkedHashSetConstReverseIterator<LinkedHashSetType> const_reverse_iterator;
     typedef typename LinkedHashSetType::Node Node;
 
 protected:
     LinkedHashSetReverseIterator(const Node* position, LinkedHashSetType* container)
@@ skipping 290 matching lines @@
     swap(static_cast<Base&>(a), static_cast<Base&>(b));
     swap(a.m_value, b.m_value);
     Allocator::leaveGCForbiddenScope();
 }
 
 } // namespace WTF
 
 using WTF::LinkedHashSet;
 
 #endif /* WTF_LinkedHashSet_h */