Add more oilpan collections support

Source/heap/Handle.h

 /*
  * Copyright (C) 2014 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 23 matching lines @@
 #include "heap/Heap.h"
 #include "heap/ThreadState.h"
 #include "heap/Visitor.h"
 
 #include "wtf/Ptr.h"
 #include "wtf/RefCounted.h"
 
 namespace WebCore {
 
 template<typename T> class Member;
+template<typename T> struct OffHeapCollectionTraceTrait;
 
 class PersistentNode {
 public:
-    explicit PersistentNode(TraceCallback trace) : m_trace(trace) { }
+    explicit PersistentNode(TraceCallback trace)
+        : m_trace(trace)
+    {
+    }
 
-    virtual ~PersistentNode() { }
+    bool isAlive() { return m_trace; }
+
+    virtual ~PersistentNode()
+    {
+        ASSERT(isAlive());
+        m_trace = 0;
+    }
 
     // Ideally the trace method should be virtual and automatically dispatch
     // to the most specific implementation. However having a virtual method
     // on PersistentNode leads to too eager template instantiation with MSVC
     // which leads to include cycles.
     // Instead we call the constructor with a TraceCallback which knows the
     // type of the most specific child and calls trace directly. See
     // TraceMethodDelegate in Visitor.h for how this is done.
     void trace(Visitor* visitor)
     {
@@ skipping 11 matching lines @@
     friend class PersistentAnchor;
     friend class ThreadState;
 };
 
 template<ThreadAffinity Affinity, typename Owner>
 class PersistentBase : public PersistentNode {
 public:
     ~PersistentBase()
     {
 #ifndef NDEBUG
+        ASSERT(isAlive());
+        ASSERT(m_next->isAlive());
+        ASSERT(m_prev->isAlive());
         m_threadState->checkThread();
 #endif
         m_next->m_prev = m_prev;
         m_prev->m_next = m_next;
     }
 
 protected:
     inline PersistentBase()
         : PersistentNode(TraceMethodDelegate<Owner, &Owner::trace>::trampoline)
 #ifndef NDEBUG
@@ skipping 40 matching lines @@
 #endif
 };
 
 // A dummy Persistent handle that ensures the list of persistents is never null.
 // This removes a test from a hot path.
 class PersistentAnchor : public PersistentNode {
 public:
     void trace(Visitor*) { }
 
 private:
-    virtual ~PersistentAnchor() { }
+    virtual ~PersistentAnchor()
+    {
+        ASSERT(m_next == this);
+        ASSERT(m_prev == this);
+    }
     PersistentAnchor() : PersistentNode(TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
     {
         m_next = this;
         m_prev = this;
     }
 
     friend class ThreadState;
 };
 
 // Persistent handles are used to store pointers into the
@@ skipping 252 matching lines @@
 // Comparison operators between (Weak)Members and Persistents
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 
+template<typename Collection, ThreadAffinity Affinity = MainThreadOnly> class CollectionPersistent;
+
+// Used to inject correctly typed operator[] into CollectionPersistent when we are wrapping Vector.
+template<typename T> class IndexingBehavior { };
+
+template<typename T, size_t inlineCapacity>
+class IndexingBehavior<CollectionPersistent<Vector<T, inlineCapacity, WTF::DefaultAllocator> > > {
+    typedef CollectionPersistent<Vector<T, inlineCapacity, WTF::DefaultAllocator> > CollectionPersistentType;
+public:
+    T& operator[] (size_t i) { return (**static_cast<CollectionPersistentType*>(this))[i]; }
+    const T& operator[] (size_t i) const { return (**static_cast<const CollectionPersistentType*>(this))[i]; }
+};
+
+template<typename Collection, ThreadAffinity Affinity>
+class CollectionPersistent
+    : public PersistentBase<Affinity, CollectionPersistent<Collection, Affinity> >
+    , public IndexingBehavior<CollectionPersistent<Collection, Affinity> > {
+public:
+    typedef Collection CollectionType;
+    typedef typename Collection::iterator iterator;
+    typedef typename Collection::const_iterator const_iterator;
+
+    CollectionPersistent() { }
+    explicit CollectionPersistent(size_t size) : m_collection(Collection(size)) { }
+    explicit CollectionPersistent(const Collection& collection) : m_collection(collection) { }
+    CollectionPersistent& operator=(const Collection& collection) { m_collection = collection; return *this; }
+    Collection* operator->() { return &m_collection; }
+    const Collection* operator->() const { return &m_collection; }
+    Collection& operator*() { return m_collection; }
+    const Collection& operator*() const { return m_collection; }
+
+    void trace(Visitor* visitor)
+    {
+        OffHeapCollectionTraceTrait<Collection>::trace(visitor, m_collection);
+    }
+
+#if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
+    virtual const char* name() OVERRIDE
+    {
+        ASSERT(this == static_cast<PersistentNode*>(this));
+        const char* n = FieldAnnotationBase::fromAddress(this);
+        return n ? n : "CollectionPersistent";
+    }
+#endif
+
+private:
+    Collection m_collection;
+};
+
 // Template aliases for the transition period where we want to support
 // both reference counting and garbage collection based on a
 // compile-time flag.
 //
 // With clang we can use c++11 template aliases which is really what
 // we want. For GCC and MSVC we simulate the template aliases with
 // stylized macros until we can use template aliases.
 #if ENABLE(OILPAN)
 
 #if COMPILER(CLANG)
@@ skipping 87 matching lines @@
 
 template<typename T> struct HashTraits<WebCore::Member<T> > : SimpleClassHashTraits<WebCore::Member<T> > {
     static const bool needsDestruction = false;
     // FIXME: 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.
     // FIXME: Implement proper const'ness for iterator types. Requires support
     // in the marking Visitor.
     typedef T* PeekInType;
     typedef T* PassInType;
-    typedef T* IteratorGetType;
-    typedef T* IteratorConstGetType;
+    typedef WebCore::Member<T>* IteratorGetType;
+    typedef const WebCore::Member<T>* IteratorConstGetType;
     typedef T* IteratorReferenceType;
     typedef T* IteratorConstReferenceType;
     static IteratorConstGetType getToConstGetConversion(const WebCore::Member<T>* x) { return x->get(); }
-    static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x; }
-    static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x; }
+    static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x->get(); }
+    static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x->get(); }
     // FIXME: Similarly, there is no need for a distinction between PeekOutType
     // and PassOutType without reference counting.
     typedef T* PeekOutType;
     typedef T* PassOutType;
 
     template<typename U>
     static void store(const U& value, WebCore::Member<T>& storage) { storage = value; }
 
     static PeekOutType peek(const WebCore::Member<T>& value) { return value; }
     static PassOutType passOut(const WebCore::Member<T>& value) { return value; }
 };
 
 template<typename T> struct HashTraits<WebCore::WeakMember<T> > : SimpleClassHashTraits<WebCore::WeakMember<T> > {
     static const bool needsDestruction = false;
     // FIXME: 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.
     // FIXME: Implement proper const'ness for iterator types. Requires support
     // in the marking Visitor.
     typedef T* PeekInType;
     typedef T* PassInType;
-    typedef T* IteratorGetType;
-    typedef T* IteratorConstGetType;
+    typedef WebCore::WeakMember<T>* IteratorGetType;
+    typedef const WebCore::WeakMember<T>* IteratorConstGetType;
     typedef T* IteratorReferenceType;
     typedef T* IteratorConstReferenceType;
     static IteratorConstGetType getToConstGetConversion(const WebCore::WeakMember<T>* x) { return x->get(); }
-    static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x; }
-    static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x; }
+    static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x->get(); }
+    static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x->get(); }
     // FIXME: Similarly, there is no need for a distinction between PeekOutType
     // and PassOutType without reference counting.
     typedef T* PeekOutType;
     typedef T* PassOutType;
 
     template<typename U>
     static void store(const U& value, WebCore::WeakMember<T>& storage) { storage = value; }
 
     static PeekOutType peek(const WebCore::WeakMember<T>& value) { return value; }
     static PassOutType passOut(const WebCore::WeakMember<T>& value) { return value; }
@@ skipping 31 matching lines @@
 };
 
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 struct IsWeak<WebCore::HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> > {
     static const bool value = Traits::isWeak;
 };
 
 } // namespace WTF
 
 #endif