- Modify dart_api.h to be a proper C API.

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"
 #include "vm/unicode.h"
 
@@ skipping 12 matching lines @@
 }
 
 
 void ApiMessageReader::Init() {
   // Initialize marker objects used to handle Lists.
   // TODO(sjesse): Remove this when message serialization format is
   // updated.
   memset(&type_arguments_marker, 0, sizeof(type_arguments_marker));
   memset(&dynamic_type_marker, 0, sizeof(dynamic_type_marker));
   type_arguments_marker.type =
-      static_cast<Dart_CObject::Type>(Dart_CObject_Internal::kTypeArguments);
+      static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kTypeArguments);
   dynamic_type_marker.type =
-      static_cast<Dart_CObject::Type>(Dart_CObject_Internal::kDynamicType);
+      static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kDynamicType);
 }
 
 
 Dart_CObject* ApiMessageReader::ReadMessage() {
   // Read the object out of the message.
   return ReadObject();
 }
 
 
 intptr_t ApiMessageReader::LookupInternalClass(intptr_t class_header) {
   if (IsVMIsolateObject(class_header)) {
     return GetVMIsolateObjectId(class_header);
   }
   ASSERT(SerializedHeaderTag::decode(class_header) == kObjectId);
   return SerializedHeaderData::decode(class_header);
 }
 
 
-Dart_CObject* ApiMessageReader::AllocateDartCObject(Dart_CObject::Type type) {
+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::AllocateDartCObjectUnsupported() {
-  return AllocateDartCObject(Dart_CObject::kUnsupported);
+  return AllocateDartCObject(Dart_CObject_kUnsupported);
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectNull() {
-  return AllocateDartCObject(Dart_CObject::kNull);
+  return AllocateDartCObject(Dart_CObject_kNull);
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectBool(bool val) {
-  Dart_CObject* value = AllocateDartCObject(Dart_CObject::kBool);
+  Dart_CObject* value = AllocateDartCObject(Dart_CObject_kBool);
   value->value.as_bool = val;
   return value;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectInt32(int32_t val) {
-  Dart_CObject* value = AllocateDartCObject(Dart_CObject::kInt32);
+  Dart_CObject* value = AllocateDartCObject(Dart_CObject_kInt32);
   value->value.as_int32 = val;
   return value;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectInt64(int64_t val) {
-  Dart_CObject* value = AllocateDartCObject(Dart_CObject::kInt64);
+  Dart_CObject* value = AllocateDartCObject(Dart_CObject_kInt64);
   value->value.as_int64 = val;
   return value;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectBigint(intptr_t length) {
   // Allocate a Dart_CObject structure followed by an array of chars
   // for the bigint hex string content. The pointer to the bigint
   // content is set up to this area.
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(
           alloc_(NULL, 0, sizeof(Dart_CObject) + length + 1));
   value->value.as_bigint = reinterpret_cast<char*>(value) + sizeof(*value);
-  value->type = Dart_CObject::kBigint;
+  value->type = Dart_CObject_kBigint;
   return value;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectDouble(double val) {
-  Dart_CObject* value = AllocateDartCObject(Dart_CObject::kDouble);
+  Dart_CObject* value = AllocateDartCObject(Dart_CObject_kDouble);
   value->value.as_double = val;
   return value;
 }
 
 
 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;
+  value->type = Dart_CObject_kString;
   return value;
 }
 
 
-static int GetTypedDataSizeInBytes(Dart_CObject::TypedDataType type) {
+static int GetTypedDataSizeInBytes(Dart_TypedData_Type type) {
   switch (type) {
-    case Dart_CObject::kInt8Array:
-    case Dart_CObject::kUint8Array:
-    case Dart_CObject::kUint8ClampedArray:
+    case Dart_TypedData_kInt8:
+    case Dart_TypedData_kUint8:
+    case Dart_TypedData_kUint8Clamped:
       return 1;
-    case Dart_CObject::kInt16Array:
-    case Dart_CObject::kUint16Array:
+    case Dart_TypedData_kInt16:
+    case Dart_TypedData_kUint16:
       return 2;
-    case Dart_CObject::kInt32Array:
-    case Dart_CObject::kUint32Array:
-    case Dart_CObject::kFloat32Array:
+    case Dart_TypedData_kInt32:
+    case Dart_TypedData_kUint32:
+    case Dart_TypedData_kFloat32:
       return 4;
-    case Dart_CObject::kInt64Array:
-    case Dart_CObject::kUint64Array:
-    case Dart_CObject::kFloat64Array:
+    case Dart_TypedData_kInt64:
+    case Dart_TypedData_kUint64:
+    case Dart_TypedData_kFloat64:
       return 8;
     default:
       break;
   }
   UNREACHABLE();
   return -1;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectTypedData(
-    Dart_CObject::TypedDataType type, intptr_t length) {
+    Dart_TypedData_Type type, 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.
   intptr_t length_in_bytes = GetTypedDataSizeInBytes(type) * length;
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(
           alloc_(NULL, 0, sizeof(Dart_CObject) + length_in_bytes));
   ASSERT(value != NULL);
-  value->type = Dart_CObject::kTypedData;
+  value->type = Dart_CObject_kTypedData;
   value->value.as_typed_data.type = type;
   value->value.as_typed_data.length = length_in_bytes;
   if (length > 0) {
     value->value.as_typed_data.values =
         reinterpret_cast<uint8_t*>(value) + sizeof(*value);
   } else {
     value->value.as_typed_data.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->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;
 }
 
 
 Dart_CObject_Internal* ApiMessageReader::AllocateDartCObjectInternal(
     Dart_CObject_Internal::Type type) {
   Dart_CObject_Internal* value =
       reinterpret_cast<Dart_CObject_Internal*>(
           alloc_(NULL, 0, sizeof(Dart_CObject_Internal)));
   ASSERT(value != NULL);
-  value->type = static_cast<Dart_CObject::Type>(type);
+  value->type = static_cast<Dart_CObject_Type>(type);
   return value;
 }
 
 
 Dart_CObject_Internal* ApiMessageReader::AllocateDartCObjectClass() {
   return AllocateDartCObjectInternal(Dart_CObject_Internal::kClass);
 }
 
 
 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;
 }
 
 
-static Dart_CObject::TypedDataType GetTypedDataTypeFromView(
+static Dart_TypedData_Type GetTypedDataTypeFromView(
     Dart_CObject_Internal* object) {
   struct {
     const char* name;
-    Dart_CObject::TypedDataType type;
+    Dart_TypedData_Type type;
   } view_class_names[] = {
-    { "_Int8ArrayView", Dart_CObject::kInt8Array },
-    { "_Uint8ArrayView", Dart_CObject::kUint8Array },
-    { "_Uint8ClampedArrayView", Dart_CObject::kUint8ClampedArray },
-    { "_Int16ArrayView", Dart_CObject::kInt16Array },
-    { "_Uint16ArrayView", Dart_CObject::kUint16Array },
-    { "_Int32ArrayView", Dart_CObject::kInt32Array },
-    { "_Uint32ArrayView", Dart_CObject::kUint32Array },
-    { "_Int64ArrayView", Dart_CObject::kInt64Array },
-    { "_Uint64ArrayView", Dart_CObject::kUint64Array },
-    { "_ByteDataView", Dart_CObject::kUint8Array },
-    { "_Float32ArrayView", Dart_CObject::kFloat32Array },
-    { "_Float64ArrayView", Dart_CObject::kFloat64Array },
-    { NULL, Dart_CObject::kNumberOfTypedDataTypes },
+    { "_Int8ArrayView", Dart_TypedData_kInt8 },
+    { "_Uint8ArrayView", Dart_TypedData_kUint8 },
+    { "_Uint8ClampedArrayView", Dart_TypedData_kUint8Clamped },
+    { "_Int16ArrayView", Dart_TypedData_kInt16 },
+    { "_Uint16ArrayView", Dart_TypedData_kUint16 },
+    { "_Int32ArrayView", Dart_TypedData_kInt32 },
+    { "_Uint32ArrayView", Dart_TypedData_kUint32 },
+    { "_Int64ArrayView", Dart_TypedData_kInt64 },
+    { "_Uint64ArrayView", Dart_TypedData_kUint64 },
+    { "_ByteDataView", Dart_TypedData_kUint8 },
+    { "_Float32ArrayView", Dart_TypedData_kFloat32 },
+    { "_Float64ArrayView", Dart_TypedData_kFloat64 },
+    { NULL, Dart_TypedData_kInvalid },
   };
 
   char* library_url =
       object->cls->internal.as_class.library_url->value.as_string;
   char* class_name =
       object->cls->internal.as_class.class_name->value.as_string;
   if (strcmp("dart:typed_data", library_url) != 0) {
-    return Dart_CObject::kNumberOfTypedDataTypes;
+    return Dart_TypedData_kInvalid;
   }
   int i = 0;
   while (view_class_names[i].name != NULL) {
     if (strncmp(view_class_names[i].name,
                 class_name,
                 strlen(view_class_names[i].name)) == 0) {
       return view_class_names[i].type;
     }
     i++;
   }
-  return Dart_CObject::kNumberOfTypedDataTypes;
+  return Dart_TypedData_kInvalid;
 }
 
 
 Dart_CObject* ApiMessageReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
   intptr_t tags = ReadIntptrValue();
   USE(tags);
   intptr_t class_id;
 
   // There is limited support for reading regular dart instances. Only
   // typed data views are currently handled.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     Dart_CObject_Internal* object =
         reinterpret_cast<Dart_CObject_Internal*>(GetBackRef(object_id));
     if (object == NULL) {
       object =
           AllocateDartCObjectInternal(Dart_CObject_Internal::kUninitialized);
       AddBackRef(object_id, object, kIsDeserialized);
       // Read class of object.
       object->cls = reinterpret_cast<Dart_CObject_Internal*>(ReadObjectImpl());
       ASSERT(object->cls->type ==
-             static_cast<Dart_CObject::Type>(Dart_CObject_Internal::kClass));
+             static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kClass));
     }
     ASSERT(object->type ==
-           static_cast<Dart_CObject::Type>(
+           static_cast<Dart_CObject_Type>(
                Dart_CObject_Internal::kUninitialized));
 
     // Handle typed data views.
-    Dart_CObject::TypedDataType type = GetTypedDataTypeFromView(object);
-    if (type != Dart_CObject::kNumberOfTypedDataTypes) {
+    Dart_TypedData_Type type = GetTypedDataTypeFromView(object);
+    if (type != Dart_TypedData_kInvalid) {
       object->type =
-          static_cast<Dart_CObject::Type>(Dart_CObject_Internal::kView);
+          static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kView);
       ReadObjectImpl();  // Skip type arguments.
       object->internal.as_view.buffer = ReadObjectImpl();
       object->internal.as_view.offset_in_bytes = ReadSmiValue();
       object->internal.as_view.length = ReadSmiValue();
       ReadObjectImpl();  // Skip last field.
 
       // The buffer is fully read now as typed data objects are
       // serialized in-line.
       Dart_CObject* buffer = object->internal.as_view.buffer;
-      ASSERT(buffer->type == Dart_CObject::kTypedData);
+      ASSERT(buffer->type == Dart_CObject_kTypedData);
 
       // Now turn the view into a byte array.
-      object->type = Dart_CObject::kTypedData;
+      object->type = Dart_CObject_kTypedData;
       object->value.as_typed_data.type = type;
       object->value.as_typed_data.length =
           object->internal.as_view.length *
           GetTypedDataSizeInBytes(type);
       object->value.as_typed_data.values =
           buffer->value.as_typed_data.values +
           object->internal.as_view.offset_in_bytes;
     } else {
       // TODO(sgjesse): Handle other instances. Currently this will
       // skew the reading as the fields of the instance is not read.
     }
     return object;
   }
 
   ASSERT((class_header & kSmiTagMask) != 0);
   class_id = LookupInternalClass(class_header);
   if ((class_id == kArrayCid) || (class_id == kImmutableArrayCid)) {
     intptr_t len = ReadSmiValue();
     Dart_CObject* value = GetBackRef(object_id);
     if (value == NULL) {
       value = AllocateDartCObjectArray(len);
       AddBackRef(object_id, value, kIsDeserialized);
     }
     // Skip type arguments.
     // TODO(sjesse): Remove this when message serialization format is
     // updated (currently type_arguments is leaked).
     Dart_CObject* type_arguments = ReadObjectImpl();
     if (type_arguments != &type_arguments_marker &&
-        type_arguments->type != Dart_CObject::kNull) {
+        type_arguments->type != Dart_CObject_kNull) {
       return AllocateDartCObjectUnsupported();
     }
     for (int i = 0; i < len; i++) {
       value->value.as_array.values[i] = ReadObjectRef();
     }
     return value;
   }
 
   return ReadInternalVMObject(class_id, object_id);
 }
@@ skipping 53 matching lines @@
   // Reading of regular dart instances has limited support in order to
   // read typed data views.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     intptr_t object_id = SerializedHeaderData::decode(value);
     Dart_CObject_Internal* object =
         AllocateDartCObjectInternal(Dart_CObject_Internal::kUninitialized);
     AddBackRef(object_id, object, kIsNotDeserialized);
     // Read class of object.
     object->cls = reinterpret_cast<Dart_CObject_Internal*>(ReadObjectImpl());
     ASSERT(object->cls->type ==
-           static_cast<Dart_CObject::Type>(Dart_CObject_Internal::kClass));
+           static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kClass));
     return object;
   }
   ASSERT((class_header & kSmiTagMask) != 0);
   intptr_t object_id = SerializedHeaderData::decode(value);
   intptr_t class_id = LookupInternalClass(class_header);
   if ((class_id == kArrayCid) || (class_id == kImmutableArrayCid)) {
     ASSERT(GetBackRef(object_id) == NULL);
     intptr_t len = ReadSmiValue();
     Dart_CObject* value = AllocateDartCObjectArray(len);
     AddBackRef(object_id, value, kIsNotDeserialized);
@@ skipping 27 matching lines @@
 
 
 Dart_CObject* ApiMessageReader::ReadInternalVMObject(intptr_t class_id,
                                                      intptr_t object_id) {
   switch (class_id) {
     case kClassCid: {
       Dart_CObject_Internal* object = AllocateDartCObjectClass();
       AddBackRef(object_id, object, kIsDeserialized);
       object->internal.as_class.library_url = ReadObjectImpl();
       ASSERT(object->internal.as_class.library_url->type ==
-             Dart_CObject::kString);
+             Dart_CObject_kString);
       object->internal.as_class.class_name = ReadObjectImpl();
       ASSERT(object->internal.as_class.class_name->type ==
-             Dart_CObject::kString);
+             Dart_CObject_kString);
       return object;
     }
     case kTypeArgumentsCid: {
       // TODO(sjesse): Remove this when message serialization format is
       // updated (currently length is leaked).
       Dart_CObject* value = &type_arguments_marker;
       AddBackRef(object_id, value, kIsDeserialized);
       Dart_CObject* length = ReadObjectImpl();
-      ASSERT(length->type == Dart_CObject::kInt32);
+      ASSERT(length->type == Dart_CObject_kInt32);
       for (int i = 0; i < length->value.as_int32; i++) {
         Dart_CObject* type = ReadObjectImpl();
         if (type != &dynamic_type_marker) {
           return AllocateDartCObjectUnsupported();
         }
       }
       return value;
     }
     case kTypeParameterCid: {
       // TODO(sgjesse): Fix this workaround ignoring the type parameter.
       Dart_CObject* value = &dynamic_type_marker;
       AddBackRef(object_id, value, kIsDeserialized);
       intptr_t index = ReadIntptrValue();
       USE(index);
       intptr_t token_index = ReadIntptrValue();
       USE(token_index);
       int8_t type_state = Read<int8_t>();
       USE(type_state);
       Dart_CObject* parameterized_class = ReadObjectImpl();
       // The type parameter is finalized, therefore parameterized_class is null.
-      ASSERT(parameterized_class->type == Dart_CObject::kNull);
+      ASSERT(parameterized_class->type == Dart_CObject_kNull);
       Dart_CObject* name = ReadObjectImpl();
-      ASSERT(name->type == Dart_CObject::kString);
+      ASSERT(name->type == Dart_CObject_kString);
       return value;
     }
     case kMintCid: {
       int64_t value = Read<int64_t>();
       Dart_CObject* object;
       if (kMinInt32 <= value && value <= kMaxInt32) {
         object = AllocateDartCObjectInt32(value);
       } else {
         object = AllocateDartCObjectInt64(value);
       }
@@ skipping 73 matching lines @@
       *p = '\0';
       ASSERT(p == (object->value.as_string + utf8_len));
       ::free(utf16);
       return object;
     }
 
 #define READ_TYPED_DATA(type, ctype)                                           \
     {                                                                          \
       intptr_t len = ReadSmiValue();                                           \
       Dart_CObject* object =                                                   \
-          AllocateDartCObjectTypedData(Dart_CObject::k##type##Array, len);     \
+          AllocateDartCObjectTypedData(Dart_TypedData_k##type, len);     \
       AddBackRef(object_id, object, kIsDeserialized);                          \
       if (len > 0) {                                                           \
         ctype* p =                                                             \
             reinterpret_cast<ctype*>(object->value.as_typed_data.values);      \
         for (intptr_t i = 0; i < len; i++) {                                   \
           p[i] = Read<ctype>();                                                \
         }                                                                      \
       }                                                                        \
       return object;                                                           \
     }                                                                          \
@@ skipping 51 matching lines @@
 
       Dart_CObject* value = GetBackRef(object_id);
       ASSERT(value == NULL);
       // Allocate an empty array for the GrowableObjectArray which
       // will be updated 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);
+      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;
       return value;
     }
     default:
       // Everything else not supported.
       Dart_CObject* value = AllocateDartCObjectUnsupported();
       AddBackRef(object_id, value, kIsDeserialized);
       return value;
@@ skipping 92 matching lines @@
   }
 }
 
 
 void ApiMessageWriter::MarkCObject(Dart_CObject* object, intptr_t object_id) {
   // Mark the object as serialized by adding the object id to the
   // upper bits of the type field in the Dart_CObject structure. Add
   // an offset for making marking of object id 0 possible.
   ASSERT(!IsCObjectMarked(object));
   intptr_t mark_value = object_id + kDartCObjectMarkOffset;
-  object->type = static_cast<Dart_CObject::Type>(
+  object->type = static_cast<Dart_CObject_Type>(
       ((mark_value) << kDartCObjectTypeBits) | object->type);
 }
 
 
 void ApiMessageWriter::UnmarkCObject(Dart_CObject* object) {
   ASSERT(IsCObjectMarked(object));
-  object->type = static_cast<Dart_CObject::Type>(
+  object->type = static_cast<Dart_CObject_Type>(
       object->type & kDartCObjectTypeMask);
 }
 
 
 bool ApiMessageWriter::IsCObjectMarked(Dart_CObject* object) {
   return (object->type & kDartCObjectMarkMask) != 0;
 }
 
 
 intptr_t ApiMessageWriter::GetMarkedCObjectMark(Dart_CObject* object) {
   ASSERT(IsCObjectMarked(object));
   intptr_t mark_value =
       ((object->type & kDartCObjectMarkMask) >> kDartCObjectTypeBits);
   // An offset was added to object id for making marking object id 0 possible.
   return mark_value - kDartCObjectMarkOffset;
 }
 
 
 void ApiMessageWriter::UnmarkAllCObjects(Dart_CObject* object) {
   if (!IsCObjectMarked(object)) return;
   UnmarkCObject(object);
-  if (object->type == Dart_CObject::kArray) {
+  if (object->type == Dart_CObject_kArray) {
     for (int i = 0; i < object->value.as_array.length; i++) {
       Dart_CObject* element = object->value.as_array.values[i];
       UnmarkAllCObjects(element);
     }
   }
 }
 
 
 void ApiMessageWriter::AddToForwardList(Dart_CObject* object) {
   if (forward_id_ >= forward_list_length_) {
@@ skipping 68 matching lines @@
 }
 
 
 bool ApiMessageWriter::WriteCObject(Dart_CObject* object) {
   if (IsCObjectMarked(object)) {
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
     return true;
   }
 
-  Dart_CObject::Type type = object->type;
-  if (type == Dart_CObject::kArray) {
+  Dart_CObject_Type type = object->type;
+  if (type == Dart_CObject_kArray) {
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class and tags information.
     WriteIndexedObject(kArrayCid);
     WriteIntptrValue(0);
 
     WriteSmi(object->value.as_array.length);
     // Write out the type arguments.
     WriteNullObject();
     // Write out array elements.
     for (int i = 0; i < object->value.as_array.length; i++) {
       bool success = WriteCObjectRef(object->value.as_array.values[i]);
       if (!success) return false;
     }
     return true;
   }
   return WriteCObjectInlined(object, type);
 }
 
 
 bool ApiMessageWriter::WriteCObjectRef(Dart_CObject* object) {
   if (IsCObjectMarked(object)) {
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
     return true;
   }
 
-  Dart_CObject::Type type = object->type;
-  if (type == Dart_CObject::kArray) {
+  Dart_CObject_Type type = object->type;
+  if (type == Dart_CObject_kArray) {
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class information.
     WriteIndexedObject(kArrayCid);
     // Write out the length information.
     WriteSmi(object->value.as_array.length);
     // Add object to forward list so that this object is serialized later.
     AddToForwardList(object);
     return true;
   }
   return WriteCObjectInlined(object, type);
 }
 
 
 bool ApiMessageWriter::WriteForwardedCObject(Dart_CObject* object) {
   ASSERT(IsCObjectMarked(object));
-  Dart_CObject::Type type =
-      static_cast<Dart_CObject::Type>(object->type & kDartCObjectTypeMask);
-  ASSERT(type == Dart_CObject::kArray);
+  Dart_CObject_Type type =
+      static_cast<Dart_CObject_Type>(object->type & kDartCObjectTypeMask);
+  ASSERT(type == Dart_CObject_kArray);
 
   // Write out the serialization header value for this object.
   intptr_t object_id = GetMarkedCObjectMark(object);
   WriteInlinedObjectHeader(kMaxPredefinedObjectIds + object_id);
   // Write out the class and tags information.
   WriteIndexedObject(kArrayCid);
   WriteIntptrValue(0);
 
   WriteSmi(object->value.as_array.length);
   // Write out the type arguments.
   WriteNullObject();
   // Write out array elements.
   for (int i = 0; i < object->value.as_array.length; i++) {
     bool success = WriteCObjectRef(object->value.as_array.values[i]);
     if (!success) return false;
   }
   return true;
 }
 
 
 bool ApiMessageWriter::WriteCObjectInlined(Dart_CObject* object,
-                                           Dart_CObject::Type type) {
+                                           Dart_CObject_Type type) {
   switch (type) {
-    case Dart_CObject::kNull:
+    case Dart_CObject_kNull:
       WriteNullObject();
       break;
-    case Dart_CObject::kBool:
+    case Dart_CObject_kBool:
       if (object->value.as_bool) {
         WriteVMIsolateObject(kTrueValue);
       } else {
         WriteVMIsolateObject(kFalseValue);
       }
       break;
-    case Dart_CObject::kInt32:
+    case Dart_CObject_kInt32:
       WriteInt32(object);
       break;
-    case Dart_CObject::kInt64:
+    case Dart_CObject_kInt64:
       WriteInt64(object);
       break;
-    case Dart_CObject::kBigint: {
+    case Dart_CObject_kBigint: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       WriteIndexedObject(kBigintCid);
       WriteIntptrValue(0);
       // Write hex string length and content
       char* hex_string = object->value.as_bigint;
       intptr_t len = strlen(hex_string);
       WriteIntptrValue(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(hex_string[i]);
       }
       break;
     }
-    case Dart_CObject::kDouble:
+    case Dart_CObject_kDouble:
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       WriteIndexedObject(kDoubleCid);
       WriteIntptrValue(0);
       // Write double value.
       Write<double>(object->value.as_double);
       break;
-    case Dart_CObject::kString: {
+    case Dart_CObject_kString: {
       const uint8_t* utf8_str =
           reinterpret_cast<const uint8_t*>(object->value.as_string);
       intptr_t utf8_len = strlen(object->value.as_string);
       if (!Utf8::IsValid(utf8_str, utf8_len)) {
         return false;
       }
 
       Utf8::Type type;
       intptr_t len = Utf8::CodeUnitCount(utf8_str, utf8_len, &type);
 
@@ skipping 23 matching lines @@
             reinterpret_cast<uint16_t*>(::malloc(len * sizeof(uint16_t)));
         bool success = Utf8::DecodeToUTF16(utf8_str, utf8_len, utf16_str, len);
         ASSERT(success);
         for (intptr_t i = 0; i < len; i++) {
           Write<uint16_t>(utf16_str[i]);
         }
         ::free(utf16_str);
       }
       break;
     }
-    case Dart_CObject::kTypedData: {
+    case Dart_CObject_kTypedData: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       intptr_t class_id;
       switch (object->value.as_typed_data.type) {
-        case Dart_CObject::kInt8Array:
+        case Dart_TypedData_kInt8:
           class_id = kTypedDataInt8ArrayCid;
           break;
-        case Dart_CObject::kUint8Array:
+        case Dart_TypedData_kUint8:
           class_id = kTypedDataUint8ArrayCid;
           break;
         default:
           class_id = kTypedDataUint8ArrayCid;
           UNIMPLEMENTED();
       }
 
       WriteIndexedObject(class_id);
       WriteIntptrValue(RawObject::ClassIdTag::update(class_id, 0));
       uint8_t* bytes = object->value.as_typed_data.values;
       intptr_t len = object->value.as_typed_data.length;
       WriteSmi(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(bytes[i]);
       }
       break;
     }
-    case Dart_CObject::kExternalTypedData: {
+    case Dart_CObject_kExternalTypedData: {
       // TODO(ager): we are writing C pointers into the message in
       // order to post external arrays through ports. We need to make
       // sure that messages containing pointers can never be posted
       // to other processes.
 
       // Write out serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tag information.
       WriteIndexedObject(kExternalTypedDataUint8ArrayCid);
       WriteIntptrValue(RawObject::ClassIdTag::update(
@@ skipping 31 matching lines @@
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart