Avoiding multiple text/string parsing while creating TextRun

Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 60 matching lines @@
     0x212B, 0x213B, 0x2150, 0x2151, 0x2152, 0x217F, 0x2189, 0x2307, 0x2312, 0x23CE,
     0x2423, 0x25A0, 0x25A1, 0x25A2, 0x25AA, 0x25AB, 0x25B1, 0x25B2, 0x25B3, 0x25B6,
     0x25B7, 0x25BC, 0x25BD, 0x25C0, 0x25C1, 0x25C6, 0x25C7, 0x25C9, 0x25CB, 0x25CC,
     0x25EF, 0x2605, 0x2606, 0x260E, 0x2616, 0x2617, 0x2640, 0x2642, 0x26A0, 0x26BD,
     0x26BE, 0x2713, 0x271A, 0x273F, 0x2740, 0x2756, 0x2B1A, 0xFE10, 0xFE11, 0xFE12,
     0xFE19, 0xFF1D,
     // Emoji.
     0x1F100
 };
 
-Font::CodePath Font::s_codePath = Auto;
+CodePath Font::s_codePath = AutoPath;
 
 TypesettingFeatures Font::s_defaultTypesettingFeatures = 0;
 
 // ============================================================================================
 // Font Implementation (Cross-Platform Portion)
 // ============================================================================================
 
 Font::Font()
     : m_letterSpacing(0)
     , m_wordSpacing(0)
@@ skipping 76 matching lines @@
 }
 
 void Font::drawText(GraphicsContext* context, const TextRunPaintInfo& runInfo, const FloatPoint& point, CustomFontNotReadyAction customFontNotReadyAction) const
 {
     // Don't draw anything while we are using custom fonts that are in the process of loading,
     // except if the 'force' argument is set to true (in which case it will use a fallback
     // font).
     if (loadingCustomFonts() && customFontNotReadyAction == DoNotPaintIfFontNotReady)
         return;
 
-    CodePath codePathToUse = codePath(runInfo.run);
+    CodePath codePathToUse = runInfo.run.characterScanForCodePathValue();
+
+    if (codePathToUse == AutoPath)
+        codePathToUse = codePath(runInfo.run);
+
     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
-    if (codePathToUse != Complex && typesettingFeatures() && (runInfo.from || runInfo.to != runInfo.run.length()))
-        codePathToUse = Complex;
+    if (codePathToUse != ComplexPath&& typesettingFeatures() && (runInfo.from || runInfo.to != runInfo.run.length()))

[eseidel, 2013/12/27 04:36:45]

nit: missing space before &&

+        codePathToUse = ComplexPath;
 
-    if (codePathToUse != Complex)
+    if (codePathToUse != ComplexPath)
         return drawSimpleText(context, runInfo, point);
 
     return drawComplexText(context, runInfo, point);
 }
 
 void Font::drawEmphasisMarks(GraphicsContext* context, const TextRunPaintInfo& runInfo, const AtomicString& mark, const FloatPoint& point) const
 {
     if (loadingCustomFonts())
         return;
 
-    CodePath codePathToUse = codePath(runInfo.run);
+    CodePath codePathToUse = runInfo.run.characterScanForCodePathValue();
+    if (codePathToUse == AutoPath)
+        codePathToUse = codePath(runInfo.run);
+
     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
-    if (codePathToUse != Complex && typesettingFeatures() && (runInfo.from || runInfo.to != runInfo.run.length()))
-        codePathToUse = Complex;
+    if (codePathToUse != ComplexPath && typesettingFeatures() && (runInfo.from || runInfo.to != runInfo.run.length()))
+        codePathToUse = ComplexPath;
 
-    if (codePathToUse != Complex)
+    if (codePathToUse != ComplexPath)
         drawEmphasisMarksForSimpleText(context, runInfo, mark, point);
     else
         drawEmphasisMarksForComplexText(context, runInfo, mark, point);
 }
 
 float Font::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
-    CodePath codePathToUse = codePath(run);
-    if (codePathToUse != Complex) {
+    CodePath codePathToUse = run.characterScanForCodePathValue();
+
+    if (codePathToUse == AutoPath)
+        codePathToUse = codePath(run);
+
+    if (codePathToUse != ComplexPath) {
         // The complex path is more restrictive about returning fallback fonts than the simple path, so we need an explicit test to make their behaviors match.
         if (!canReturnFallbackFontsForComplexText())
             fallbackFonts = 0;
         // The simple path can optimize the case where glyph overflow is not observable.
-        if (codePathToUse != SimpleWithGlyphOverflow && (glyphOverflow && !glyphOverflow->computeBounds))
+        if (codePathToUse != SimpleWithGlyphOverflowPath && (glyphOverflow && !glyphOverflow->computeBounds))
             glyphOverflow = 0;
     }
 
     bool hasKerningOrLigatures = typesettingFeatures() & (Kerning | Ligatures);
     bool hasWordSpacingOrLetterSpacing = wordSpacing() || letterSpacing();
     float* cacheEntry = m_fontFallbackList->widthCache().add(run, std::numeric_limits<float>::quiet_NaN(), hasKerningOrLigatures, hasWordSpacingOrLetterSpacing, glyphOverflow);
     if (cacheEntry && !std::isnan(*cacheEntry))
         return *cacheEntry;
 
     float result;
-    if (codePathToUse == Complex)
+    if (codePathToUse == ComplexPath)
         result = floatWidthForComplexText(run, fallbackFonts, glyphOverflow);
     else
         result = floatWidthForSimpleText(run, fallbackFonts, glyphOverflow);
 
     if (cacheEntry && (!fallbackFonts || fallbackFonts->isEmpty()))
         *cacheEntry = result;
     return result;
 }
 
 float Font::width(const TextRun& run, int& charsConsumed, String& glyphName) const
@@ skipping 25 matching lines @@
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 #endif
 
 FloatRect Font::selectionRectForText(const TextRun& run, const FloatPoint& point, int h, int from, int to) const
 {
     to = (to == -1 ? run.length() : to);
 
-    CodePath codePathToUse = codePath(run);
+    CodePath codePathToUse = run.characterScanForCodePathValue();
+
+    if (codePathToUse == AutoPath)
+        codePathToUse = codePath(run);
+
     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
-    if (codePathToUse != Complex && typesettingFeatures() && (from || to != run.length()))
-        codePathToUse = Complex;
+    if (codePathToUse != ComplexPath && typesettingFeatures() && (from || to != run.length()))
+        codePathToUse = ComplexPath;
 
-    if (codePathToUse != Complex)
+    if (codePathToUse != ComplexPath)
         return selectionRectForSimpleText(run, point, h, from, to);
 
     return selectionRectForComplexText(run, point, h, from, to);
 }
 
 int Font::offsetForPosition(const TextRun& run, float x, bool includePartialGlyphs) const
 {
     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
-    if (codePath(run) != Complex && !typesettingFeatures())
+    CodePath codePathToUse = run.characterScanForCodePathValue();
+
+    if (codePathToUse == AutoPath)
+        codePathToUse = codePath(run);
+
+    if (codePathToUse != ComplexPath && !typesettingFeatures())
         return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
 
     return offsetForPositionForComplexText(run, x, includePartialGlyphs);
 }
 
 template <typename CharacterType>
 static inline String normalizeSpacesInternal(const CharacterType* characters, unsigned length)
 {
     StringBuilder normalized;
     normalized.reserveCapacity(length);
@@ skipping 25 matching lines @@
 bool Font::shouldUseSmoothing()
 {
     return shouldUseFontSmoothing;
 }
 
 void Font::setCodePath(CodePath p)
 {
     s_codePath = p;
 }
 
-Font::CodePath Font::codePath()
+CodePath Font::codePath()
 {
     return s_codePath;
 }
 
 void Font::setDefaultTypesettingFeatures(TypesettingFeatures typesettingFeatures)
 {
     s_defaultTypesettingFeatures = typesettingFeatures;
 }
 
 TypesettingFeatures Font::defaultTypesettingFeatures()
 {
     return s_defaultTypesettingFeatures;
 }
 
-Font::CodePath Font::codePath(const TextRun& run) const
+CodePath Font::codePath(const TextRun& run) const
 {
-    if (s_codePath != Auto)
+    if (s_codePath != AutoPath)
         return s_codePath;
 
 #if ENABLE(SVG_FONTS)
     if (run.renderingContext())
-        return Simple;
+        return SimplePath;
 #endif
 
     if (m_fontDescription.featureSettings() && m_fontDescription.featureSettings()->size() > 0)
-        return Complex;
+        return ComplexPath;
 
     if (run.length() > 1 && !WidthIterator::supportsTypesettingFeatures(*this))
-        return Complex;
+        return ComplexPath;
 
     if (!run.characterScanForCodePath())
-        return Simple;
+        return SimplePath;
 
     if (run.is8Bit())
-        return Simple;
+        return SimplePath;
 
     // Start from 0 since drawing and highlighting also measure the characters before run->from.
     return characterRangeCodePath(run.characters16(), run.length());
 }
 
 static inline UChar keyExtractorUChar(const UChar* value)
 {
     return *value;
 }
 
 static inline UChar32 keyExtractorUChar32(const UChar32* value)
 {
     return *value;
 }
 
-Font::CodePath Font::characterRangeCodePath(const UChar* characters, unsigned len)
+CodePath Font::characterRangeCodePath(const UChar* characters, unsigned len)
 {
     static const UChar complexCodePathRanges[] = {
         // U+02E5 through U+02E9 (Modifier Letters : Tone letters)
         0x2E5, 0x2E9,
         // U+0300 through U+036F Combining diacritical marks
         0x300, 0x36F,
         // U+0591 through U+05CF excluding U+05BE Hebrew combining marks, ...
         0x0591, 0x05BD,
         // ... Hebrew punctuation Paseq, Sof Pasuq and Nun Hafukha
         0x05BF, 0x05CF,
@@ skipping 31 matching lines @@
         0xA800, 0xABFF,
         // U+D7B0 through U+D7FF Hangul Jamo Ext. B
         0xD7B0, 0xD7FF,
         // U+FE00 through U+FE0F Unicode variation selectors
         0xFE00, 0xFE0F,
         // U+FE20 through U+FE2F Combining half marks
         0xFE20, 0xFE2F
     };
     static size_t complexCodePathRangesCount = WTF_ARRAY_LENGTH(complexCodePathRanges);
 
-    CodePath result = Simple;
+    CodePath result = SimplePath;
     for (unsigned i = 0; i < len; i++) {
         const UChar c = characters[i];
 
         // Shortcut for common case
         if (c < 0x2E5)
             continue;
 
         // U+1E00 through U+2000 characters with diacritics and stacked diacritics
         if (c >= 0x1E00 && c <= 0x2000) {
-            result = SimpleWithGlyphOverflow;
+            result = SimpleWithGlyphOverflowPath;
             continue;
         }
 
         // Surrogate pairs
         if (c > 0xD7FF && c <= 0xDBFF) {
             if (i == len - 1)
                 continue;
 
             UChar next = characters[++i];
             if (!U16_IS_TRAIL(next))
                 continue;
 
             UChar32 supplementaryCharacter = U16_GET_SUPPLEMENTARY(c, next);
 
             if (supplementaryCharacter < 0x1F1E6) // U+1F1E6 through U+1F1FF Regional Indicator Symbols
                 continue;
             if (supplementaryCharacter <= 0x1F1FF)
-                return Complex;
+                return ComplexPath;
 
             if (supplementaryCharacter < 0xE0100) // U+E0100 through U+E01EF Unicode variation selectors.
                 continue;
             if (supplementaryCharacter <= 0xE01EF)
-                return Complex;
+                return ComplexPath;
 
             // FIXME: Check for Brahmi (U+11000 block), Kaithi (U+11080 block) and other complex scripts
             // in plane 1 or higher.
 
             continue;
         }
 
         // Search for other Complex cases
         UChar* boundingCharacter = approximateBinarySearch<UChar, UChar>(
             (UChar*)complexCodePathRanges, complexCodePathRangesCount, c, keyExtractorUChar);
         // Exact matches are complex
         if (*boundingCharacter == c)
-            return Complex;
+            return ComplexPath;
         bool isEndOfRange = ((boundingCharacter - complexCodePathRanges) % 2);
         if (*boundingCharacter < c) {
             // Determine if we are in a range or out
             if (!isEndOfRange)
-                return Complex;
+                return ComplexPath;
             continue;
         }
         ASSERT(*boundingCharacter > c);
         // Determine if we are in a range or out - opposite condition to above
         if (isEndOfRange)
-            return Complex;
+            return ComplexPath;
     }
 
     return result;
 }
 
 bool Font::isCJKIdeograph(UChar32 c)
 {
     static const UChar32 cjkIdeographRanges[] = {
         // CJK Radicals Supplement and Kangxi Radicals.
         0x2E80, 0x2FDF,
@@ skipping 187 matching lines @@
 }
 
 void Font::willUseFontData() const
 {
     const FontFamily& family = fontDescription().family();
     if (m_fontFallbackList && m_fontFallbackList->fontSelector() && !family.familyIsEmpty())
         m_fontFallbackList->fontSelector()->willUseFontData(fontDescription(), family.family());
 }
 
 }