Further extend TypedArray support in d8:

- Add copy constructors.
- Add subarray methods.
- Make instanceof and constructor property work.
- Rename PixelArray to Uint8ClampedArray.

Also fix broken definition of assertInstanceof in MJSUnit test harness.

R=mstarzinger@chromium.org
BUG=
TEST=

Review URL: https://chromiumcodereview.appspot.com/10558005

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@11949 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

include/v8.h

@@ -1550,6 +1550,12 @@ class Object : public Value {
    */
   V8EXPORT Local<String> ObjectProtoToString();
 
+  /**
+   * Returns the function invoked as a constructor for this object.
+   * May be the null value.
+   */
+  V8EXPORT Local<Value> GetConstructor();
+
   /**
    * Returns the name of the function invoked as a constructor for this object.
    */

src/api.cc

@@ -3031,6 +3031,17 @@ Local<String> v8::Object::ObjectProtoToString() {
 }
 
 
+Local<Value> v8::Object::GetConstructor() {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  ON_BAILOUT(isolate, "v8::Object::GetConstructor()",
+             return Local<v8::Function>());
+  ENTER_V8(isolate);
+  i::Handle<i::JSObject> self = Utils::OpenHandle(this);
+  i::Handle<i::Object> constructor(self->GetConstructor());
+  return Utils::ToLocal(constructor);
+}
+
+
 Local<String> v8::Object::GetConstructorName() {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::GetConstructorName()",

src/d8.h

@@ -322,7 +322,8 @@ class Shell : public i::AllStatic {
   static Handle<Value> Uint32Array(const Arguments& args);
   static Handle<Value> Float32Array(const Arguments& args);
   static Handle<Value> Float64Array(const Arguments& args);
-  static Handle<Value> PixelArray(const Arguments& args);
+  static Handle<Value> Uint8ClampedArray(const Arguments& args);
+  static Handle<Value> SubArray(const Arguments& args);
   // The OS object on the global object contains methods for performing
   // operating system calls:
   //
@@ -366,6 +367,7 @@ class Shell : public i::AllStatic {
 
  private:
   static Persistent<Context> evaluation_context_;
+  static Persistent<FunctionTemplate> array_buffer_template_;
 #ifndef V8_SHARED
   static Persistent<Context> utility_context_;
   static CounterMap* counter_map_;
@@ -383,8 +385,16 @@ class Shell : public i::AllStatic {
   static void RunShell();
   static bool SetOptions(int argc, char* argv[]);
   static Handle<ObjectTemplate> CreateGlobalTemplate();
-  static Handle<Value> CreateExternalArrayBuffer(int32_t size);
-  static Handle<Value> CreateExternalArrayBuffer(const Arguments& args);
+  static Handle<FunctionTemplate> CreateArrayTemplate(InvocationCallback);
+  static Handle<Value> CreateExternalArrayBuffer(Handle<Object> buffer,
+                                                 int32_t size);
+  static Handle<Object> CreateExternalArray(Handle<Object> array,
+                                            Handle<Object> buffer,
+                                            ExternalArrayType type,
+                                            int32_t length,
+                                            int32_t byteLength,
+                                            int32_t byteOffset,
+                                            int32_t element_size);
   static Handle<Value> CreateExternalArray(const Arguments& args,
                                            ExternalArrayType type,
                                            int32_t element_size);

src/objects-inl.h

@@ -4798,6 +4798,11 @@ Object* JSReceiver::GetPrototype() {
 }
 
 
+Object* JSReceiver::GetConstructor() {
+  return map()->constructor();
+}
+
+
 bool JSReceiver::HasProperty(String* name) {
   if (IsJSProxy()) {
     return JSProxy::cast(this)->HasPropertyWithHandler(name);

src/objects.h

@@ -1435,6 +1435,9 @@ class JSReceiver: public HeapObject {
   // Return the object's prototype (might be Heap::null_value()).
   inline Object* GetPrototype();
 
+  // Return the constructor function (may be Heap::null_value()).
+  inline Object* GetConstructor();
+
   // Set the object's prototype (only JSReceiver and null are allowed).
   MUST_USE_RESULT MaybeObject* SetPrototype(Object* value,
                                             bool skip_hidden_prototypes);

test/mjsunit/elements-kind.js

@@ -143,7 +143,7 @@ assertKind(elements_kind.external_int,            new Int32Array(0xF));
 assertKind(elements_kind.external_unsigned_int,   new Uint32Array(23));
 assertKind(elements_kind.external_float,          new Float32Array(7));
 assertKind(elements_kind.external_double,         new Float64Array(0));
-assertKind(elements_kind.external_pixel,          new PixelArray(512));
+assertKind(elements_kind.external_pixel,          new Uint8ClampedArray(512));
 
 // Crankshaft support for smi-only array elements.
 function monomorphic(array) {

test/mjsunit/external-array.js

@@ -27,6 +27,12 @@
 
 // Flags: --allow-natives-syntax --expose-gc
 
+// Helper
+function assertInstance(o, f) {
+  assertSame(o.constructor, f);
+  assertInstanceof(o, f);
+}
+
 // This is a regression test for overlapping key and value registers.
 function f(a) {
   a[0] = 0;
@@ -51,49 +57,58 @@ assertThrows(abfunc1);
 
 // Test derivation from an ArrayBuffer
 var ab = new ArrayBuffer(12);
+assertInstance(ab, ArrayBuffer);
 var derived_uint8 = new Uint8Array(ab);
+assertInstance(derived_uint8, Uint8Array);
 assertSame(ab, derived_uint8.buffer);
 assertEquals(12, derived_uint8.length);
 assertEquals(12, derived_uint8.byteLength);
 assertEquals(0, derived_uint8.byteOffset);
 assertEquals(1, derived_uint8.BYTES_PER_ELEMENT);
 var derived_uint8_2 = new Uint8Array(ab,7);
+assertInstance(derived_uint8_2, Uint8Array);
 assertSame(ab, derived_uint8_2.buffer);
 assertEquals(5, derived_uint8_2.length);
 assertEquals(5, derived_uint8_2.byteLength);
 assertEquals(7, derived_uint8_2.byteOffset);
 assertEquals(1, derived_uint8_2.BYTES_PER_ELEMENT);
 var derived_int16 = new Int16Array(ab);
+assertInstance(derived_int16, Int16Array);
 assertSame(ab, derived_int16.buffer);
 assertEquals(6, derived_int16.length);
 assertEquals(12, derived_int16.byteLength);
 assertEquals(0, derived_int16.byteOffset);
 assertEquals(2, derived_int16.BYTES_PER_ELEMENT);
 var derived_int16_2 = new Int16Array(ab,6);
+assertInstance(derived_int16_2, Int16Array);
 assertSame(ab, derived_int16_2.buffer);
 assertEquals(3, derived_int16_2.length);
 assertEquals(6, derived_int16_2.byteLength);
 assertEquals(6, derived_int16_2.byteOffset);
 assertEquals(2, derived_int16_2.BYTES_PER_ELEMENT);
 var derived_uint32 = new Uint32Array(ab);
+assertInstance(derived_uint32, Uint32Array);
 assertSame(ab, derived_uint32.buffer);
 assertEquals(3, derived_uint32.length);
 assertEquals(12, derived_uint32.byteLength);
 assertEquals(0, derived_uint32.byteOffset);
 assertEquals(4, derived_uint32.BYTES_PER_ELEMENT);
 var derived_uint32_2 = new Uint32Array(ab,4);
+assertInstance(derived_uint32_2, Uint32Array);
 assertSame(ab, derived_uint32_2.buffer);
 assertEquals(2, derived_uint32_2.length);
 assertEquals(8, derived_uint32_2.byteLength);
 assertEquals(4, derived_uint32_2.byteOffset);
 assertEquals(4, derived_uint32_2.BYTES_PER_ELEMENT);
 var derived_uint32_3 = new Uint32Array(ab,4,1);
+assertInstance(derived_uint32_3, Uint32Array);
 assertSame(ab, derived_uint32_3.buffer);
 assertEquals(1, derived_uint32_3.length);
 assertEquals(4, derived_uint32_3.byteLength);
 assertEquals(4, derived_uint32_3.byteOffset);
 assertEquals(4, derived_uint32_3.BYTES_PER_ELEMENT);
 var derived_float64 = new Float64Array(ab,0,1);
+assertInstance(derived_float64, Float64Array);
 assertSame(ab, derived_float64.buffer);
 assertEquals(1, derived_float64.length);
 assertEquals(8, derived_float64.byteLength);
@@ -198,7 +213,7 @@ assertEquals(4, array_with_length_from_non_number.length);
 
 // Test loads and stores.
 types = [Array, Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array,
-         Uint32Array, PixelArray, Float32Array, Float64Array];
+         Uint32Array, Uint8ClampedArray, Float32Array, Float64Array];
 
 test_result_nan = [NaN, 0, 0, 0, 0, 0, 0, 0, NaN, NaN];
 test_result_low_int = [-1, -1, 255, -1, 65535, -1, 0xFFFFFFFF, 0, -1, -1];
@@ -412,22 +427,113 @@ assertTrue(isNaN(float64_array[0]));
 
 
 // Check handling of 0-sized buffers and arrays.
-
 ab = new ArrayBuffer(0);
+assertInstance(ab, ArrayBuffer);
 assertEquals(0, ab.byteLength);
 a = new Int8Array(ab);
+assertInstance(a, Int8Array);
 assertEquals(0, a.byteLength);
 assertEquals(0, a.length);
 a[0] = 1;
-assertEquals(undefined, a[0])
+assertEquals(undefined, a[0]);
 ab = new ArrayBuffer(16);
+assertInstance(ab, ArrayBuffer);
 a = new Float32Array(ab,4,0);
+assertInstance(a, Float32Array);
 assertEquals(0, a.byteLength);
 assertEquals(0, a.length);
 a[0] = 1;
-assertEquals(undefined, a[0])
+assertEquals(undefined, a[0]);
 a = new Uint16Array(0);
+assertInstance(a, Uint16Array);
 assertEquals(0, a.byteLength);
 assertEquals(0, a.length);
 a[0] = 1;
-assertEquals(undefined, a[0])
+assertEquals(undefined, a[0]);
+
+
+// Check construction from arrays.
+a = new Uint32Array([]);
+assertInstance(a, Uint32Array);
+assertEquals(0, a.length);
+assertEquals(0, a.byteLength);
+assertEquals(0, a.buffer.byteLength);
+assertEquals(4, a.BYTES_PER_ELEMENT);
+a = new Uint16Array([1,2,3]);
+assertInstance(a, Uint16Array);
+assertEquals(3, a.length);
+assertEquals(6, a.byteLength);
+assertEquals(6, a.buffer.byteLength);
+assertEquals(2, a.BYTES_PER_ELEMENT);
+assertEquals(1, a[0]);
+assertEquals(3, a[2]);
+a = new Uint32Array(a);
+assertInstance(a, Uint32Array);
+assertEquals(3, a.length);
+assertEquals(12, a.byteLength);
+assertEquals(12, a.buffer.byteLength);
+assertEquals(4, a.BYTES_PER_ELEMENT);
+assertEquals(1, a[0]);
+assertEquals(3, a[2]);
+
+
+// Check subarrays.
+a = new Uint16Array([1,2,3,4,5,6]);
+aa = a.subarray(3);
+assertInstance(aa, Uint16Array);
+assertEquals(3, aa.length);
+assertEquals(6, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(3,5);
+assertInstance(aa, Uint16Array);
+assertEquals(2, aa.length);
+assertEquals(4, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(4,8);
+assertInstance(aa, Uint16Array);
+assertEquals(2, aa.length);
+assertEquals(4, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(9);
+assertInstance(aa, Uint16Array);
+assertEquals(0, aa.length);
+assertEquals(0, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(-4);
+assertInstance(aa, Uint16Array);
+assertEquals(4, aa.length);
+assertEquals(8, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(-3,-1);
+assertInstance(aa, Uint16Array);
+assertEquals(2, aa.length);
+assertEquals(4, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(3,2);
+assertInstance(aa, Uint16Array);
+assertEquals(0, aa.length);
+assertEquals(0, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(-3,-4);
+assertInstance(aa, Uint16Array);
+assertEquals(0, aa.length);
+assertEquals(0, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(0,-8);
+assertInstance(aa, Uint16Array);
+assertEquals(0, aa.length);
+assertEquals(0, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+
+assertThrows(function(){ a.subarray.call({}, 0) });
+assertThrows(function(){ a.subarray.call([], 0) });
+assertThrows(function(){ a.subarray.call(a) });

test/mjsunit/mjsunit.js

@@ -321,7 +321,7 @@ var assertUnreachable;
   assertInstanceof = function assertInstanceof(obj, type) {
     if (!(obj instanceof type)) {
       var actualTypeName = null;
-      var actualConstructor = Object.prototypeOf(obj).constructor;
+      var actualConstructor = Object.getPrototypeOf(obj).constructor;
       if (typeof actualConstructor == "function") {
         actualTypeName = actualConstructor.name || String(actualConstructor);
       }

test/mjsunit/pixel-array-rounding.js

@@ -27,7 +27,7 @@
 
 // Flags: --allow-natives-syntax
 
-var pixels = new PixelArray(8);
+var pixels = new Uint8ClampedArray(8);
 
 function f() {
   for (var i = 0; i < 8; i++) {

test/mjsunit/regress/regress-1563.js

@@ -27,7 +27,7 @@
 
 // Flags: --allow-natives-syntax
 
-obj = new PixelArray(10);
+obj = new Uint8ClampedArray(10);
 
 // Test that undefined gets properly clamped in Crankshafted pixel array
 // assignments.