Remove __ prefix from Harmony typed arrays implementation

test/mjsunit/harmony/typedarrays.js

 // Copyright 2013 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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Flags: --harmony-typed-arrays
 
 // ArrayBuffer
 
 function TestByteLength(param, expectedByteLength) {
-  var ab = new __ArrayBuffer(param);
+  var ab = new ArrayBuffer(param);
   assertSame(expectedByteLength, ab.byteLength);
 }
 
 function TestArrayBufferCreation() {
   TestByteLength(1, 1);
   TestByteLength(256, 256);
   TestByteLength(-10, 0);
   TestByteLength(2.567, 2);
   TestByteLength(-2.567, 0);
 
   TestByteLength("abc", 0);
 
   TestByteLength(0, 0);
 
 /* TODO[dslomov]: Reenable the test
   assertThrows(function() {
-    var ab1 = new __ArrayBuffer(0xFFFFFFFFFFFF)
+    var ab1 = new ArrayBuffer(0xFFFFFFFFFFFF)
   }, RangeError);
 */
 
-  var ab = new __ArrayBuffer();
+  var ab = new ArrayBuffer();
   assertSame(0, ab.byteLength);
 }
 
 TestArrayBufferCreation();
 
 function TestByteLengthNotWritable() {
-  var ab = new __ArrayBuffer(1024);
+  var ab = new ArrayBuffer(1024);
   assertSame(1024, ab.byteLength);
 
   assertThrows(function() { "use strict"; ab.byteLength = 42; }, TypeError);
 }
 
 TestByteLengthNotWritable();
 
 function TestSlice(expectedResultLen, initialLen, start, end) {
-  var ab = new __ArrayBuffer(initialLen);
+  var ab = new ArrayBuffer(initialLen);
   var slice = ab.slice(start, end);
   assertSame(expectedResultLen, slice.byteLength);
 }
 
 function TestArrayBufferSlice() {
-  var ab = new __ArrayBuffer(1024);
+  var ab = new ArrayBuffer(1024);
   var ab1 = ab.slice(512, 1024);
   assertSame(512, ab1.byteLength);
 
   TestSlice(512, 1024, 512, 1024);
   TestSlice(512, 1024, 512);
 
   TestSlice(0, 0, 1, 20);
   TestSlice(100, 100, 0, 100);
   TestSlice(100, 100, 0, 1000);
   TestSlice(0, 100, 5, 1);
@@ skipping 17 matching lines @@
 
   TestSlice(10, 100, 90);
   TestSlice(10, 100, -10);
 }
 
 TestArrayBufferSlice();
 
 // Typed arrays
 
 function TestTypedArray(proto, elementSize, typicalElement) {
-  var ab = new __ArrayBuffer(256*elementSize);
+  var ab = new ArrayBuffer(256*elementSize);
 
   var a1 = new proto(ab, 128*elementSize, 128);
   assertSame(ab, a1.buffer);
   assertSame(elementSize, a1.BYTES_PER_ELEMENT);
   assertSame(128, a1.length);
   assertSame(128*elementSize, a1.byteLength);
   assertSame(128*elementSize, a1.byteOffset);
 
 
   var a2 = new proto(ab, 64*elementSize, 128);
@@ skipping 43 matching lines @@
 
   for (i = 128; i < 256; i++) {
     assertSame(typicalElement, a4[i]);
   }
 
   assertThrows(function () { new proto(ab, 256*elementSize); }, RangeError);
 
   if (elementSize !== 1) {
     assertThrows(function() { new proto(ab, 128*elementSize - 1, 10); },
                  RangeError);
-    var unalignedArrayBuffer = new __ArrayBuffer(10*elementSize + 1);
+    var unalignedArrayBuffer = new ArrayBuffer(10*elementSize + 1);
     var goodArray = new proto(unalignedArrayBuffer, 0, 10);
     assertSame(10, goodArray.length);
     assertSame(10*elementSize, goodArray.byteLength);
     assertThrows(function() { new proto(unalignedArrayBuffer)}, RangeError);
     assertThrows(function() { new proto(unalignedArrayBuffer, 5*elementSize)},
                  RangeError);
   }
 
 }
 
-TestTypedArray(__Uint8Array, 1, 0xFF);
-TestTypedArray(__Int8Array, 1, -0x7F);
-TestTypedArray(__Uint16Array, 2, 0xFFFF);
-TestTypedArray(__Int16Array, 2, -0x7FFF);
-TestTypedArray(__Uint32Array, 4, 0xFFFFFFFF);
-TestTypedArray(__Int32Array, 4, -0x7FFFFFFF);
-TestTypedArray(__Float32Array, 4, 0.5);
-TestTypedArray(__Float64Array, 8, 0.5);
+TestTypedArray(Uint8Array, 1, 0xFF);
+TestTypedArray(Int8Array, 1, -0x7F);
+TestTypedArray(Uint16Array, 2, 0xFFFF);
+TestTypedArray(Int16Array, 2, -0x7FFF);
+TestTypedArray(Uint32Array, 4, 0xFFFFFFFF);
+TestTypedArray(Int32Array, 4, -0x7FFFFFFF);
+TestTypedArray(Float32Array, 4, 0.5);
+TestTypedArray(Float64Array, 8, 0.5);
 
 
 // General tests for properties
 
 // Test property attribute [[Enumerable]]
 function TestEnumerable(func, obj) {
   function props(x) {
     var array = [];
     for (var p in x) array.push(p);
     return array.sort();
   }
   assertArrayEquals([], props(func));
   assertArrayEquals([], props(func.prototype));
   if (obj)
     assertArrayEquals([], props(obj));
 }
-TestEnumerable(__ArrayBuffer, new __ArrayBuffer());
-TestEnumerable(__Uint8Array);
+TestEnumerable(ArrayBuffer, new ArrayBuffer());
+TestEnumerable(Uint8Array);
 
 
 // Test arbitrary properties on ArrayBuffer
 function TestArbitrary(m) {
   function TestProperty(map, property, value) {
     map[property] = value;
     assertEquals(value, map[property]);
   }
   for (var i = 0; i < 20; i++) {
     TestProperty(m, i, 'val' + i);
     TestProperty(m, 'foo' + i, 'bar' + i);
   }
 }
-TestArbitrary(new __ArrayBuffer(256));
+TestArbitrary(new ArrayBuffer(256));
 
 // Test direct constructor call
-assertTrue(__ArrayBuffer() instanceof __ArrayBuffer);
+assertTrue(ArrayBuffer() instanceof ArrayBuffer);