Consolidate Font::codePath kerning & ligatures exceptions

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.
  * Copyright (c) 2007, 2008, 2010 Google 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
@@ skipping 32 matching lines @@
 #include "wtf/MainThread.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/unicode/CharacterNames.h"
 #include "wtf/unicode/Unicode.h"
 
 using namespace WTF;
 using namespace Unicode;
 
 namespace blink {
 
-CodePath Font::s_codePath = AutoPath;
-
 Font::Font()
 {
 }
 
 Font::Font(const FontDescription& fd)
     : m_fontDescription(fd)
 {
 }
 
 Font::Font(const Font& other)
@@ skipping 38 matching lines @@
 }
 
 float 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 (shouldSkipDrawing() && customFontNotReadyAction == DoNotPaintIfFontNotReady)
         return 0;
 
-    CodePath 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 != ComplexPath && fontDescription().typesettingFeatures() && (runInfo.from || runInfo.to != runInfo.run.length()))
-        codePathToUse = ComplexPath;
-
-    if (codePathToUse != ComplexPath)
+    if (codePath(runInfo) != 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 (shouldSkipDrawing())
         return;
 
-    CodePath 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 != ComplexPath && fontDescription().typesettingFeatures() && (runInfo.from || runInfo.to != runInfo.run.length()))
-        codePathToUse = ComplexPath;
-
-    if (codePathToUse != ComplexPath)
+    if (codePath(runInfo) != ComplexPath)
         drawEmphasisMarksForSimpleText(context, runInfo, mark, point);
     else
         drawEmphasisMarksForComplexText(context, runInfo, mark, point);
 }
 
 static inline void updateGlyphOverflowFromBounds(const IntRectExtent& glyphBounds,
     const FontMetrics& fontMetrics, GlyphOverflow* glyphOverflow)
 {
     glyphOverflow->top = std::max<int>(glyphOverflow->top,
         glyphBounds.top() - (glyphOverflow->computeBounds ? 0 : fontMetrics.ascent()));
     glyphOverflow->bottom = std::max<int>(glyphOverflow->bottom,
         glyphBounds.bottom() - (glyphOverflow->computeBounds ? 0 : fontMetrics.descent()));
     glyphOverflow->left = glyphBounds.left();
     glyphOverflow->right = glyphBounds.right();
 }
 
 float Font::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
-    CodePath codePathToUse = codePath(run);
+    CodePath codePathToUse = codePath(TextRunPaintInfo(run));
     if (codePathToUse != ComplexPath) {
         // The simple path can optimize the case where glyph overflow is not observable.
         if (codePathToUse != SimpleWithGlyphOverflowPath && (glyphOverflow && !glyphOverflow->computeBounds))
             glyphOverflow = 0;
     }
 
     bool hasWordSpacingOrLetterSpacing = fontDescription().wordSpacing() || fontDescription().letterSpacing();
     bool isCacheable = codePathToUse == ComplexPath
         && !hasWordSpacingOrLetterSpacing // Word spacing and letter spacing can change the width of a word.
         && !run.allowTabs(); // If we allow tabs and a tab occurs inside a word, the width of the word varies based on its position on the line.
@@ skipping 40 matching lines @@
 
 PassTextBlobPtr Font::buildTextBlob(const TextRunPaintInfo& runInfo, const FloatPoint& textOrigin, bool couldUseLCDRenderedText, CustomFontNotReadyAction customFontNotReadyAction) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
     // FIXME: Some logic in common with Font::drawText. Would be nice to
     // deduplicate.
     if (shouldSkipDrawing() && customFontNotReadyAction == DoNotPaintIfFontNotReady)
         return nullptr;
 
-    CodePath 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 != ComplexPath && fontDescription().typesettingFeatures() && (runInfo.from || runInfo.to != runInfo.run.length()))
-        codePathToUse = ComplexPath;
-
-    if (codePathToUse != ComplexPath)
+    if (codePath(runInfo) != ComplexPath)
         return buildTextBlobForSimpleText(runInfo, textOrigin, couldUseLCDRenderedText);
 
     return nullptr;
 }
 
 PassTextBlobPtr Font::buildTextBlobForSimpleText(const TextRunPaintInfo& runInfo, const FloatPoint& textOrigin, bool couldUseLCDRenderedText) const
 {
     GlyphBuffer glyphBuffer;
     float initialAdvance = getGlyphsAndAdvancesForSimpleText(runInfo, glyphBuffer);
 
@@ skipping 60 matching lines @@
 
     advance = x;
     return adoptRef(builder.build());
 }
 
 
 FloatRect Font::selectionRectForText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
 {
     to = (to == -1 ? run.length() : to);
 
-    CodePath 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 != ComplexPath && fontDescription().typesettingFeatures() && (from || to != run.length()))
-        codePathToUse = ComplexPath;
+    TextRunPaintInfo runInfo(run);
+    runInfo.from = from;
+    runInfo.to = to;
 
-    if (codePathToUse != ComplexPath)
+    if (codePath(runInfo) != ComplexPath)
         return selectionRectForSimpleText(run, point, h, from, to, accountForGlyphBounds);
 
     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) != ComplexPath && !fontDescription().typesettingFeatures())
+    if (codePath(TextRunPaintInfo(run)) != ComplexPath && !fontDescription().typesettingFeatures())
         return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
 
     return offsetForPositionForComplexText(run, x, includePartialGlyphs);
 }
 
-void Font::setCodePath(CodePath p)
+CodePath Font::codePath(const TextRunPaintInfo& runInfo) const
 {
-    s_codePath = p;
-}
+    const TextRun& run = runInfo.run;
 
-CodePath Font::codePath()
-{
-    return s_codePath;
-}
-
-CodePath Font::codePath(const TextRun& run) const
-{
-    if (s_codePath != AutoPath)
-        return s_codePath;
+    if (fontDescription().typesettingFeatures() && (runInfo.from || runInfo.to != run.length()))
+        return ComplexPath;
 
 #if ENABLE(SVG_FONTS)
     if (run.renderingContext())
         return SimplePath;
 #endif
 
     if (m_fontDescription.featureSettings() && m_fontDescription.featureSettings()->size() > 0 && m_fontDescription.letterSpacing() == 0)
         return ComplexPath;
 
     if (m_fontDescription.widthVariant() != RegularWidth)
@@ skipping 838 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink