Setting the ICU default locale is made explicit. This leads to a few more...

app/l10n_util.cc

 // Copyright (c) 2006-2008 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 "app/l10n_util.h"
 
 #include <cstdlib>
 #include "app/app_paths.h"
 #include "app/app_switches.h"
 #include "app/gfx/canvas.h"
@@ skipping 170 matching lines @@
   "zh-TW",  // Chinese (Traditional)
   "zu",     // Zulu
 };
 
 
 // Get language and region from the OS.
 void GetLanguageAndRegionFromOS(std::string* lang, std::string* region) {
   // Later we may have to change this to be OS-dependent so that
   // it's not affected by ICU's default locale. It's all right
   // to do this way because SetICUDefaultLocale is internal
-  // to this file and we know where/when it's called.
+  // to this file and we know that it's not yet called when this function
+  // is called.
   icu::Locale locale = icu::Locale::getDefault();
   const char* language = locale.getLanguage();
   const char* country = locale.getCountry();
   DCHECK(language);
   *lang = language;
   *region = country;
 }
 
 // Convert Chrome locale name to ICU locale name
 std::string ICULocaleName(const std::string& locale_string) {
@@ skipping 16 matching lines @@
       return lang;
     }
     return "es-MX";
   }
   // Currently, Chrome has only "es" and "es-419", but later we may have
   // more specific "es-RR".
   return locale_string;
 }
 
 // Sets the default locale of ICU.
-// When the application locale (UI locale) of Chrome is specified with
-// '--lang' command line flag or 'intl.app_locale' entry in the "Preferences",
+// Once the application locale of Chrome in GetApplicationLocale is determined,
 // the default locale of ICU need to be changed to match the application locale
 // so that ICU functions work correctly in a locale-dependent manner.
 // This is handy in that we don't have to call GetApplicationLocale()
 // everytime we call locale-dependent ICU APIs as long as we make sure
 // that this is called before any locale-dependent API is called.
-UBool SetICUDefaultLocale(const std::string& locale_string) {
+void SetICUDefaultLocale(const std::string& locale_string) {
   icu::Locale locale(ICULocaleName(locale_string).c_str());
   UErrorCode error_code = U_ZERO_ERROR;
   icu::Locale::setDefault(locale, error_code);
   // This return value is actually bogus because Locale object is
   // an ID and setDefault seems to always succeed (regardless of the
   // presence of actual locale data). However,
   // it does not hurt to have it as a sanity check.
-  return U_SUCCESS(error_code);
+  DCHECK(U_SUCCESS(error_code));
 }
 
 // Returns true if |locale_name| has an alias in the ICU data file.
 bool IsDuplicateName(const std::string& locale_name) {
   static const char* const kDuplicateNames[] = {
     "en",
     "pt",
     "zh",
     "zh_hans_cn",
     "zh_hant_tw"
@@ skipping 36 matching lines @@
   return !IsLocaleNameTranslated("en", locale_name);
 }
 
 bool IsLocaleAvailable(const std::string& locale,
                        const FilePath& locale_path) {
   // If locale has any illegal characters in it, we don't want to try to
   // load it because it may be pointing outside the locale data file directory.
   if (!file_util::IsFilenameLegal(ASCIIToUTF16(locale)))
     return false;
 
+  // IsLocalePartiallyPopulated() can be called here for an early return w/o
+  // checking the resource availability below. It'd help when Chrome is run
+  // under a system locale Chrome is not localized to (e.g.Farsi on Linux),
+  // but it'd slow down the start up time a little bit for locales Chrome is
+  // localized to. So, we don't call it here.
   if (!l10n_util::IsLocaleSupportedByOS(locale))
     return false;
 
   FilePath test_path = locale_path;
   test_path =
     test_path.AppendASCII(locale).ReplaceExtension(kLocaleFileExtension);
-  return file_util::PathExists(test_path) && SetICUDefaultLocale(locale);
+  return file_util::PathExists(test_path);
 }
 
 bool CheckAndResolveLocale(const std::string& locale,
                            const FilePath& locale_path,
                            std::string* resolved_locale) {
   if (IsLocaleAvailable(locale, locale_path)) {
     *resolved_locale = locale;
     return true;
   }
   // If the locale matches language but not country, use that instead.
   // TODO(jungshik) : Nothing is done about languages that Chrome
   // does not support but available on Windows. We fall
   // back to en-US in GetApplicationLocale so that it's a not critical,
   // but we can do better.
-  std::string::size_type hyphen_pos = locale.find(L'-');
+  std::string::size_type hyphen_pos = locale.find('-');
   if (hyphen_pos != std::string::npos && hyphen_pos > 0) {
     std::string lang(locale, 0, hyphen_pos);
     std::string region(locale, hyphen_pos + 1);
     std::string tmp_locale(lang);
     // Map es-RR other than es-ES to es-419 (Chrome's Latin American
     // Spanish locale).
     if (LowerCaseEqualsASCII(lang, "es") && !LowerCaseEqualsASCII(region, "es"))
       tmp_locale.append("-419");
     else if (LowerCaseEqualsASCII(lang, "zh")) {
       // Map zh-HK and zh-MK to zh-TW. Otherwise, zh-FOO is mapped to zh-CN.
@@ skipping 124 matching lines @@
 #elif defined(OS_LINUX)
   // On Linux, we also check LANGUAGE environment variable, which is supported
   // by gettext to specify a priority list of prefered languages.
   const char* env_language = ::getenv("LANGUAGE");
   if (env_language)
     SplitAndNormalizeLanguageList(env_language, &candidates);
 
   // Only fallback to the system locale if LANGUAGE is not specified.
   // We emulate gettext's behavior here, which ignores LANG/LC_MESSAGES/LC_ALL
   // when LANGUAGE is specified. If no language specified in LANGUAGE is valid,
-  // then just fallback to the default language, which is en-US for us.
+  // then just fallback to the locale based on LC_ALL/LANG.
   if (candidates.empty())
     candidates.push_back(system_locale);
 #endif
 
   std::vector<std::string>::const_iterator i = candidates.begin();
   for (; i != candidates.end(); ++i) {
-    if (CheckAndResolveLocale(*i, locale_path, &resolved_locale))
+    if (CheckAndResolveLocale(*i, locale_path, &resolved_locale)) {
+      SetICUDefaultLocale(resolved_locale);
       return resolved_locale;
+    }
   }
 
   // Fallback on en-US.
   const std::string fallback_locale("en-US");
-  if (IsLocaleAvailable(fallback_locale, locale_path))
+  if (IsLocaleAvailable(fallback_locale, locale_path)) {
+    SetICUDefaultLocale(fallback_locale);
     return fallback_locale;
+  }
 
   // No locale data file was found; we shouldn't get here.
   NOTREACHED();
 
   return std::string();
 
 #else  // !defined(OS_MACOSX)
 
   // Use any override (Cocoa for the browser), otherwise use the command line
   // argument.
   std::string app_locale = l10n_util::GetLocaleOverride();
   if (app_locale.empty()) {
     const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
     app_locale = parsed_command_line.GetSwitchValueASCII(switches::kLang);
   }
 
   // The above should handle all of the cases Chrome normally hits, but for some
   // unit tests, we need something to fall back too.
   if (app_locale.empty())
     app_locale = "en-US";
 
-  // Windows/Linux call CheckAndResolveLocale which calls IsLocaleAvailable
-  // which calls SetICUDefaultLocale to let ICU use the same locale.  Mac
-  // doesn't use a locale directory tree of resources (it uses Mac style
-  // resources), so mirror that ICU behavior by calling SetICUDefaultLocale
-  // directly.
-  UBool icu_set = SetICUDefaultLocale(app_locale);
-  DCHECK(icu_set);
+  // Windows/Linux call SetICUDefaultLocale after determining the actual locale
+  // with CheckAndResolveLocal to make ICU APIs work in that locale.
+  // Mac doesn't use a locale directory tree of resources (it uses Mac style
+  // resources), so mirror the Windows/Linux behavior of calling
+  // SetICUDefaultLocale.
+  SetICUDefaultLocale(app_locale);
   return app_locale;
 #endif  // !defined(OS_MACOSX)
 }
 
 string16 GetDisplayNameForLocale(const std::string& locale_code,
                                  const std::string& display_locale,
                                  bool is_for_ui) {
   UErrorCode error = U_ZERO_ERROR;
   const int buffer_size = 1024;
 
@@ skipping 258 matching lines @@
         (gtk_dir == GTK_TEXT_DIR_LTR) ? LEFT_TO_RIGHT : RIGHT_TO_LEFT;
 #else
     const icu::Locale& locale = icu::Locale::getDefault();
     g_text_direction = GetTextDirectionForLocale(locale.getName());
 #endif
   }
   return g_text_direction;
 }
 
 TextDirection GetTextDirectionForLocale(const char* locale_name) {
-  UScriptCode scripts[10];  // 10 scripts should be enough for any locale.
-  UErrorCode error = U_ZERO_ERROR;
-  int n = uscript_getCode(locale_name, scripts, 10, &error);
-  DCHECK(U_SUCCESS(error) && n > 0);
-
-  // Checking Arabic and Hebrew scripts cover Arabic, Hebrew, Farsi,
-  // Urdu and Azerbaijani written in Arabic. Syriac script
-  // (another RTL) is not a living script and we didn't yet localize
-  // to locales using other living RTL scripts such as Thaana and N'ko.
-  // TODO(jungshik): Use a new ICU API, uloc_getCharacterOrientation to avoid
-  // 'hardcoded-comparision' with Arabic and Hebrew scripts once we
-  // upgrade ICU to 4.0 or later or port it to our copy of ICU.
-  if (scripts[0] == USCRIPT_ARABIC || scripts[0] == USCRIPT_HEBREW)
-    return RIGHT_TO_LEFT;
-  return LEFT_TO_RIGHT;
+  UErrorCode status = U_ZERO_ERROR;
+  ULayoutType layout_dir = uloc_getCharacterOrientation(locale_name, &status);
+  DCHECK(U_SUCCESS(status));
+  // Treat anything other than RTL as LTR.
+  return (layout_dir != ULOC_LAYOUT_RTL) ? LEFT_TO_RIGHT : RIGHT_TO_LEFT;
 }
 
 TextDirection GetFirstStrongCharacterDirection(const std::wstring& text) {
 #if defined(WCHAR_T_IS_UTF32)
   string16 text_utf16 = WideToUTF16(text);
   const UChar* string = text_utf16.c_str();
 #else
   const UChar* string = text.c_str();
 #endif
   size_t length = text.length();
@@ skipping 248 matching lines @@
 }
 
 void BiDiLineIterator::GetLogicalRun(int start,
                                      int* end,
                                      UBiDiLevel* level) {
   DCHECK(bidi_ != NULL);
   ubidi_getLogicalRun(bidi_, start, end, level);
 }
 
 }  // namespace l10n_util