[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 673 matching lines @@
 
     template<typename U>
     Result(const Member<U>& other)
         : m_raw(other.raw())
 #ifndef NDEBUG
         , m_doNotAllocate()
 #endif
     {
     }
 
+    template<typename U>

[Mads Ager (chromium), 2013/08/16 10:23:41]

We really shouldn't be using this unless we really know what we are doing. Can
we make this private and only accessible from the iterators?

[Erik Corry, 2013/08/16 11:39:27]

Done.

+    Result(const Member<U>* other)
+        : m_raw(other->raw())
+#ifndef NDEBUG
+        , m_doNotAllocate()
+#endif
+    {
+    }
+
     ~Result()
     {
     }
 
     template<typename U>
     Result& operator=(const Persistent<U>& other)
     {
         COMPILE_ASSERT(!sizeof(T*), Result_should_never_be_assigned_to);
         return *this;
     }
@@ skipping 18 matching lines @@
         return *this;
     }
 
     template<typename U>
     Result& operator=(const Member<U>& other)
     {
         COMPILE_ASSERT(!sizeof(T*), Result_should_never_be_assigned_to);
         return *this;
     }
 
+    template<typename U>
+    Result& operator=(const Member<U>* other)
+    {
+        COMPILE_ASSERT(!sizeof(T*), Result_should_never_be_assigned_to);
+        return *this;
+    }
+
     template<typename U> bool operator==(const U* other) const { return other == m_raw; }
     template<typename U> bool operator!=(const U* other) const { return other != m_raw; }
 
     template<typename U> bool operator==(const Handle<U>& other) const { return other.raw() == m_raw; }
     template<typename U> bool operator!=(const Handle<U>& other) const { return other.raw() != m_raw; }
 
     template<typename U> bool operator==(const Result<U>& other) const { return other.m_raw == m_raw; }
     template<typename U> bool operator!=(const Result<U>& other) const { return other.m_raw != m_raw; }
 
     template<typename U> bool operator==(const Persistent<U>& other) const { return other.raw() == m_raw; }
@@ skipping 65 matching lines @@
     }
 
     // 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 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 Member<U>::operator==(const Result<V>&);
@@ skipping 626 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