Merge Blink code to cache SkTextBlob

sky/engine/core/rendering/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 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 46 matching lines @@
     unsigned variables[1];
     unsigned short variables2[2];
     void* pointers[2];
 };
 
 COMPILE_ASSERT(sizeof(InlineTextBox) == sizeof(SameSizeAsInlineTextBox), InlineTextBox_should_stay_small);
 
 typedef WTF::HashMap<const InlineTextBox*, LayoutRect> InlineTextBoxOverflowMap;
 static InlineTextBoxOverflowMap* gTextBoxesWithOverflow;
 
+typedef WTF::HashMap<const InlineTextBox*, TextBlobPtr> InlineTextBoxBlobCacheMap;
+static InlineTextBoxBlobCacheMap* gTextBlobCache;

[esprehn, 2015/01/21 09:58:57]

Lets just add a ptr to InlineTextBox. I don't know why they didn't.

[abarth-chromium, 2015/01/21 19:30:35]

It was part of the first CL.  I think they were worried about adding memory
while the feature was off.  /me will change.

+
 static const int misspellingLineThickness = 3;
 
 void InlineTextBox::destroy()
 {
     if (!knownToHaveNoOverflow() && gTextBoxesWithOverflow)
         gTextBoxesWithOverflow->remove(this);
+    if (gTextBlobCache)
+        gTextBlobCache->remove(this);
     InlineBox::destroy();
 }
 
 void InlineTextBox::markDirty()
 {
     m_len = 0;
     m_start = 0;
     InlineBox::markDirty();
 }
 
@@ skipping 326 matching lines @@
         if (!stateSaver.saved())
             stateSaver.save();
         context->setDrawLooper(textStyle.shadow->createDrawLooper(DrawLooperBuilder::ShadowIgnoresAlpha));
     }
 }
 
 void paintText(GraphicsContext* context,
     const Font& font, const TextRun& textRun,
     const AtomicString& emphasisMark, int emphasisMarkOffset,
     int startOffset, int endOffset, int truncationPoint,
-    const FloatPoint& textOrigin, const FloatRect& boxRect)
+    const FloatPoint& textOrigin, const FloatRect& boxRect,
+    TextBlobPtr* cachedTextBlob = 0)
 {
     TextRunPaintInfo textRunPaintInfo(textRun);
     textRunPaintInfo.bounds = boxRect;
     if (startOffset <= endOffset) {
         textRunPaintInfo.from = startOffset;
         textRunPaintInfo.to = endOffset;
+        // FIXME: We should be able to use cachedTextBlob in more cases.
+        textRunPaintInfo.cachedTextBlob = cachedTextBlob;
         if (emphasisMark.isEmpty())
             context->drawText(font, textRunPaintInfo, textOrigin);
         else
             context->drawEmphasisMarks(font, textRunPaintInfo, emphasisMark, textOrigin + IntSize(0, emphasisMarkOffset));
     } else {
         if (endOffset > 0) {
             textRunPaintInfo.from = 0;
             textRunPaintInfo.to = endOffset;
             if (emphasisMark.isEmpty())
                 context->drawText(font, textRunPaintInfo, textOrigin);
@@ skipping 17 matching lines @@
     const Font& font, const TextRun& textRun,
     const FloatPoint& textOrigin, const FloatRect& boxRect)
 {
     ASSERT(!emphasisMark.isEmpty());
     paintText(context, font, textRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, paintRunLength, textOrigin, boxRect);
 }
 
 void paintTextWithEmphasisMark(
     GraphicsContext* context, const Font& font, const TextPaintingStyle& textStyle, const TextRun& textRun,
     const AtomicString& emphasisMark, int emphasisMarkOffset, int startOffset, int endOffset, int length,
-    const FloatPoint& textOrigin, const FloatRect& boxRect)
+    const FloatPoint& textOrigin, const FloatRect& boxRect, TextBlobPtr* cachedTextBlob = 0)
 {
     GraphicsContextStateSaver stateSaver(*context, false);
     updateGraphicsContext(context, textStyle, stateSaver);
-    paintText(context, font, textRun, nullAtom, 0, startOffset, endOffset, length, textOrigin, boxRect);
+    paintText(context, font, textRun, nullAtom, 0, startOffset, endOffset, length, textOrigin, boxRect, cachedTextBlob);
 
     if (!emphasisMark.isEmpty()) {
         if (textStyle.emphasisMarkColor != textStyle.fillColor)
             context->setFillColor(textStyle.emphasisMarkColor);
         paintEmphasisMark(context, emphasisMark, emphasisMarkOffset, startOffset, endOffset, length, font, textRun, textOrigin, boxRect);
     }
 }
 
+TextBlobPtr* addToTextBlobCache(InlineTextBox& inlineTextBox)
+{
+    if (!gTextBlobCache)
+        gTextBlobCache = new InlineTextBoxBlobCacheMap;
+    return &gTextBlobCache->add(&inlineTextBox, nullptr).storedValue->value;
+}
+
 } // namespace
 
 void InlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
 {
     if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(&renderer())
         || m_truncation == cFullTruncation || paintInfo.phase == PaintPhaseOutline || !m_len)
         return;
 
     ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
 
@@ skipping 110 matching lines @@
         emphasisMarkOffset = emphasisMarkPosition == TextEmphasisPositionOver ? -font.fontMetrics().ascent() - font.emphasisMarkDescent(emphasisMark) : font.fontMetrics().descent() + font.emphasisMarkAscent(emphasisMark);
 
     if (!paintSelectedTextOnly) {
         // FIXME: Truncate right-to-left text correctly.
         int startOffset = 0;
         int endOffset = length;
         if (paintSelectedTextSeparately && ePos > sPos) {
             startOffset = ePos;
             endOffset = sPos;
         }
-        paintTextWithEmphasisMark(context, font, textStyle, textRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, length, textOrigin, boxRect);
+        // FIXME: This cache should probably ultimately be held somewhere else.
+        // A hashmap is convenient to avoid a memory hit when the
+        // RuntimeEnabledFeature is off.
+        bool textBlobIsCacheable = RuntimeEnabledFeatures::textBlobEnabled() && startOffset == 0 && endOffset == length;
+        TextBlobPtr* cachedTextBlob = 0;
+        if (textBlobIsCacheable)
+            cachedTextBlob = addToTextBlobCache(*this);
+        paintTextWithEmphasisMark(context, font, textStyle, textRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, length, textOrigin, boxRect, cachedTextBlob);
     }
 
     if ((paintSelectedTextOnly || paintSelectedTextSeparately) && sPos < ePos) {
         // paint only the text that is selected
-        paintTextWithEmphasisMark(context, font, selectionStyle, textRun, emphasisMark, emphasisMarkOffset, sPos, ePos, length, textOrigin, boxRect);
+        bool textBlobIsCacheable = RuntimeEnabledFeatures::textBlobEnabled() && sPos == 0 && ePos == length;
+        TextBlobPtr* cachedTextBlob = 0;
+        if (textBlobIsCacheable)
+            cachedTextBlob = addToTextBlobCache(*this);
+        paintTextWithEmphasisMark(context, font, selectionStyle, textRun, emphasisMark, emphasisMarkOffset, sPos, ePos, length, textOrigin, boxRect, cachedTextBlob);
     }
 
     // Paint decorations
     TextDecoration textDecorations = styleToUse->textDecorationsInEffect();
     if (textDecorations != TextDecorationNone && !paintSelectedTextOnly) {
         GraphicsContextStateSaver stateSaver(*context, false);
         updateGraphicsContext(context, textStyle, stateSaver);
         paintDecoration(context, boxOrigin, textDecorations);
     }
 
@@ skipping 717 matching lines @@
     printedCharacters = fprintf(stderr, "\t%s %p", obj.renderName(), &obj);
     const int rendererCharacterOffset = 24;
     for (; printedCharacters < rendererCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
 }
 
 #endif
 
 } // namespace blink