Replace two ASSERT()s for HashMap iterators with DCHECK_NE()s.

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 186 matching lines @@
     }
     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);
     }
 
+    std::ostream& printTo(std::ostream& stream) const
+    {
+        if (m_position == m_endPosition)
+            return stream << "iterator representing <end>";
+        // TODO(tkent): Change |m_position| to |*m_position| to show the
+        // pointed object. It requires a lot of new stream printer functions.
+        return stream << "iterator pointing to " << m_position;
+    }
+
 private:
     PointerType m_position;
     PointerType m_endPosition;
 #if ENABLE(ASSERT)
     const HashTableType* m_container;
     int64_t m_containerModifications;
 #endif
 };
 
+template <typename Key, typename Value, typename Extractor, typename Hash, typename Traits, typename KeyTraits, typename Allocator>
+std::ostream& operator<<(std::ostream& stream, const HashTableConstIterator<Key, Value, Extractor, Hash, Traits, KeyTraits, Allocator>& iterator)
+{
+    return iterator.printTo(stream);
+}
+
 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;
     typedef Value ValueType;
     typedef typename Traits::IteratorGetType GetType;
     typedef ValueType* PointerType;
@@ skipping 16 matching lines @@
 
     // postfix ++ intentionally omitted
 
     // Comparison.
     bool operator==(const iterator& other) const { return m_iterator == other.m_iterator; }
     bool operator!=(const iterator& other) const { return m_iterator != other.m_iterator; }
     bool operator==(const const_iterator& other) const { return m_iterator == other; }
     bool operator!=(const const_iterator& other) const { return m_iterator != other; }
 
     operator const_iterator() const { return m_iterator; }
+    std::ostream& printTo(std::ostream& stream) const { return m_iterator.printTo(stream); }
 
 private:
     const_iterator m_iterator;
 };
 
+template <typename Key, typename Value, typename Extractor, typename Hash, typename Traits, typename KeyTraits, typename Allocator>
+std::ostream& operator<<(std::ostream& stream, const HashTableIterator<Key, Value, Extractor, Hash, Traits, KeyTraits, Allocator>& iterator)
+{
+    return iterator.printTo(stream);
+}
+
 using std::swap;
 
 template <typename T, typename Allocator, bool enterGCForbiddenScope> struct Mover {
     STATIC_ONLY(Mover);
     static void move(T&& from, T& to)
     {
         to.~T();
         new (NotNull, &to) T(std::move(from));
     }
 };
@@ skipping 1186 matching lines @@
     GetType get() const { return const_cast<GetType>(SourceGetType(m_impl.get())); }
     typename Traits::IteratorConstReferenceType operator*() const { return Traits::getToReferenceConstConversion(get()); }
     GetType operator->() const { return get(); }
 
     HashTableConstIteratorAdapter& operator++() { ++m_impl; return *this; }
     // postfix ++ intentionally omitted
 
     typename HashTableType::const_iterator m_impl;
 };
 
+template <typename HashTable, typename Traits>
+std::ostream& operator<<(std::ostream& stream, const HashTableConstIteratorAdapter<HashTable, Traits>& iterator)
+{
+    return stream << iterator.m_impl;
+}
+
 template <typename HashTableType, typename Traits> struct HashTableIteratorAdapter {
     STACK_ALLOCATED();
     typedef typename Traits::IteratorGetType GetType;
     typedef typename HashTableType::ValueTraits::IteratorGetType SourceGetType;
 
     HashTableIteratorAdapter() {}
     HashTableIteratorAdapter(const typename HashTableType::iterator& impl) : m_impl(impl) {}
 
     GetType get() const { return const_cast<GetType>(SourceGetType(m_impl.get())); }
     typename Traits::IteratorReferenceType operator*() const { return Traits::getToReferenceConversion(get()); }
     GetType operator->() const { return get(); }
 
     HashTableIteratorAdapter& operator++() { ++m_impl; return *this; }
     // postfix ++ intentionally omitted
 
     operator HashTableConstIteratorAdapter<HashTableType, Traits>()
     {
         typename HashTableType::const_iterator i = m_impl;
         return i;
     }
 
     typename HashTableType::iterator m_impl;
 };
 
+template <typename HashTable, typename Traits>
+std::ostream& operator<<(std::ostream& stream, const HashTableIteratorAdapter<HashTable, Traits>& iterator)
+{
+    return stream << iterator.m_impl;
+}
+
 template <typename T, typename U>
 inline bool operator==(const HashTableConstIteratorAdapter<T, U>& a, const HashTableConstIteratorAdapter<T, U>& b)
 {
     return a.m_impl == b.m_impl;
 }
 
 template <typename T, typename U>
 inline bool operator!=(const HashTableConstIteratorAdapter<T, U>& a, const HashTableConstIteratorAdapter<T, U>& b)
 {
     return a.m_impl != b.m_impl;
@@ skipping 45 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