Add more oilpan collections support

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 185 matching lines @@
     }
 
     template<typename T, bool useSwap> struct Mover;
     template<typename T> struct Mover<T, true> { static void move(T& from, T& to) { hashTableSwap(from, to); } };
     template<typename T> struct Mover<T, false> { static void move(T& from, T& to) { to = from; } };
 
     template<typename HashFunctions> class 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> static void translate(T& location, const U&, const T& value) { location = value; }
+        template<typename T, typename U, typename V> static void translate(T& location, const U&, const V& value) { location = value; }
     };
 
     template<typename IteratorType> struct HashTableAddResult {
         HashTableAddResult(IteratorType iter, bool isNewEntry) : iterator(iter), isNewEntry(isNewEntry) { }
         IteratorType iterator;
         bool isNewEntry;
     };
 
     template<typename Value, typename Extractor, typename KeyTraits>
     struct HashTableHelper {
@@ skipping 844 matching lines @@
         // while we are iterating over them. The weakProcessing callback will
         // mark the backing as a void pointer, and will perform weak processing
         // if needed.
         if (!Traits::isWeak)
             Allocator::markNoTracing(visitor, m_table);
         else
             Allocator::registerWeakMembers(visitor, this, WeakProcessingHashTableHelper<Traits::isWeak, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::process);
         if (Traits::needsTracing) {
             for (ValueType* element = m_table + m_tableSize - 1; element >= m_table; element--) {
                 if (!isEmptyOrDeletedBucket(*element))
-                    Allocator::template mark<ValueType, Traits>(visitor, *element);
+                    Allocator::template trace<ValueType, Traits>(visitor, *element);
             }
         }
     }
 
     // iterator adapters
 
     template<typename HashTableType, typename Traits> struct HashTableConstIteratorAdapter {
         HashTableConstIteratorAdapter() {}
         HashTableConstIteratorAdapter(const typename HashTableType::const_iterator& impl) : m_impl(impl) {}
         typedef typename Traits::IteratorConstGetType GetType;
         typedef typename HashTableType::ValueTraits::IteratorConstGetType SourceGetType;
 
-        GetType get() const { return (GetType)SourceGetType(m_impl.get()); }
+        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 HashTableType, typename Traits> struct HashTableIteratorAdapter {
         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 (GetType)SourceGetType(m_impl.get()); }
+        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;
@@ skipping 49 matching lines @@
     inline bool operator!=(const HashTableIteratorAdapter<T, U>& a, const HashTableConstIteratorAdapter<T, U>& b)
     {
         return a.m_impl != b.m_impl;
     }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h