Add option to gen_snapshot for creating a Makefile describing a snapshot's dependencies.

runtime/platform/growable_array.h

Index: runtime/platform/growable_array.h
diff --git a/runtime/vm/growable_array.h b/runtime/platform/growable_array.h
similarity index 63%
copy from runtime/vm/growable_array.h
copy to runtime/platform/growable_array.h
index b2d03e08bf4fedf2d2cc5733a4743f0a89f45c48..4a449e001fa91ac02956ed838467fd597e014ae5 100644
--- a/runtime/vm/growable_array.h
+++ b/runtime/platform/growable_array.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2017, 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:
@@ -7,17 +7,15 @@
 // - MallocGrowableArray: allocates using malloc/realloc; free is only called
 //   at destruction.
 
-#ifndef RUNTIME_VM_GROWABLE_ARRAY_H_
-#define RUNTIME_VM_GROWABLE_ARRAY_H_
+#ifndef RUNTIME_PLATFORM_GROWABLE_ARRAY_H_
+#define RUNTIME_PLATFORM_GROWABLE_ARRAY_H_
 
+#include "platform/allocation.h"
 #include "platform/utils.h"
-#include "vm/allocation.h"
-#include "vm/isolate.h"
-#include "vm/zone.h"
 
 namespace dart {
 
-template <typename T, typename B, typename Allocator = Zone>
+template <typename T, typename B, typename Allocator>
 class BaseGrowableArray : public B {
  public:
   explicit BaseGrowableArray(Allocator* allocator)
@@ -68,7 +66,7 @@ class BaseGrowableArray : public B {
     return operator[](length_ - 1);
   }
 
-  void AddArray(const BaseGrowableArray<T, B>& src) {
+  void AddArray(const BaseGrowableArray<T, B, Allocator>& src) {
     for (intptr_t i = 0; i < src.length(); i++) {
       Add(src[i]);
     }
@@ -168,86 +166,6 @@ void BaseGrowableArray<T, B, Allocator>::SetLength(intptr_t new_length) {
 }
 
 
-template <typename T>
-class GrowableArray : public BaseGrowableArray<T, ValueObject> {
- public:
-  GrowableArray(Zone* zone, intptr_t initial_capacity)
-      : BaseGrowableArray<T, ValueObject>(initial_capacity,
-                                          ASSERT_NOTNULL(zone)) {}
-  explicit GrowableArray(intptr_t initial_capacity)
-      : BaseGrowableArray<T, ValueObject>(
-            initial_capacity,
-            ASSERT_NOTNULL(Thread::Current()->zone())) {}
-  GrowableArray()
-      : BaseGrowableArray<T, ValueObject>(
-            ASSERT_NOTNULL(Thread::Current()->zone())) {}
-};
-
-
-template <typename T>
-class ZoneGrowableArray : public BaseGrowableArray<T, ZoneAllocated> {
- public:
-  ZoneGrowableArray(Zone* zone, intptr_t initial_capacity)
-      : BaseGrowableArray<T, ZoneAllocated>(initial_capacity,
-                                            ASSERT_NOTNULL(zone)) {}
-  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.
-  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); }
-
-  void SetAt(intptr_t index, const T& t) {
-    array_[index] = &T::ZoneHandle(zone_, t.raw());
-  }
-
-  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>
@@ -280,4 +198,4 @@ class MallocGrowableArray : public BaseGrowableArray<T, EmptyBase, Malloc> {
 
 }  // namespace dart
 
-#endif  // RUNTIME_VM_GROWABLE_ARRAY_H_
+#endif  // RUNTIME_PLATFORM_GROWABLE_ARRAY_H_