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 144 matching lines @@
   value->value.as_array.length = length;
   if (length > 0) {
     value->value.as_array.values = reinterpret_cast<Dart_CObject**>(value + 1);
   } else {
     value->value.as_array.values = NULL;
   }
   return value;
 }
 
 
+Dart_CObject* ApiMessageReader::AllocateDartCObjectGrowableObjectArray(
+    intptr_t length) {
+  // Allocate a Dart_CObject structure for holding the GrowableObjectArray

[Mads Ager (google), 2012/09/10 13:28:18]

Move this comment to before the method as it is a method comment?

[Søren Gjesse, 2012/09/10 14:02:02]

Ended up removing this method.

+  // length. This object will be patched to an array when the actual content
+  // of the GrowableObjectArray is read.
+  Dart_CObject* value =
+      reinterpret_cast<Dart_CObject*>(
+          alloc_(NULL, 0, sizeof(Dart_CObject)));
+  ASSERT(value != NULL);
+  // Temporarily assign an illegal type.
+  value->type = static_cast<Dart_CObject::Type>(Dart_CObject::kNumberOfTypes);
+  value->value.as_array.length = length;
+  value->value.as_array.values = NULL;
+  return value;
+}
+
+
 ApiMessageReader::BackRefNode* ApiMessageReader::AllocateBackRefNode(
     Dart_CObject* reference,
     DeserializeState state) {
   BackRefNode* value =
       reinterpret_cast<BackRefNode*>(alloc_(NULL, 0, sizeof(BackRefNode)));
   value->set_reference(reference);
   value->set_state(state);
   return value;
 }
 
@@ skipping 24 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);
+    if (value == NULL) {
+      value = AllocateDartCObjectGrowableObjectArray(len);
+      AddBackRef(object_id, value, kIsDeserialized);
+    }
+    // Read the content of the GrowableObjectArray.
+    Dart_CObject* content = ReadObjectImpl();
+    ASSERT(content->type == Dart_CObject::kArray);
+    // Make the GrowableObjectArray read into an array.

[Mads Ager (google), 2012/09/10 13:28:18]

I find this comment confusing. Maybe add comments in the style of the method
comment for the partial allocation? Something along the lines of:

if (value == NULL) {
  // Allocate a partially initialized array
  // CObject structure.
  ...
}
// Read the content of the GrowableObjectArray.
...
// Finish the initialization of the array CObject structure.

[Søren Gjesse, 2012/09/10 14:02:02]

Simplified to just allocate an empty array for the GrowableObjectArray and
update length and values fields after the backing store is read.

+    value->type = content->type;
+    value->value.as_array.values = content->value.as_array.values;
+    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