Support receiving GrowableObjectArray on native ports

runtime/vm/dart_api_message.cc

 // 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.
 
 #include "vm/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 
 namespace dart {
@@ skipping 188 matching lines @@
     // updated (currently type_arguments is leaked).
     Dart_CObject* type_arguments = ReadObjectImpl();
     if (type_arguments != &type_arguments_marker &&
         type_arguments->type != Dart_CObject::kNull) {
       return AllocateDartCObjectUnsupported();
     }
     for (int i = 0; i < len; i++) {
       value->value.as_array.values[i] = ReadObjectRef();
     }
     return value;
+  } else if (class_id == kGrowableObjectArrayCid) {
+    // A GrowableObjectArray is serialized as its length followed by its backing
+    // store. The backing store is an array with a length which might be longer
+    // than the length of the GrowableObjectArray.
+    intptr_t len = ReadSmiValue();
+    Dart_CObject* value = GetBackRef(object_id);
+    ASSERT(value == NULL);
+    // Allocate an empty array for the GrowableObjectArray this will be updated

[Mads Ager (google), 2012/09/10 14:05:05]

this will -> which will

[Søren Gjesse, 2012/09/11 14:36:04]

Done.

+    // to point to the content when the backing store has been deserialized.
+    value = AllocateDartCObjectArray(0);
+    AddBackRef(object_id, value, kIsDeserialized);
+    // Read the content of the GrowableObjectArray.
+    Dart_CObject* content = ReadObjectImpl();
+    ASSERT(content->type == Dart_CObject::kArray);
+    // Make the empty array allocated point to the backing store content.
+    value->value.as_array.length = len;
+    value->value.as_array.values = content->value.as_array.values;

[siva, 2012/09/11 01:46:23]

How will this work if the allocator specified in the constructor for
ApiMessageReader is a malloc allocator?

A free of the returned object will not deallocate the backing store right.

Agreed that we currently only use a zone allocator in the
native message handler and all the test cases and this is
not an issue with a zone allocator.

The ApiMessageHandler class itself doesn't specify that only a zone allocator
should be used.

[Søren Gjesse, 2012/09/11 14:36:04]

We don't really have a way of running through the decoded structure to free the
individual pieces. This was already the case before as the decoded structure can
have cycles and there is no specification of how the various pieces for the
decoded structure are allocated.

I added a comment to the ApiMessageReader saying that the allocator needs to
keep track of data allocated to be able to free it again.

+    return value;
   }
 
   return ReadInternalVMObject(class_id, object_id);
 }
 
 
 Dart_CObject* ApiMessageReader::ReadVMSymbol(intptr_t object_id) {
   if (Symbols::IsVMSymbolId(object_id)) {
     RawOneByteString* str =
         reinterpret_cast<RawOneByteString*>(Symbols::GetVMSymbol(object_id));
@@ skipping 557 matching lines @@
   // Write out all objects that were added to the forward list and have
   // not been serialized yet. These would typically be fields of arrays.
   // NOTE: The forward list might grow as we process the list.
   for (intptr_t i = 0; i < forward_id_; i++) {
     WriteForwardedCObject(forward_list_[i]);
   }
   UnmarkAllCObjects(object);
 }
 
 }  // namespace dart