base/i18n/icu_util.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/i18n/icu_util.h"
   6
   7 #if defined(OS_WIN)
   8 #include <windows.h>
   9 #endif
  10
  11 #include <string>
  12
  13 #include "base/files/file_path.h"
  14 #include "base/files/memory_mapped_file.h"
  15 #include "base/logging.h"
  16 #include "base/path_service.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/sys_string_conversions.h"
  19 #include "third_party/icu/source/common/unicode/putil.h"
  20 #include "third_party/icu/source/common/unicode/udata.h"
  21
  22 #if defined(OS_MACOSX)
  23 #include "base/mac/foundation_util.h"
  24 #endif
  25
  26 #define ICU_UTIL_DATA_FILE   0
  27 #define ICU_UTIL_DATA_SHARED 1
  28 #define ICU_UTIL_DATA_STATIC 2
  29
  30 #if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
  31 // Use an unversioned file name to simplify a icu version update down the road.
  32 // No need to change the filename in multiple places (gyp files, windows
  33 // build pkg configurations, etc). 'l' stands for Little Endian.
  34 #define ICU_UTIL_DATA_FILE_NAME "icudtl.dat"
  35 #elif ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_SHARED
  36 #define ICU_UTIL_DATA_SYMBOL "icudt" U_ICU_VERSION_SHORT "_dat"
  37 #if defined(OS_WIN)
  38 #define ICU_UTIL_DATA_SHARED_MODULE_NAME "icudt.dll"
  39 #endif
  40 #endif
  41
  42 namespace base {
  43 namespace i18n {
  44
  45 namespace {
  46
  47 #if !defined(NDEBUG)
  48 // Assert that we are not called more than once.  Even though calling this
  49 // function isn't harmful (ICU can handle it), being called twice probably
  50 // indicates a programming error.
  51 bool g_called_once = false;
  52 bool g_check_called_once = true;
  53 #endif
  54 }
  55
  56
  57 #if defined(OS_ANDROID)
  58 bool InitializeICUWithFileDescriptor(int data_fd) {
  59 #if !defined(NDEBUG)
  60   DCHECK(!g_check_called_once || !g_called_once);
  61   g_called_once = true;
  62 #endif
  63
  64 #if (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_STATIC)
  65   // The ICU data is statically linked.
  66   return true;
  67 #elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE)
  68   CR_DEFINE_STATIC_LOCAL(base::MemoryMappedFile, mapped_file, ());
  69   if (!mapped_file.IsValid()) {
  70     if (!mapped_file.Initialize(base::File(data_fd))) {
  71       LOG(ERROR) << "Couldn't mmap icu data file";
  72       return false;
  73     }
  74   }
  75   UErrorCode err = U_ZERO_ERROR;
  76   udata_setCommonData(const_cast<uint8*>(mapped_file.data()), &err);
  77   return err == U_ZERO_ERROR;
  78 #endif // ICU_UTIL_DATA_FILE
  79 }
  80 #endif
  81
  82
  83 bool InitializeICU() {
  84 #if !defined(NDEBUG)
  85   DCHECK(!g_check_called_once || !g_called_once);
  86   g_called_once = true;
  87 #endif
  88
  89 #if (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_SHARED)
  90   // We expect to find the ICU data module alongside the current module.
  91   FilePath data_path;
  92   PathService::Get(base::DIR_MODULE, &data_path);
  93   data_path = data_path.AppendASCII(ICU_UTIL_DATA_SHARED_MODULE_NAME);
  94
  95   HMODULE module = LoadLibrary(data_path.value().c_str());
  96   if (!module) {
  97     LOG(ERROR) << "Failed to load " << ICU_UTIL_DATA_SHARED_MODULE_NAME;
  98     return false;
  99   }
 100
 101   FARPROC addr = GetProcAddress(module, ICU_UTIL_DATA_SYMBOL);
 102   if (!addr) {
 103     LOG(ERROR) << ICU_UTIL_DATA_SYMBOL << ": not found in "
 104                << ICU_UTIL_DATA_SHARED_MODULE_NAME;
 105     return false;
 106   }
 107
 108   UErrorCode err = U_ZERO_ERROR;
 109   udata_setCommonData(reinterpret_cast<void*>(addr), &err);
 110   return err == U_ZERO_ERROR;
 111 #elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_STATIC)
 112   // The ICU data is statically linked.
 113   return true;
 114 #elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE)
 115   // If the ICU data directory is set, ICU won't actually load the data until
 116   // it is needed.  This can fail if the process is sandboxed at that time.
 117   // Instead, we map the file in and hand off the data so the sandbox won't
 118   // cause any problems.
 119
 120   // Chrome doesn't normally shut down ICU, so the mapped data shouldn't ever
 121   // be released.
 122   CR_DEFINE_STATIC_LOCAL(base::MemoryMappedFile, mapped_file, ());
 123   if (!mapped_file.IsValid()) {
 124 #if !defined(OS_MACOSX)
 125     FilePath data_path;
 126 #if defined(OS_WIN)
 127     // The data file will be in the same directory as the current module.
 128     bool path_ok = PathService::Get(base::DIR_MODULE, &data_path);
 129 #elif defined(OS_ANDROID)
 130     bool path_ok = PathService::Get(base::DIR_ANDROID_APP_DATA, &data_path);
 131 #else
 132     // For now, expect the data file to be alongside the executable.
 133     // This is sufficient while we work on unit tests, but will eventually
 134     // likely live in a data directory.
 135     bool path_ok = PathService::Get(base::DIR_EXE, &data_path);
 136 #endif
 137     DCHECK(path_ok);
 138     data_path = data_path.AppendASCII(ICU_UTIL_DATA_FILE_NAME);
 139 #else
 140     // Assume it is in the framework bundle's Resources directory.
 141     FilePath data_path =
 142       base::mac::PathForFrameworkBundleResource(CFSTR(ICU_UTIL_DATA_FILE_NAME));
 143     if (data_path.empty()) {
 144       LOG(ERROR) << ICU_UTIL_DATA_FILE_NAME << " not found in bundle";
 145       return false;
 146     }
 147 #endif  // OS check
 148     if (!mapped_file.Initialize(data_path)) {
 149       LOG(ERROR) << "Couldn't mmap " << data_path.AsUTF8Unsafe();
 150       return false;
 151     }
 152   }
 153   UErrorCode err = U_ZERO_ERROR;
 154   udata_setCommonData(const_cast<uint8*>(mapped_file.data()), &err);
 155   return err == U_ZERO_ERROR;
 156 #endif
 157 }
 158
 159 void AllowMultipleInitializeCallsForTesting() {
 160 #if !defined(NDEBUG)
 161   g_check_called_once = false;
 162 #endif
 163 }
 164
 165 }  // namespace i18n
 166 }  // namespace base