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

runtime/vm/snapshot_test.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 "include/dart_debugger_api.h"
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
@@ skipping 47 matching lines @@
   Zone* zone = Isolate::Current()->current_zone();
   return zone->Realloc<uint8_t>(ptr, old_size, new_size);
 }
 
 
 // Compare two Dart_CObject object graphs rooted in first and
 // second. The second graph will be destroyed by this operation no matter
 // whether the graphs are equal or not.
 static void CompareDartCObjects(Dart_CObject* first, Dart_CObject* second) {
   // Return immediately if entering a cycle.
-  if (second->type == Dart_CObject::kNumberOfTypes) return;
+  if (second->type == Dart_CObject_kNumberOfTypes) return;
 
   EXPECT_NE(first, second);
   EXPECT_EQ(first->type, second->type);
   switch (first->type) {
-    case Dart_CObject::kNull:
+    case Dart_CObject_kNull:
       // Nothing more to compare.
       break;
-    case Dart_CObject::kBool:
+    case Dart_CObject_kBool:
       EXPECT_EQ(first->value.as_bool, second->value.as_bool);
       break;
-    case Dart_CObject::kInt32:
+    case Dart_CObject_kInt32:
       EXPECT_EQ(first->value.as_int32, second->value.as_int32);
       break;
-    case Dart_CObject::kInt64:
+    case Dart_CObject_kInt64:
       EXPECT_EQ(first->value.as_int64, second->value.as_int64);
       break;
-    case Dart_CObject::kBigint:
+    case Dart_CObject_kBigint:
       EXPECT_STREQ(first->value.as_bigint, second->value.as_bigint);
       break;
-    case Dart_CObject::kDouble:
+    case Dart_CObject_kDouble:
       EXPECT_EQ(first->value.as_double, second->value.as_double);
       break;
-    case Dart_CObject::kString:
+    case Dart_CObject_kString:
       EXPECT_STREQ(first->value.as_string, second->value.as_string);
       break;
-    case Dart_CObject::kTypedData:
+    case Dart_CObject_kTypedData:
       EXPECT_EQ(first->value.as_typed_data.length,
                 second->value.as_typed_data.length);
       for (int i = 0; i < first->value.as_typed_data.length; i++) {
         EXPECT_EQ(first->value.as_typed_data.values[i],
                   second->value.as_typed_data.values[i]);
       }
       break;
-    case Dart_CObject::kArray:
+    case Dart_CObject_kArray:
       // Use invalid type as a visited marker to avoid infinite
       // recursion on graphs with cycles.
-      second->type = Dart_CObject::kNumberOfTypes;
+      second->type = Dart_CObject_kNumberOfTypes;
       EXPECT_EQ(first->value.as_array.length, second->value.as_array.length);
       for (int i = 0; i < first->value.as_array.length; i++) {
         CompareDartCObjects(first->value.as_array.values[i],
                             second->value.as_array.values[i]);
       }
       break;
     default:
       EXPECT(false);
   }
 }
@@ skipping 26 matching lines @@
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(null_object, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kNull, root->type);
+  EXPECT_EQ(Dart_CObject_kNull, root->type);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeSmi1) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator);
   const Smi& smi = Smi::Handle(Smi::New(124));
   writer.WriteMessage(smi);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(smi, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kInt32, root->type);
+  EXPECT_EQ(Dart_CObject_kInt32, root->type);
   EXPECT_EQ(smi.Value(), root->value.as_int32);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeSmi2) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator);
   const Smi& smi = Smi::Handle(Smi::New(-1));
   writer.WriteMessage(smi);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(smi, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kInt32, root->type);
+  EXPECT_EQ(Dart_CObject_kInt32, root->type);
   EXPECT_EQ(smi.Value(), root->value.as_int32);
   CheckEncodeDecodeMessage(root);
 }
 
 
 Dart_CObject* SerializeAndDeserializeMint(const Mint& mint) {
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator);
   writer.WriteMessage(mint);
@@ skipping 19 matching lines @@
 
   Mint& mint = Mint::Handle();
   mint ^= Integer::New(value);
   ApiNativeScope scope;
   Dart_CObject* mint_cobject = SerializeAndDeserializeMint(mint);
   // On 64-bit platforms mints always require 64-bits as the smi range
   // here covers most of the 64-bit range. On 32-bit platforms the smi
   // range covers most of the 32-bit range and values outside that
   // range are also represented as mints.
 #if defined(ARCH_IS_64_BIT)
-  EXPECT_EQ(Dart_CObject::kInt64, mint_cobject->type);
+  EXPECT_EQ(Dart_CObject_kInt64, mint_cobject->type);
   EXPECT_EQ(value, mint_cobject->value.as_int64);
 #else
   if (kMinInt32 < value && value < kMaxInt32) {
-    EXPECT_EQ(Dart_CObject::kInt32, mint_cobject->type);
+    EXPECT_EQ(Dart_CObject_kInt32, mint_cobject->type);
     EXPECT_EQ(value, mint_cobject->value.as_int32);
   } else {
-    EXPECT_EQ(Dart_CObject::kInt64, mint_cobject->type);
+    EXPECT_EQ(Dart_CObject_kInt64, mint_cobject->type);
     EXPECT_EQ(value, mint_cobject->value.as_int64);
   }
 #endif
 }
 
 
 TEST_CASE(SerializeMints) {
   // Min positive mint.
   CheckMint(Smi::kMaxValue + 1);
   // Min positive mint + 1.
@@ skipping 27 matching lines @@
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(dbl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kDouble, root->type);
+  EXPECT_EQ(Dart_CObject_kDouble, root->type);
   EXPECT_EQ(dbl.value(), root->value.as_double);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeTrue) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with true object.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator);
   const Bool& bl = Bool::True();
   writer.WriteMessage(bl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   fprintf(stderr, "%s / %s\n", bl.ToCString(), serialized_object.ToCString());
 
   EXPECT(Equals(bl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kBool, root->type);
+  EXPECT_EQ(Dart_CObject_kBool, root->type);
   EXPECT_EQ(true, root->value.as_bool);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeFalse) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with false object.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator);
   const Bool& bl = Bool::False();
   writer.WriteMessage(bl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(bl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kBool, root->type);
+  EXPECT_EQ(Dart_CObject_kBool, root->type);
   EXPECT_EQ(false, root->value.as_bool);
   CheckEncodeDecodeMessage(root);
 }
 
 
 static uword allocator(intptr_t size) {
   return reinterpret_cast<uword>(malloc(size));
 }
 
 
@@ skipping 18 matching lines @@
 
   EXPECT_STREQ(BigintOperations::ToHexCString(bigint, &allocator),
                BigintOperations::ToHexCString(obj, &allocator));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   // Bigint not supported.
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kBigint, root->type);
+  EXPECT_EQ(Dart_CObject_kBigint, root->type);
   EXPECT_STREQ("270FFFFFFFFFFFFFD8F0", root->value.as_bigint);
   CheckEncodeDecodeMessage(root);
 }
 
 
 Dart_CObject* SerializeAndDeserializeBigint(const Bigint& bigint) {
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator);
   writer.WriteMessage(bigint);
@@ skipping 21 matching lines @@
 }
 
 
 void CheckBigint(const char* bigint_value) {
   StackZone zone(Isolate::Current());
   ApiNativeScope scope;
 
   Bigint& bigint = Bigint::Handle();
   bigint ^= BigintOperations::NewFromCString(bigint_value);
   Dart_CObject* bigint_cobject = SerializeAndDeserializeBigint(bigint);
-  EXPECT_EQ(Dart_CObject::kBigint, bigint_cobject->type);
+  EXPECT_EQ(Dart_CObject_kBigint, bigint_cobject->type);
   if (bigint_value[0] == '0') {
     EXPECT_STREQ(bigint_value + 2, bigint_cobject->value.as_bigint);
   } else {
     EXPECT_EQ('-', bigint_value[0]);
     EXPECT_EQ('-', bigint_cobject->value.as_bigint[0]);
     EXPECT_STREQ(bigint_value + 3, bigint_cobject->value.as_bigint + 1);
   }
 }
 
 
@@ skipping 65 matching lines @@
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   String& serialized_str = String::Handle();
   serialized_str ^= reader.ReadObject();
   EXPECT(str.Equals(serialized_str));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
-  EXPECT_EQ(Dart_CObject::kString, root->type);
+  EXPECT_EQ(Dart_CObject_kString, root->type);
   EXPECT_STREQ(cstr, root->value.as_string);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeString) {
   TestString("This string shall be serialized");
   TestString("æøå");  // This file is UTF-8 encoded.
   const char* data = "\x01"
                      "\x7F"
@@ skipping 27 matching lines @@
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   Array& serialized_array = Array::Handle();
   serialized_array ^= reader.ReadObject();
   EXPECT(array.Equals(serialized_array));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
-  EXPECT_EQ(Dart_CObject::kArray, root->type);
+  EXPECT_EQ(Dart_CObject_kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
   for (int i = 0; i < kArrayLength; i++) {
     Dart_CObject* element = root->value.as_array.values[i];
-    EXPECT_EQ(Dart_CObject::kInt32, element->type);
+    EXPECT_EQ(Dart_CObject_kInt32, element->type);
     EXPECT_EQ(i, element->value.as_int32);
   }
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeEmptyArray) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator);
   const int kArrayLength = 0;
   Array& array = Array::Handle(Array::New(kArrayLength));
   writer.WriteMessage(array);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   Array& serialized_array = Array::Handle();
   serialized_array ^= reader.ReadObject();
   EXPECT(array.Equals(serialized_array));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
-  EXPECT_EQ(Dart_CObject::kArray, root->type);
+  EXPECT_EQ(Dart_CObject_kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
   EXPECT(root->value.as_array.values == NULL);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeByteArray) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
@@ skipping 12 matching lines @@
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   TypedData& serialized_typed_data = TypedData::Handle();
   serialized_typed_data ^= reader.ReadObject();
   EXPECT(serialized_typed_data.IsTypedData());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
-  EXPECT_EQ(Dart_CObject::kTypedData, root->type);
+  EXPECT_EQ(Dart_CObject_kTypedData, root->type);
   EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
   for (int i = 0; i < kTypedDataLength; i++) {
     EXPECT(root->value.as_typed_data.values[i] == i);
   }
   CheckEncodeDecodeMessage(root);
 }
 
 
 #define TEST_TYPED_ARRAY(darttype, ctype)                                     \
   {                                                                           \
@@ skipping 88 matching lines @@
   SnapshotReader reader(buffer, buffer_len,
                         Snapshot::kMessage, Isolate::Current());
   TypedData& serialized_typed_data = TypedData::Handle();
   serialized_typed_data ^= reader.ReadObject();
   EXPECT(serialized_typed_data.IsTypedData());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
-  EXPECT_EQ(Dart_CObject::kTypedData, root->type);
-  EXPECT_EQ(Dart_CObject::kUint8Array, root->value.as_typed_data.type);
+  EXPECT_EQ(Dart_CObject_kTypedData, root->type);
+  EXPECT_EQ(Dart_TypedData_kUint8, root->value.as_typed_data.type);
   EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
   EXPECT(root->value.as_typed_data.values == NULL);
   CheckEncodeDecodeMessage(root);
 }
 
 
 class TestSnapshotWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   TestSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
@@ skipping 474 matching lines @@
 
   static const int kArrayLength = 2;
   intptr_t data[kArrayLength] = {1, 2};
   int len = kArrayLength;
   writer.WriteMessage(len, data);
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, writer.BytesWritten(), &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
-  EXPECT_EQ(Dart_CObject::kArray, root->type);
+  EXPECT_EQ(Dart_CObject_kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
   for (int i = 0; i < kArrayLength; i++) {
     Dart_CObject* element = root->value.as_array.values[i];
-    EXPECT_EQ(Dart_CObject::kInt32, element->type);
+    EXPECT_EQ(Dart_CObject_kInt32, element->type);
     EXPECT_EQ(i + 1, element->value.as_int32);
   }
   CheckEncodeDecodeMessage(root);
 }
 
 
 // Helper function to call a top level Dart function, serialize the
 // result and deserialize the result into a Dart_CObject structure.
 static Dart_CObject* GetDeserializedDartMessage(Dart_Handle lib,
                                                 const char* dart_function) {
@@ skipping 21 matching lines @@
   String& str = String::Handle();
   str ^= Api::UnwrapHandle(dart_string);
   writer.WriteMessage(str);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kString, root->type);
+  EXPECT_EQ(Dart_CObject_kString, root->type);
   EXPECT_STREQ(expected, root->value.as_string);
   CheckEncodeDecodeMessage(root);
 }
 
 
 static void CheckStringInvalid(Dart_Handle dart_string) {
   StackZone zone(Isolate::Current());
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator);
   String& str = String::Handle();
   str ^= Api::UnwrapHandle(dart_string);
   writer.WriteMessage(str);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
-  EXPECT_EQ(Dart_CObject::kUnsupported, root->type);
+  EXPECT_EQ(Dart_CObject_kUnsupported, root->type);
 }
 
 
 UNIT_TEST_CASE(DartGeneratedMessages) {
   static const char* kCustomIsolateScriptChars =
       "getSmi() {\n"
       "  return 42;\n"
       "}\n"
       "getBigint() {\n"
       "  return -0x424242424242424242424242424242424242;\n"
@@ skipping 89 matching lines @@
       Smi& smi = Smi::Handle();
       smi ^= Api::UnwrapHandle(smi_result);
       writer.WriteMessage(smi);
       intptr_t buffer_len = writer.BytesWritten();
 
       // Read object back from the snapshot into a C structure.
       ApiNativeScope scope;
       ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
       Dart_CObject* root = api_reader.ReadMessage();
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kInt32, root->type);
+      EXPECT_EQ(Dart_CObject_kInt32, root->type);
       EXPECT_EQ(42, root->value.as_int32);
       CheckEncodeDecodeMessage(root);
     }
     {
       StackZone zone(Isolate::Current());
       uint8_t* buffer;
       MessageWriter writer(&buffer, &zone_allocator);
       Bigint& bigint = Bigint::Handle();
       bigint ^= Api::UnwrapHandle(bigint_result);
       writer.WriteMessage(bigint);
       intptr_t buffer_len = writer.BytesWritten();
 
       // Read object back from the snapshot into a C structure.
       ApiNativeScope scope;
       ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
       Dart_CObject* root = api_reader.ReadMessage();
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kBigint, root->type);
+      EXPECT_EQ(Dart_CObject_kBigint, root->type);
       EXPECT_STREQ("-424242424242424242424242424242424242",
                    root->value.as_bigint);
       CheckEncodeDecodeMessage(root);
     }
     CheckString(ascii_string_result, "Hello, world!");
     CheckString(non_ascii_string_result, "Blåbærgrød");
     CheckString(non_bmp_string_result,
                 "\xf0\x90\x80\x80"
                 "\xf0\x9f\x98\x81"
                 "\xf0\x9f\x98\xb7"
@@ skipping 42 matching lines @@
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
     DARTSCOPE(isolate);
     {
       // Generate a list of nulls from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
-        EXPECT_EQ(Dart_CObject::kNull, root->value.as_array.values[i]->type);
+        EXPECT_EQ(Dart_CObject_kNull, root->value.as_array.values[i]->type);
       }
       CheckEncodeDecodeMessage(root);
     }
     {
       // Generate a list of ints from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getIntList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
-        EXPECT_EQ(Dart_CObject::kInt32, root->value.as_array.values[i]->type);
+        EXPECT_EQ(Dart_CObject_kInt32, root->value.as_array.values[i]->type);
         EXPECT_EQ(i, root->value.as_array.values[i]->value.as_int32);
       }
       CheckEncodeDecodeMessage(root);
     }
     {
       // Generate a list of strings from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getStringList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
-        EXPECT_EQ(Dart_CObject::kString, root->value.as_array.values[i]->type);
+        EXPECT_EQ(Dart_CObject_kString, root->value.as_array.values[i]->type);
         char buffer[3];
         snprintf(buffer, sizeof(buffer), "%d", i);
         EXPECT_STREQ(buffer, root->value.as_array.values[i]->value.as_string);
       }
     }
     {
       // Generate a list of objects of different types from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getMixedList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
 
-      EXPECT_EQ(Dart_CObject::kInt32, root->value.as_array.values[0]->type);
+      EXPECT_EQ(Dart_CObject_kInt32, root->value.as_array.values[0]->type);
       EXPECT_EQ(0, root->value.as_array.values[0]->value.as_int32);
-      EXPECT_EQ(Dart_CObject::kString, root->value.as_array.values[1]->type);
+      EXPECT_EQ(Dart_CObject_kString, root->value.as_array.values[1]->type);
       EXPECT_STREQ("1", root->value.as_array.values[1]->value.as_string);
-      EXPECT_EQ(Dart_CObject::kDouble, root->value.as_array.values[2]->type);
+      EXPECT_EQ(Dart_CObject_kDouble, root->value.as_array.values[2]->type);
       EXPECT_EQ(2.2, root->value.as_array.values[2]->value.as_double);
-      EXPECT_EQ(Dart_CObject::kBool, root->value.as_array.values[3]->type);
+      EXPECT_EQ(Dart_CObject_kBool, root->value.as_array.values[3]->type);
       EXPECT_EQ(true, root->value.as_array.values[3]->value.as_bool);
 
       for (int i = 0; i < kArrayLength; i++) {
         if (i > 3) {
-          EXPECT_EQ(Dart_CObject::kNull, root->value.as_array.values[i]->type);
+          EXPECT_EQ(Dart_CObject_kNull, root->value.as_array.values[i]->type);
         }
       }
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
 
 UNIT_TEST_CASE(DartGeneratedArrayLiteralMessages) {
@@ skipping 44 matching lines @@
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
     DARTSCOPE(isolate);
     {
       // Generate a list of nulls from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
-        EXPECT_EQ(Dart_CObject::kNull, root->value.as_array.values[i]->type);
+        EXPECT_EQ(Dart_CObject_kNull, root->value.as_array.values[i]->type);
       }
       CheckEncodeDecodeMessage(root);
     }
     {
       // Generate a list of ints from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getIntList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
-        EXPECT_EQ(Dart_CObject::kInt32, root->value.as_array.values[i]->type);
+        EXPECT_EQ(Dart_CObject_kInt32, root->value.as_array.values[i]->type);
         EXPECT_EQ(i, root->value.as_array.values[i]->value.as_int32);
       }
       CheckEncodeDecodeMessage(root);
     }
     {
       // Generate a list of strings from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getStringList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
-        EXPECT_EQ(Dart_CObject::kString, root->value.as_array.values[i]->type);
+        EXPECT_EQ(Dart_CObject_kString, root->value.as_array.values[i]->type);
         char buffer[3];
         snprintf(buffer, sizeof(buffer), "%d", i);
         EXPECT_STREQ(buffer, root->value.as_array.values[i]->value.as_string);
       }
     }
     {
       // Generate a list of lists from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getListList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
-        EXPECT_EQ(Dart_CObject::kArray, element->type);
+        EXPECT_EQ(Dart_CObject_kArray, element->type);
         EXPECT_EQ(i, element->value.as_array.length);
         for (int j = 0; j < i; j++) {
-          EXPECT_EQ(Dart_CObject::kInt32,
+          EXPECT_EQ(Dart_CObject_kInt32,
                     element->value.as_array.values[j]->type);
           EXPECT_EQ(j, element->value.as_array.values[j]->value.as_int32);
         }
       }
     }
     {
       // Generate a list of objects of different types from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getMixedList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
 
-      EXPECT_EQ(Dart_CObject::kInt32, root->value.as_array.values[0]->type);
+      EXPECT_EQ(Dart_CObject_kInt32, root->value.as_array.values[0]->type);
       EXPECT_EQ(0, root->value.as_array.values[0]->value.as_int32);
-      EXPECT_EQ(Dart_CObject::kString, root->value.as_array.values[1]->type);
+      EXPECT_EQ(Dart_CObject_kString, root->value.as_array.values[1]->type);
       EXPECT_STREQ("1", root->value.as_array.values[1]->value.as_string);
-      EXPECT_EQ(Dart_CObject::kDouble, root->value.as_array.values[2]->type);
+      EXPECT_EQ(Dart_CObject_kDouble, root->value.as_array.values[2]->type);
       EXPECT_EQ(2.2, root->value.as_array.values[2]->value.as_double);
-      EXPECT_EQ(Dart_CObject::kBool, root->value.as_array.values[3]->type);
+      EXPECT_EQ(Dart_CObject_kBool, root->value.as_array.values[3]->type);
       EXPECT_EQ(true, root->value.as_array.values[3]->value.as_bool);
 
       for (int i = 0; i < kArrayLength; i++) {
         if (i > 3) {
-          EXPECT_EQ(Dart_CObject::kArray, root->value.as_array.values[i]->type);
+          EXPECT_EQ(Dart_CObject_kArray, root->value.as_array.values[i]->type);
         }
       }
 
       Dart_CObject* element;
       Dart_CObject* e;
 
       // []
       element = root->value.as_array.values[4];
       EXPECT_EQ(0, element->value.as_array.length);
 
       // [[]]
       element = root->value.as_array.values[5];
       EXPECT_EQ(1, element->value.as_array.length);
       element = element->value.as_array.values[0];
-      EXPECT_EQ(Dart_CObject::kArray, element->type);
+      EXPECT_EQ(Dart_CObject_kArray, element->type);
       EXPECT_EQ(0, element->value.as_array.length);
 
       // [[[]]]"
       element = root->value.as_array.values[6];
       EXPECT_EQ(1, element->value.as_array.length);
       element = element->value.as_array.values[0];
-      EXPECT_EQ(Dart_CObject::kArray, element->type);
+      EXPECT_EQ(Dart_CObject_kArray, element->type);
       EXPECT_EQ(1, element->value.as_array.length);
       element = element->value.as_array.values[0];
-      EXPECT_EQ(Dart_CObject::kArray, element->type);
+      EXPECT_EQ(Dart_CObject_kArray, element->type);
       EXPECT_EQ(0, element->value.as_array.length);
 
       // [1, [2, [3]]]
       element = root->value.as_array.values[7];
       EXPECT_EQ(2, element->value.as_array.length);
       e = element->value.as_array.values[0];
-      EXPECT_EQ(Dart_CObject::kInt32, e->type);
+      EXPECT_EQ(Dart_CObject_kInt32, e->type);
       EXPECT_EQ(1, e->value.as_int32);
       element = element->value.as_array.values[1];
-      EXPECT_EQ(Dart_CObject::kArray, element->type);
+      EXPECT_EQ(Dart_CObject_kArray, element->type);
       EXPECT_EQ(2, element->value.as_array.length);
       e = element->value.as_array.values[0];
-      EXPECT_EQ(Dart_CObject::kInt32, e->type);
+      EXPECT_EQ(Dart_CObject_kInt32, e->type);
       EXPECT_EQ(2, e->value.as_int32);
       element = element->value.as_array.values[1];
-      EXPECT_EQ(Dart_CObject::kArray, element->type);
+      EXPECT_EQ(Dart_CObject_kArray, element->type);
       EXPECT_EQ(1, element->value.as_array.length);
       e = element->value.as_array.values[0];
-      EXPECT_EQ(Dart_CObject::kInt32, e->type);
+      EXPECT_EQ(Dart_CObject_kInt32, e->type);
       EXPECT_EQ(3, e->value.as_int32);
 
       // [1, [1, 2, [1, 2, 3]]]
       element = root->value.as_array.values[8];
       EXPECT_EQ(2, element->value.as_array.length);
       e = element->value.as_array.values[0];
-      EXPECT_EQ(Dart_CObject::kInt32, e->type);
+      EXPECT_EQ(Dart_CObject_kInt32, e->type);
       e = element->value.as_array.values[0];
-      EXPECT_EQ(Dart_CObject::kInt32, e->type);
+      EXPECT_EQ(Dart_CObject_kInt32, e->type);
       EXPECT_EQ(1, e->value.as_int32);
       element = element->value.as_array.values[1];
-      EXPECT_EQ(Dart_CObject::kArray, element->type);
+      EXPECT_EQ(Dart_CObject_kArray, element->type);
       EXPECT_EQ(3, element->value.as_array.length);
       for (int i = 0; i < 2; i++) {
         e = element->value.as_array.values[i];
-        EXPECT_EQ(Dart_CObject::kInt32, e->type);
+        EXPECT_EQ(Dart_CObject_kInt32, e->type);
         EXPECT_EQ(i + 1, e->value.as_int32);
       }
       element = element->value.as_array.values[2];
-      EXPECT_EQ(Dart_CObject::kArray, element->type);
+      EXPECT_EQ(Dart_CObject_kArray, element->type);
       EXPECT_EQ(3, element->value.as_array.length);
       for (int i = 0; i < 3; i++) {
         e = element->value.as_array.values[i];
-        EXPECT_EQ(Dart_CObject::kInt32, e->type);
+        EXPECT_EQ(Dart_CObject_kInt32, e->type);
         EXPECT_EQ(i + 1, e->value.as_int32);
       }
 
       // [1, 2, 3]
       element = root->value.as_array.values[9];
       EXPECT_EQ(3, element->value.as_array.length);
       for (int i = 0; i < 3; i++) {
         e = element->value.as_array.values[i];
-        EXPECT_EQ(Dart_CObject::kInt32, e->type);
+        EXPECT_EQ(Dart_CObject_kInt32, e->type);
         EXPECT_EQ(i + 1, e->value.as_int32);
       }
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
 
 UNIT_TEST_CASE(DartGeneratedListMessagesWithBackref) {
@@ skipping 64 matching lines @@
   EXPECT_VALID(lib);
 
   {
     DARTSCOPE(isolate);
 
     {
       // Generate a list of strings from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getStringList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kString, element->type);
+        EXPECT_EQ(Dart_CObject_kString, element->type);
         EXPECT_STREQ("Hello, world!", element->value.as_string);
       }
     }
     {
       // Generate a list of medium ints from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getMintList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kInt64, element->type);
+        EXPECT_EQ(Dart_CObject_kInt64, element->type);
         EXPECT_EQ(DART_INT64_C(0x7FFFFFFFFFFFFFFF), element->value.as_int64);
       }
     }
     {
       // Generate a list of bigints from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getBigintList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kBigint, element->type);
+        EXPECT_EQ(Dart_CObject_kBigint, element->type);
         EXPECT_STREQ("1234567890123456789012345678901234567890",
                      element->value.as_bigint);
       }
     }
     {
       // Generate a list of doubles from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getDoubleList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kDouble, element->type);
+        EXPECT_EQ(Dart_CObject_kDouble, element->type);
         EXPECT_EQ(3.14, element->value.as_double);
       }
     }
     {
       // Generate a list of Uint8Lists from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getTypedDataList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kTypedData, element->type);
-        EXPECT_EQ(Dart_CObject::kUint8Array, element->value.as_typed_data.type);
+        EXPECT_EQ(Dart_CObject_kTypedData, element->type);
+        EXPECT_EQ(Dart_TypedData_kUint8, element->value.as_typed_data.type);
         EXPECT_EQ(256, element->value.as_typed_data.length);
       }
     }
     {
       // Generate a list of Uint8List views from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root =
           GetDeserializedDartMessage(lib, "getTypedDataViewList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kTypedData, element->type);
-        EXPECT_EQ(Dart_CObject::kUint8Array, element->value.as_typed_data.type);
+        EXPECT_EQ(Dart_CObject_kTypedData, element->type);
+        EXPECT_EQ(Dart_TypedData_kUint8, element->value.as_typed_data.type);
         EXPECT_EQ(128, element->value.as_typed_data.length);
         EXPECT_EQ(1, element->value.as_typed_data.values[0]);
         EXPECT_EQ(0, element->value.as_typed_data.values[1]);
       }
     }
     {
       // Generate a list of objects of different types from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getMixedList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         if ((i % 2) == 0) {
           EXPECT_EQ(root->value.as_array.values[0], element);
-          EXPECT_EQ(Dart_CObject::kString, element->type);
+          EXPECT_EQ(Dart_CObject_kString, element->type);
           EXPECT_STREQ("A", element->value.as_string);
         } else {
           EXPECT_EQ(root->value.as_array.values[1], element);
-          EXPECT_EQ(Dart_CObject::kDouble, element->type);
+          EXPECT_EQ(Dart_CObject_kDouble, element->type);
           EXPECT_STREQ(2.72, element->value.as_double);
         }
       }
     }
     {
       // Generate a list of objects of different types from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getSelfRefList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
-        EXPECT_EQ(Dart_CObject::kArray, element->type);
+        EXPECT_EQ(Dart_CObject_kArray, element->type);
         EXPECT_EQ(root, element);
       }
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
 
 UNIT_TEST_CASE(DartGeneratedArrayLiteralMessagesWithBackref) {
@@ skipping 69 matching lines @@
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
     DARTSCOPE(isolate);
     {
       // Generate a list of strings from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getStringList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kString, element->type);
+        EXPECT_EQ(Dart_CObject_kString, element->type);
         EXPECT_STREQ("Hello, world!", element->value.as_string);
       }
     }
     {
       // Generate a list of medium ints from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getMintList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kInt64, element->type);
+        EXPECT_EQ(Dart_CObject_kInt64, element->type);
         EXPECT_EQ(DART_INT64_C(0x7FFFFFFFFFFFFFFF), element->value.as_int64);
       }
     }
     {
       // Generate a list of bigints from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getBigintList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kBigint, element->type);
+        EXPECT_EQ(Dart_CObject_kBigint, element->type);
         EXPECT_STREQ("1234567890123456789012345678901234567890",
                      element->value.as_bigint);
       }
     }
     {
       // Generate a list of doubles from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getDoubleList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kDouble, element->type);
+        EXPECT_EQ(Dart_CObject_kDouble, element->type);
         EXPECT_EQ(3.14, element->value.as_double);
       }
     }
     {
       // Generate a list of Uint8Lists from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getTypedDataList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kTypedData, element->type);
-        EXPECT_EQ(Dart_CObject::kUint8Array, element->value.as_typed_data.type);
+        EXPECT_EQ(Dart_CObject_kTypedData, element->type);
+        EXPECT_EQ(Dart_TypedData_kUint8, element->value.as_typed_data.type);
         EXPECT_EQ(256, element->value.as_typed_data.length);
       }
     }
     {
       // Generate a list of Uint8List views from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root =
           GetDeserializedDartMessage(lib, "getTypedDataViewList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(root->value.as_array.values[0], element);
-        EXPECT_EQ(Dart_CObject::kTypedData, element->type);
-        EXPECT_EQ(Dart_CObject::kUint8Array, element->value.as_typed_data.type);
+        EXPECT_EQ(Dart_CObject_kTypedData, element->type);
+        EXPECT_EQ(Dart_TypedData_kUint8, element->value.as_typed_data.type);
         EXPECT_EQ(128, element->value.as_typed_data.length);
         EXPECT_EQ(1, element->value.as_typed_data.values[0]);
         EXPECT_EQ(0, element->value.as_typed_data.values[1]);
       }
     }
     {
       // Generate a list of objects of different types from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getMixedList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
         if ((i % 2) == 0) {
           EXPECT_EQ(root->value.as_array.values[0], element);
-          EXPECT_EQ(Dart_CObject::kString, element->type);
+          EXPECT_EQ(Dart_CObject_kString, element->type);
           EXPECT_STREQ(".", element->value.as_string);
         } else {
           EXPECT_EQ(root->value.as_array.values[1], element);
-          EXPECT_EQ(Dart_CObject::kDouble, element->type);
+          EXPECT_EQ(Dart_CObject_kDouble, element->type);
           EXPECT_STREQ(2.72, element->value.as_double);
         }
       }
     }
     {
       // Generate a list of objects of different types from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getSelfRefList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
       for (int i = 0; i < kArrayLength; i++) {
         Dart_CObject* element = root->value.as_array.values[i];
-        EXPECT_EQ(Dart_CObject::kArray, element->type);
+        EXPECT_EQ(Dart_CObject_kArray, element->type);
         EXPECT_EQ(root, element);
       }
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
 
 static void CheckTypedData(Dart_CObject* object,
-                           Dart_CObject::TypedDataType typed_data_type,
+                           Dart_TypedData_Type typed_data_type,
                            int len) {
-    EXPECT_EQ(Dart_CObject::kTypedData, object->type);
+    EXPECT_EQ(Dart_CObject_kTypedData, object->type);
     EXPECT_EQ(typed_data_type, object->value.as_typed_data.type);
     EXPECT_EQ(len, object->value.as_typed_data.length);
 }
 
 UNIT_TEST_CASE(DartGeneratedListMessagesWithTypedData) {
   static const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "getTypedDataList() {\n"
       "  var list = new List(10);\n"
       "  var index = 0;\n"
@@ skipping 71 matching lines @@
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
     DARTSCOPE(isolate);
     {
       // Generate a list of Uint8Lists from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserializedDartMessage(lib, "getTypedDataList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       struct {
-        Dart_CObject::TypedDataType type;
+        Dart_TypedData_Type type;
         int size;
       } expected[] = {
-        { Dart_CObject::kInt8Array, 256},
-        { Dart_CObject::kUint8Array, 256},
-        { Dart_CObject::kInt16Array, 512},
-        { Dart_CObject::kUint16Array, 512},
-        { Dart_CObject::kInt32Array, 1024},
-        { Dart_CObject::kUint32Array, 1024},
-        { Dart_CObject::kInt64Array, 2048},
-        { Dart_CObject::kUint64Array, 2048},
-        { Dart_CObject::kFloat32Array, 1024},
-        { Dart_CObject::kFloat64Array, 2048},
-        { Dart_CObject::kNumberOfTypedDataTypes, -1 }
+        { Dart_TypedData_kInt8, 256},
+        { Dart_TypedData_kUint8, 256},
+        { Dart_TypedData_kInt16, 512},
+        { Dart_TypedData_kUint16, 512},
+        { Dart_TypedData_kInt32, 1024},
+        { Dart_TypedData_kUint32, 1024},
+        { Dart_TypedData_kInt64, 2048},
+        { Dart_TypedData_kUint64, 2048},
+        { Dart_TypedData_kFloat32, 1024},
+        { Dart_TypedData_kFloat64, 2048},
+        { Dart_TypedData_kInvalid, -1 }
       };
 
       int i = 0;
-      while (expected[i].type != Dart_CObject::kNumberOfTypedDataTypes) {
+      while (expected[i].type != Dart_TypedData_kInvalid) {
         CheckTypedData(root->value.as_array.values[i],
                        expected[i].type,
                        expected[i].size);
         i++;
       }
       EXPECT_EQ(i, root->value.as_array.length);
     }
     {
       // Generate a list of Uint8List views from Dart code.
 
       ApiNativeScope scope;
       Dart_CObject* root =
           GetDeserializedDartMessage(lib, "getTypedDataViewList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       struct {
-        Dart_CObject::TypedDataType type;
+        Dart_TypedData_Type type;
         int size;
       } expected[] = {
-        { Dart_CObject::kInt8Array, 256},
-        { Dart_CObject::kUint8Array, 256},
-        { Dart_CObject::kInt16Array, 512},
-        { Dart_CObject::kUint16Array, 512},
-        { Dart_CObject::kInt32Array, 1024},
-        { Dart_CObject::kUint32Array, 1024},
-        { Dart_CObject::kInt64Array, 2048},
-        { Dart_CObject::kUint64Array, 2048},
-        { Dart_CObject::kFloat32Array, 1024},
-        { Dart_CObject::kFloat64Array, 2048},
+        { Dart_TypedData_kInt8, 256},
+        { Dart_TypedData_kUint8, 256},
+        { Dart_TypedData_kInt16, 512},
+        { Dart_TypedData_kUint16, 512},
+        { Dart_TypedData_kInt32, 1024},
+        { Dart_TypedData_kUint32, 1024},
+        { Dart_TypedData_kInt64, 2048},
+        { Dart_TypedData_kUint64, 2048},
+        { Dart_TypedData_kFloat32, 1024},
+        { Dart_TypedData_kFloat64, 2048},
 
-        { Dart_CObject::kInt8Array, 512},
-        { Dart_CObject::kUint8Array, 512},
-        { Dart_CObject::kInt8Array, 1024},
-        { Dart_CObject::kUint8Array, 1024},
-        { Dart_CObject::kInt8Array, 2048},
-        { Dart_CObject::kUint8Array, 2048},
-        { Dart_CObject::kInt8Array, 1024},
-        { Dart_CObject::kUint8Array, 1024},
-        { Dart_CObject::kInt8Array, 2048},
-        { Dart_CObject::kUint8Array, 2048},
+        { Dart_TypedData_kInt8, 512},
+        { Dart_TypedData_kUint8, 512},
+        { Dart_TypedData_kInt8, 1024},
+        { Dart_TypedData_kUint8, 1024},
+        { Dart_TypedData_kInt8, 2048},
+        { Dart_TypedData_kUint8, 2048},
+        { Dart_TypedData_kInt8, 1024},
+        { Dart_TypedData_kUint8, 1024},
+        { Dart_TypedData_kInt8, 2048},
+        { Dart_TypedData_kUint8, 2048},
 
-        { Dart_CObject::kInt16Array, 256},
-        { Dart_CObject::kUint16Array, 256},
-        { Dart_CObject::kInt16Array, 1024},
-        { Dart_CObject::kUint16Array, 1024},
-        { Dart_CObject::kInt16Array, 2048},
-        { Dart_CObject::kUint16Array, 2048},
-        { Dart_CObject::kInt16Array, 1024},
-        { Dart_CObject::kUint16Array, 1024},
-        { Dart_CObject::kInt16Array, 2048},
-        { Dart_CObject::kUint16Array, 2048},
+        { Dart_TypedData_kInt16, 256},
+        { Dart_TypedData_kUint16, 256},
+        { Dart_TypedData_kInt16, 1024},
+        { Dart_TypedData_kUint16, 1024},
+        { Dart_TypedData_kInt16, 2048},
+        { Dart_TypedData_kUint16, 2048},
+        { Dart_TypedData_kInt16, 1024},
+        { Dart_TypedData_kUint16, 1024},
+        { Dart_TypedData_kInt16, 2048},
+        { Dart_TypedData_kUint16, 2048},
 
-        { Dart_CObject::kNumberOfTypedDataTypes, -1 }
+        { Dart_TypedData_kInvalid, -1 }
       };
 
       int i = 0;
-      while (expected[i].type != Dart_CObject::kNumberOfTypedDataTypes) {
+      while (expected[i].type != Dart_TypedData_kInvalid) {
         CheckTypedData(root->value.as_array.values[i],
                        expected[i].type,
                        expected[i].size);
         i++;
       }
       EXPECT_EQ(i, root->value.as_array.length);
     }
     {
       // Generate a list of Uint8Lists from Dart code.
       ApiNativeScope scope;
       Dart_CObject* root =
           GetDeserializedDartMessage(lib, "getMultipleTypedDataViewList");
       EXPECT_NOTNULL(root);
-      EXPECT_EQ(Dart_CObject::kArray, root->type);
+      EXPECT_EQ(Dart_CObject_kArray, root->type);
       struct {
-        Dart_CObject::TypedDataType type;
+        Dart_TypedData_Type type;
         int size;
       } expected[] = {
-        { Dart_CObject::kInt8Array, 256},
-        { Dart_CObject::kUint8Array, 256},
-        { Dart_CObject::kInt16Array, 256},
-        { Dart_CObject::kUint16Array, 256},
-        { Dart_CObject::kInt32Array, 256},
-        { Dart_CObject::kUint32Array, 256},
-        { Dart_CObject::kInt64Array, 256},
-        { Dart_CObject::kUint64Array, 256},
-        { Dart_CObject::kFloat32Array, 256},
-        { Dart_CObject::kFloat64Array, 256},
-        { Dart_CObject::kNumberOfTypedDataTypes, -1 }
+        { Dart_TypedData_kInt8, 256},
+        { Dart_TypedData_kUint8, 256},
+        { Dart_TypedData_kInt16, 256},
+        { Dart_TypedData_kUint16, 256},
+        { Dart_TypedData_kInt32, 256},
+        { Dart_TypedData_kUint32, 256},
+        { Dart_TypedData_kInt64, 256},
+        { Dart_TypedData_kUint64, 256},
+        { Dart_TypedData_kFloat32, 256},
+        { Dart_TypedData_kFloat64, 256},
+        { Dart_TypedData_kInvalid, -1 }
       };
 
       int i = 0;
-      while (expected[i].type != Dart_CObject::kNumberOfTypedDataTypes) {
+      while (expected[i].type != Dart_TypedData_kInvalid) {
         CheckTypedData(root->value.as_array.values[i],
                        expected[i].type,
                        expected[i].size);
 
         // All views point to the same data.
         EXPECT_EQ(root->value.as_array.values[0]->value.as_typed_data.values,
                   root->value.as_array.values[i]->value.as_typed_data.values);
         i++;
       }
       EXPECT_EQ(i, root->value.as_array.length);
@@ skipping 35 matching lines @@
   Dart_Handle result = Dart_GetField(send_port, NewString("_id"));
   ASSERT(!Dart_IsError(result));
   ASSERT(Dart_IsInteger(result));
   int64_t send_port_id;
   Dart_Handle result2 = Dart_IntegerToInt64(result, &send_port_id);
   ASSERT(!Dart_IsError(result2));
 
   // Setup single object message.
   Dart_CObject object;
 
-  object.type = Dart_CObject::kNull;
+  object.type = Dart_CObject_kNull;
   EXPECT(Dart_PostCObject(send_port_id, &object));
 
-  object.type = Dart_CObject::kBool;
+  object.type = Dart_CObject_kBool;
   object.value.as_bool = true;
   EXPECT(Dart_PostCObject(send_port_id, &object));
 
-  object.type = Dart_CObject::kBool;
+  object.type = Dart_CObject_kBool;
   object.value.as_bool = false;
   EXPECT(Dart_PostCObject(send_port_id, &object));
 
-  object.type = Dart_CObject::kInt32;
+  object.type = Dart_CObject_kInt32;
   object.value.as_int32 = 123;
   EXPECT(Dart_PostCObject(send_port_id, &object));
 
-  object.type = Dart_CObject::kString;
+  object.type = Dart_CObject_kString;
   object.value.as_string = const_cast<char*>("456");
   EXPECT(Dart_PostCObject(send_port_id, &object));
 
-  object.type = Dart_CObject::kString;
+  object.type = Dart_CObject_kString;
   object.value.as_string = const_cast<char*>("æøå");
   EXPECT(Dart_PostCObject(send_port_id, &object));
 
-  object.type = Dart_CObject::kDouble;
+  object.type = Dart_CObject_kDouble;
   object.value.as_double = 3.14;
   EXPECT(Dart_PostCObject(send_port_id, &object));
 
-  object.type = Dart_CObject::kArray;
+  object.type = Dart_CObject_kArray;
   object.value.as_array.length = 0;
   EXPECT(Dart_PostCObject(send_port_id, &object));
 
   static const int kArrayLength = 10;
   Dart_CObject* array =
       reinterpret_cast<Dart_CObject*>(
           Dart_ScopeAllocate(
               sizeof(Dart_CObject) + sizeof(Dart_CObject*) * kArrayLength));  // NOLINT
-  array->type = Dart_CObject::kArray;
+  array->type = Dart_CObject_kArray;
   array->value.as_array.length = kArrayLength;
   array->value.as_array.values =
       reinterpret_cast<Dart_CObject**>(array + 1);
   for (int i = 0; i < kArrayLength; i++) {
     Dart_CObject* element =
         reinterpret_cast<Dart_CObject*>(
             Dart_ScopeAllocate(sizeof(Dart_CObject)));
-    element->type = Dart_CObject::kInt32;
+    element->type = Dart_CObject_kInt32;
     element->value.as_int32 = i;
     array->value.as_array.values[i] = element;
   }
   EXPECT(Dart_PostCObject(send_port_id, array));
 
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: nulltruefalse123456æøå3.14[]100123456789\n",
                    Dart_GetError(result));
 
   Dart_ExitScope();
 }
 
 }  // namespace dart