Wire GrowableArray to use the internal VM object.

vm/object.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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 3483 matching lines @@
  public:
   intptr_t Capacity() const {
     NoGCScope no_gc;
     ASSERT(!IsNull());
     return Smi::Value(DataArray()->length_);
   }
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
+  void SetLength(intptr_t value) const {
+    // This is only safe because we create a new Smi, which does not cause
+    // heap allocation.
+    raw_ptr()->length_ = Smi::New(value);
+  }
+
+  RawArray* data() const { return raw_ptr()->data_; }
+  void SetData(const Array& value) const {
+    StorePointer(&raw_ptr()->data_, value.raw());
+  }
 
   RawObject* At(intptr_t index) const {
     NoGCScope no_gc;
     ASSERT(!IsNull());
     ASSERT(index < Length());
     return *ObjectAddr(index);
   }
   void SetAt(intptr_t index, const Object& value) const {
     NoGCScope no_gc;
     ASSERT(!IsNull());
     ASSERT(index < Length());
     StorePointer(ObjectAddr(index), value.raw());
   }
 
   void Add(const Object& value, Heap::Space space = Heap::kNew) const;
+  void Grow(intptr_t new_capacity, Heap::Space space = Heap::kNew) const;
   RawObject* RemoveLast() const;
 
   virtual RawAbstractTypeArguments* GetTypeArguments() const {
     const Array& contents = Array::Handle(data());
     return contents.GetTypeArguments();
   }
   virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
     const Array& contents = Array::Handle(data());
     contents.SetTypeArguments(value);
+    raw_ptr()->type_arguments_ = value.Canonicalize();
   }
 
   virtual bool Equals(const Instance& other) const;
 
+  static intptr_t type_arguments_offset() {
+    return OFFSET_OF(RawGrowableObjectArray, type_arguments_);
+  }
+
   static intptr_t length_offset() {
     return OFFSET_OF(RawGrowableObjectArray, length_);
   }
   static intptr_t data_offset() {
     return OFFSET_OF(RawGrowableObjectArray, data_);
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawGrowableObjectArray));
   }
 
   static RawGrowableObjectArray* New(Heap::Space space = Heap::kNew) {
     return New(kDefaultInitialCapacity, space);
   }
   static RawGrowableObjectArray* New(intptr_t capacity,
                                      Heap::Space space = Heap::kNew);
+  static RawGrowableObjectArray* New(const Array& array,
+                                     Heap::Space space = Heap::kNew);
 
  private:
-  RawArray* data() const { return raw_ptr()->data_; }
-  void SetLength(intptr_t value) const {
-    // This is only safe because we create a new Smi, which does not cause
-    // heap allocation.
-    raw_ptr()->length_ = Smi::New(value);
-  }
-  void SetData(const Array& value) const {
-    StorePointer(&raw_ptr()->data_, value.raw());
-  }
   RawArray* DataArray() const { return data()->ptr(); }
   RawObject** ObjectAddr(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
     return &(DataArray()->data()[index]);
   }
 
   static const int kDefaultInitialCapacity = 4;
 
   HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
   friend class Class;
@@ skipping 405 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_