Replace our homegrown ARRAY_SIZE() with Chrome's arraysize().

test/cctest/compiler/test-representation-change.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <limits>
 
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 
@@ skipping 120 matching lines @@
     Node* val = r.changer()->GetRepresentationFor(node, kRepBit, kRepTagged);
     r.CheckHeapConstant(val, i == 0 ? r.isolate()->heap()->false_value()
                                     : r.isolate()->heap()->true_value());
   }
 }
 
 
 TEST(ToTagged_constant) {
   RepresentationChangerTester r;
 
-  for (size_t i = 0; i < ARRAY_SIZE(double_inputs); i++) {
+  for (size_t i = 0; i < arraysize(double_inputs); i++) {
     Node* n = r.jsgraph()->Float64Constant(double_inputs[i]);
     Node* c = r.changer()->GetRepresentationFor(n, kRepFloat64, kRepTagged);
     r.CheckNumberConstant(c, double_inputs[i]);
   }
 
-  for (size_t i = 0; i < ARRAY_SIZE(int32_inputs); i++) {
+  for (size_t i = 0; i < arraysize(int32_inputs); i++) {
     Node* n = r.jsgraph()->Int32Constant(int32_inputs[i]);
     Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeInt32,
                                                 kRepTagged);
     r.CheckNumberConstant(c, static_cast<double>(int32_inputs[i]));
   }
 
-  for (size_t i = 0; i < ARRAY_SIZE(uint32_inputs); i++) {
+  for (size_t i = 0; i < arraysize(uint32_inputs); i++) {
     Node* n = r.jsgraph()->Int32Constant(uint32_inputs[i]);
     Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeUint32,
                                                 kRepTagged);
     r.CheckNumberConstant(c, static_cast<double>(uint32_inputs[i]));
   }
 }
 
 
 static void CheckChange(IrOpcode::Value expected, MachineTypeUnion from,
                         MachineTypeUnion to) {
@@ skipping 46 matching lines @@
               kRepWord32 | kTypeUint32);
   CheckChange(IrOpcode::kChangeInt32ToFloat64, kRepWord32, kRepFloat64);
   CheckChange(IrOpcode::kChangeFloat64ToInt32, kRepFloat64, kRepWord32);
 }
 
 
 TEST(Nops) {
   RepresentationChangerTester r;
 
   // X -> X is always a nop for any single representation X.
-  for (size_t i = 0; i < ARRAY_SIZE(all_reps); i++) {
+  for (size_t i = 0; i < arraysize(all_reps); i++) {
     r.CheckNop(all_reps[i], all_reps[i]);
   }
 
   // 32-bit or 64-bit words can be used as branch conditions (kRepBit).
   r.CheckNop(kRepWord32, kRepBit);
   r.CheckNop(kRepWord32, kRepBit | kTypeBool);
   r.CheckNop(kRepWord64, kRepBit);
   r.CheckNop(kRepWord64, kRepBit | kTypeBool);
 
   // 32-bit words can be used as smaller word sizes and vice versa, because
@@ skipping 34 matching lines @@
   r.CheckTypeError(kRepTagged | kTypeBool, kRepWord64);
 
   // Word64 / Word32 shouldn't be implicitly converted.
   r.CheckTypeError(kRepWord64, kRepWord32);
   r.CheckTypeError(kRepWord32, kRepWord64);
   r.CheckTypeError(kRepWord64, kRepWord32 | kTypeInt32);
   r.CheckTypeError(kRepWord32 | kTypeInt32, kRepWord64);
   r.CheckTypeError(kRepWord64, kRepWord32 | kTypeUint32);
   r.CheckTypeError(kRepWord32 | kTypeUint32, kRepWord64);
 
-  for (size_t i = 0; i < ARRAY_SIZE(all_reps); i++) {
-    for (size_t j = 0; j < ARRAY_SIZE(all_reps); j++) {
+  for (size_t i = 0; i < arraysize(all_reps); i++) {
+    for (size_t j = 0; j < arraysize(all_reps); j++) {
       if (i == j) continue;
       // Only a single from representation is allowed.
       r.CheckTypeError(all_reps[i] | all_reps[j], kRepTagged);
     }
   }
 }
 
 
 TEST(CompleteMatrix) {
   // TODO(titzer): test all variants in the matrix.
   // rB
   // tBrB
   // tBrT
   // rW32
   // tIrW32
   // tUrW32
   // rW64
   // tIrW64
   // tUrW64
   // rF64
   // tIrF64
   // tUrF64
   // tArF64
   // rT
   // tArT
 }