[oilpan] Fix iterators over member collections to return Result<T>

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 95 matching lines @@
 
     typedef enum { HashItemKnownGood } HashItemKnownGoodTag;
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     class HashTableConstIterator {
     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 const ValueType& ReferenceType;
+        typedef typename Traits::IteratorConstGetType GetType;
         typedef const ValueType* PointerType;
         typedef typename Allocator::template IteratorWitness<HashTableType>::Type IteratorWitnessType;
 
         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;
@@ skipping 58 matching lines @@
 
 #if CHECK_HASHTABLE_ITERATORS
             m_witness = other.m_witness;
 #endif
             addIterator(other.m_table, this);
 
             return *this;
         }
 #endif
 
-        PointerType get() const
+        GetType get() const
         {
             checkValidity();
             return m_position;
         }
-        ReferenceType operator*() const { return *get(); }
-        PointerType operator->() const { return get(); }
+        typename Traits::IteratorConstReferenceType operator*() const { return Traits::getToReferenceConstConversion(get()); }
+        GetType operator->() const { return get(); }
 
         const_iterator& operator++()
         {
             checkValidity();
             ASSERT(m_position != m_endPosition);
             --m_position;
             skipEmptyBuckets();
             return *this;
         }
 
@@ skipping 55 matching lines @@
 #endif
     };
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     class HashTableIterator {
     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 ValueType& ReferenceType;
+        typedef typename Traits::IteratorGetType GetType;
         typedef ValueType* PointerType;
         typedef typename Allocator::template IteratorWitness<HashTableType>::Type IteratorWitnessType;
 
         friend class HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>;
 
         HashTableIterator(HashTableType* table, PointerType pos, PointerType end, IteratorWitnessType witness) : m_iterator(table, pos, end, witness) { }
         HashTableIterator(HashTableType* table, PointerType pos, PointerType end, HashItemKnownGoodTag tag, IteratorWitnessType witness) : m_iterator(table, pos, end, tag, witness) { }
 
     public:
         HashTableIterator() { }
 
         // default copy, assignment and destructor are OK
 
-        PointerType get() const { return const_cast<PointerType>(m_iterator.get()); }
-        ReferenceType operator*() const { return *get(); }
-        PointerType operator->() const { return get(); }
+        GetType get() const { return const_cast<PointerType>(m_iterator.get()); }
+        typename Traits::IteratorReferenceType operator*() const { return Traits::getToReferenceConversion(get()); }
+        GetType operator->() const { return get(); }
 
         iterator& operator++() { ++m_iterator; return *this; }
 
         // 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; }
@@ skipping 1119 matching lines @@
 
         it->m_table = 0;
         it->m_next = 0;
         it->m_previous = 0;
     }
 
 #endif // CHECK_HASHTABLE_ITERATORS
 
     // iterator adapters
 
-    template<typename HashTableType, typename ValueType> struct HashTableConstIteratorAdapter {
+    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;
 
-        const ValueType* get() const { return (const ValueType*)m_impl.get(); }
-        const ValueType& operator*() const { return *get(); }
-        const ValueType* operator->() const { return get(); }
+        GetType get() const { return (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 ValueType> struct HashTableIteratorAdapter {
+    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) {}
 
-        ValueType* get() const { return (ValueType*)m_impl.get(); }
-        ValueType& operator*() const { return *get(); }
-        ValueType* operator->() const { return get(); }
+        GetType get() const { return (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, ValueType>() {
+        operator HashTableConstIteratorAdapter<HashTableType, Traits>()
+        {
             typename HashTableType::const_iterator i = m_impl;
             return i;
         }
 
         typename HashTableType::iterator m_impl;
     };
 
     template<typename T, typename U>
     inline bool operator==(const HashTableConstIteratorAdapter<T, U>& a, const HashTableConstIteratorAdapter<T, U>& b)
     {
@@ skipping 41 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