Convert ARRAYSIZE_UNSAFE -> arraysize in base/.

base/strings/utf_offset_string_conversions_unittest.cc

 // Copyright (c) 2011 The Chromium 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 <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 16 matching lines @@
     {"", kNpos, kNpos},
     {"\xe4\xbd\xa0\xe5\xa5\xbd", 1, kNpos},
     {"\xe4\xbd\xa0\xe5\xa5\xbd", 3, 1},
     {"\xed\xb0\x80z", 3, 1},
     {"A\xF0\x90\x8C\x80z", 1, 1},
     {"A\xF0\x90\x8C\x80z", 2, kNpos},
     {"A\xF0\x90\x8C\x80z", 5, 3},
     {"A\xF0\x90\x8C\x80z", 6, 4},
     {"A\xF0\x90\x8C\x80z", kNpos, kNpos},
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(utf8_to_utf16_cases); ++i) {
+  for (size_t i = 0; i < arraysize(utf8_to_utf16_cases); ++i) {
     const size_t offset = utf8_to_utf16_cases[i].input_offset;
     std::vector<size_t> offsets;
     offsets.push_back(offset);
     UTF8ToUTF16AndAdjustOffsets(utf8_to_utf16_cases[i].utf8, &offsets);
     EXPECT_EQ(utf8_to_utf16_cases[i].output_offset, offsets[0]);
   }
 
   struct UTF16ToUTF8Case {
     char16 utf16[10];
     size_t input_offset;
     size_t output_offset;
   } utf16_to_utf8_cases[] = {
       {{}, 0, 0},
       // Converted to 3-byte utf-8 sequences
       {{0x5909, 0x63DB}, 3, kNpos},
       {{0x5909, 0x63DB}, 2, 6},
       {{0x5909, 0x63DB}, 1, 3},
       {{0x5909, 0x63DB}, 0, 0},
       // Converted to 2-byte utf-8 sequences
       {{'A', 0x00bc, 0x00be, 'z'}, 1, 1},
       {{'A', 0x00bc, 0x00be, 'z'}, 2, 3},
       {{'A', 0x00bc, 0x00be, 'z'}, 3, 5},
       {{'A', 0x00bc, 0x00be, 'z'}, 4, 6},
       // Surrogate pair
       {{'A', 0xd800, 0xdf00, 'z'}, 1, 1},
       {{'A', 0xd800, 0xdf00, 'z'}, 2, kNpos},
       {{'A', 0xd800, 0xdf00, 'z'}, 3, 5},
       {{'A', 0xd800, 0xdf00, 'z'}, 4, 6},
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(utf16_to_utf8_cases); ++i) {
+  for (size_t i = 0; i < arraysize(utf16_to_utf8_cases); ++i) {
     size_t offset = utf16_to_utf8_cases[i].input_offset;
     std::vector<size_t> offsets;
     offsets.push_back(offset);
     UTF16ToUTF8AndAdjustOffsets(utf16_to_utf8_cases[i].utf16, &offsets);
     EXPECT_EQ(utf16_to_utf8_cases[i].output_offset, offsets[0]) << i;
   }
 }
 
 TEST(UTFOffsetStringConversionsTest, LimitOffsets) {
   const size_t kLimit = 10;
@@ skipping 209 matching lines @@
   EXPECT_EQ(1u, adjustments_on_adjusted_string[3].output_length);
   EXPECT_EQ(19u, adjustments_on_adjusted_string[4].original_offset);
   EXPECT_EQ(3u, adjustments_on_adjusted_string[4].original_length);
   EXPECT_EQ(0u, adjustments_on_adjusted_string[4].output_length);
   EXPECT_EQ(25u, adjustments_on_adjusted_string[5].original_offset);
   EXPECT_EQ(1u, adjustments_on_adjusted_string[5].original_length);
   EXPECT_EQ(2u, adjustments_on_adjusted_string[5].output_length);
 }
 
 }  // namaspace base