Add %TypedArray% to proto chain

test/mjsunit/harmony/sharedarraybuffer.js

 // Copyright 2015 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 69 matching lines @@
 // Typed arrays using SharedArrayBuffers
 
 // TODO(binji): how many of these tests are necessary if there are no new
 // TypedArray types?
 
 function MakeSharedTypedArray(constr, numElements) {
   var sab = new SharedArrayBuffer(constr.BYTES_PER_ELEMENT * numElements);
   return new constr(sab);
 }
 
+function getPropertyDescriptor(object, field, expectedDepth) {
+  for (var depth = 0; depth < expectedDepth; depth++) {
+    assertFalse(Object.hasOwnProperty(object, field));
+    object = object.__proto__;
+  }
+  return Object.getOwnPropertyDescriptor(object, field);
+}
+
 function TestTypedArray(constr, elementSize, typicalElement) {
   assertSame(elementSize, constr.BYTES_PER_ELEMENT);
 
   var sab = new SharedArrayBuffer(256*elementSize);
 
   var a0 = new constr(30);
   assertEquals("[object " + constr.name + "]",
       Object.prototype.toString.call(a0));
 
   // TODO(binji): Should this return false here? It is a view, but it doesn't
@@ skipping 96 matching lines @@
   var aOverAbLen0 = new constr(abLen0);
   assertSame(abLen0, aOverAbLen0.buffer);
   assertSame(elementSize, aOverAbLen0.BYTES_PER_ELEMENT);
   assertSame(0, aOverAbLen0.length);
   assertSame(0, aOverAbLen0.byteLength);
   assertSame(0, aOverAbLen0.byteOffset);
 
   var a = new constr(sab, 64*elementSize, 128);
   assertEquals("[object " + constr.name + "]",
       Object.prototype.toString.call(a));
-  var desc = Object.getOwnPropertyDescriptor(
-      constr.prototype, Symbol.toStringTag);
+  var desc = getPropertyDescriptor(constr.prototype, Symbol.toStringTag, 1);
   assertTrue(desc.configurable);
   assertFalse(desc.enumerable);
   assertFalse(!!desc.writable);
   assertFalse(!!desc.set);
   assertEquals("function", typeof desc.get);
 }
 
 TestTypedArray(Uint8Array, 1, 0xFF);
 TestTypedArray(Int8Array, 1, -0x7F);
 TestTypedArray(Uint16Array, 2, 0xFFFF);
@@ skipping 85 matching lines @@
   Uint16Array,
   Int16Array,
   Uint32Array,
   Int32Array,
   Uint8ClampedArray,
   Float32Array,
   Float64Array];
 
 function TestPropertyTypeChecks(constructor) {
   function CheckProperty(name) {
-    var d = Object.getOwnPropertyDescriptor(constructor.prototype, name);
+    var d = getPropertyDescriptor(constructor.prototype, name, 1);
     var o = {};
     assertThrows(function() {d.get.call(o);}, TypeError);
     for (var i = 0; i < typedArrayConstructors.length; i++) {
       var ctor = typedArrayConstructors[i];
       var a = MakeSharedTypedArray(ctor, 10);
-      if (ctor === constructor) {
-        d.get.call(a); // shouldn't throw
-      } else {
-        assertThrows(function() {d.get.call(a);}, TypeError);
-      }
+      d.get.call(a); // shouldn't throw on any type
     }
   }
 
   CheckProperty("buffer");
   CheckProperty("byteOffset");
   CheckProperty("byteLength");
   CheckProperty("length");
 }
 
 for(i = 0; i < typedArrayConstructors.length; i++) {
@@ skipping 234 matching lines @@
 for(i = 0; i < typedArrayConstructors.length; i++) {
   TestArbitrary(MakeSharedTypedArray(typedArrayConstructors[i], 10));
 }
 
 // Test direct constructor call
 assertThrows(function() { SharedArrayBuffer(); }, TypeError);
 for(i = 0; i < typedArrayConstructors.length; i++) {
   assertThrows(function(i) { typedArrayConstructors[i](); }.bind(this, i),
                TypeError);
 }