| OLD | NEW |
|---|
| (Empty) |
| 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/debug/alias.h" | |
| 14 #include "base/files/file_path.h" | |
| 15 #include "base/files/memory_mapped_file.h" | |
| 16 #include "base/logging.h" | |
| 17 #include "base/path_service.h" | |
| 18 #include "base/strings/string_util.h" | |
| 19 #include "base/strings/sys_string_conversions.h" | |
| 20 #include "third_party/icu/source/common/unicode/putil.h" | |
| 21 #include "third_party/icu/source/common/unicode/udata.h" | |
| 22 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) | |
| 23 #include "third_party/icu/source/i18n/unicode/timezone.h" | |
| 24 #endif | |
| 25 | |
| 26 #if defined(OS_ANDROID) | |
| 27 #include "base/android/apk_assets.h" | |
| 28 #endif | |
| 29 | |
| 30 #if defined(OS_MACOSX) | |
| 31 #include "base/mac/foundation_util.h" | |
| 32 #endif | |
| 33 | |
| 34 #define ICU_UTIL_DATA_FILE 0 | |
| 35 #define ICU_UTIL_DATA_SHARED 1 | |
| 36 #define ICU_UTIL_DATA_STATIC 2 | |
| 37 | |
| 38 namespace base { | |
| 39 namespace i18n { | |
| 40 | |
| 41 #if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_SHARED | |
| 42 #define ICU_UTIL_DATA_SYMBOL "icudt" U_ICU_VERSION_SHORT "_dat" | |
| 43 #if defined(OS_WIN) | |
| 44 #define ICU_UTIL_DATA_SHARED_MODULE_NAME "icudt.dll" | |
| 45 #endif | |
| 46 #endif | |
| 47 | |
| 48 namespace { | |
| 49 #if !defined(OS_NACL) | |
| 50 #if !defined(NDEBUG) | |
| 51 // Assert that we are not called more than once. Even though calling this | |
| 52 // function isn't harmful (ICU can handle it), being called twice probably | |
| 53 // indicates a programming error. | |
| 54 bool g_check_called_once = true; | |
| 55 bool g_called_once = false; | |
| 56 #endif // !defined(NDEBUG) | |
| 57 | |
| 58 #if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE | |
| 59 // Use an unversioned file name to simplify a icu version update down the road. | |
| 60 // No need to change the filename in multiple places (gyp files, windows | |
| 61 // build pkg configurations, etc). 'l' stands for Little Endian. | |
| 62 // This variable is exported through the header file. | |
| 63 const char kIcuDataFileName[] = "icudtl.dat"; | |
| 64 #if defined(OS_ANDROID) | |
| 65 const char kAndroidAssetsIcuDataFileName[] = "assets/icudtl.dat"; | |
| 66 #endif | |
| 67 | |
| 68 // File handle intentionally never closed. Not using File here because its | |
| 69 // Windows implementation guards against two instances owning the same | |
| 70 // PlatformFile (which we allow since we know it is never freed). | |
| 71 const PlatformFile kInvalidPlatformFile = | |
| 72 #if defined(OS_WIN) | |
| 73 INVALID_HANDLE_VALUE; | |
| 74 #else | |
| 75 -1; | |
| 76 #endif | |
| 77 PlatformFile g_icudtl_pf = kInvalidPlatformFile; | |
| 78 MemoryMappedFile* g_icudtl_mapped_file = nullptr; | |
| 79 MemoryMappedFile::Region g_icudtl_region; | |
| 80 | |
| 81 void LazyInitIcuDataFile() { | |
| 82 if (g_icudtl_pf != kInvalidPlatformFile) { | |
| 83 return; | |
| 84 } | |
| 85 #if defined(OS_ANDROID) | |
| 86 int fd = base::android::OpenApkAsset(kAndroidAssetsIcuDataFileName, | |
| 87 &g_icudtl_region); | |
| 88 g_icudtl_pf = fd; | |
| 89 if (fd != -1) { | |
| 90 return; | |
| 91 } | |
| 92 // For unit tests, data file is located on disk, so try there as a fallback. | |
| 93 #endif // defined(OS_ANDROID) | |
| 94 #if !defined(OS_MACOSX) | |
| 95 FilePath data_path; | |
| 96 #if defined(OS_WIN) | |
| 97 // The data file will be in the same directory as the current module. | |
| 98 bool path_ok = PathService::Get(DIR_MODULE, &data_path); | |
| 99 wchar_t tmp_buffer[_MAX_PATH] = {0}; | |
| 100 wcscpy_s(tmp_buffer, data_path.value().c_str()); | |
| 101 debug::Alias(tmp_buffer); | |
| 102 CHECK(path_ok); // TODO(scottmg): http://crbug.com/445616 | |
| 103 #elif defined(OS_ANDROID) | |
| 104 bool path_ok = PathService::Get(DIR_ANDROID_APP_DATA, &data_path); | |
| 105 #else | |
| 106 // For now, expect the data file to be alongside the executable. | |
| 107 // This is sufficient while we work on unit tests, but will eventually | |
| 108 // likely live in a data directory. | |
| 109 bool path_ok = PathService::Get(DIR_EXE, &data_path); | |
| 110 #endif | |
| 111 DCHECK(path_ok); | |
| 112 data_path = data_path.AppendASCII(kIcuDataFileName); | |
| 113 | |
| 114 #if defined(OS_WIN) | |
| 115 // TODO(scottmg): http://crbug.com/445616 | |
| 116 wchar_t tmp_buffer2[_MAX_PATH] = {0}; | |
| 117 wcscpy_s(tmp_buffer2, data_path.value().c_str()); | |
| 118 debug::Alias(tmp_buffer2); | |
| 119 #endif | |
| 120 | |
| 121 #else | |
| 122 // Assume it is in the framework bundle's Resources directory. | |
| 123 ScopedCFTypeRef<CFStringRef> data_file_name( | |
| 124 SysUTF8ToCFStringRef(kIcuDataFileName)); | |
| 125 FilePath data_path = mac::PathForFrameworkBundleResource(data_file_name); | |
| 126 if (data_path.empty()) { | |
| 127 LOG(ERROR) << kIcuDataFileName << " not found in bundle"; | |
| 128 return; | |
| 129 } | |
| 130 #endif // !defined(OS_MACOSX) | |
| 131 File file(data_path, File::FLAG_OPEN | File::FLAG_READ); | |
| 132 if (file.IsValid()) { | |
| 133 g_icudtl_pf = file.TakePlatformFile(); | |
| 134 g_icudtl_region = MemoryMappedFile::Region::kWholeFile; | |
| 135 } | |
| 136 } | |
| 137 | |
| 138 bool InitializeICUWithFileDescriptorInternal( | |
| 139 PlatformFile data_fd, | |
| 140 const MemoryMappedFile::Region& data_region) { | |
| 141 // This can be called multiple times in tests. | |
| 142 if (g_icudtl_mapped_file) { | |
| 143 return true; | |
| 144 } | |
| 145 if (data_fd == kInvalidPlatformFile) { | |
| 146 return false; | |
| 147 } | |
| 148 | |
| 149 scoped_ptr<MemoryMappedFile> icudtl_mapped_file(new MemoryMappedFile()); | |
| 150 if (!icudtl_mapped_file->Initialize(File(data_fd), data_region)) { | |
| 151 LOG(ERROR) << "Couldn't mmap icu data file"; | |
| 152 return false; | |
| 153 } | |
| 154 g_icudtl_mapped_file = icudtl_mapped_file.release(); | |
| 155 | |
| 156 UErrorCode err = U_ZERO_ERROR; | |
| 157 udata_setCommonData(const_cast<uint8*>(g_icudtl_mapped_file->data()), &err); | |
| 158 return err == U_ZERO_ERROR; | |
| 159 } | |
| 160 #endif // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE | |
| 161 #endif // !defined(OS_NACL) | |
| 162 | |
| 163 } // namespace | |
| 164 | |
| 165 #if !defined(OS_NACL) | |
| 166 #if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE | |
| 167 bool InitializeICUWithFileDescriptor( | |
| 168 PlatformFile data_fd, | |
| 169 const MemoryMappedFile::Region& data_region) { | |
| 170 #if !defined(NDEBUG) | |
| 171 DCHECK(!g_check_called_once || !g_called_once); | |
| 172 g_called_once = true; | |
| 173 #endif | |
| 174 return InitializeICUWithFileDescriptorInternal(data_fd, data_region); | |
| 175 } | |
| 176 | |
| 177 PlatformFile GetIcuDataFileHandle(MemoryMappedFile::Region* out_region) { | |
| 178 CHECK_NE(g_icudtl_pf, kInvalidPlatformFile); | |
| 179 *out_region = g_icudtl_region; | |
| 180 return g_icudtl_pf; | |
| 181 } | |
| 182 #endif // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE | |
| 183 | |
| 184 bool InitializeICU() { | |
| 185 #if !defined(NDEBUG) | |
| 186 DCHECK(!g_check_called_once || !g_called_once); | |
| 187 g_called_once = true; | |
| 188 #endif | |
| 189 | |
| 190 bool result; | |
| 191 #if (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_SHARED) | |
| 192 // We expect to find the ICU data module alongside the current module. | |
| 193 FilePath data_path; | |
| 194 PathService::Get(DIR_MODULE, &data_path); | |
| 195 data_path = data_path.AppendASCII(ICU_UTIL_DATA_SHARED_MODULE_NAME); | |
| 196 | |
| 197 HMODULE module = LoadLibrary(data_path.value().c_str()); | |
| 198 if (!module) { | |
| 199 LOG(ERROR) << "Failed to load " << ICU_UTIL_DATA_SHARED_MODULE_NAME; | |
| 200 return false; | |
| 201 } | |
| 202 | |
| 203 FARPROC addr = GetProcAddress(module, ICU_UTIL_DATA_SYMBOL); | |
| 204 if (!addr) { | |
| 205 LOG(ERROR) << ICU_UTIL_DATA_SYMBOL << ": not found in " | |
| 206 << ICU_UTIL_DATA_SHARED_MODULE_NAME; | |
| 207 return false; | |
| 208 } | |
| 209 | |
| 210 UErrorCode err = U_ZERO_ERROR; | |
| 211 udata_setCommonData(reinterpret_cast<void*>(addr), &err); | |
| 212 result = (err == U_ZERO_ERROR); | |
| 213 #elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_STATIC) | |
| 214 // The ICU data is statically linked. | |
| 215 result = true; | |
| 216 #elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE) | |
| 217 // If the ICU data directory is set, ICU won't actually load the data until | |
| 218 // it is needed. This can fail if the process is sandboxed at that time. | |
| 219 // Instead, we map the file in and hand off the data so the sandbox won't | |
| 220 // cause any problems. | |
| 221 LazyInitIcuDataFile(); | |
| 222 result = | |
| 223 InitializeICUWithFileDescriptorInternal(g_icudtl_pf, g_icudtl_region); | |
| 224 #if defined(OS_WIN) | |
| 225 CHECK(result); // TODO(scottmg): http://crbug.com/445616 | |
| 226 #endif | |
| 227 #endif | |
| 228 | |
| 229 // To respond to the timezone change properly, the default timezone | |
| 230 // cache in ICU has to be populated on starting up. | |
| 231 // TODO(jungshik): Some callers do not care about tz at all. If necessary, | |
| 232 // add a boolean argument to this function to init'd the default tz only | |
| 233 // when requested. | |
| 234 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) | |
| 235 if (result) | |
| 236 scoped_ptr<icu::TimeZone> zone(icu::TimeZone::createDefault()); | |
| 237 #endif | |
| 238 return result; | |
| 239 } | |
| 240 #endif // !defined(OS_NACL) | |
| 241 | |
| 242 void AllowMultipleInitializeCallsForTesting() { | |
| 243 #if !defined(NDEBUG) && !defined(OS_NACL) | |
| 244 g_check_called_once = false; | |
| 245 #endif | |
| 246 } | |
| 247 | |
| 248 } // namespace i18n | |
| 249 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
