Support src/build/linux/unbundle in CharacterDataGenerator

third_party/WebKit/Source/platform/fonts/Character.cpp

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/fonts/Character.h"
 
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include <algorithm>
 #include <unicode/uobject.h>
 #include <unicode/uscript.h>
+
+#if defined(USING_SYSTEM_ICU)
+#include "CharacterData.h"
+#include <unicode/uniset.h>
+#else
 #define MUTEX_H // Prevent compile failure of utrie2.h on Windows
 #include <utrie2.h>
+#endif
 
 using namespace WTF;
 using namespace Unicode;
 
 namespace blink {
 
+#if defined(USING_SYSTEM_ICU)
+static icu::UnicodeSet* createUnicodeSet(
+    const UChar32* characters, size_t charactersCount,
+    const UChar32* ranges, size_t rangesCount)
+{
+    icu::UnicodeSet* unicodeSet = new icu::UnicodeSet();
+    for (size_t i = 0; i < charactersCount; i++)
+        unicodeSet->add(characters[i]);
+    for (size_t i = 0; i < rangesCount; i += 2)
+        unicodeSet->add(ranges[i], ranges[i + 1]);
+    unicodeSet->freeze();
+    return unicodeSet;
+}
+
+#define CREATE_UNICODE_SET(name) \
+    createUnicodeSet( \
+        name##Array, WTF_ARRAY_LENGTH(name##Array), \
+        name##Ranges, WTF_ARRAY_LENGTH(name##Ranges))
+
+#define RETURN_HAS_PROPERTY(c, name) \
+    static icu::UnicodeSet* unicodeSet = nullptr; \
+    if (!unicodeSet) \
+        unicodeSet = CREATE_UNICODE_SET(name); \
+    return unicodeSet->contains(c);
+#else
 // Freezed trie tree, see CharacterDataGenerator.cpp.
 extern int32_t serializedCharacterDataSize;
 extern uint8_t serializedCharacterData[];
 
 static UTrie2* createTrie()
 {
     // Create a Trie from the value array.
     UErrorCode error = U_ZERO_ERROR;
     UTrie2* trie = utrie2_openFromSerialized(
         UTrie2ValueBits::UTRIE2_16_VALUE_BITS,
         serializedCharacterData, serializedCharacterDataSize,
         nullptr, &error);
     ASSERT(error == U_ZERO_ERROR);
     return trie;
 }
 
-bool Character::hasProperty(UChar32 c, CharacterProperty property)
+static bool hasProperty(UChar32 c, CharacterProperty property)
 {
     static UTrie2* trie = nullptr;
     if (!trie)
         trie = createTrie();
     return UTRIE2_GET16(trie, c)
         & static_cast<CharacterPropertyType>(property);
 }
 
+#define RETURN_HAS_PROPERTY(c, name) \
+    return hasProperty(c, CharacterProperty::name);
+#endif
+
 // Takes a flattened list of closed intervals
 template <class T, size_t size>
 bool valueInIntervalList(const T (&intervalList)[size], const T& value)
 {
     const T* bound = std::upper_bound(&intervalList[0], &intervalList[size], value);
     if ((bound - intervalList) % 2 == 1)
         return true;
     return bound > intervalList && *(bound - 1) == value;
 }
 
@@ skipping 96 matching lines @@
         // Search for other Complex cases
         if (valueInIntervalList(complexCodePathRanges, c))
             return ComplexPath;
     }
 
     return result;
 }
 
 bool Character::isUprightInMixedVertical(UChar32 character)
 {
-    return hasProperty(character, CharacterProperty::isUprightInMixedVertical);
+    RETURN_HAS_PROPERTY(character, isUprightInMixedVertical)
 }
 
 bool Character::isCJKIdeographOrSymbol(UChar32 c)
 {
     // Likely common case
     if (c < 0x2C7)
         return false;
 
-    return hasProperty(c, CharacterProperty::isCJKIdeographOrSymbol);
+    RETURN_HAS_PROPERTY(c, isCJKIdeographOrSymbol)
 }
 
 unsigned Character::expansionOpportunityCount(const LChar* characters, size_t length, TextDirection direction, bool& isAfterExpansion, const TextJustify textJustify)
 {
     unsigned count = 0;
     if (textJustify == TextJustifyDistribute) {
         isAfterExpansion = true;
         return length;
     }
 
@@ skipping 106 matching lines @@
 }
 
 bool Character::isCommonOrInheritedScript(UChar32 character)
 {
     UErrorCode status = U_ZERO_ERROR;
     UScriptCode script = uscript_getScript(character, &status);
     return U_SUCCESS(status) && (script == USCRIPT_COMMON || script == USCRIPT_INHERITED);
 }
 
 } // namespace blink