Move two locale functions from rtl.h into l10n_util.h

ui/base/l10n/l10n_util.cc

 // Copyright (c) 2012 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 "ui/base/l10n/l10n_util.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <iterator>
 #include <string>
@@ skipping 285 matching lines @@
       }
       locales->push_back(locale_name);
     }
 
     // Manually add 'es-419' to the list. See the comment in IsDuplicateName().
     locales->push_back("es-419");
     return locales;
   }
 };
 
+// Extract language, country and variant, but ignore keywords.  For example,
+// en-US, ca@valencia, ca-ES@valencia.
+std::string GetLocaleString(const icu::Locale& locale) {
+  const char* language = locale.getLanguage();
+  const char* country = locale.getCountry();
+  const char* variant = locale.getVariant();
+
+  std::string result =
+      (language != NULL && *language != '\0') ? language : "und";
+
+  if (country != NULL && *country != '\0') {
+    result += '-';
+    result += country;
+  }
+
+  if (variant != NULL && *variant != '\0') {
+    std::string variant_str(variant);
+    base::StringToLowerASCII(&variant_str);
+    result += '@' + variant_str;
+  }
+
+  return result;
+}
+
 base::LazyInstance<std::vector<std::string>, AvailableLocalesTraits>
     g_available_locales = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace l10n_util {
 
+// Convert the ICU default locale to a string.
+std::string GetConfiguredLocale() {
+  return GetLocaleString(icu::Locale::getDefault());
+}
+
+// Convert the ICU canonicalized locale to a string.
+std::string GetCanonicalLocale(const char* locale) {
+  return GetLocaleString(icu::Locale::createCanonical(locale));
+}
+
 std::string GetCanonicalLocale(const std::string& locale) {
-  return base::i18n::GetCanonicalLocale(locale.c_str());
+  return GetCanonicalLocale(locale.c_str());
 }
 
 std::string GetLanguage(const std::string& locale) {
   const std::string::size_type hyphen_pos = locale.find('-');
   return std::string(locale, 0, hyphen_pos);
 }
 
 bool CheckAndResolveLocale(const std::string& locale,
                            std::string* resolved_locale) {
 #if defined(OS_MACOSX)
@@ skipping 112 matching lines @@
     candidates.push_back(GetCanonicalLocale(pref_locale));
 
   // Next, try the overridden locale.
   const std::vector<std::string>& languages = l10n_util::GetLocaleOverrides();
   if (!languages.empty()) {
     candidates.reserve(candidates.size() + languages.size());
     std::transform(languages.begin(), languages.end(),
                    std::back_inserter(candidates), &GetCanonicalLocale);
   } else {
     // If no override was set, defer to ICU
-    candidates.push_back(base::i18n::GetConfiguredLocale());
+    candidates.push_back(GetConfiguredLocale());
   }
 
 #elif defined(OS_ANDROID)
 
   // On Android, query java.util.Locale for the default locale.
   candidates.push_back(base::android::GetDefaultLocale());
 
 #elif defined(USE_GLIB) && !defined(OS_CHROMEOS)
 
   // GLib implements correct environment variable parsing with
   // the precedence order: LANGUAGE, LC_ALL, LC_MESSAGES and LANG.
   // We used to use our custom parsing code along with ICU for this purpose.
   // If we have a port that does not depend on GTK, we have to
   // restore our custom code for that port.
   const char* const* languages = g_get_language_names();
   DCHECK(languages);  // A valid pointer is guaranteed.
   DCHECK(*languages);  // At least one entry, "C", is guaranteed.
 
   for (; *languages != NULL; ++languages) {
-    candidates.push_back(base::i18n::GetCanonicalLocale(*languages));
+    candidates.push_back(GetCanonicalLocale(*languages));
   }
 
 #else
 
   // By default, use the application locale preference. This applies to ChromeOS
   // and linux systems without glib.
   if (!pref_locale.empty())
     candidates.push_back(pref_locale);
 
 #endif
@@ skipping 400 matching lines @@
 
 const char* const* GetAcceptLanguageListForTesting() {
   return kAcceptLanguageList;
 }
 
 size_t GetAcceptLanguageListSizeForTesting() {
   return arraysize(kAcceptLanguageList);
 }
 
 }  // namespace l10n_util