TextBlob: Start caching a text blob per InlineTextBox.

Source/core/rendering/TextPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/rendering/TextPainter.h"
 
 #include "core/rendering/InlineTextBox.h"
 #include "core/rendering/RenderCombineText.h"
 #include "core/rendering/style/ShadowList.h"
@@ skipping 29 matching lines @@
     if (emphasisMark.isNull()) {
         m_emphasisMarkOffset = 0;
     } else if (position == TextEmphasisPositionOver) {
         m_emphasisMarkOffset = -m_font.fontMetrics().ascent() - m_font.emphasisMarkDescent(emphasisMark);
     } else {
         ASSERT(position == TextEmphasisPositionUnder);
         m_emphasisMarkOffset = m_font.fontMetrics().descent() + m_font.emphasisMarkAscent(emphasisMark);
     }
 }
 
-void TextPainter::paint(int startOffset, int endOffset, int length, const Style& textStyle)
+void TextPainter::paint(int startOffset, int endOffset, int length, const Style& textStyle, TextBlobPtr* textBlobCache)
 {
     GraphicsContextStateSaver stateSaver(*m_graphicsContext, false);
     updateGraphicsContext(textStyle, stateSaver);
-    paintInternal<PaintText>(startOffset, endOffset, length);
+    paintInternal<PaintText>(startOffset, endOffset, length, textBlobCache);
 
     if (!m_emphasisMark.isEmpty()) {
         if (textStyle.emphasisMarkColor != textStyle.fillColor)
             m_graphicsContext->setFillColor(textStyle.emphasisMarkColor);
 
         if (m_combinedText)
             paintEmphasisMarkForCombinedText();
         else
             paintInternal<PaintEmphasisMark>(startOffset, endOffset, length);
     }
@@ skipping 24 matching lines @@
     }
 
     // Text shadows are disabled when printing. http://crbug.com/258321
     if (textStyle.shadow && !context->printing()) {
         if (!stateSaver.saved())
             stateSaver.save();
         context->setDrawLooper(textStyle.shadow->createDrawLooper(DrawLooperBuilder::ShadowIgnoresAlpha, horizontal));
     }
 }
 
+static bool graphicsContextAllowsTextBlobs(GraphicsContext* context)
+{
+    // Text blobs affect the shader coordinate space.
+    // FIXME: Fix this, most likely in Skia.
+    return !context->strokeGradient() && !context->strokePattern() && !context->fillGradient() && !context->fillPattern();
+}
+
 template <TextPainter::PaintInternalStep step>
-void TextPainter::paintInternalRun(TextRunPaintInfo& textRunPaintInfo, int from, int to)
+void TextPainter::paintInternalRun(TextRunPaintInfo& textRunPaintInfo, int from, int to, TextBlobPtr* textBlobCache)
 {
     textRunPaintInfo.from = from;
     textRunPaintInfo.to = to;
-    if (step == PaintEmphasisMark)
+
+    if (step == PaintEmphasisMark) {
         m_graphicsContext->drawEmphasisMarks(m_font, textRunPaintInfo, m_emphasisMark, m_textOrigin + IntSize(0, m_emphasisMarkOffset));
-    else
+        return;
+    }
+
+    ASSERT(step == PaintText);
+
+    // We transfer the original ref back and forth with the cache to avoid
+    // thrashing the ref count. Skia will take a ref, so we can't just ref
+    // the blob here and then pass that reference to Skia.

[f(malita), 2014/09/12 13:21:23]

We may be able to attain the same using something like

    TextBlobPtr throwAwayBlob;
    if (!textBlobCache) {
        textBlobCache = &throwAwayBlob;
    }

    if (!*textBlobCache && canUseTextBlobs)
        *textBlobCache = m_font.buildTextBlob(textRunPaintInfo, m_textOrigin,
            m_graphicsContext->couldUseLCDRenderedText());
    if (*textBlobCache && canUseTextBlobs) {
        m_font.drawTextBlob(m_graphicsContext, textBlobCache->get(),
m_textOrigin.data());
    } else {
        m_graphicsContext->drawText(m_font, textRunPaintInfo, m_textOrigin);
    }

WDYT?

[jbroman, 2014/09/13 00:06:42]

Yeah, okay. I'm not sure whether that's clearer or not, but I have no objection.

[jbroman, 2014/09/17 22:25:37]

I've changed to a variation on this theme.

+    TextBlobPtr textBlob = textBlobCache ? textBlobCache->release() : nullptr;
+    bool canUseTextBlobs = RuntimeEnabledFeatures::textBlobEnabled() && graphicsContextAllowsTextBlobs(m_graphicsContext);
+
+    if (!textBlob && canUseTextBlobs)
+        textBlob = m_font.buildTextBlob(textRunPaintInfo, m_textOrigin, m_graphicsContext->couldUseLCDRenderedText());
+
+    if (textBlob && canUseTextBlobs) {
+        m_font.drawTextBlob(m_graphicsContext, textBlob.get(), m_textOrigin.data());
+        if (textBlobCache)
+            *textBlobCache = textBlob.release();
+    } else {
         m_graphicsContext->drawText(m_font, textRunPaintInfo, m_textOrigin);
-
+    }
 }
 
 template <TextPainter::PaintInternalStep Step>
-void TextPainter::paintInternal(int startOffset, int endOffset, int truncationPoint)
+void TextPainter::paintInternal(int startOffset, int endOffset, int truncationPoint, TextBlobPtr* textBlobCache)
 {
+    // FIXME: We should be able to use textBlobCache in more cases.
     TextRunPaintInfo textRunPaintInfo(m_run);
     textRunPaintInfo.bounds = m_textBounds;
     if (startOffset <= endOffset) {
-        paintInternalRun<Step>(textRunPaintInfo, startOffset, endOffset);
+        paintInternalRun<Step>(textRunPaintInfo, startOffset, endOffset, textBlobCache);
     } else {
         if (endOffset > 0)
             paintInternalRun<Step>(textRunPaintInfo, 0, endOffset);
         if (startOffset < truncationPoint)
             paintInternalRun<Step>(textRunPaintInfo, startOffset, truncationPoint);
     }
 }
 
 void TextPainter::paintEmphasisMarkForCombinedText()
 {
     ASSERT(m_combinedText);
     DEFINE_STATIC_LOCAL(TextRun, objectReplacementCharacterTextRun, (&objectReplacementCharacter, 1));
     FloatPoint emphasisMarkTextOrigin(m_textBounds.x() + m_textBounds.width() / 2, m_textBounds.y() + m_font.fontMetrics().ascent() + m_emphasisMarkOffset);
     TextRunPaintInfo textRunPaintInfo(objectReplacementCharacterTextRun);
     textRunPaintInfo.bounds = m_textBounds;
     m_graphicsContext->concatCTM(InlineTextBox::rotation(m_textBounds, InlineTextBox::Clockwise));
     m_graphicsContext->drawEmphasisMarks(m_combinedText->originalFont(), textRunPaintInfo, m_emphasisMark, emphasisMarkTextOrigin);
     m_graphicsContext->concatCTM(InlineTextBox::rotation(m_textBounds, InlineTextBox::Counterclockwise));
 }
 
 } // namespace blink