.: Replace "Apple Computer, Inc." with "Apple Inc." in copyright headers
[WebKit-https.git] / Source / WebCore / platform / text / TextEncodingRegistry.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2011 Apple Inc. All rights reserved.
3  * Copyright (C) 2007-2009 Torch Mobile, Inc.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "TextEncodingRegistry.h"
29
30 #include "TextCodecICU.h"
31 #include "TextCodecLatin1.h"
32 #include "TextCodecUserDefined.h"
33 #include "TextCodecUTF16.h"
34 #include "TextCodecUTF8.h"
35 #include "TextEncoding.h"
36 #include <mutex>
37 #include <wtf/ASCIICType.h>
38 #include <wtf/HashMap.h>
39 #include <wtf/HashSet.h>
40 #include <wtf/MainThread.h>
41 #include <wtf/NeverDestroyed.h>
42 #include <wtf/StdLibExtras.h>
43 #include <wtf/StringExtras.h>
44
45 #if PLATFORM(MAC)
46 #include "TextCodecMac.h"
47 #endif
48
49 #include <wtf/CurrentTime.h>
50 #include <wtf/text/CString.h>
51
52 using namespace WTF;
53
54 namespace WebCore {
55
56 const size_t maxEncodingNameLength = 63;
57
58 // Hash for all-ASCII strings that does case folding.
59 struct TextEncodingNameHash {
60     static bool equal(const char* s1, const char* s2)
61     {
62         char c1;
63         char c2;
64         do {
65             c1 = *s1++;
66             c2 = *s2++;
67             if (toASCIILower(c1) != toASCIILower(c2))
68                 return false;
69         } while (c1 && c2);
70         return !c1 && !c2;
71     }
72
73     // This algorithm is the one-at-a-time hash from:
74     // http://burtleburtle.net/bob/hash/hashfaq.html
75     // http://burtleburtle.net/bob/hash/doobs.html
76     static unsigned hash(const char* s)
77     {
78         unsigned h = WTF::stringHashingStartValue;
79         for (;;) {
80             char c = *s++;
81             if (!c) {
82                 h += (h << 3);
83                 h ^= (h >> 11);
84                 h += (h << 15);
85                 return h;
86             }
87             h += toASCIILower(c);
88             h += (h << 10); 
89             h ^= (h >> 6); 
90         }
91     }
92
93     static const bool safeToCompareToEmptyOrDeleted = false;
94 };
95
96 struct TextCodecFactory {
97     NewTextCodecFunction function;
98     const void* additionalData;
99     TextCodecFactory(NewTextCodecFunction f = 0, const void* d = 0) : function(f), additionalData(d) { }
100 };
101
102 typedef HashMap<const char*, const char*, TextEncodingNameHash> TextEncodingNameMap;
103 typedef HashMap<const char*, TextCodecFactory> TextCodecMap;
104
105 static std::mutex& encodingRegistryMutex()
106 {
107     // We don't have to construct this mutex in a thread safe way because this function
108     // is called on the main thread for any page before it is used in worker threads.
109     static NeverDestroyed<std::mutex> mutex;
110
111     return mutex;
112 }
113
114 static TextEncodingNameMap* textEncodingNameMap;
115 static TextCodecMap* textCodecMap;
116 static bool didExtendTextCodecMaps;
117 static HashSet<const char*>* japaneseEncodings;
118 static HashSet<const char*>* nonBackslashEncodings;
119
120 static const char* const textEncodingNameBlacklist[] = { "UTF-7" };
121
122 #if ERROR_DISABLED
123
124 static inline void checkExistingName(const char*, const char*) { }
125
126 #else
127
128 static void checkExistingName(const char* alias, const char* atomicName)
129 {
130     const char* oldAtomicName = textEncodingNameMap->get(alias);
131     if (!oldAtomicName)
132         return;
133     if (oldAtomicName == atomicName)
134         return;
135     // Keep the warning silent about one case where we know this will happen.
136     if (strcmp(alias, "ISO-8859-8-I") == 0
137             && strcmp(oldAtomicName, "ISO-8859-8-I") == 0
138             && strcasecmp(atomicName, "iso-8859-8") == 0)
139         return;
140     LOG_ERROR("alias %s maps to %s already, but someone is trying to make it map to %s", alias, oldAtomicName, atomicName);
141 }
142
143 #endif
144
145 static bool isUndesiredAlias(const char* alias)
146 {
147     // Reject aliases with version numbers that are supported by some back-ends (such as "ISO_2022,locale=ja,version=0" in ICU).
148     for (const char* p = alias; *p; ++p) {
149         if (*p == ',')
150             return true;
151     }
152     // 8859_1 is known to (at least) ICU, but other browsers don't support this name - and having it caused a compatibility
153     // problem, see bug 43554.
154     if (0 == strcmp(alias, "8859_1"))
155         return true;
156     return false;
157 }
158
159 static void addToTextEncodingNameMap(const char* alias, const char* name)
160 {
161     ASSERT(strlen(alias) <= maxEncodingNameLength);
162     if (isUndesiredAlias(alias))
163         return;
164     const char* atomicName = textEncodingNameMap->get(name);
165     ASSERT(strcmp(alias, name) == 0 || atomicName);
166     if (!atomicName)
167         atomicName = name;
168     checkExistingName(alias, atomicName);
169     textEncodingNameMap->add(alias, atomicName);
170 }
171
172 static void addToTextCodecMap(const char* name, NewTextCodecFunction function, const void* additionalData)
173 {
174     const char* atomicName = textEncodingNameMap->get(name);
175     ASSERT(atomicName);
176     textCodecMap->add(atomicName, TextCodecFactory(function, additionalData));
177 }
178
179 static void pruneBlacklistedCodecs()
180 {
181     for (size_t i = 0; i < WTF_ARRAY_LENGTH(textEncodingNameBlacklist); ++i) {
182         const char* atomicName = textEncodingNameMap->get(textEncodingNameBlacklist[i]);
183         if (!atomicName)
184             continue;
185
186         Vector<const char*> names;
187         TextEncodingNameMap::const_iterator it = textEncodingNameMap->begin();
188         TextEncodingNameMap::const_iterator end = textEncodingNameMap->end();
189         for (; it != end; ++it) {
190             if (it->value == atomicName)
191                 names.append(it->key);
192         }
193
194         size_t length = names.size();
195         for (size_t j = 0; j < length; ++j)
196             textEncodingNameMap->remove(names[j]);
197
198         textCodecMap->remove(atomicName);
199     }
200 }
201
202 static void buildBaseTextCodecMaps()
203 {
204     ASSERT(isMainThread());
205     ASSERT(!textCodecMap);
206     ASSERT(!textEncodingNameMap);
207
208     textCodecMap = new TextCodecMap;
209     textEncodingNameMap = new TextEncodingNameMap;
210
211     TextCodecLatin1::registerEncodingNames(addToTextEncodingNameMap);
212     TextCodecLatin1::registerCodecs(addToTextCodecMap);
213
214     TextCodecUTF8::registerEncodingNames(addToTextEncodingNameMap);
215     TextCodecUTF8::registerCodecs(addToTextCodecMap);
216
217     TextCodecUTF16::registerEncodingNames(addToTextEncodingNameMap);
218     TextCodecUTF16::registerCodecs(addToTextCodecMap);
219
220     TextCodecUserDefined::registerEncodingNames(addToTextEncodingNameMap);
221     TextCodecUserDefined::registerCodecs(addToTextCodecMap);
222 }
223
224 static void addEncodingName(HashSet<const char*>* set, const char* name)
225 {
226     // We must not use atomicCanonicalTextEncodingName() because this function is called in it.
227     const char* atomicName = textEncodingNameMap->get(name);
228     if (atomicName)
229         set->add(atomicName);
230 }
231
232 static void buildQuirksSets()
233 {
234     // FIXME: Having isJapaneseEncoding() and shouldShowBackslashAsCurrencySymbolIn()
235     // and initializing the sets for them in TextEncodingRegistry.cpp look strange.
236
237     ASSERT(!japaneseEncodings);
238     ASSERT(!nonBackslashEncodings);
239
240     japaneseEncodings = new HashSet<const char*>;
241     addEncodingName(japaneseEncodings, "EUC-JP");
242     addEncodingName(japaneseEncodings, "ISO-2022-JP");
243     addEncodingName(japaneseEncodings, "ISO-2022-JP-1");
244     addEncodingName(japaneseEncodings, "ISO-2022-JP-2");
245     addEncodingName(japaneseEncodings, "ISO-2022-JP-3");
246     addEncodingName(japaneseEncodings, "JIS_C6226-1978");
247     addEncodingName(japaneseEncodings, "JIS_X0201");
248     addEncodingName(japaneseEncodings, "JIS_X0208-1983");
249     addEncodingName(japaneseEncodings, "JIS_X0208-1990");
250     addEncodingName(japaneseEncodings, "JIS_X0212-1990");
251     addEncodingName(japaneseEncodings, "Shift_JIS");
252     addEncodingName(japaneseEncodings, "Shift_JIS_X0213-2000");
253     addEncodingName(japaneseEncodings, "cp932");
254     addEncodingName(japaneseEncodings, "x-mac-japanese");
255
256     nonBackslashEncodings = new HashSet<const char*>;
257     // The text encodings below treat backslash as a currency symbol for IE compatibility.
258     // See http://blogs.msdn.com/michkap/archive/2005/09/17/469941.aspx for more information.
259     addEncodingName(nonBackslashEncodings, "x-mac-japanese");
260     addEncodingName(nonBackslashEncodings, "ISO-2022-JP");
261     addEncodingName(nonBackslashEncodings, "EUC-JP");
262     // Shift_JIS_X0213-2000 is not the same encoding as Shift_JIS on Mac. We need to register both of them.
263     addEncodingName(nonBackslashEncodings, "Shift_JIS");
264     addEncodingName(nonBackslashEncodings, "Shift_JIS_X0213-2000");
265 }
266
267 bool isJapaneseEncoding(const char* canonicalEncodingName)
268 {
269     return canonicalEncodingName && japaneseEncodings && japaneseEncodings->contains(canonicalEncodingName);
270 }
271
272 bool shouldShowBackslashAsCurrencySymbolIn(const char* canonicalEncodingName)
273 {
274     return canonicalEncodingName && nonBackslashEncodings && nonBackslashEncodings->contains(canonicalEncodingName);
275 }
276
277 static void extendTextCodecMaps()
278 {
279     TextCodecICU::registerEncodingNames(addToTextEncodingNameMap);
280     TextCodecICU::registerCodecs(addToTextCodecMap);
281
282 #if PLATFORM(MAC)
283     TextCodecMac::registerEncodingNames(addToTextEncodingNameMap);
284     TextCodecMac::registerCodecs(addToTextCodecMap);
285 #endif
286
287     pruneBlacklistedCodecs();
288     buildQuirksSets();
289 }
290
291 PassOwnPtr<TextCodec> newTextCodec(const TextEncoding& encoding)
292 {
293     std::lock_guard<std::mutex> lock(encodingRegistryMutex());
294
295     ASSERT(textCodecMap);
296     TextCodecFactory factory = textCodecMap->get(encoding.name());
297     ASSERT(factory.function);
298     return factory.function(encoding, factory.additionalData);
299 }
300
301 const char* atomicCanonicalTextEncodingName(const char* name)
302 {
303     if (!name || !name[0])
304         return nullptr;
305
306     if (!textEncodingNameMap)
307         buildBaseTextCodecMaps();
308
309     std::lock_guard<std::mutex> lock(encodingRegistryMutex());
310
311     if (const char* atomicName = textEncodingNameMap->get(name))
312         return atomicName;
313     if (didExtendTextCodecMaps)
314         return nullptr;
315
316     extendTextCodecMaps();
317     didExtendTextCodecMaps = true;
318     return textEncodingNameMap->get(name);
319 }
320
321 template <typename CharacterType>
322 const char* atomicCanonicalTextEncodingName(const CharacterType* characters, size_t length)
323 {
324     char buffer[maxEncodingNameLength + 1];
325     size_t j = 0;
326     for (size_t i = 0; i < length; ++i) {
327         CharacterType c = characters[i];
328         if (j == maxEncodingNameLength)
329             return 0;
330         buffer[j++] = c;
331     }
332     buffer[j] = 0;
333     return atomicCanonicalTextEncodingName(buffer);
334 }
335
336 const char* atomicCanonicalTextEncodingName(const String& alias)
337 {
338     if (!alias.length())
339         return 0;
340
341     if (alias.is8Bit())
342         return atomicCanonicalTextEncodingName<LChar>(alias.characters8(), alias.length());
343
344     return atomicCanonicalTextEncodingName<UChar>(alias.deprecatedCharacters(), alias.length());
345 }
346
347 bool noExtendedTextEncodingNameUsed()
348 {
349     // If the calling thread did not use extended encoding names, it is fine for it to use a stale false value.
350     return !didExtendTextCodecMaps;
351 }
352
353 #ifndef NDEBUG
354 void dumpTextEncodingNameMap()
355 {
356     unsigned size = textEncodingNameMap->size();
357     fprintf(stderr, "Dumping %u entries in WebCore::textEncodingNameMap...\n", size);
358
359     std::lock_guard<std::mutex> lock(encodingRegistryMutex());
360
361     TextEncodingNameMap::const_iterator it = textEncodingNameMap->begin();
362     TextEncodingNameMap::const_iterator end = textEncodingNameMap->end();
363     for (; it != end; ++it)
364         fprintf(stderr, "'%s' => '%s'\n", it->key, it->value);
365 }
366 #endif
367
368 } // namespace WebCore