Clean up locale_utils to use base::StringPiece.

This cleanup CL changes no functionality, it just cleans up some
functions in components/language/core/common/locale_util.cc to use
base::StringPiece instead of std::string where needed, as well as
updating the callers of these methods accordingly.

This CL also moves language::ContainsSameBaseLanguage into an
anonymous namespace in the single file that it's called from.

Change-Id: Ia2f8be1361b976e96aba95d78c59b88697343729
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2316811
Auto-Submit: Scott Little <sclittle@chromium.org>
Commit-Queue: anthonyvd <anthonyvd@chromium.org>
Reviewed-by: anthonyvd <anthonyvd@chromium.org>
Reviewed-by: Megan Jablonski <megjablon@chromium.org>
Cr-Commit-Position: refs/heads/master@{#792838}

components/language/core/common/language_util.cc

@@ -6,12 +6,16 @@
 
 #include <stddef.h>
 #include <algorithm>
+#include <tuple>
 
-#include "base/stl_util.h"
+#include "base/strings/strcat.h"
+#include "base/strings/string_piece.h"
 #include "components/language/core/common/locale_util.h"
 
 namespace language {
 
+namespace {
+
 struct LanguageCodePair {
   // Code used in supporting list of Translate.
   const char* const translate_language;
@@ -54,17 +58,17 @@ const LanguageCodePair kLanguageCodeChineseCompatiblePairs[] = {
     {"zh-CN", "zh-SG"},
 };
 
+}  // namespace
+
 void ToTranslateLanguageSynonym(std::string* language) {
-  for (size_t i = 0; i < base::size(kChromeToTranslateLanguageMap); ++i) {
-    if (*language == kChromeToTranslateLanguageMap[i].chrome_language) {
-      *language =
-          std::string(kChromeToTranslateLanguageMap[i].translate_language);
+  for (const auto& language_pair : kChromeToTranslateLanguageMap) {
+    if (*language == language_pair.chrome_language) {
+      *language = language_pair.translate_language;
       return;
     }
   }
 
-  std::string main_part, tail_part;
-  language::SplitIntoMainAndTail(*language, &main_part, &tail_part);
+  base::StringPiece main_part = language::SplitIntoMainAndTail(*language).first;
   if (main_part.empty())
     return;
 
@@ -75,9 +79,9 @@ void ToTranslateLanguageSynonym(std::string* language) {
   // instead of the main_part.
   // Note that "zh" does not have any mapping and as such we leave it as is. See
   // https://crbug/798512 for more info.
-  for (size_t i = 0; i < base::size(kLanguageCodeChineseCompatiblePairs); ++i) {
-    if (*language == kLanguageCodeChineseCompatiblePairs[i].chrome_language) {
-      *language = kLanguageCodeChineseCompatiblePairs[i].translate_language;
+  for (const auto& language_pair : kLanguageCodeChineseCompatiblePairs) {
+    if (*language == language_pair.chrome_language) {
+      *language = language_pair.translate_language;
       return;
     }
   }
@@ -86,37 +90,38 @@ void ToTranslateLanguageSynonym(std::string* language) {
   }
 
   // Apply linear search here because number of items in the list is just four.
-  for (size_t i = 0; i < base::size(kLanguageCodeSynonyms); ++i) {
-    if (main_part == kLanguageCodeSynonyms[i].chrome_language) {
-      main_part = std::string(kLanguageCodeSynonyms[i].translate_language);
+  for (const auto& language_pair : kLanguageCodeSynonyms) {
+    if (main_part == language_pair.chrome_language) {
+      main_part = language_pair.translate_language;
       break;
     }
   }
 
-  *language = main_part;
+  *language = std::string(main_part);
 }
 
 void ToChromeLanguageSynonym(std::string* language) {
-  for (size_t i = 0; i < base::size(kTranslateToChromeLanguageMap); ++i) {
-    if (*language == kTranslateToChromeLanguageMap[i].translate_language) {
-      *language = std::string(kTranslateToChromeLanguageMap[i].chrome_language);
+  for (const auto& language_pair : kTranslateToChromeLanguageMap) {
+    if (*language == language_pair.translate_language) {
+      *language = language_pair.chrome_language;
       return;
     }
   }
 
-  std::string main_part, tail_part;
-  language::SplitIntoMainAndTail(*language, &main_part, &tail_part);
+  base::StringPiece main_part, tail_part;
+  std::tie(main_part, tail_part) = language::SplitIntoMainAndTail(*language);
   if (main_part.empty())
     return;
 
-  // Apply liner search here because number of items in the list is just four.
-  for (size_t i = 0; i < base::size(kLanguageCodeSynonyms); ++i) {
-    if (main_part == kLanguageCodeSynonyms[i].translate_language) {
-      main_part = std::string(kLanguageCodeSynonyms[i].chrome_language);
+  // Apply linear search here because number of items in the list is just four.
+  for (const auto& language_pair : kLanguageCodeSynonyms) {
+    if (main_part == language_pair.translate_language) {
+      main_part = language_pair.chrome_language;
       break;
     }
   }
 
-  *language = main_part + tail_part;
+  *language = base::StrCat({main_part, tail_part});
 }
+
 }  // namespace language

components/language/core/common/locale_util.cc

@@ -4,13 +4,10 @@
 
 #include "components/language/core/common/locale_util.h"
 
+#include <stddef.h>
+
 #include <algorithm>
-#include <set>
-#include <vector>
 
-#include "base/command_line.h"
-#include "base/macros.h"
-#include "base/strings/string_split.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace language {
@@ -52,87 +49,61 @@ const LocaleUIFallbackPair kLocaleUIFallbackTable[] = {
     // clang-format on
 };
 
-bool LocaleCompare(const LocaleUIFallbackPair& p1, const std::string& p2) {
-  return p1.chosen_locale < p2;
-}
-
-bool GetUIFallbackLocale(const std::string& input, std::string* const output) {
-  *output = input;
-  const auto* it =
-      std::lower_bound(std::begin(kLocaleUIFallbackTable),
-                       std::end(kLocaleUIFallbackTable), input, LocaleCompare);
-  if (it != std::end(kLocaleUIFallbackTable) && it->chosen_locale == input) {
-    *output = it->fallback_locale;
-    return true;
-  }
-  return false;
+base::StringPiece GetUIFallbackLocale(base::StringPiece input) {
+  const auto* it = std::lower_bound(
+      std::begin(kLocaleUIFallbackTable), std::end(kLocaleUIFallbackTable),
+      input, [](const LocaleUIFallbackPair& p1, base::StringPiece p2) {
+        return p1.chosen_locale < p2;
+      });
+  if (it != std::end(kLocaleUIFallbackTable) && it->chosen_locale == input)
+    return it->fallback_locale;
+  return input;
 }
 
 // Checks if |locale| is one of the actual locales supported as a UI languages.
-bool IsAvailableUILocale(const std::string& locale) {
-  const std::vector<std::string>& ui_locales = l10n_util::GetAvailableLocales();
-  return std::find(ui_locales.begin(), ui_locales.end(), locale) !=
-         ui_locales.end();
-}
-
-}  // namespace
-
-void SplitIntoMainAndTail(const std::string& locale,
-                          std::string* main_part,
-                          std::string* tail_part) {
-  DCHECK(main_part);
-  DCHECK(tail_part);
-
-  std::vector<base::StringPiece> chunks = base::SplitStringPiece(
-      locale, "-", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-  if (chunks.empty())
-    return;
-
-  main_part->assign(chunks[0].data(), chunks[0].size());
-  *tail_part = locale.substr(main_part->size());
-}
-
-std::string ExtractBaseLanguage(const std::string& language_code) {
-  std::string base;
-  std::string tail;
-  SplitIntoMainAndTail(language_code, &base, &tail);
-  return base;
-}
-
-bool ContainsSameBaseLanguage(const std::vector<std::string>& list,
-                              const std::string& language_code) {
-  const std::string base_language = ExtractBaseLanguage(language_code);
-  for (const auto& item : list) {
-    const std::string compare_base = ExtractBaseLanguage(item);
-    if (compare_base == base_language)
+bool IsAvailableUILocale(base::StringPiece locale) {
+  for (const auto& ui_locale : l10n_util::GetAvailableLocales()) {
+    if (ui_locale == locale)
       return true;
   }
-
   return false;
 }
 
 bool ConvertToFallbackUILocale(std::string* input_locale) {
   // 1) Convert input to a fallback, if available.
-  std::string fallback;
-  GetUIFallbackLocale(*input_locale, &fallback);
+  base::StringPiece fallback = GetUIFallbackLocale(*input_locale);
 
   // 2) Check if input is part of the UI languages.
   if (IsAvailableUILocale(fallback)) {
-    *input_locale = fallback;
+    *input_locale = std::string(fallback);
     return true;
   }
 
   return false;
 }
 
+}  // namespace
+
+std::pair<base::StringPiece, base::StringPiece> SplitIntoMainAndTail(
+    base::StringPiece locale) {
+  size_t hyphen_pos = static_cast<size_t>(
+      std::find(locale.begin(), locale.end(), '-') - locale.begin());
+  return std::make_pair(locale.substr(0U, hyphen_pos),
+                        locale.substr(hyphen_pos));
+}
+
+base::StringPiece ExtractBaseLanguage(base::StringPiece language_code) {
+  return SplitIntoMainAndTail(language_code).first;
+}
+
 bool ConvertToActualUILocale(std::string* input_locale) {
   if (ConvertToFallbackUILocale(input_locale))
     return true;
 
   // Check if the base language of the input is part of the UI languages.
-  const std::string base = ExtractBaseLanguage(*input_locale);
+  base::StringPiece base = ExtractBaseLanguage(*input_locale);
   if (base != *input_locale && IsAvailableUILocale(base)) {
-    *input_locale = base;
+    *input_locale = std::string(base);
     return true;
   }
 

components/language/core/common/locale_util.h

@@ -6,29 +6,20 @@
 #define COMPONENTS_LANGUAGE_CORE_COMMON_LOCALE_UTIL_H_
 
 #include <string>
-#include <vector>
+#include <utility>
+
+#include "base/strings/string_piece.h"
 
 namespace language {
 
 // Split the |locale| into two parts. For example, if |locale| is 'en-US',
 // this will be split into the main part 'en' and the tail part '-US'.
-void SplitIntoMainAndTail(const std::string& locale,
-                          std::string* main_part,
-                          std::string* tail_part);
+std::pair<base::StringPiece, base::StringPiece> SplitIntoMainAndTail(
+    base::StringPiece locale);
 
 // Given a language code, extract the base language only.
 // Example: from "en-US", extract "en".
-std::string ExtractBaseLanguage(const std::string& language_code);
-
-// Returns whether or not the given list includes at least one language with
-// the same base as the input language.
-// For example: "en-US" and "en-UK" share the same base "en".
-bool ContainsSameBaseLanguage(const std::vector<std::string>& list,
-                              const std::string& language_code);
-
-// Converts |input_locale| to a fallback if needed and checks that the
-// resulting locale is supported as a UI locale.
-bool ConvertToFallbackUILocale(std::string* input_locale);
+base::StringPiece ExtractBaseLanguage(base::StringPiece language_code);
 
 // Converts the input locale into its corresponding actual UI locale that
 // Chrome should use for display and returns whether such locale exist.

components/language/core/common/locale_util_unittest.cc

@@ -8,90 +8,22 @@
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace language {
+namespace {
+
 typedef testing::Test LocaleUtilTest;
 
 TEST_F(LocaleUtilTest, SplitIntoMainAndTail) {
-  std::string locale;
-  std::string main;
-  std::string tail;
-
-  locale = "";
-  language::SplitIntoMainAndTail(locale, &main, &tail);
-  EXPECT_TRUE(main.empty());
-  EXPECT_TRUE(tail.empty());
-
-  locale = "en";
-  main.clear();
-  tail.clear();
-  language::SplitIntoMainAndTail(locale, &main, &tail);
-  EXPECT_EQ("en", main);
-  EXPECT_TRUE(tail.empty());
-
-  locale = "ogard543i";
-  main.clear();
-  tail.clear();
-  language::SplitIntoMainAndTail(locale, &main, &tail);
-  EXPECT_EQ("ogard543i", main);
-  EXPECT_TRUE(tail.empty());
-
-  locale = "en-AU";
-  main.clear();
-  tail.clear();
-  language::SplitIntoMainAndTail(locale, &main, &tail);
-  EXPECT_EQ("en", main);
-  EXPECT_EQ("-AU", tail);
-
-  locale = "es-419";
-  main.clear();
-  tail.clear();
-  language::SplitIntoMainAndTail(locale, &main, &tail);
-  EXPECT_EQ("es", main);
-  EXPECT_EQ("-419", tail);
-
-  locale = "en-AU-2009";
-  main.clear();
-  tail.clear();
-  language::SplitIntoMainAndTail(locale, &main, &tail);
-  EXPECT_EQ("en", main);
-  EXPECT_EQ("-AU-2009", tail);
-}
-
-TEST_F(LocaleUtilTest, ContainsSameBaseLanguage) {
-  std::vector<std::string> list;
-
-  // Empty input.
-  EXPECT_EQ(false, language::ContainsSameBaseLanguage(list, ""));
-
-  // Empty list.
-  EXPECT_EQ(false, language::ContainsSameBaseLanguage(list, "fr-FR"));
-
-  // Empty language.
-  list = {"en-US"};
-  EXPECT_EQ(false, language::ContainsSameBaseLanguage(list, ""));
-
-  // One element, no match.
-  list = {"en-US"};
-  EXPECT_EQ(false, language::ContainsSameBaseLanguage(list, "fr-FR"));
-
-  // One element, with match.
-  list = {"fr-CA"};
-  EXPECT_EQ(true, language::ContainsSameBaseLanguage(list, "fr-FR"));
-
-  // Multiple elements, no match.
-  list = {"en-US", "es-AR", "en-GB"};
-  EXPECT_EQ(false, language::ContainsSameBaseLanguage(list, "fr-FR"));
-
-  // Multiple elements, with match.
-  list = {"en-US", "fr-CA", "es-AR"};
-  EXPECT_EQ(true, language::ContainsSameBaseLanguage(list, "fr-FR"));
-
-  // Multiple elements matching.
-  list = {"en-US", "fr-CA", "es-AR", "fr-FR"};
-  EXPECT_EQ(true, language::ContainsSameBaseLanguage(list, "fr-FR"));
-
-  // List includes base language.
-  list = {"en-US", "fr", "es-AR", "fr-FR"};
-  EXPECT_EQ(true, language::ContainsSameBaseLanguage(list, "fr-FR"));
+  typedef std::pair<base::StringPiece, base::StringPiece> StringPiecePair;
+
+  EXPECT_EQ(StringPiecePair("", ""), SplitIntoMainAndTail(""));
+  EXPECT_EQ(StringPiecePair("en", ""), SplitIntoMainAndTail("en"));
+  EXPECT_EQ(StringPiecePair("ogard543i", ""),
+            SplitIntoMainAndTail("ogard543i"));
+  EXPECT_EQ(StringPiecePair("en", "-AU"), SplitIntoMainAndTail("en-AU"));
+  EXPECT_EQ(StringPiecePair("es", "-419"), SplitIntoMainAndTail("es-419"));
+  EXPECT_EQ(StringPiecePair("en", "-AU-2009"),
+            SplitIntoMainAndTail("en-AU-2009"));
 }
 
 TEST_F(LocaleUtilTest, ConvertToActualUILocale) {
@@ -101,17 +33,17 @@ TEST_F(LocaleUtilTest, ConvertToActualUILocale) {
   // Languages that are enabled as display UI.
   //---------------------------------------------------------------------------
   locale = "en-US";
-  bool is_ui = language::ConvertToActualUILocale(&locale);
+  bool is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("en-US", locale);
 
   locale = "it";
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("it", locale);
 
   locale = "fr-FR";
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("fr-FR", locale);
 
@@ -120,115 +52,51 @@ TEST_F(LocaleUtilTest, ConvertToActualUILocale) {
   //---------------------------------------------------------------------------
 
   // All Latin American Spanish languages fall back to "es-419".
-  locale = "es-AR";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-CL";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-CO";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-CR";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-HN";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-MX";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-PE";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-US";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-UY";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
-
-  locale = "es-VE";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("es-419", locale);
+  for (const char* es_locale : {"es-AR", "es-CL", "es-CO", "es-CR", "es-HN",
+                                "es-MX", "es-PE", "es-US", "es-UY", "es-VE"}) {
+    locale = es_locale;
+    is_ui = ConvertToActualUILocale(&locale);
+    EXPECT_TRUE(is_ui) << es_locale;
+    EXPECT_EQ("es-419", locale) << es_locale;
+  }
 
   // English falls back to US.
   locale = "en";
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("en-US", locale);
 
   // All other regional English languages fall back to UK.
-  locale = "en-AU";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("en-GB", locale);
-
-  locale = "en-CA";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("en-GB", locale);
-
-  locale = "en-GB-oxendict";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("en-GB", locale);
-
-  locale = "en-IN";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("en-GB", locale);
-
-  locale = "en-NZ";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("en-GB", locale);
-
-  locale = "en-ZA";
-  is_ui = language::ConvertToActualUILocale(&locale);
-  EXPECT_TRUE(is_ui);
-  EXPECT_EQ("en-GB", locale);
+  for (const char* en_locale :
+       {"en-AU", "en-CA", "en-GB-oxendict", "en-IN", "en-NZ", "en-ZA"}) {
+    locale = en_locale;
+    is_ui = ConvertToActualUILocale(&locale);
+    EXPECT_TRUE(is_ui) << en_locale;
+    EXPECT_EQ("en-GB", locale) << en_locale;
+  }
 
   locale = "pt";
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("pt-PT", locale);
 
   locale = "it-CH";
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("it", locale);
 
   locale = "no";
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("nb", locale);
 
   locale = "it-IT";
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("it-IT", locale);
 
   locale = "de-DE";
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_TRUE(is_ui);
   EXPECT_EQ("de-DE", locale);
 
@@ -239,23 +107,26 @@ TEST_F(LocaleUtilTest, ConvertToActualUILocale) {
 // where users can set the display UI.
 #if defined(OS_CHROMEOS) || defined(OS_WIN)
   locale = "sd";  // Sindhi
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_FALSE(is_ui);
 
   locale = "af";  // Afrikaans
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_FALSE(is_ui);
 
   locale = "ga";  // Irish
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_FALSE(is_ui);
 
   locale = "ky";  // Kyrgyz
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_FALSE(is_ui);
 
   locale = "zu";  // Zulu
-  is_ui = language::ConvertToActualUILocale(&locale);
+  is_ui = ConvertToActualUILocale(&locale);
   EXPECT_FALSE(is_ui);
 #endif
 }
+
+}  // namespace
+}  // namespace language

components/translate/core/browser/translate_manager.cc

@@ -6,6 +6,8 @@
 
 #include <map>
 #include <memory>
+#include <tuple>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ -13,6 +15,7 @@
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ -613,31 +616,33 @@ bool TranslateManager::ShouldSuppressBubbleUI(
 
 void TranslateManager::AddTargetLanguageToAcceptLanguages(
     const std::string& target_language_code) {
-  std::string target_language, tail;
+  auto prefs = translate_client_->GetTranslatePrefs();
+  std::vector<std::string> languages;
+  prefs->GetLanguageList(&languages);
+
+  base::StringPiece target_language, tail;
   // |target_language_code| should satisfy BCP47 and consist of a language code
   // and an optional region code joined by an hyphen.
-  language::SplitIntoMainAndTail(target_language_code, &target_language, &tail);
+  std::tie(target_language, tail) =
+      language::SplitIntoMainAndTail(target_language_code);
 
-  std::function<bool(const std::string&)> is_redundant;
+  // Don't add the target language if it's redundant with another already in the
+  // list.
   if (tail.empty()) {
-    is_redundant = [&target_language](const std::string& language) {
-      return language::ExtractBaseLanguage(language) == target_language;
-    };
+    for (const auto& language : languages) {
+      if (language::ExtractBaseLanguage(language) == target_language)
+        return;
+    }
   } else {
-    is_redundant = [&target_language_code](const std::string& language) {
-      return language == target_language_code;
-    };
+    for (const auto& language : languages) {
+      if (language == target_language_code)
+        return;
+    }
   }
 
-  auto prefs = translate_client_->GetTranslatePrefs();
-  std::vector<std::string> languages;
-  prefs->GetLanguageList(&languages);
-
-  // Only add the target language if it's not redundant with another already in
-  // the list, and if it's not an automatic target (such as when translation
-  // happens because of an hrefTranslate navigation).
-  if (std::none_of(languages.begin(), languages.end(), is_redundant) &&
-      language_state_.AutoTranslateTo() != target_language_code &&
+  // Only add the target language if it's not an automatic target (such as when
+  // translation happens because of an hrefTranslate navigation).
+  if (language_state_.AutoTranslateTo() != target_language_code &&
       language_state_.href_translate() != target_language_code) {
     prefs->AddToLanguageList(target_language_code, /*force_blocked=*/false);
   }

components/translate/core/browser/translate_prefs.cc

@@ -38,6 +38,24 @@
 
 namespace translate {
 
+namespace {
+
+// Returns whether or not the given list includes at least one language with
+// the same base as the input language.
+// For example: "en-US" and "en-UK" share the same base "en".
+bool ContainsSameBaseLanguage(const std::vector<std::string>& list,
+                              base::StringPiece language_code) {
+  base::StringPiece base_language =
+      language::ExtractBaseLanguage(language_code);
+  for (const auto& item : list) {
+    if (base_language == language::ExtractBaseLanguage(item))
+      return true;
+  }
+  return false;
+}
+
+}  // namespace
+
 const char kForceTriggerTranslateCount[] =
     "translate_force_trigger_on_english_count_for_backoff_1";
 const char TranslatePrefs::kPrefTranslateSiteBlacklistDeprecated[] =
@@ -222,7 +240,7 @@ void TranslatePrefs::AddToLanguageList(const std::string& input_language,
   // We should block the language if the list does not already contain another
   // language with the same base language.
   const bool should_block =
-      !language::ContainsSameBaseLanguage(languages, chrome_language);
+      !ContainsSameBaseLanguage(languages, chrome_language);
 
   if (force_blocked || should_block) {
     BlockLanguage(input_language);
@@ -260,7 +278,7 @@ void TranslatePrefs::RemoveFromLanguageList(const std::string& input_language) {
 
     // We should unblock the language if this was the last one from the same
     // language family.
-    if (!language::ContainsSameBaseLanguage(languages, chrome_language)) {
+    if (!ContainsSameBaseLanguage(languages, chrome_language)) {
       UnblockLanguage(input_language);
     }
   }
@@ -943,13 +961,13 @@ bool TranslatePrefs::IsDictionaryEmpty(const char* pref_id) const {
 void TranslatePrefs::PurgeUnsupportedLanguagesInLanguageFamily(
     const std::string& language,
     std::vector<std::string>* list) {
-  std::string base_language = language::ExtractBaseLanguage(language);
+  base::StringPiece base_language = language::ExtractBaseLanguage(language);
   std::set<std::string> languages_in_same_family;
 
   std::copy_if(
       list->begin(), list->end(),
       std::inserter(languages_in_same_family, languages_in_same_family.end()),
-      [&base_language](const std::string& lang) {
+      [base_language](const std::string& lang) {
         return base_language == language::ExtractBaseLanguage(lang);
       });