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

Source/heap/Handle.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 
 #include "heap/Heap.h"
 #include "heap/Visitor.h"
 #include <wtf/HashFunctions.h>
 #include <wtf/HashMap.h>
 #include <wtf/HashTraits.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/TypeTraits.h>
 #include <wtf/Vector.h>
 
+namespace WTF {
+
+template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> class HashTableConstIterator;
+
+}
+
 namespace WebCore {
 
 // Forward declarations.
 template<typename T> class Result;
 template<typename T> class Handle;
 template<typename T> class Member;
 template<typename T> struct HeapObjectHash;
 
 /*
  * Handles are used to store pointers into the managed heap.
@@ skipping 699 matching lines @@
 
     // FIXME(oilpan): Remove once TreeShared no longer requires reference counting.
     PassRefPtr<T> passRefPtr() const
     {
         return PassRefPtr<T>(releaseRaw());
     }
 
     Handle<T> handle() const { return Handle<T>(releaseRaw()); }
 
 private:
+    template<typename U>
+    Result(const Member<U>* other)
+        : m_raw(other->raw())
+#ifndef NDEBUG
+        , m_doNotAllocate()
+#endif
+    {
+    }
+
+    template<typename U>
+    Result& operator=(const Member<U>* other)
+    {
+        COMPILE_ASSERT(!sizeof(T*), Result_should_never_be_assigned_to);
+        return *this;
+    }
+
     explicit Result(T* raw)
         : m_raw(raw)
 #ifndef NDEBUG
         , m_doNotAllocate()
 #endif
     {
     }
 
     T* releaseRaw() const
     {
         T* raw = m_raw;
         m_raw = 0;
 #ifndef NDEBUG
         m_doNotAllocate.release();
 #endif
         return raw;
     }
 
     // Mutable to allow raw() to steal the pointer when creating a
     // Handle from the Result.
     mutable T* m_raw;
 
 #ifndef NDEBUG
     mutable NoAllocation m_doNotAllocate;
 #endif
 
+    template<typename U> friend void Visitor::visit(const class Result<U>&);
     template<typename U> friend class Persistent;
     template<typename U> friend class Handle;
     template<typename U> friend class Member;
     template<typename U> friend class Result;
     template<typename U> friend Result<U> adopt(U*);
     template<typename U> friend Result<U> adoptRawResult(U*);
     template<typename U> friend Result<U> adoptTreeShared(U*);
     template<typename U, typename V> friend bool operator==(const Result<U>&, const Handle<V>&);
     template<typename U, typename V> friend bool operator!=(const Result<U>&, const Handle<V>&);
     template<typename U, typename V> friend bool operator==(const Handle<U>&, const Result<V>&);
     template<typename U, typename V> friend bool operator!=(const Handle<U>&, const Result<V>&);
     template<typename U, typename V> friend bool operator==(const Result<U>&, const Persistent<V>&);
     template<typename U, typename V> friend bool operator!=(const Result<U>&, const Persistent<V>&);
     template<typename U, typename V> friend bool operator==(const Persistent<U>&, const Result<V>&);
     template<typename U, typename V> friend bool operator!=(const Persistent<U>&, const Result<V>&);
     template<typename U, typename V> friend bool operator==(const Result<U>&, const Member<V>&);
     template<typename U, typename V> friend bool operator!=(const Result<U>&, const Member<V>&);
     template<typename U, typename V> friend bool operator==(const Member<U>&, const Result<V>&);
     template<typename U, typename V> friend bool operator!=(const Member<U>&, const Result<V>&);
     template<typename U, typename V> friend bool operator==(const Result<U>&, const Result<V>&);
     template<typename U, typename V> friend bool operator!=(const Result<U>&, const Result<V>&);
     template<typename U, typename V> friend bool operator==(const Result<U>&, const V*);
     template<typename U, typename V> friend bool operator!=(const Result<U>&, const V*);
     template<typename U, typename V> friend bool operator==(const U*, const Result<V>&);
     template<typename U, typename V> friend bool operator!=(const U*, const Result<V>&);
+    template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> friend class WTF::HashTableConstIterator;
 };
 
 template<class T>
 inline Result<T> adopt(T* raw)
 {
     Shelter::adopt(raw);
     return Result<T>(raw);
 }
 
 // Use of this function may indicate that you have a raw pointer
@@ skipping 523 matching lines @@
     // non-heap allocated hashes must arrange their own visiting. Eg.
     // CollectionRoot visits the members in the collections it contains.
     static const bool needsVisiting = true;
 
     static const bool needsDestruction = false;
     // FIXME(oilpan): The distinction between PeekInType and PassInType is
     // there for the sake of the reference counting handles. When they are gone
     // the two types can be merged into PassInType.
     typedef const typename WebCore::Handle<T>& PeekInType;
     typedef const typename WebCore::Handle<T>& PassInType;
+    typedef WebCore::Result<T> IteratorGetType;
+    typedef WebCore::Result<T> IteratorConstGetType;
+    typedef WebCore::Result<T> IteratorReferenceType;
+    typedef WebCore::Result<T> IteratorConstReferenceType;
+    static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x; }
+    static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x; }
     // FIXME(oilpan): Similarly, there is no need for a distinction between
     // PeekType and PassOutType without reference counting.
     typedef typename WebCore::Result<T> PeekType;
     typedef typename WebCore::Result<T> PassOutType;
 
     template<typename U>
     static void store(const U& value, WebCore::Member<T>& storage) { storage = value; }
 
     static PeekType peek(const WebCore::Member<T>& value) { return value; }
     static PassOutType passOut(const WebCore::Member<T>& value) { return value; }
@@ skipping 14 matching lines @@
     typedef PtrHash<WebCore::Member<T> > Hash;
 };
 
 #define DEFINE_SELF_HANDLE(Type)                                   \
     Result<Type> selfHandle() { return adoptRawResult(this); }             \
     Result<const Type> selfHandle() const { return adoptRawResult(this); }
 
 }
 
 #endif