Use SkTextBlob for nvpr color bitmap fallbacks

src/gpu/GrStencilAndCoverTextContext.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStencilAndCoverTextContext.h"
 #include "GrAtlasTextContext.h"
 #include "GrDrawContext.h"
@@ skipping 74 matching lines @@
                                                  int scalarsPerPosition,
                                                  const SkPoint& offset,
                                                  const SkIRect& regionClipBounds) {
     TextRun run(skPaint);
     run.setPosText(text, byteLength, pos, scalarsPerPosition, offset, fContext, &fSurfaceProps);
     run.draw(dc, rt, clip, paint, viewMatrix, regionClipBounds, fFallbackTextContext, skPaint);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+class GrStencilAndCoverTextContext::FallbackBlobBuilder {
+public:
+    FallbackBlobBuilder() : fBuffIdx(0) {}
+
+    bool isInitialized() const { return SkToBool(fBuilder); }
+
+    void init(const SkPaint& font, SkScalar textRatio);
+
+    void appendGlyph(uint16_t glyphId, const SkPoint& pos);
+
+    const SkTextBlob* buildIfInitialized();
+
+private:
+    enum { kWriteBufferSize = 1024 };
+
+    void flush();
+
+    SkAutoTDelete<SkTextBlobBuilder>   fBuilder;
+    SkPaint                            fFont;
+    int                                fBuffIdx;
+    uint16_t                           fGlyphIds[kWriteBufferSize];
+    SkPoint                            fPositions[kWriteBufferSize];
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 GrStencilAndCoverTextContext::TextRun::TextRun(const SkPaint& fontAndStroke)
     : fStroke(fontAndStroke),
       fFont(fontAndStroke) {
     SkASSERT(!fStroke.isHairlineStyle()); // Hairlines are not supported.
 
     // Setting to "fill" ensures that no strokes get baked into font outlines. (We use the GPU path
     // rendering API for stroking).
     fFont.setStyle(SkPaint::kFill_Style);
 
     if (fFont.isFakeBoldText() && SkStrokeRec::kStroke_Style != fStroke.getStyle()) {
@@ skipping 86 matching lines @@
         x -= alignX;
         y -= alignY;
     }
 
     SkAutoKern autokern;
 
     SkFixed fixedSizeRatio = SkScalarToFixed(fTextRatio);
 
     SkFixed fx = SkScalarToFixed(x);
     SkFixed fy = SkScalarToFixed(y);
+    FallbackBlobBuilder fallback;
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(glyphCache, &text, 0, 0);
         fx += SkFixedMul(autokern.adjust(glyph), fixedSizeRatio);
         if (glyph.fWidth) {
-            this->appendGlyph(glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)));
+            this->appendGlyph(glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)),
+                              &fallback);
         }
 
         fx += SkFixedMul(glyph.fAdvanceX, fixedSizeRatio);
         fy += SkFixedMul(glyph.fAdvanceY, fixedSizeRatio);
     }
+
+    fFallbackTextBlob.reset(fallback.buildIfInitialized());
 }
 
 void GrStencilAndCoverTextContext::TextRun::setPosText(const char text[], size_t byteLength,
                                                        const SkScalar pos[], int scalarsPerPosition,
                                                        const SkPoint& offset, GrContext* ctx,
                                                        const SkSurfaceProps* surfaceProps) {
     SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     SkAutoGlyphCacheNoGamma autoGlyphCache(fFont, surfaceProps, nullptr);
     SkGlyphCache* glyphCache = autoGlyphCache.getCache();
 
     fDraw.reset(GrPathRangeDraw::Create(this->createGlyphs(ctx, glyphCache),
                                         GrPathRendering::kTranslate_PathTransformType,
                                         fFont.countText(text, byteLength)));
 
     SkDrawCacheProc glyphCacheProc = fFont.getDrawCacheProc();
 
     const char* stop = text + byteLength;
 
     SkTextMapStateProc tmsProc(SkMatrix::I(), offset, scalarsPerPosition);
     SkTextAlignProc alignProc(fFont.getTextAlign());
+    FallbackBlobBuilder fallback;
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(glyphCache, &text, 0, 0);
         if (glyph.fWidth) {
             SkPoint tmsLoc;
             tmsProc(pos, &tmsLoc);
             SkPoint loc;
             alignProc(tmsLoc, glyph, &loc);
 
-            this->appendGlyph(glyph, loc);
+            this->appendGlyph(glyph, loc, &fallback);
         }
         pos += scalarsPerPosition;
     }
+
+    fFallbackTextBlob.reset(fallback.buildIfInitialized());
 }
 
 GrPathRange* GrStencilAndCoverTextContext::TextRun::createGlyphs(GrContext* ctx,
                                                                  SkGlyphCache* glyphCache) {
     SkTypeface* typeface = fUsingRawGlyphPaths ? fFont.getTypeface()
                                                : glyphCache->getScalerContext()->getTypeface();
     const SkDescriptor* desc = fUsingRawGlyphPaths ? nullptr : &glyphCache->getDescriptor();
 
     static const GrUniqueKey::Domain kPathGlyphDomain = GrUniqueKey::GenerateDomain();
     int strokeDataCount = fStroke.computeUniqueKeyFragmentData32Cnt();
@@ skipping 13 matching lines @@
         glyphs.reset(ctx->resourceProvider()->createGlyphs(typeface, desc, fStroke));
         ctx->resourceProvider()->assignUniqueKeyToResource(glyphKey, glyphs);
     } else {
         SkASSERT(nullptr == desc || glyphs->isEqualTo(*desc));
     }
 
     return glyphs.detach();
 }
 
 inline void GrStencilAndCoverTextContext::TextRun::appendGlyph(const SkGlyph& glyph,
-                                                               const SkPoint& pos) {
-    // Stick the glyphs we can't draw into the fallback arrays.
+                                                               const SkPoint& pos,
+                                                               FallbackBlobBuilder* fallback) {
+    // Stick the glyphs we can't draw into the fallback text blob.
     if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
-        fFallbackIndices.push_back(glyph.getGlyphID());
-        fFallbackPositions.push_back(pos);
+        if (!fallback->isInitialized()) {
+            fallback->init(fFont, fTextRatio);
+        }
+        fallback->appendGlyph(glyph.getGlyphID(), pos);
     } else {
         float translate[] = { fTextInverseRatio * pos.x(), fTextInverseRatio * pos.y() };
         fDraw->append(glyph.getGlyphID(), translate);
     }
 }
 
 void GrStencilAndCoverTextContext::TextRun::draw(GrDrawContext* dc,
                                                  GrRenderTarget* rt,
                                                  const GrClip& clip,
                                                  const GrPaint& paint,
@@ skipping 18 matching lines @@
 
         *pipelineBuilder.stencil() = kStencilPass;
 
         SkMatrix drawMatrix(viewMatrix);
         drawMatrix.preScale(fTextRatio, fTextRatio);
 
         dc->drawPathsFromRange(&pipelineBuilder, drawMatrix, fLocalMatrix, paint.getColor(), fDraw,
                                GrPathRendering::kWinding_FillType);
     }
 
-    if (fFallbackIndices.count()) {
-        SkASSERT(fFallbackPositions.count() == fFallbackIndices.count());
-
-        enum { kPreservedFlags = SkPaint::kFakeBoldText_Flag | SkPaint::kLinearText_Flag |
-                                 SkPaint::kLCDRenderText_Flag | SkPaint::kAutoHinting_Flag };
-
+    if (fFallbackTextBlob) {
         SkPaint fallbackSkPaint(originalSkPaint);
         fStroke.applyToPaint(&fallbackSkPaint);
         if (!fStroke.isFillStyle()) {
             fallbackSkPaint.setStrokeWidth(fStroke.getWidth() * fTextRatio);
         }
-        fallbackSkPaint.setTextAlign(SkPaint::kLeft_Align); // Align has already been accounted for.
-        fallbackSkPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
-        fallbackSkPaint.setHinting(fFont.getHinting());
-        fallbackSkPaint.setFlags((fFont.getFlags() & kPreservedFlags) |
-                                 (originalSkPaint.getFlags() & ~kPreservedFlags));
-        // No need for subpixel positioning with bitmap glyphs. TODO: revisit if non-bitmap color
-        // glyphs show up and https://code.google.com/p/skia/issues/detail?id=4408 gets resolved.
-        fallbackSkPaint.setSubpixelText(false);
-        fallbackSkPaint.setTextSize(fFont.getTextSize() * fTextRatio);
 
-        fallbackTextContext->drawPosText(dc, rt, clip, paint, fallbackSkPaint, viewMatrix,
-                                         (char*)fFallbackIndices.begin(),
-                                         sizeof(uint16_t) * fFallbackIndices.count(),
-                                         fFallbackPositions[0].asScalars(), 2, SkPoint::Make(0, 0),
-                                         regionClipBounds);
+        fallbackTextContext->drawTextBlob(dc, rt, clip, fallbackSkPaint, viewMatrix,
+                                          fFallbackTextBlob, 0, 0, nullptr, regionClipBounds);
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void GrStencilAndCoverTextContext::FallbackBlobBuilder::init(const SkPaint& font,
+                                                             SkScalar textRatio) {
+    SkASSERT(!this->isInitialized());
+    fBuilder.reset(new SkTextBlobBuilder);
+    fFont = font;
+    fFont.setTextAlign(SkPaint::kLeft_Align); // The glyph positions will already account for align.
+    fFont.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+    // No need for subpixel positioning with bitmap glyphs. TODO: revisit if non-bitmap color glyphs
+    // show up and https://code.google.com/p/skia/issues/detail?id=4408 gets resolved.
+    fFont.setSubpixelText(false);
+    fFont.setTextSize(fFont.getTextSize() * textRatio);
+    fBuffIdx = 0;
+}
+
+void GrStencilAndCoverTextContext::FallbackBlobBuilder::appendGlyph(uint16_t glyphId,
+                                                                    const SkPoint& pos) {
+    SkASSERT(this->isInitialized());
+    if (fBuffIdx >= kWriteBufferSize) {
+        this->flush();
+    }
+    fGlyphIds[fBuffIdx] = glyphId;
+    fPositions[fBuffIdx] = pos;
+    fBuffIdx++;
+}
+
+void GrStencilAndCoverTextContext::FallbackBlobBuilder::flush() {
+    SkASSERT(this->isInitialized());
+    SkASSERT(fBuffIdx <= kWriteBufferSize);
+    if (!fBuffIdx) {
+        return;
+    }
+    // This will automatically merge with previous runs since we use the same font.
+    const SkTextBlobBuilder::RunBuffer& buff = fBuilder->allocRunPos(fFont, fBuffIdx);
+    memcpy(buff.glyphs, fGlyphIds, fBuffIdx * sizeof(uint16_t));
+    memcpy(buff.pos, fPositions[0].asScalars(), fBuffIdx * 2 * sizeof(SkScalar));
+    fBuffIdx = 0;
+}
+
+const SkTextBlob* GrStencilAndCoverTextContext::FallbackBlobBuilder::buildIfInitialized() {
+    if (!this->isInitialized()) {
+        return nullptr;
+    }
+    this->flush();
+    return fBuilder->build();
+}