Fix a NOTIMPLEMENTED() in l10n_util.cc from it expecting .dll in the file name.

chrome/common/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 "build/build_config.h"
 
 #include "chrome/common/l10n_util.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/resource_bundle.h"
 
 // TODO(playmobil): remove this undef once SkPostConfig.h is fixed.
 // skia/include/corecg/SkPostConfig.h #defines strcasecmp() so we can't use
 // base::strcasecmp() without #undefing it here.
 #undef strcasecmp
 
 namespace {
 
+#if defined(OS_WIN)
+static const FilePath::CharType kLocaleFileExtension[] = L".dll";
+#elif defined(OS_POSIX)
+static const FilePath::CharType kLocaleFileExtension[] = ".pak";
+#endif
+
 // Added to the end of strings that are too big in TrucateString.
 static const wchar_t* const kElideString = L"\x2026";
 
 // 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.
   Locale locale = Locale::getDefault();
   const char* language = locale.getLanguage();
   const char* country = locale.getCountry();
   DCHECK(language);
   *lang = language;
   *region = country;
 }
 
-// Convert Chrome locale name (DLL name) to ICU locale name
+// Convert Chrome locale name to ICU locale name
 std::string ICULocaleName(const std::wstring& locale_string) {
   // If not Spanish, just return it.
   if (locale_string.substr(0, 2) != L"es")
     return WideToASCII(locale_string);
   // Expand es to es-ES.
   if (LowerCaseEqualsASCII(locale_string, "es"))
     return "es-ES";
   // Map es-419 (Latin American Spanish) to es-FOO depending on the system
   // locale.  If it's es-RR other than es-ES, map to es-RR. Otherwise, map
   // to es-MX (the most populous in Spanish-speaking Latin America).
@@ skipping 51 matching lines @@
     if (base::strcasecmp(kDuplicateNames[i], locale_name.c_str()) == 0)
       return true;
   }
   return false;
 }
 
 bool IsLocaleAvailable(const std::wstring& locale,
                        const std::wstring& locale_path) {
   std::wstring test_locale = locale;
   // 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 dll directory.
+  // load it because it may be pointing outside the locale data file directory.
   file_util::ReplaceIllegalCharacters(&test_locale, ' ');
   if (test_locale != locale)
     return false;
 
-  std::wstring test_path = locale_path;
-  file_util::AppendToPath(&test_path, locale + L".dll");
+  FilePath test_path = FilePath::FromWStringHack(locale_path)
+      .Append(FilePath::FromWStringHack(locale))
+      .ReplaceExtension(kLocaleFileExtension);
   return file_util::PathExists(test_path) && SetICUDefaultLocale(locale);
 }
 
 bool CheckAndResolveLocale(const std::wstring& locale,
                            const std::wstring& locale_path,
                            std::wstring* resolved_locale) {
   if (IsLocaleAvailable(locale, locale_path)) {
     *resolved_locale = locale;
     return true;
   }
@@ skipping 96 matching lines @@
   // Next, try the system locale.
   const std::wstring system_locale = GetSystemLocale();
   if (CheckAndResolveLocale(system_locale, locale_path, &resolved_locale))
     return resolved_locale;
 
   // Fallback on en-US.
   const std::wstring fallback_locale(L"en-US");
   if (IsLocaleAvailable(fallback_locale, locale_path))
     return fallback_locale;
 
-#if defined(OS_WIN)
-  // No DLL, we shouldn't get here.
+  // No locale data file was found; we shouldn't get here.
   NOTREACHED();
-#else
-  // We need a locale data file.
-  NOTIMPLEMENTED();
-#endif
 
   return std::wstring();
 }
 
 std::wstring GetLocalName(const std::wstring& locale_code_wstr,
                           const std::wstring& app_locale_wstr,
                           bool is_for_ui) {
   std::string locale_code_str = WideToASCII(locale_code_wstr);
   const std::string app_locale = WideToASCII(app_locale_wstr);
   const char* locale_code = locale_code_str.c_str();
@@ skipping 385 matching lines @@
 
 const std::vector<std::wstring>& GetAvailableLocales() {
   static std::vector<std::wstring> locales;
   if (locales.empty()) {
     int num_locales = uloc_countAvailable();
     for (int i = 0; i < num_locales; ++i) {
       std::string locale_name = uloc_getAvailable(i);
       // Filter out the names that have aliases.
       if (IsDuplicateName(locale_name))
         continue;
-      // Normalize underscores to hyphens because that's what our locale dlls
+      // Normalize underscores to hyphens because that's what our locale files
       // use.
       std::replace(locale_name.begin(), locale_name.end(), '_', '-');
 
       // Map the Chinese locale names over to zh-CN and zh-TW.
       if (LowerCaseEqualsASCII(locale_name, "zh-hans")) {
         locale_name = "zh-CN";
       } else if (LowerCaseEqualsASCII(locale_name, "zh-hant")) {
         locale_name = "zh-TW";
       }
       locales.push_back(ASCIIToWide(locale_name));
@@ skipping 48 matching lines @@
 }
 
 void BiDiLineIterator::GetLogicalRun(int start,
                                      int* end,
                                      UBiDiLevel* level) {
   DCHECK(bidi_ != NULL);
   ubidi_getLogicalRun(bidi_, start, end, level);
 }
 
 }