Added {Zone}GrowableHandlePtrArray types: simplifies code, makes code safer

runtime/vm/growable_array.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 // Defines growable array classes, that differ where they are allocated:
 // - GrowableArray: allocated on stack.
 // - ZoneGrowableArray: allocated in the zone.
 // - MallocGrowableArray: allocates using malloc/realloc; free is only called
 //   at destruction.
 
 #ifndef VM_GROWABLE_ARRAY_H_
@@ skipping 177 matching lines @@
   explicit ZoneGrowableArray(intptr_t initial_capacity)
       : BaseGrowableArray<T, ZoneAllocated>(
           initial_capacity,
           ASSERT_NOTNULL(Thread::Current()->zone())) {}
   ZoneGrowableArray()
       : BaseGrowableArray<T, ZoneAllocated>(
           ASSERT_NOTNULL(Thread::Current()->zone())) {}
 };
 
 
+// T must be a Handle type.
+template<typename T, typename B>
+class BaseGrowableHandlePtrArray : public B {
+ public:
+  BaseGrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
+      : zone_(zone), array_(zone, initial_capacity) {}
+
+  // Use unique zone handles to store objects.

[Florian Schneider, 2015/08/31 07:02:59]

Why do the handles need to be unique?

I think you could only re-wrap if the handle is not a zone handle.

[srdjan, 2015/08/31 14:52:40]

Often, e.g., in a loop, we reuse the handles. This means that we could
accidentally overwrite the content of the handle stored in the array, unless the
caller takes extra precaution that the handle is not being reused (which is a
fragile assumption).  That kind of bug appeared several times before.

+  void Add(const T& t) {
+    array_.Add(&T::ZoneHandle(zone_, t.raw()));
+  }
+
+  T& operator[](intptr_t index) const {
+    return *array_[index];
+  }
+
+  const T& At(intptr_t index) const {
+    return operator[](index);
+  }
+
+  intptr_t length() const { return array_.length(); }
+
+  const GrowableArray<T*>& growable_array() const { return array_; }
+
+ private:
+  Zone* zone_;
+  GrowableArray<T*> array_;
+
+  DISALLOW_COPY_AND_ASSIGN(BaseGrowableHandlePtrArray);
+};
+
+
+template<typename T>
+class GrowableHandlePtrArray :
+    public BaseGrowableHandlePtrArray<T, ValueObject> {
+ public:
+  GrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
+      : BaseGrowableHandlePtrArray<T, ValueObject>(zone, initial_capacity) {}
+};
+
+
+template<typename T>
+class ZoneGrowableHandlePtrArray :
+    public BaseGrowableHandlePtrArray<T, ZoneAllocated> {
+ public:
+  ZoneGrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
+      : BaseGrowableHandlePtrArray<T, ZoneAllocated>(zone, initial_capacity) {}
+};
+
+
+
 class Malloc : public AllStatic {
  public:
   template <class T>
   static inline T* Alloc(intptr_t len) {
     return reinterpret_cast<T*>(malloc(len * sizeof(T)));
   }
 
   template <class T>
   static inline T* Realloc(T* old_array, intptr_t old_len, intptr_t new_len) {
     return reinterpret_cast<T*>(realloc(old_array, new_len * sizeof(T)));
@@ skipping 14 matching lines @@
  public:
   explicit MallocGrowableArray(intptr_t initial_capacity)
       : BaseGrowableArray<T, EmptyBase, Malloc>(initial_capacity, NULL) {}
   MallocGrowableArray()
       : BaseGrowableArray<T, EmptyBase, Malloc>(NULL) {}
 };
 
 }  // namespace dart
 
 #endif  // VM_GROWABLE_ARRAY_H_