Avoid WeakProcessingHashTableHelper<> type redefinitions.

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 1258 matching lines @@
 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) {}
 };
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 struct WeakProcessingHashTableHelper<WeakHandlingInCollections, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> {
     STATIC_ONLY(WeakProcessingHashTableHelper);
+
+    using HashTableType = HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>;
+    using ValueType = typename HashTableType::ValueType;
+
     // Used for purely weak and for weak-and-strong tables (ephemerons).
     static void process(typename Allocator::Visitor* visitor, void* closure)
     {
-        typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> HashTableType;
         HashTableType* table = reinterpret_cast<HashTableType*>(closure);
         if (!table->m_table)
             return;
         // Now perform weak processing (this is a no-op if the backing was
         // accessible through an iterator and was already marked strongly).
-        typedef typename HashTableType::ValueType ValueType;
         for (ValueType* element = table->m_table + table->m_tableSize - 1; element >= table->m_table; element--) {
             if (!HashTableType::isEmptyOrDeletedBucket(*element)) {
                 // At this stage calling trace can make no difference
                 // (everything is already traced), but we use the return value
                 // to remove things from the collection.
 
                 // FIXME: This should be rewritten so that this can check if the
                 // element is dead without calling trace, which is semantically
                 // not correct to be called in weak processing stage.
                 if (TraceInCollectionTrait<WeakHandlingInCollections, WeakPointersActWeak, ValueType, Traits>::trace(visitor, *element)) {
                     table->registerModification();
                     HashTableType::deleteBucket(*element); // Also calls the destructor.
                     table->m_deletedCount++;
                     table->m_keyCount--;
                     // We don't rehash the backing until the next add or delete,
                     // because that would cause allocation during GC.
                 }
             }
         }
     }
 
     // Called repeatedly for tables that have both weak and strong pointers.
     static void ephemeronIteration(typename Allocator::Visitor* visitor, void* closure)
     {
-        typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> HashTableType;
         HashTableType* table = reinterpret_cast<HashTableType*>(closure);
         ASSERT(table->m_table);
         // Check the hash table for elements that we now know will not be
         // removed by weak processing. Those elements need to have their strong
         // pointers traced.
-        typedef typename HashTableType::ValueType ValueType;
         for (ValueType* element = table->m_table + table->m_tableSize - 1; element >= table->m_table; element--) {
             if (!HashTableType::isEmptyOrDeletedBucket(*element))
                 TraceInCollectionTrait<WeakHandlingInCollections, WeakPointersActWeak, ValueType, Traits>::trace(visitor, *element);
         }
     }
 
     // Called when the ephemeron iteration is done and before running the per
     // thread weak processing. It is guaranteed to be called before any thread
     // is resumed.
     static void ephemeronIterationDone(typename Allocator::Visitor* visitor, void* closure)
     {
-        typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> HashTableType;
         HashTableType* table = reinterpret_cast<HashTableType*>(closure);
         ASSERT(Allocator::weakTableRegistered(visitor, table));
         table->clearEnqueued();
     }
 };
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 template <typename VisitorDispatcher>
 void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::trace(VisitorDispatcher visitor)
 {
@@ skipping 17 matching lines @@
     // needed.
     if (Traits::weakHandlingFlag == NoWeakHandlingInCollections) {
         Allocator::markNoTracing(visitor, m_table);
     } else {
         Allocator::registerDelayedMarkNoTracing(visitor, m_table);
         // Since we're delaying marking this HashTable, it is possible that the
         // registerWeakMembers is called multiple times (in rare
         // cases). However, it shouldn't cause any issue.
         Allocator::registerWeakMembers(visitor, this, m_table, WeakProcessingHashTableHelper<Traits::weakHandlingFlag, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::process);
     }
-    if (NeedsTracingTrait<Traits>::value) {
-        if (Traits::weakHandlingFlag == WeakHandlingInCollections) {
-            // If we have both strong and weak pointers in the collection then
-            // we queue up the collection for fixed point iteration a la
-            // Ephemerons:
-            // http://dl.acm.org/citation.cfm?doid=263698.263733 - see also
-            // http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak
-            ASSERT(!enqueued() || Allocator::weakTableRegistered(visitor, this));
-            if (!enqueued()) {
-                Allocator::registerWeakTable(visitor, this,
-                    WeakProcessingHashTableHelper<Traits::weakHandlingFlag, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::ephemeronIteration,
-                    WeakProcessingHashTableHelper<Traits::weakHandlingFlag, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::ephemeronIterationDone);
-                setEnqueued();
-            }
-            // We don't need to trace the elements here, since registering as a
-            // weak table above will cause them to be traced (perhaps several
-            // times). It's better to wait until everything else is traced
-            // before tracing the elements for the first time; this may reduce
-            // (by one) the number of iterations needed to get to a fixed point.
-            return;
+    if (!NeedsTracingTrait<Traits>::value)
+        return;
+    if (Traits::weakHandlingFlag == WeakHandlingInCollections) {
+        // If we have both strong and weak pointers in the collection then
+        // we queue up the collection for fixed point iteration a la
+        // Ephemerons:
+        // http://dl.acm.org/citation.cfm?doid=263698.263733 - see also
+        // http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak
+        ASSERT(!enqueued() || Allocator::weakTableRegistered(visitor, this));
+        if (!enqueued()) {
+            Allocator::registerWeakTable(visitor, this,
+                WeakProcessingHashTableHelper<Traits::weakHandlingFlag, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::ephemeronIteration,
+                WeakProcessingHashTableHelper<Traits::weakHandlingFlag, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::ephemeronIterationDone);
+            setEnqueued();
         }
-        for (ValueType* element = m_table + m_tableSize - 1; element >= m_table; element--) {
-            if (!isEmptyOrDeletedBucket(*element))
-                Allocator::template trace<VisitorDispatcher, ValueType, Traits>(visitor, *element);
-        }
+        // We don't need to trace the elements here, since registering as a
+        // weak table above will cause them to be traced (perhaps several
+        // times). It's better to wait until everything else is traced
+        // before tracing the elements for the first time; this may reduce
+        // (by one) the number of iterations needed to get to a fixed point.
+        return;
+    }
+    for (ValueType* element = m_table + m_tableSize - 1; element >= m_table; element--) {
+        if (!isEmptyOrDeletedBucket(*element))
+            Allocator::template trace<VisitorDispatcher, ValueType, Traits>(visitor, *element);
     }
 }
 
 // iterator adapters
 
 template <typename HashTableType, typename Traits> struct HashTableConstIteratorAdapter {
     STACK_ALLOCATED();
     HashTableConstIteratorAdapter() {}
     HashTableConstIteratorAdapter(const typename HashTableType::const_iterator& impl) : m_impl(impl) {}
     typedef typename Traits::IteratorConstGetType GetType;
@@ skipping 91 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