[oilpan] Wrap NodeVector into CollectionRoot for ensure that contained nodes stay alive.

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 1110 matching lines @@
 
     static void visit(Visitor* v, Collection& collection)
     {
         for (typename Collection::iterator it = collection.begin(), end = collection.end(); it != end; ++it) {
             IfMemberTrait<K>::visit(v, it->key);
             IfMemberTrait<V>::visit(v, it->value);
         }
     }
 };
 
+template<typename Collection> class CollectionRoot;
+
+// Used to inject correctly typed operator[] into CollectionRoot when we are wrapping Vector.
+template<typename T> class IndexingBehavior { };
+
+template<typename T, size_t inlineCapacity, typename Allocator>
+class IndexingBehavior<CollectionRoot<Vector<T, inlineCapacity, Allocator> > > {
+    typedef CollectionRoot<Vector<T, inlineCapacity, Allocator> > CollectionRootType;
+public:
+    T& operator[] (size_t i) { return (**static_cast<CollectionRootType*>(this))[i]; }
+    const T& operator[] (size_t i) const { return (**static_cast<const CollectionRootType*>(this))[i]; }
+};
+
 template<typename Collection>
-class CollectionRoot : public PersistentBase {
+class CollectionRoot : public PersistentBase, public IndexingBehavior<CollectionRoot<Collection> > {
 public:
     typedef Collection CollectionType;
+    typedef typename Collection::iterator iterator;
+    typedef typename Collection::const_iterator const_iterator;
 
     CollectionRoot() { }
     explicit CollectionRoot(size_t size) : m_collection(Collection(size)) { }
     // FIXME(oilpan): this constructor might be extremely ineffecient.
     explicit CollectionRoot(const Collection& collection) : m_collection(collection) { }
 
     Collection* operator->() { return &m_collection; }
     const Collection* operator->() const { return &m_collection; }
     Collection& operator*() { return m_collection; }
     const Collection& operator*() const { return m_collection; }
@@ skipping 265 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