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

test/cctest/compiler/test-structured-machine-assembler.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 "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/base/utils/random-number-generator.h"
 #include "src/compiler/structured-machine-assembler.h"
 #include "test/cctest/compiler/codegen-tester.h"
@@ skipping 261 matching lines @@
   for (size_t j = 0; i != inputs.end(); j++, ++i) {
     int32_t result = m.Call(*i);
     CHECK_EQ(j < max ? hit : miss, result);
   }
 }
 
 
 TEST(RunIfBuilderDisjunction) {
   size_t len = ValueHelper::int32_vector().size() - 1;
   size_t max = len > 10 ? 10 : len - 1;
-  for (size_t i = 0; i < ARRAY_SIZE(all_branch_types); i++) {
-    for (size_t j = 0; j < ARRAY_SIZE(all_branch_types); j++) {
+  for (size_t i = 0; i < arraysize(all_branch_types); i++) {
+    for (size_t j = 0; j < arraysize(all_branch_types); j++) {
       for (size_t size = 1; size < max; size++) {
         RunIfBuilderDisjunction(size, all_branch_types[i], all_branch_types[j]);
       }
       RunIfBuilderDisjunction(len, all_branch_types[i], all_branch_types[j]);
     }
   }
 }
 
 
 static void RunIfBuilderConjunction(size_t max, IfBuilderBranchType then_type,
@@ skipping 44 matching lines @@
   for (size_t j = 0; i != inputs.end(); j++, ++i) {
     int32_t result = m.Call(*i);
     CHECK_EQ(j >= max ? hit : miss, result);
   }
 }
 
 
 TEST(RunIfBuilderConjunction) {
   size_t len = ValueHelper::int32_vector().size() - 1;
   size_t max = len > 10 ? 10 : len - 1;
-  for (size_t i = 0; i < ARRAY_SIZE(all_branch_types); i++) {
-    for (size_t j = 0; j < ARRAY_SIZE(all_branch_types); j++) {
+  for (size_t i = 0; i < arraysize(all_branch_types); i++) {
+    for (size_t j = 0; j < arraysize(all_branch_types); j++) {
       for (size_t size = 1; size < max; size++) {
         RunIfBuilderConjunction(size, all_branch_types[i], all_branch_types[j]);
       }
       RunIfBuilderConjunction(len, all_branch_types[i], all_branch_types[j]);
     }
   }
 }
 
 
 static void RunDisjunctionVariables(int disjunctions, bool explicit_then,
@@ skipping 316 matching lines @@
     // prv_1 = res
     res.Set(m.Int32Add(prv_0.Get(), prv_1.Get()));
     prv_0.Set(prv_1.Get());
     prv_1.Set(res.Get());
     // cnt--
     cnt.Set(m.Int32Sub(cnt.Get(), one));
   }
   m.Return(res.Get());
 
   int32_t values[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144};
-  for (size_t i = 0; i < ARRAY_SIZE(values); i++) {
+  for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(values[i], m.Call(static_cast<int32_t>(i)));
   }
 }
 
 
 static int VariableIntroduction() {
   while (true) {
     int ret = 0;
     for (int i = 0; i < 10; i++) {
       for (int j = i; j < 10; j++) {
@@ skipping 190 matching lines @@
         stack_frame_size_(Int32Constant(kFrameVariables * 4)),
         left_offset_(Int32Constant(0 * 4)),
         right_offset_(Int32Constant(1 * 4)) {
     Build();
   }
 
   int32_t DoCall(int32_t* input, int32_t input_length) {
     int32_t stack_space[20];
     // Do call.
     int32_t return_val = Call(input, input_length, stack_space,
-                              static_cast<int32_t>(ARRAY_SIZE(stack_space)));
+                              static_cast<int32_t>(arraysize(stack_space)));
     // Ran out of stack space.
     if (return_val != 0) return return_val;
     // Check sorted.
     int32_t last = input[0];
     for (int32_t i = 0; i < input_length; i++) {
       CHECK(last <= input[i]);
       last = input[i];
     }
     return return_val;
   }
@@ skipping 103 matching lines @@
   // Frame constants.
   Node* const stack_frame_size_;
   Node* const left_offset_;
   Node* const right_offset_;
 };
 
 
 TEST(RunSimpleQuicksort) {
   QuicksortHelper m;
   int32_t inputs[] = {9, 7, 1, 8, 11};
-  CHECK_EQ(0, m.DoCall(inputs, ARRAY_SIZE(inputs)));
+  CHECK_EQ(0, m.DoCall(inputs, arraysize(inputs)));
 }
 
 
 TEST(RunRandomQuicksort) {
   QuicksortHelper m;
 
   v8::base::RandomNumberGenerator rng;
   static const int kMaxLength = 40;
   int32_t inputs[kMaxLength];
 
@@ skipping 14 matching lines @@
   for (int i = 0; i < 10; i++) {
     IfBuilder b(&m);
     b.If(m.Int32Constant(0)).Then();
     m.NewVariable(m.Int32Constant(0));
   }
   m.Return(m.Int32Constant(0));
   CHECK_EQ(0, m.Call());
 }
 
 #endif