Add support for byte arrays to native messages

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/object_store.h"
 
 namespace dart {
 
@@ skipping 38 matching lines @@
   SerializedHeaderType header_type = SerializedHeaderTag::decode(class_header);
   ASSERT(header_type == kObjectId);
   intptr_t header_value = SerializedHeaderData::decode(class_header);
   return header_value;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObject(Dart_CObject::Type type) {
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(alloc_(NULL, 0, sizeof(Dart_CObject)));
+  ASSERT(value != NULL);
   value->type = type;
   return value;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectNull() {
   return AllocateDartCObject(Dart_CObject::kNull);
 }
 
 
@@ skipping 18 matching lines @@
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectString(intptr_t length) {
   // Allocate a Dart_CObject structure followed by an array of chars
   // for the string content. The pointer to the string content is set
   // up to this area.
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(
           alloc_(NULL, 0, sizeof(Dart_CObject) + length + 1));
+  ASSERT(value != NULL);
   value->value.as_string = reinterpret_cast<char*>(value) + sizeof(*value);
   value->type = Dart_CObject::kString;
   return value;
 }
 
 
+Dart_CObject* ApiMessageReader::AllocateDartCObjectByteArray(intptr_t length) {
+  // Allocate a Dart_CObject structure followed by an array of bytes
+  // for the byte array content. The pointer to the byte array content
+  // is set up to this area.
+  Dart_CObject* value =
+      reinterpret_cast<Dart_CObject*>(
+          alloc_(NULL, 0, sizeof(Dart_CObject) + length));
+  ASSERT(value != NULL);
+  value->type = Dart_CObject::kByteArray;
+  value->value.as_array.length = length;
+  if (length > 0) {
+    value->value.as_byte_array.values =
+        reinterpret_cast<uint8_t*>(value) + sizeof(*value);
+  } else {
+    value->value.as_byte_array.values = NULL;
+  }
+  return value;
+}
+
+
 Dart_CObject* ApiMessageReader::AllocateDartCObjectArray(intptr_t length) {
   // Allocate a Dart_CObject structure followed by an array of
   // pointers to Dart_CObject structures. The pointer to the array
   // content is set up to this area.
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(
           alloc_(NULL, 0, sizeof(Dart_CObject) + length * sizeof(value)));
+  ASSERT(value != NULL);
   value->type = Dart_CObject::kArray;
   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;
 }
 
@@ skipping 55 matching lines @@
       break;
     }
     case ObjectStore::kOneByteStringClass: {
       intptr_t len = ReadSmiValue();
       intptr_t hash = ReadSmiValue();
       USE(hash);
       Dart_CObject* object = AllocateDartCObjectString(len);
       AddBackwardReference(object_id, object);
       char* p = object->value.as_string;
       for (intptr_t i = 0; i < len; i++) {
-        *p = Read<uint8_t>();
-        p++;
+        p[i] = Read<uint8_t>();
       }
-      *p = '\0';
+      p[len] = '\0';
       return object;
       break;
     }
     case ObjectStore::kTwoByteStringClass:
       // Two byte strings not supported.
       return NULL;
       break;
     case ObjectStore::kFourByteStringClass:
       // Four byte strings not supported.
       return NULL;
       break;
+    case ObjectStore::kInternalByteArrayClass: {
+      intptr_t len = ReadSmiValue();
+      Dart_CObject* object = AllocateDartCObjectByteArray(len);
+      AddBackwardReference(object_id, object);
+      if (len > 0) {
+        uint8_t* p = object->value.as_byte_array.values;
+        for (intptr_t i = 0; i < len; i++) {
+          p[i] = Read<uint8_t>();
+        }
+      }
+      return object;
+      break;
+    }
     default:
       // Everything else not supported.
       return NULL;
   }
 }
 
 
 Dart_CObject* ApiMessageReader::ReadIndexedObject(intptr_t object_id) {
   if (object_id == Object::kNullObject) {
     return AllocateDartCObjectNull();
   } else if (object_id == ObjectStore::kTrueValue) {
     return AllocateDartCObjectBool(true);
   } else if (object_id == ObjectStore::kFalseValue) {
     return AllocateDartCObjectBool(false);
   } else if (object_id == ObjectStore::kDynamicType ||
              object_id == ObjectStore::kDoubleInterface ||
              object_id == ObjectStore::kIntInterface ||
              object_id == ObjectStore::kBoolInterface ||
-             object_id == ObjectStore::kStringInterface) {
+             object_id == ObjectStore::kStringInterface ||
+             object_id == ObjectStore::kByteArrayInterface) {
     // Always return dynamic type (this is only a marker).
     return &dynamic_type_marker;
   } else {
     intptr_t index = object_id - kMaxPredefinedObjectIds;
     ASSERT(index < backward_references_.length());
     ASSERT(backward_references_[index] != NULL);
     return backward_references_[index];
   }
   return NULL;
 }
@@ skipping 21 matching lines @@
   return ReadObjectImpl(value);
 }
 
 
 void ApiMessageReader::AddBackwardReference(intptr_t id, Dart_CObject* obj) {
   ASSERT((id - kMaxPredefinedObjectIds) == backward_references_.length());
   backward_references_.Add(obj);
 }
 
 }  // namespace dart