Add typed data interface to Dart API, this only changes the C++ API as dicussed in a previous email…

vm/dart_api_impl_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_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
@@ skipping 798 matching lines @@
   result = Dart_ListSetAsBytes(list_access_test_obj, 0, native_array, 3);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_IsUnhandledExceptionError(result));
 
   result = Dart_ListSetAt(list_access_test_obj, 0, Dart_NewInteger(42));
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_IsUnhandledExceptionError(result));
 }
 
 
-TEST_CASE(ByteArrayAccess) {
-  Dart_Handle byte_array1 = Dart_NewByteArray(10);
+TEST_CASE(TypedDataAccess) {
+  EXPECT_EQ(kInvalid, Dart_GetTypeOfTypedData(Dart_True()));
+  EXPECT_EQ(kInvalid, Dart_GetTypeOfExternalTypedData(Dart_False()));
+  Dart_Handle byte_array1 = Dart_NewTypedData(kUint8, 10);
   EXPECT_VALID(byte_array1);
-  EXPECT(Dart_IsByteArray(byte_array1));
-  EXPECT(!Dart_IsByteArrayExternal(byte_array1));
+  EXPECT_EQ(kUint8, Dart_GetTypeOfTypedData(byte_array1));
+  EXPECT_EQ(kInvalid, Dart_GetTypeOfExternalTypedData(byte_array1));
   EXPECT(Dart_IsList(byte_array1));
 
   intptr_t length = 0;
   Dart_Handle result = Dart_ListLength(byte_array1, &length);
   EXPECT_VALID(result);
   EXPECT_EQ(10, length);
 
   result = Dart_ListSetAt(byte_array1, -1, Dart_NewInteger(1));
   EXPECT(Dart_IsError(result));
 
   result = Dart_ListSetAt(byte_array1, 10, Dart_NewInteger(1));
   EXPECT(Dart_IsError(result));
 
   // Set through the List API.
   for (intptr_t i = 0; i < 10; ++i) {
     EXPECT_VALID(Dart_ListSetAt(byte_array1, i, Dart_NewInteger(i + 1)));
   }
   for (intptr_t i = 0; i < 10; ++i) {
     // Get through the List API.
     Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
     EXPECT_VALID(integer_obj);
     int64_t int64_t_value = -1;
     EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
     EXPECT_EQ(i + 1, int64_t_value);
   }
 
-  Dart_Handle byte_array2 = Dart_NewByteArray(10);
+  Dart_Handle byte_array2 = Dart_NewTypedData(kUint8, 10);
   bool is_equal = false;
   Dart_ObjectEquals(byte_array1, byte_array2, &is_equal);
   EXPECT(!is_equal);
 
   // Set through the List API.
   for (intptr_t i = 0; i < 10; ++i) {
     result = Dart_ListSetAt(byte_array1, i, Dart_NewInteger(i + 2));
     EXPECT_VALID(result);
     result = Dart_ListSetAt(byte_array2, i, Dart_NewInteger(i + 2));
     EXPECT_VALID(result);
@@ skipping 15 matching lines @@
   for (intptr_t i = 0; i < 10; ++i) {
     Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
     EXPECT_VALID(integer_obj);
     int64_t int64_t_value = -1;
     EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
     EXPECT_EQ(10 - i, int64_t_value);
   }
 }
 
 
-TEST_CASE(ScalarListDirectAccess) {
+TEST_CASE(TypedDataDirectAccess) {
   Dart_Handle str = Dart_NewStringFromCString("junk");
-  Dart_Handle byte_array = Dart_NewByteArray(10);
+  Dart_Handle byte_array = Dart_NewTypedData(kUint8, 10);
   EXPECT_VALID(byte_array);
   Dart_Handle result;
-  result = Dart_ScalarListAcquireData(byte_array, NULL, NULL, NULL);
-  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'type'"
+  result = Dart_TypedDataAcquireData(byte_array, NULL, NULL, NULL);
+  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'type'"
                        " to be non-null.");
-  Dart_Scalar_Type type;
-  result = Dart_ScalarListAcquireData(byte_array, &type, NULL, NULL);
-  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'data'"
+  Dart_TypedData_Type type;
+  result = Dart_TypedDataAcquireData(byte_array, &type, NULL, NULL);
+  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'data'"
                        " to be non-null.");
   void* data;
-  result = Dart_ScalarListAcquireData(byte_array, &type, &data, NULL);
-  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'len'"
+  result = Dart_TypedDataAcquireData(byte_array, &type, &data, NULL);
+  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'len'"
                        " to be non-null.");
   intptr_t len;
-  result = Dart_ScalarListAcquireData(Dart_Null(), &type, &data, &len);
-  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'array'"
+  result = Dart_TypedDataAcquireData(Dart_Null(), &type, &data, &len);
+  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'object'"
                        " to be non-null.");
-  result = Dart_ScalarListAcquireData(str, &type, &data, &len);
-  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'array'"
-                       " to be of type 'scalar list'.");
+  result = Dart_TypedDataAcquireData(str, &type, &data, &len);
+  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'object'"
+                       " to be of type 'TypedData'.");
 
-  result = Dart_ScalarListReleaseData(Dart_Null());
-  EXPECT_ERROR(result, "Dart_ScalarListReleaseData expects argument 'array'"
+  result = Dart_TypedDataReleaseData(Dart_Null());
+  EXPECT_ERROR(result, "Dart_TypedDataReleaseData expects argument 'object'"
                        " to be non-null.");
-  result = Dart_ScalarListReleaseData(str);
-  EXPECT_ERROR(result, "Dart_ScalarListReleaseData expects argument 'array'"
-                       " to be of type 'scalar list'.");
+  result = Dart_TypedDataReleaseData(str);
+  EXPECT_ERROR(result, "Dart_TypedDataReleaseData expects argument 'object'"
+                       " to be of type 'TypedData'.");
 }
 
 
 static void TestDirectAccess(Dart_Handle lib,
                              Dart_Handle array,
-                             Dart_Scalar_Type expected_type) {
+                             Dart_TypedData_Type expected_type) {
   // Invoke the dart function that sets initial values.
   Dart_Handle dart_args[1];
   dart_args[0] = array;
   Dart_Invoke(lib, NewString("setMain"), 1, dart_args);
 
-  // Now Get a direct access to this typed array and check it's contents.
+  // Now Get a direct access to this typed data object and check it's contents.
   const int kLength = 10;
   Dart_Handle result;
-  Dart_Scalar_Type type;
+  Dart_TypedData_Type type;
   void* data;
   intptr_t len;
-  result = Dart_ScalarListAcquireData(array, &type, &data, &len);
+  result = Dart_TypedDataAcquireData(array, &type, &data, &len);
   EXPECT_VALID(result);
   EXPECT_EQ(expected_type, type);
   EXPECT_EQ(kLength, len);
   int8_t* dataP = reinterpret_cast<int8_t*>(data);
   for (int i = 0; i < kLength; i++) {
     EXPECT_EQ(i, dataP[i]);
   }
 
   // Now modify the values in the directly accessible array and then check
   // it we see the changes back in dart.
   for (int i = 0; i < kLength; i++) {
     dataP[i] += 10;
   }
 
-  // Release direct accesss to the typed array.
-  result = Dart_ScalarListReleaseData(array);
+  // Release direct accesss to the typed data object.
+  result = Dart_TypedDataReleaseData(array);
   EXPECT_VALID(result);
 
   // Invoke the dart function in order to check the modified values.
   Dart_Invoke(lib, NewString("testMain"), 1, dart_args);
 }
 
 
-TEST_CASE(ScalarListDirectAccess1) {
+TEST_CASE(TypedDataDirectAccess1) {
   const char* kScriptChars =
       "import 'dart:scalarlist';\n"
       "void setMain(var a) {"
       "  for (var i = 0; i < 10; i++) {"
       "    a[i] = i;"
       "  }"
       "}\n"
       "void testMain(var list) {"
       "  for (var i = 0; i < 10; i++) {"
       "    Expect.equals((10 + i), list[i]);"
       "  }\n"
       "}\n"
       "List main() {"
       "  var a = new Int8List(10);"
       "  return a;"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
-  // Test with an regular typed array object.
+  // Test with an regular typed data object.
   Dart_Handle list_access_test_obj;
   list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(list_access_test_obj);
   TestDirectAccess(lib, list_access_test_obj, kInt8);
 
-  // Test with an external typed array object.
+  // Test with an external typed data object.
   uint8_t data[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
   intptr_t data_length = ARRAY_SIZE(data);
   Dart_Handle ext_list_access_test_obj;
-  ext_list_access_test_obj = Dart_NewExternalByteArray(data,
+  ext_list_access_test_obj = Dart_NewExternalTypedData(kUint8,
+                                                       data,
                                                        data_length,
                                                        NULL, NULL);
   EXPECT_VALID(ext_list_access_test_obj);
   TestDirectAccess(lib, ext_list_access_test_obj, kUint8);
 }
 
 
-static void ExternalByteArrayAccessTests(Dart_Handle obj,
+static void ExternalTypedDataAccessTests(Dart_Handle obj,
+                                         Dart_TypedData_Type expected_type,
                                          uint8_t data[],
                                          intptr_t data_length) {
   EXPECT_VALID(obj);
-  EXPECT(Dart_IsByteArray(obj));
-  EXPECT(Dart_IsByteArrayExternal(obj));
+  EXPECT_EQ(expected_type, Dart_GetTypeOfTypedData(obj));
+  EXPECT_EQ(expected_type, Dart_GetTypeOfExternalTypedData(obj));
   EXPECT(Dart_IsList(obj));
 
   void* raw_data = NULL;
-  EXPECT_VALID(Dart_ExternalByteArrayGetData(obj, &raw_data));
+  intptr_t len;
+  Dart_TypedData_Type type;
+  EXPECT_VALID(Dart_TypedDataAcquireData(obj, &type, &raw_data, &len));
   EXPECT(raw_data == data);
+  EXPECT_EQ(data_length, len);
+  EXPECT_EQ(expected_type, type);
+  EXPECT_VALID(Dart_TypedDataReleaseData(obj));
 
   void* peer = &data;  // just a non-NULL value
-  EXPECT_VALID(Dart_ExternalByteArrayGetPeer(obj, &peer));
+  EXPECT_VALID(Dart_ExternalTypedDataGetPeer(obj, &peer));
   EXPECT(peer == NULL);
 
   intptr_t list_length = 0;
   EXPECT_VALID(Dart_ListLength(obj, &list_length));
   EXPECT_EQ(data_length, list_length);
 
   // Load and check values from underlying array and API.
   for (intptr_t i = 0; i < list_length; ++i) {
     EXPECT_EQ(11 * i, data[i]);
     Dart_Handle elt = Dart_ListGetAt(obj, i);
@@ skipping 22 matching lines @@
     EXPECT_VALID(value);
     EXPECT_VALID(Dart_ListSetAt(obj, i, value));
   }
   // Read them back through the underlying array.
   for (intptr_t i = 0; i < data_length; ++i) {
     EXPECT_EQ(33 * i, data[i]);
   }
 }
 
 
-TEST_CASE(ExternalByteArrayAccess) {
+TEST_CASE(ExternalTypedDataAccess) {
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
 
-  Dart_Handle obj = Dart_NewExternalByteArray(data, data_length, NULL, NULL);
-  ExternalByteArrayAccessTests(obj, data, data_length);
+  Dart_Handle obj = Dart_NewExternalTypedData(kUint8,
+                                              data, data_length,
+                                              NULL, NULL);
+  ExternalTypedDataAccessTests(obj, kUint8, data, data_length);
 }
 
 
-TEST_CASE(ExternalClampedByteArrayAccess) {
+TEST_CASE(ExternalClampedTypedDataAccess) {
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
 
-  Dart_Handle obj = Dart_NewExternalClampedByteArray(
-      data, data_length, NULL, NULL);
-  ExternalByteArrayAccessTests(obj, data, data_length);
+  Dart_Handle obj = Dart_NewExternalTypedData(kUint8Clamped,
+                                              data, data_length,
+                                              NULL, NULL);
+  ExternalTypedDataAccessTests(obj, kUint8Clamped, data, data_length);
 }
 
 
 TEST_CASE(ExternalUint8ClampedArrayAccess) {
     const char* kScriptChars =
       "testClamped(List a) {\n"
       "  if (a[1] != 11) return false;\n"
       "  a[1] = 3;\n"
       "  if (a[1] != 3) return false;\n"
       "  a[1] = -12;\n"
       "  if (a[1] != 0) return false;\n"
       "  a[1] = 1200;\n"
       "  if (a[1] != 255) return false;\n"
       "  return true;\n"
       "}\n";
 
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
-  Dart_Handle obj = Dart_NewExternalClampedByteArray(
-      data, data_length, NULL, NULL);
+  Dart_Handle obj = Dart_NewExternalTypedData(kUint8Clamped,
+                                              data, data_length,
+                                              NULL, NULL);
   EXPECT_VALID(obj);
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle args[1];
   args[0] = obj;
   result = Dart_Invoke(lib, NewString("testClamped"), 1, args);
 
   // Check that result is true.
   EXPECT_VALID(result);
   EXPECT(Dart_IsBoolean(result));
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
-static void ExternalByteArrayCallbackFinalizer(Dart_Handle handle, void* peer) {
+static void ExternalTypedDataCallbackFinalizer(Dart_Handle handle,
+                                               void* peer) {
   Dart_DeletePersistentHandle(handle);
   *static_cast<int*>(peer) = 42;
 }
 
 
-TEST_CASE(ExternalByteArrayCallback) {
+TEST_CASE(ExternalTypedDataCallback) {
   int peer = 0;
   {
     Dart_EnterScope();
     uint8_t data[] = { 1, 2, 3, 4 };
-    Dart_Handle obj = Dart_NewExternalByteArray(
+    Dart_Handle obj = Dart_NewExternalTypedData(
+        kUint8,
         data,
         ARRAY_SIZE(data),
         &peer,
-        ExternalByteArrayCallbackFinalizer);
+        ExternalTypedDataCallbackFinalizer);
     EXPECT_VALID(obj);
     void* api_peer = NULL;
-    EXPECT_VALID(Dart_ExternalByteArrayGetPeer(obj, &api_peer));
+    EXPECT_VALID(Dart_ExternalTypedDataGetPeer(obj, &api_peer));
     EXPECT_EQ(api_peer, &peer);
     Dart_ExitScope();
   }
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT(peer == 42);
 }
 
@@ skipping 6281 matching lines @@
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(260, value);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart