[clang-tidy] Apply modernize-loop-convert in /base/i18n

This change applies clang-tidy's modernize-loop-convert [1] in /base/i18n.

Reproduction steps:
- run clang-tidy's modernize-loop-convert
- run git cl format
- manually remove unused constants due to -Wunused-const-variable

[1] https://clang.llvm.org/extra/clang-tidy/checks/modernize-loop-convert.html

This CL was uploaded by git cl split.

R=jshin@chromium.org

Bug: 895746
Change-Id: I9b9790b60aaca3f6afb2b4bd1109d800aec5b26a
Reviewed-on: https://chromium-review.googlesource.com/c/1282404
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Reviewed-by: Jungshik Shin <jshin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#614377}

base/i18n/break_iterator_unittest.cc

@@ -448,8 +448,8 @@ TEST(BreakIteratorTest, BreakCharacter) {
   };
   std::vector<string16> characters;
   string16 text;
-  for (size_t i = 0; i < arraysize(kCharacters); ++i) {
-    characters.push_back(WideToUTF16(kCharacters[i]));
+  for (auto*& i : kCharacters) {
+    characters.push_back(WideToUTF16(i));
     text.append(characters.back());
   }
   BreakIterator iter(text, BreakIterator::BREAK_CHARACTER);

base/i18n/build_utf8_validator_tables.cc

@@ -263,9 +263,9 @@ void MoveAllCharsToSets(PairVector* pairs) {
 // algorithm is working. Use the command-line option
 // --vmodule=build_utf8_validator_tables=1 to see this output.
 void LogStringSets(const PairVector& pairs) {
-  for (auto pair_it = pairs.begin(); pair_it != pairs.end(); ++pair_it) {
+  for (const auto& pair_it : pairs) {
     std::string set_as_string;
-    for (auto set_it = pair_it->set.begin(); set_it != pair_it->set.end();
+    for (auto set_it = pair_it.set.begin(); set_it != pair_it.set.end();
          ++set_it) {
       set_as_string += base::StringPrintf("[\\x%02x-\\x%02x]",
                                           static_cast<int>(set_it->from()),
@@ -373,13 +373,13 @@ void PrintStates(const std::vector<State>& states, FILE* stream) {
   std::vector<uint8_t> shifts;
   uint8_t pos = 0;
 
-  for (auto state_it = states.begin(); state_it != states.end(); ++state_it) {
+  for (const auto& state_it : states) {
     // We want to set |shift| to the (0-based) index of the least-significant
     // set bit in any of the ranges for this state, since this tells us how many
     // bits we can discard and still determine what range a byte lies in. Sadly
     // it appears that ffs() is not portable, so we do it clumsily.
     uint8_t shift = 7;
-    for (auto range_it = state_it->begin(); range_it != state_it->end();
+    for (auto range_it = state_it.begin(); range_it != state_it.end();
          ++range_it) {
       while (shift > 0 && range_it->from % (1 << shift) != 0) {
         --shift;

base/i18n/file_util_icu_unittest.cc

@@ -38,10 +38,10 @@ static const struct GoodBadPairLinux {
 };
 
 TEST_F(FileUtilICUTest, ReplaceIllegalCharactersInPathLinuxTest) {
-  for (size_t i = 0; i < arraysize(kLinuxIllegalCharacterCases); ++i) {
-    std::string bad_name(kLinuxIllegalCharacterCases[i].bad_name);
+  for (auto i : kLinuxIllegalCharacterCases) {
+    std::string bad_name(i.bad_name);
     ReplaceIllegalCharactersInPath(&bad_name, '-');
-    EXPECT_EQ(kLinuxIllegalCharacterCases[i].good_name, bad_name);
+    EXPECT_EQ(i.good_name, bad_name);
   }
 }
 
@@ -85,15 +85,15 @@ static const struct goodbad_pair {
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_POSIX)
 
 TEST_F(FileUtilICUTest, ReplaceIllegalCharactersInPathTest) {
-  for (size_t i = 0; i < arraysize(kIllegalCharacterCases); ++i) {
+  for (auto i : kIllegalCharacterCases) {
 #if defined(OS_WIN)
-    std::wstring bad_name(kIllegalCharacterCases[i].bad_name);
+    std::wstring bad_name(i.bad_name);
     ReplaceIllegalCharactersInPath(&bad_name, '-');
-    EXPECT_EQ(kIllegalCharacterCases[i].good_name, bad_name);
+    EXPECT_EQ(i.good_name, bad_name);
 #else
-    std::string bad_name(WideToUTF8(kIllegalCharacterCases[i].bad_name));
+    std::string bad_name(WideToUTF8(i.bad_name));
     ReplaceIllegalCharactersInPath(&bad_name, '-');
-    EXPECT_EQ(WideToUTF8(kIllegalCharacterCases[i].good_name), bad_name);
+    EXPECT_EQ(WideToUTF8(i.good_name), bad_name);
 #endif
   }
 }

base/i18n/number_formatting_unittest.cc

@@ -36,15 +36,13 @@ TEST(NumberFormattingTest, FormatNumber) {
 
   test::ScopedRestoreICUDefaultLocale restore_locale;
 
-  for (size_t i = 0; i < arraysize(cases); ++i) {
+  for (const auto& i : cases) {
     i18n::SetICUDefaultLocale("en");
     testing::ResetFormatters();
-    EXPECT_EQ(cases[i].expected_english,
-              UTF16ToUTF8(FormatNumber(cases[i].number)));
+    EXPECT_EQ(i.expected_english, UTF16ToUTF8(FormatNumber(i.number)));
     i18n::SetICUDefaultLocale("de");
     testing::ResetFormatters();
-    EXPECT_EQ(cases[i].expected_german,
-              UTF16ToUTF8(FormatNumber(cases[i].number)));
+    EXPECT_EQ(i.expected_german, UTF16ToUTF8(FormatNumber(i.number)));
   }
 }
 
@@ -82,15 +80,15 @@ TEST(NumberFormattingTest, FormatDouble) {
   };
 
   test::ScopedRestoreICUDefaultLocale restore_locale;
-  for (size_t i = 0; i < arraysize(cases); ++i) {
+  for (const auto& i : cases) {
     i18n::SetICUDefaultLocale("en");
     testing::ResetFormatters();
-    EXPECT_EQ(cases[i].expected_english,
-              UTF16ToUTF8(FormatDouble(cases[i].number, cases[i].frac_digits)));
+    EXPECT_EQ(i.expected_english,
+              UTF16ToUTF8(FormatDouble(i.number, i.frac_digits)));
     i18n::SetICUDefaultLocale("de");
     testing::ResetFormatters();
-    EXPECT_EQ(cases[i].expected_german,
-              UTF16ToUTF8(FormatDouble(cases[i].number, cases[i].frac_digits)));
+    EXPECT_EQ(i.expected_german,
+              UTF16ToUTF8(FormatDouble(i.number, i.frac_digits)));
   }
 }
 
@@ -119,22 +117,17 @@ TEST(NumberFormattingTest, FormatPercent) {
   };
 
   test::ScopedRestoreICUDefaultLocale restore_locale;
-  for (size_t i = 0; i < arraysize(cases); ++i) {
+  for (const auto& i : cases) {
     i18n::SetICUDefaultLocale("en");
-    EXPECT_EQ(ASCIIToUTF16(cases[i].expected_english),
-              FormatPercent(cases[i].number));
+    EXPECT_EQ(ASCIIToUTF16(i.expected_english), FormatPercent(i.number));
     i18n::SetICUDefaultLocale("de");
-    EXPECT_EQ(UTF8ToUTF16(cases[i].expected_german),
-              FormatPercent(cases[i].number));
+    EXPECT_EQ(UTF8ToUTF16(i.expected_german), FormatPercent(i.number));
     i18n::SetICUDefaultLocale("fa");
-    EXPECT_EQ(UTF8ToUTF16(cases[i].expected_persian),
-              FormatPercent(cases[i].number));
+    EXPECT_EQ(UTF8ToUTF16(i.expected_persian), FormatPercent(i.number));
     i18n::SetICUDefaultLocale("ar");
-    EXPECT_EQ(UTF8ToUTF16(cases[i].expected_arabic),
-              FormatPercent(cases[i].number));
+    EXPECT_EQ(UTF8ToUTF16(i.expected_arabic), FormatPercent(i.number));
     i18n::SetICUDefaultLocale("ar-EG");
-    EXPECT_EQ(UTF8ToUTF16(cases[i].expected_arabic_egypt),
-              FormatPercent(cases[i].number));
+    EXPECT_EQ(UTF8ToUTF16(i.expected_arabic_egypt), FormatPercent(i.number));
   }
 }
 

base/i18n/rtl_unittest.cc

@@ -91,9 +91,9 @@ TEST_F(RTLTest, GetFirstStrongCharacterDirection) {
       LEFT_TO_RIGHT },
    };
 
-  for (size_t i = 0; i < arraysize(cases); ++i)
-    EXPECT_EQ(cases[i].direction,
-              GetFirstStrongCharacterDirection(WideToUTF16(cases[i].text)));
+  for (auto& i : cases)
+    EXPECT_EQ(i.direction,
+              GetFirstStrongCharacterDirection(WideToUTF16(i.text)));
 }
 
 
@@ -153,9 +153,9 @@ TEST_F(RTLTest, GetLastStrongCharacterDirection) {
       LEFT_TO_RIGHT },
    };
 
-  for (size_t i = 0; i < arraysize(cases); ++i)
-    EXPECT_EQ(cases[i].direction,
-              GetLastStrongCharacterDirection(WideToUTF16(cases[i].text)));
+  for (auto& i : cases)
+    EXPECT_EQ(i.direction,
+              GetLastStrongCharacterDirection(WideToUTF16(i.text)));
 }
 
 TEST_F(RTLTest, GetStringDirection) {
@@ -231,9 +231,8 @@ TEST_F(RTLTest, GetStringDirection) {
       LEFT_TO_RIGHT },
    };
 
-  for (size_t i = 0; i < arraysize(cases); ++i)
-    EXPECT_EQ(cases[i].direction,
-              GetStringDirection(WideToUTF16(cases[i].text)));
+  for (auto& i : cases)
+    EXPECT_EQ(i.direction, GetStringDirection(WideToUTF16(i.text)));
 }
 
 TEST_F(RTLTest, WrapPathWithLTRFormatting) {
@@ -266,18 +265,17 @@ TEST_F(RTLTest, WrapPathWithLTRFormatting) {
     L""
   };
 
-  for (size_t i = 0; i < arraysize(cases); ++i) {
+  for (auto*& i : cases) {
     FilePath path;
 #if defined(OS_WIN)
-    std::wstring win_path(cases[i]);
+    std::wstring win_path(i);
     std::replace(win_path.begin(), win_path.end(), '/', '\\');
     path = FilePath(win_path);
     std::wstring wrapped_expected =
         std::wstring(L"\x202a") + win_path + L"\x202c";
 #else
-    path = FilePath(base::SysWideToNativeMB(cases[i]));
-    std::wstring wrapped_expected =
-        std::wstring(L"\x202a") + cases[i] + L"\x202c";
+    path = FilePath(base::SysWideToNativeMB(i));
+    std::wstring wrapped_expected = std::wstring(L"\x202a") + i + L"\x202c";
 #endif
     string16 localized_file_path_string;
     WrapPathWithLTRFormatting(path, &localized_file_path_string);
@@ -311,8 +309,8 @@ TEST_F(RTLTest, WrapString) {
     WrapStringWithRTLFormatting(&empty);
     EXPECT_TRUE(empty.empty());
 
-    for (size_t i = 0; i < arraysize(cases); ++i) {
-      string16 input = WideToUTF16(cases[i]);
+    for (auto*& i : cases) {
+      string16 input = WideToUTF16(i);
       string16 ltr_wrap = input;
       WrapStringWithLTRFormatting(&ltr_wrap);
       EXPECT_EQ(ltr_wrap[0], kLeftToRightEmbeddingMark);
@@ -352,11 +350,11 @@ TEST_F(RTLTest, GetDisplayStringInLTRDirectionality) {
   for (size_t i = 0; i < 2; ++i) {
     // Toggle the application default text direction (to try each direction).
     SetRTLForTesting(!IsRTL());
-    for (size_t i = 0; i < arraysize(cases); ++i) {
-      string16 input = WideToUTF16(cases[i].path);
+    for (auto& i : cases) {
+      string16 input = WideToUTF16(i.path);
       string16 output = GetDisplayStringInLTRDirectionality(input);
       // Test the expected wrapping behavior for the current UI directionality.
-      if (IsRTL() ? cases[i].wrap_rtl : cases[i].wrap_ltr)
+      if (IsRTL() ? i.wrap_rtl : i.wrap_ltr)
         EXPECT_NE(output, input);
       else
         EXPECT_EQ(output, input);
@@ -440,8 +438,8 @@ TEST_F(RTLTest, UnadjustStringForLocaleDirection) {
     // Toggle the application default text direction (to try each direction).
     SetRTLForTesting(!IsRTL());
 
-    for (size_t i = 0; i < arraysize(cases); ++i) {
-      string16 test_case = WideToUTF16(cases[i]);
+    for (auto*& i : cases) {
+      string16 test_case = WideToUTF16(i);
       string16 adjusted_string = test_case;
 
       if (!AdjustStringForLocaleDirection(&adjusted_string))
@@ -490,9 +488,9 @@ TEST_F(RTLTest, EnsureTerminatedDirectionalFormatting) {
   for (size_t i = 0; i < 2; ++i) {
     // Toggle the application default text direction (to try each direction).
     SetRTLForTesting(!IsRTL());
-    for (size_t i = 0; i < arraysize(cases); ++i) {
-      string16 unsanitized_text = WideToUTF16(cases[i].unformated_text);
-      string16 sanitized_text = WideToUTF16(cases[i].formatted_text);
+    for (auto& i : cases) {
+      string16 unsanitized_text = WideToUTF16(i.unformated_text);
+      string16 sanitized_text = WideToUTF16(i.formatted_text);
       EnsureTerminatedDirectionalFormatting(&unsanitized_text);
       EXPECT_EQ(sanitized_text, unsanitized_text);
     }
@@ -523,16 +521,15 @@ TEST_F(RTLTest, SanitizeUserSuppliedString) {
 
   };
 
-  for (size_t i = 0; i < arraysize(cases); ++i) {
+  for (auto& i : cases) {
     // On Windows for an LTR locale, no changes to the string are made.
     string16 prefix, suffix = WideToUTF16(L"");
 #if !defined(OS_WIN)
     prefix = WideToUTF16(L"\x200e\x202b");
     suffix = WideToUTF16(L"\x202c\x200e");
 #endif  // !OS_WIN
-    string16 unsanitized_text = WideToUTF16(cases[i].unformatted_text);
-    string16 sanitized_text =
-        prefix + WideToUTF16(cases[i].formatted_text) + suffix;
+    string16 unsanitized_text = WideToUTF16(i.unformatted_text);
+    string16 sanitized_text = prefix + WideToUTF16(i.formatted_text) + suffix;
     SanitizeUserSuppliedString(&unsanitized_text);
     EXPECT_EQ(sanitized_text, unsanitized_text);
   }

base/i18n/streaming_utf8_validator_perftest.cc

@@ -51,8 +51,8 @@ const size_t kTestLengths[] = {1, 32, 256, 32768, 1 << 20};
 // the results will not be meaningful with sequences containing
 // top-bit-set bytes.
 bool IsString7Bit(const std::string& s) {
-  for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {
-    if (*it & 0x80)
+  for (auto it : s) {
+    if (it & 0x80)
       return false;
   }
   return true;
@@ -154,8 +154,7 @@ void RunSomeTests(
     base::Callback<std::string(size_t length)> construct_test_string,
     const TestFunctionDescription* test_functions,
     size_t test_count) {
-  for (size_t i = 0; i < arraysize(kTestLengths); ++i) {
-    const size_t length = kTestLengths[i];
+  for (auto length : kTestLengths) {
     const std::string test_string = construct_test_string.Run(length);
     const int real_length = static_cast<int>(test_string.length());
     const int times = (1 << 24) / real_length;

base/i18n/streaming_utf8_validator_unittest.cc

@@ -253,10 +253,8 @@ class StreamingUtf8ValidatorSingleSequenceTest : public ::testing::Test {
       StreamingUtf8Validator validator;
       base::StringPiece sequence = *it;
       StreamingUtf8Validator::State state = VALID_ENDPOINT;
-      for (base::StringPiece::const_iterator cit = sequence.begin();
-           cit != sequence.end();
-           ++cit) {
-        state = validator.AddBytes(&*cit, 1);
+      for (const auto& cit : sequence) {
+        state = validator.AddBytes(&cit, 1);
       }
       EXPECT_EQ(expected, state) << "Failed for \"" << sequence << "\"";
     }