Externalization API for ArrayBuffer

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2475 matching lines @@
   CHECK(obj->Has(sym1));
   CHECK(obj->Has(sym2));
   CHECK(obj->Delete(sym2));
   CHECK(obj->Has(sym1));
   CHECK(!obj->Has(sym2));
   CHECK_EQ(2002, obj->Get(sym1)->Int32Value());
   CHECK_EQ(1, obj->GetOwnPropertyNames()->Length());
 }
 
 
 THREADED_TEST(ArrayBuffer) {

[Sven Panne, 2013/05/23 07:57:01]

Can we please split this test into several tests? Currently it is very hard to
see what the various parts are actually testing. Furthermore, do we have simple
test to see what happens on the JavaScript side when an ArrayBuffer moves to the
"externalized" state? If there is one, I can't see it...

[Dmitry Lomov (no reviews), 2013/05/23 08:42:15]

Done.

   i::FLAG_harmony_array_buffer = true;
   i::FLAG_harmony_typed_arrays = true;
 
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(1024);
+  CHECK_EQ(1024, ab->ByteLength());
+  CHECK(!ab->IsExternal());
   HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
 
-  CHECK_EQ(1024, static_cast<int>(ab->ByteLength()));
-  uint8_t* data = static_cast<uint8_t*>(ab->Data());
+  v8::ArrayBufferContents ab_contents;
+  ab->Externalize(&ab_contents);
+  CHECK(ab->IsExternal());
+
+  CHECK_EQ(1024, static_cast<int>(ab_contents.ByteLength()));
+  uint8_t* data = static_cast<uint8_t*>(ab_contents.Data());
   ASSERT(data != NULL);
   env->Global()->Set(v8_str("ab"), ab);
 
   v8::Handle<v8::Value> result = CompileRun("ab.byteLength");
   CHECK_EQ(1024, result->Int32Value());
 
   result = CompileRun("var u8 = new Uint8Array(ab);"
                       "u8[0] = 0xFF;"
                       "u8[1] = 0xAA;"
                       "u8.length");
   CHECK_EQ(1024, result->Int32Value());
   CHECK_EQ(0xFF, data[0]);
   CHECK_EQ(0xAA, data[1]);
   data[0] = 0xCC;
   data[1] = 0x11;
   result = CompileRun("u8[0] + u8[1]");
   CHECK_EQ(0xDD, result->Int32Value());
 
   result = CompileRun("var ab1 = new ArrayBuffer(2);"
                       "var u8_a = new Uint8Array(ab1);"
                       "u8_a[0] = 0xAA;"
                       "u8_a[1] = 0xFF; u8_a.buffer");
   Local<v8::ArrayBuffer> ab1 = v8::ArrayBuffer::Cast(*result);
   CHECK_EQ(2, static_cast<int>(ab1->ByteLength()));
-  uint8_t* ab1_data = static_cast<uint8_t*>(ab1->Data());
+  CHECK(!ab1->IsExternal());
+  v8::ArrayBufferContents ab1_contents;
+  ab1->Externalize(&ab1_contents);
+  CHECK(ab1->IsExternal());
+
+  CHECK_EQ(2, static_cast<int>(ab1_contents.ByteLength()));
+  uint8_t* ab1_data = static_cast<uint8_t*>(ab1_contents.Data());
   CHECK_EQ(0xAA, ab1_data[0]);
   CHECK_EQ(0xFF, ab1_data[1]);
   ab1_data[0] = 0xCC;
   ab1_data[1] = 0x11;
   result = CompileRun("u8_a[0] + u8_a[1]");
   CHECK_EQ(0xDD, result->Int32Value());
 
   uint8_t* my_data = new uint8_t[100];
   memset(my_data, 0, 100);
   Local<v8::ArrayBuffer> ab3 = v8::ArrayBuffer::New(my_data, 100);
   CHECK_EQ(100, static_cast<int>(ab3->ByteLength()));
-  CHECK_EQ(my_data, ab3->Data());
+  CHECK(ab3->IsExternal());
+
   env->Global()->Set(v8_str("ab3"), ab3);
+
+  result = CompileRun("ab3.byteLength");
+  CHECK_EQ(100, result->Int32Value());
+
   result = CompileRun("var u8_b = new Uint8Array(ab3);"
                       "u8_b[0] = 0xBB;"
                       "u8_b[1] = 0xCC;"
                       "u8_b.length");
   CHECK_EQ(100, result->Int32Value());
   CHECK_EQ(0xBB, my_data[0]);
   CHECK_EQ(0xCC, my_data[1]);
   my_data[0] = 0xCC;
   my_data[1] = 0x11;
   result = CompileRun("u8_b[0] + u8_b[1]");
   CHECK_EQ(0xDD, result->Int32Value());
 
   delete[] my_data;
 }
 
 
-
-
-
 THREADED_TEST(HiddenProperties) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Local<v8::Object> obj = v8::Object::New();
   v8::Local<v8::String> key = v8_str("api-test::hidden-key");
   v8::Local<v8::String> empty = v8_str("");
   v8::Local<v8::String> prop_name = v8_str("prop_name");
 
   HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
@@ skipping 12877 matching lines @@
 
 
 template <typename ElementType, typename TypedArray,
           class ExternalArrayClass>
 void TypedArrayTestHelper(v8::ExternalArrayType array_type,
                           int64_t low, int64_t high) {
   const int kElementCount = 50;
   i::FLAG_harmony_array_buffer = true;
   i::FLAG_harmony_typed_arrays = true;
 
-  LocalContext env;
-  v8::Isolate* isolate = env->GetIsolate();
-  v8::HandleScope handle_scope(isolate);
+  ElementType* backing_store = new ElementType[kElementCount+2];

[Sven Panne, 2013/05/23 07:57:01]

Using 'ScopedVector<ElementType> backing_store(kElementCount+2)' simplifies
things here.

[Dmitry Lomov (no reviews), 2013/05/23 08:42:15]

Done.

+  {
+    LocalContext env;
+    v8::Isolate* isolate = env->GetIsolate();
+    v8::HandleScope handle_scope(isolate);
 
-  Local<v8::ArrayBuffer> ab =
-      v8::ArrayBuffer::New((kElementCount+2)*sizeof(ElementType));
-  Local<TypedArray> ta =
-      TypedArray::New(ab, 2*sizeof(ElementType), kElementCount);
-  CHECK_EQ(kElementCount, static_cast<int>(ta->Length()));
-  CHECK_EQ(2*sizeof(ElementType), static_cast<int>(ta->ByteOffset()));
-  CHECK_EQ(kElementCount*sizeof(ElementType),
-           static_cast<int>(ta->ByteLength()));
-  CHECK_EQ(ab, ta->Buffer());
+    Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
+        backing_store, (kElementCount+2)*sizeof(ElementType));
+    Local<TypedArray> ta =
+        TypedArray::New(ab, 2*sizeof(ElementType), kElementCount);
+    CHECK_EQ(kElementCount, static_cast<int>(ta->Length()));
+    CHECK_EQ(2*sizeof(ElementType), static_cast<int>(ta->ByteOffset()));
+    CHECK_EQ(kElementCount*sizeof(ElementType),
+             static_cast<int>(ta->ByteLength()));
+    CHECK_EQ(ab, ta->Buffer());
 
-  ElementType* data = static_cast<ElementType*>(ab->Data()) + 2;
-  for (int i = 0; i < kElementCount; i++) {
-    data[i] = static_cast<ElementType>(i);
+    ElementType* data = backing_store + 2;
+    for (int i = 0; i < kElementCount; i++) {
+      data[i] = static_cast<ElementType>(i);
+    }
+
+    ObjectWithExternalArrayTestHelper<ExternalArrayClass, ElementType>(
+        env.local(), ta, kElementCount, array_type, low, high);
   }
-
-  ObjectWithExternalArrayTestHelper<ExternalArrayClass, ElementType>(
-      env.local(), ta, kElementCount, array_type, low, high);
+  delete[] backing_store;
 }
 
 
 THREADED_TEST(Uint8Array) {
   TypedArrayTestHelper<uint8_t, v8::Uint8Array, i::ExternalUnsignedByteArray>(
       v8::kExternalUnsignedByteArray, 0, 0xFF);
 }
 
 
 THREADED_TEST(Int8Array) {
@@ skipping 3758 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32