Fix caching of nvpr glyphs

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 63 matching lines @@
                                               const GrClip& clip,
                                               const GrPaint& paint,
                                               const SkPaint& skPaint,
                                               const SkMatrix& viewMatrix,
                                               const char text[],
                                               size_t byteLength,
                                               SkScalar x, SkScalar y,
                                               const SkIRect& clipBounds) {
     TextRun run(skPaint);
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
-    run.setText(text, byteLength, x, y, fContext, &fSurfaceProps);
-    run.draw(dc, &pipelineBuilder, paint.getColor(), viewMatrix, 0, 0, clipBounds,
+    run.setText(text, byteLength, x, y);
+    run.draw(fContext, dc, &pipelineBuilder, paint.getColor(), viewMatrix, 0, 0, clipBounds,
              fFallbackTextContext, skPaint);
 }
 
 void GrStencilAndCoverTextContext::onDrawPosText(GrDrawContext* dc, GrRenderTarget* rt,
                                                  const GrClip& clip,
                                                  const GrPaint& paint,
                                                  const SkPaint& skPaint,
                                                  const SkMatrix& viewMatrix,
                                                  const char text[],
                                                  size_t byteLength,
                                                  const SkScalar pos[],
                                                  int scalarsPerPosition,
                                                  const SkPoint& offset,
                                                  const SkIRect& clipBounds) {
     TextRun run(skPaint);
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
-    run.setPosText(text, byteLength, pos, scalarsPerPosition, offset, fContext, &fSurfaceProps);
-    run.draw(dc, &pipelineBuilder, paint.getColor(), viewMatrix, 0, 0, clipBounds,
+    run.setPosText(text, byteLength, pos, scalarsPerPosition, offset);
+    run.draw(fContext, dc, &pipelineBuilder, paint.getColor(), viewMatrix, 0, 0, clipBounds,
              fFallbackTextContext, skPaint);
 }
 
 void GrStencilAndCoverTextContext::drawTextBlob(GrDrawContext* dc, GrRenderTarget* rt,
                                                 const GrClip& clip, const SkPaint& skPaint,
                                                 const SkMatrix& viewMatrix,
                                                 const SkTextBlob* skBlob, SkScalar x, SkScalar y,
                                                 SkDrawFilter* drawFilter,
                                                 const SkIRect& clipBounds) {
     if (!this->internalCanDraw(skPaint)) {
@@ skipping 16 matching lines @@
     GrPaint paint;
     if (!SkPaintToGrPaint(fContext, skPaint, viewMatrix, &paint)) {
         return;
     }
 
     const TextBlob& blob = this->findOrCreateTextBlob(skBlob, skPaint);
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
 
     TextBlob::Iter iter(blob);
     for (TextRun* run = iter.get(); run; run = iter.next()) {
-        run->draw(dc, &pipelineBuilder, paint.getColor(), viewMatrix, x, y, clipBounds,
+        run->draw(fContext, dc, &pipelineBuilder, paint.getColor(), viewMatrix, x, y, clipBounds,
                   fFallbackTextContext, skPaint);
+        run->releaseGlyphCache();
     }
 }
 
 const GrStencilAndCoverTextContext::TextBlob&
 GrStencilAndCoverTextContext::findOrCreateTextBlob(const SkTextBlob* skBlob,
                                                    const SkPaint& skPaint) {
     // The font-related parameters are baked into the text blob and will override this skPaint, so
     // the only remaining properties that can affect a TextBlob are the ones related to stroke.
     if (SkPaint::kFill_Style == skPaint.getStyle()) { // Fast path.
         if (TextBlob** found = fBlobIdCache.find(skBlob->uniqueID())) {
             fLRUList.remove(*found);
             fLRUList.addToTail(*found);
             return **found;
         }
-        TextBlob* blob = new TextBlob(skBlob->uniqueID(), skBlob, skPaint, fContext,
-                                      &fSurfaceProps);
+        TextBlob* blob = new TextBlob(skBlob->uniqueID(), skBlob, skPaint);
         this->purgeToFit(*blob);
         fBlobIdCache.set(skBlob->uniqueID(), blob);
         fLRUList.addToTail(blob);
         fCacheSize += blob->cpuMemorySize();
         return *blob;
     } else {
         GrStrokeInfo stroke(skPaint);
         SkSTArray<4, uint32_t, true> key;
         key.reset(1 + stroke.computeUniqueKeyFragmentData32Cnt());
         key[0] = skBlob->uniqueID();
         stroke.asUniqueKeyFragment(&key[1]);
         if (TextBlob** found = fBlobKeyCache.find(key)) {
             fLRUList.remove(*found);
             fLRUList.addToTail(*found);
             return **found;
         }
-        TextBlob* blob = new TextBlob(key, skBlob, skPaint, fContext, &fSurfaceProps);
+        TextBlob* blob = new TextBlob(key, skBlob, skPaint);
         this->purgeToFit(*blob);
         fBlobKeyCache.set(blob);
         fLRUList.addToTail(blob);
         fCacheSize += blob->cpuMemorySize();
         return *blob;
     }
 }
 
 void GrStencilAndCoverTextContext::purgeToFit(const TextBlob& blob) {
-    static const int maxCacheSize = 4 * 1024 * 1024; // Allow up to 4 MB for caching text blobs.
+    static const size_t maxCacheSize = 4 * 1024 * 1024; // Allow up to 4 MB for caching text blobs.
 
-    int maxSizeForNewBlob = maxCacheSize - blob.cpuMemorySize();
+    size_t maxSizeForNewBlob = maxCacheSize - blob.cpuMemorySize();
     while (fCacheSize && fCacheSize > maxSizeForNewBlob) {
         TextBlob* lru = fLRUList.head();
         if (1 == lru->key().count()) {
             // 1-length keys are unterstood to be the blob id.
             fBlobIdCache.remove(lru->key()[0]);
         } else {
             fBlobKeyCache.remove(lru->key());
         }
         fLRUList.remove(lru);
         fCacheSize -= lru->cpuMemorySize();
         delete lru;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void GrStencilAndCoverTextContext::TextBlob::init(const SkTextBlob* skBlob, const SkPaint& skPaint,
-                                                  GrContext* ctx, const SkSurfaceProps* props) {
+void GrStencilAndCoverTextContext::TextBlob::init(const SkTextBlob* skBlob,
+                                                  const SkPaint& skPaint) {
     fCpuMemorySize = sizeof(TextBlob);
     SkPaint runPaint(skPaint);
     for (SkTextBlob::RunIterator iter(skBlob); !iter.done(); iter.next()) {
         iter.applyFontToPaint(&runPaint); // No need to re-seed the paint.
         TextRun* run = SkNEW_INSERT_AT_LLIST_TAIL(this, TextRun, (runPaint));
 
         const char* text = reinterpret_cast<const char*>(iter.glyphs());
         size_t byteLength = sizeof(uint16_t) * iter.glyphCount();
         const SkPoint& runOffset = iter.offset();
 
         switch (iter.positioning()) {
             case SkTextBlob::kDefault_Positioning:
-                run->setText(text, byteLength, runOffset.fX, runOffset.fY, ctx, props);
+                run->setText(text, byteLength, runOffset.fX, runOffset.fY);
                 break;
             case SkTextBlob::kHorizontal_Positioning:
-                run->setPosText(text, byteLength, iter.pos(), 1, SkPoint::Make(0, runOffset.fY),
-                                ctx, props);
+                run->setPosText(text, byteLength, iter.pos(), 1, SkPoint::Make(0, runOffset.fY));
                 break;
             case SkTextBlob::kFull_Positioning:
-                run->setPosText(text, byteLength, iter.pos(), 2, SkPoint::Make(0, 0), ctx, props);
+                run->setPosText(text, byteLength, iter.pos(), 2, SkPoint::Make(0, 0));
                 break;
         }
 
-        fCpuMemorySize += run->cpuMemorySize();
+        fCpuMemorySize += run->computeSizeInCache();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 class GrStencilAndCoverTextContext::FallbackBlobBuilder {
 public:
     FallbackBlobBuilder() : fBuffIdx(0) {}
 
     bool isInitialized() const { return SkToBool(fBuilder); }
@@ skipping 14 matching lines @@
     int                                fBuffIdx;
     uint16_t                           fGlyphIds[kWriteBufferSize];
     SkPoint                            fPositions[kWriteBufferSize];
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrStencilAndCoverTextContext::TextRun::TextRun(const SkPaint& fontAndStroke)
     : fStroke(fontAndStroke),
       fFont(fontAndStroke),
-      fTotalGlyphCount(0) {
+      fTotalGlyphCount(0),
+      fDetachedGlyphCache(nullptr),
+      fLastDrawnGlyphsID(SK_InvalidUniqueID) {
     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()) {
         // Instead of letting fake bold get baked into the glyph outlines, do it with GPU stroke.
         SkScalar fakeBoldScale = SkScalarInterpFunc(fFont.getTextSize(),
                                                     kStdFakeBoldInterpKeys,
@@ skipping 26 matching lines @@
 
         fUsingRawGlyphPaths = SK_Scalar1 == fFont.getTextScaleX() &&
                               0 == fFont.getTextSkewX() &&
                               !fFont.isFakeBoldText() &&
                               !fFont.isVerticalText();
     } else {
         fTextRatio = fTextInverseRatio = 1.0f;
         fUsingRawGlyphPaths = false;
     }
 
+    // Generate the key that will be used to cache the GPU glyph path objects.
+    if (fUsingRawGlyphPaths && fStroke.isFillStyle()) {
+        static const GrUniqueKey::Domain kRawFillPathGlyphDomain = GrUniqueKey::GenerateDomain();
+
+        const SkTypeface* typeface = fFont.getTypeface();
+        GrUniqueKey::Builder builder(&fGlyphPathsKey, kRawFillPathGlyphDomain, 1);
+        reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
+    } else {
+        static const GrUniqueKey::Domain kPathGlyphDomain = GrUniqueKey::GenerateDomain();
+
+        int strokeDataCount = fStroke.computeUniqueKeyFragmentData32Cnt();
+        if (fUsingRawGlyphPaths) {
+            const SkTypeface* typeface = fFont.getTypeface();
+            GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain, 2 + strokeDataCount);
+            reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
+            reinterpret_cast<uint32_t&>(builder[1]) = strokeDataCount;
+            fStroke.asUniqueKeyFragment(&builder[2]);
+        } else {
+            SkGlyphCache* glyphCache = this->getGlyphCache();
+            const SkTypeface* typeface = glyphCache->getScalerContext()->getTypeface();
+            const SkDescriptor* desc = &glyphCache->getDescriptor();
+            int descDataCount = (desc->getLength() + 3) / 4;
+            GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain,
+                                         2 + strokeDataCount + descDataCount);
+            reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
+            reinterpret_cast<uint32_t&>(builder[1]) = strokeDataCount | (descDataCount << 16);
+            fStroke.asUniqueKeyFragment(&builder[2]);
+            memcpy(&builder[2 + strokeDataCount], desc, desc->getLength());
+        }
+    }
+
     // When drawing from canonically sized paths, the actual local coords are fTextRatio * coords.
     fLocalMatrixTemplate.setScale(fTextRatio, fTextRatio);
 }
 
 GrStencilAndCoverTextContext::TextRun::~TextRun() {
+    this->releaseGlyphCache();
 }
 
 void GrStencilAndCoverTextContext::TextRun::setText(const char text[], size_t byteLength,
-                                                    SkScalar x, SkScalar y, GrContext* ctx,
-                                                    const SkSurfaceProps* surfaceProps) {
+                                                    SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != nullptr);
 
-    SkAutoGlyphCacheNoGamma autoGlyphCache(fFont, surfaceProps, nullptr);
-    SkGlyphCache* glyphCache = autoGlyphCache.getCache();
+    SkGlyphCache* glyphCache = this->getGlyphCache();
+    SkDrawCacheProc glyphCacheProc = fFont.getDrawCacheProc();
 
-    fTotalGlyphCount = fFont.countText(text, byteLength);
-    fDraw.reset(GrPathRangeDraw::Create(this->createGlyphs(ctx, glyphCache),
-                                        GrPathRendering::kTranslate_PathTransformType,
-                                        fTotalGlyphCount));
-
-    SkDrawCacheProc glyphCacheProc = fFont.getDrawCacheProc();
+    fDraw.reset(GrPathRangeDraw::Create(GrPathRendering::kTranslate_PathTransformType,
+                                        fTotalGlyphCount = fFont.countText(text, byteLength)));
 
     const char* stop = text + byteLength;
 
     // Measure first if needed.
     if (fFont.getTextAlign() != SkPaint::kLeft_Align) {
         SkFixed    stopX = 0;
         SkFixed    stopY = 0;
 
         const char* textPtr = text;
         while (textPtr < stop) {
@@ skipping 30 matching lines @@
         fx += SkFixedMul(autokern.adjust(glyph), fixedSizeRatio);
         if (glyph.fWidth) {
             this->appendGlyph(glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)),
                               &fallback);
         }
 
         fx += SkFixedMul(glyph.fAdvanceX, fixedSizeRatio);
         fy += SkFixedMul(glyph.fAdvanceY, fixedSizeRatio);
     }
 
-    fDraw->loadGlyphPathsIfNeeded();
-
     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) {
+                                                       const SkPoint& offset) {
     SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
-    SkAutoGlyphCacheNoGamma autoGlyphCache(fFont, surfaceProps, nullptr);
-    SkGlyphCache* glyphCache = autoGlyphCache.getCache();
+    SkGlyphCache* glyphCache = this->getGlyphCache();
+    SkDrawCacheProc glyphCacheProc = fFont.getDrawCacheProc();
 
-    fTotalGlyphCount = fFont.countText(text, byteLength);
-    fDraw.reset(GrPathRangeDraw::Create(this->createGlyphs(ctx, glyphCache),
-                                        GrPathRendering::kTranslate_PathTransformType,
-                                        fTotalGlyphCount));
-
-    SkDrawCacheProc glyphCacheProc = fFont.getDrawCacheProc();
+    fDraw.reset(GrPathRangeDraw::Create(GrPathRendering::kTranslate_PathTransformType,
+                                        fTotalGlyphCount = fFont.countText(text, byteLength)));
 
     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, &fallback);
         }
         pos += scalarsPerPosition;
     }
 
-    fDraw->loadGlyphPathsIfNeeded();
-
     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();
-    GrUniqueKey glyphKey;
-    GrUniqueKey::Builder builder(&glyphKey, kPathGlyphDomain, 2 + strokeDataCount);
-    reinterpret_cast<uint32_t&>(builder[0]) = desc ? desc->getChecksum() : 0;
-    reinterpret_cast<uint32_t&>(builder[1]) = typeface ? typeface->uniqueID() : 0;
-    if (strokeDataCount > 0) {
-        fStroke.asUniqueKeyFragment(&builder[2]);
+GrPathRange* GrStencilAndCoverTextContext::TextRun::createGlyphs(GrContext* ctx) const {
+    GrPathRange* glyphs = static_cast<GrPathRange*>(
+            ctx->resourceProvider()->findAndRefResourceByUniqueKey(fGlyphPathsKey));
+    if (nullptr == glyphs) {
+        if (fUsingRawGlyphPaths) {
+            glyphs = ctx->resourceProvider()->createGlyphs(fFont.getTypeface(), nullptr, fStroke);
+        } else {
+            SkGlyphCache* cache = this->getGlyphCache();
+            glyphs = ctx->resourceProvider()->createGlyphs(cache->getScalerContext()->getTypeface(),
+                                                           &cache->getDescriptor(),
+                                                           fStroke);
+        }
+        ctx->resourceProvider()->assignUniqueKeyToResource(fGlyphPathsKey, glyphs);
     }
-    builder.finish();
-
-    SkAutoTUnref<GrPathRange> glyphs(
-        static_cast<GrPathRange*>(
-            ctx->resourceProvider()->findAndRefResourceByUniqueKey(glyphKey)));
-    if (nullptr == glyphs) {
-        glyphs.reset(ctx->resourceProvider()->createGlyphs(typeface, desc, fStroke));
-        ctx->resourceProvider()->assignUniqueKeyToResource(glyphKey, glyphs);
-    } else {
-        SkASSERT(nullptr == desc || glyphs->isEqualTo(*desc));
-    }
-
-    return glyphs.detach();
+    return glyphs;
 }
 
 inline void GrStencilAndCoverTextContext::TextRun::appendGlyph(const SkGlyph& glyph,
                                                                const SkPoint& pos,
                                                                FallbackBlobBuilder* fallback) {
     // Stick the glyphs we can't draw into the fallback text blob.
     if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
         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,
+void GrStencilAndCoverTextContext::TextRun::draw(GrContext* ctx,
+                                                 GrDrawContext* dc,
                                                  GrPipelineBuilder* pipelineBuilder,
                                                  GrColor color,
                                                  const SkMatrix& viewMatrix,
                                                  SkScalar x, SkScalar y,
                                                  const SkIRect& clipBounds,
                                                  GrTextContext* fallbackTextContext,
                                                  const SkPaint& originalSkPaint) const {
     SkASSERT(fDraw);
     SkASSERT(pipelineBuilder->getRenderTarget()->isStencilBufferMultisampled() ||
              !fFont.isAntiAlias());
 
     if (fDraw->count()) {
         pipelineBuilder->setState(GrPipelineBuilder::kHWAntialias_Flag, fFont.isAntiAlias());
 
         GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
                                      kZero_StencilOp,
                                      kKeep_StencilOp,
                                      kNotEqual_StencilFunc,
                                      0xffff,
                                      0x0000,
                                      0xffff);
 
         *pipelineBuilder->stencil() = kStencilPass;
 
+        SkAutoTUnref<GrPathRange> glyphs(this->createGlyphs(ctx));
+        if (fLastDrawnGlyphsID != glyphs->getUniqueID()) {
+            // Either this is the first draw or the glyphs object was purged since last draw.
+            glyphs->loadPathsIfNeeded(fDraw->indices(), fDraw->count());
+            fLastDrawnGlyphsID = glyphs->getUniqueID();
+        }
+
         SkMatrix drawMatrix(viewMatrix);
         drawMatrix.preTranslate(x, y);
         drawMatrix.preScale(fTextRatio, fTextRatio);
 
         SkMatrix& localMatrix = fLocalMatrixTemplate;
         localMatrix.setTranslateX(x);
         localMatrix.setTranslateY(y);
 
-        dc->drawPathsFromRange(pipelineBuilder, drawMatrix, localMatrix, color, fDraw,
+        dc->drawPathsFromRange(pipelineBuilder, drawMatrix, localMatrix, color, glyphs, fDraw,
                                GrPathRendering::kWinding_FillType);
     }
 
     if (fFallbackTextBlob) {
         SkPaint fallbackSkPaint(originalSkPaint);
         fStroke.applyToPaint(&fallbackSkPaint);
         if (!fStroke.isFillStyle()) {
             fallbackSkPaint.setStrokeWidth(fStroke.getWidth() * fTextRatio);
         }
 
         fallbackTextContext->drawTextBlob(dc, pipelineBuilder->getRenderTarget(),
                                           pipelineBuilder->clip(), fallbackSkPaint, viewMatrix,
                                           fFallbackTextBlob, x, y, nullptr, clipBounds);
     }
 }
 
-int GrStencilAndCoverTextContext::TextRun::cpuMemorySize() const {
-    int size = sizeof(TextRun) + fTotalGlyphCount * (sizeof(uint16_t) + 2 * sizeof(float));
+SkGlyphCache* GrStencilAndCoverTextContext::TextRun::getGlyphCache() const {
+    if (!fDetachedGlyphCache) {
+        fDetachedGlyphCache = fFont.detachCache(nullptr, nullptr, true /*ignoreGamma*/);
+    }
+    return fDetachedGlyphCache;
+}
+
+
+void GrStencilAndCoverTextContext::TextRun::releaseGlyphCache() const {
+    if (fDetachedGlyphCache) {
+        SkGlyphCache::AttachCache(fDetachedGlyphCache);
+        fDetachedGlyphCache = nullptr;
+    }
+}
+
+size_t GrStencilAndCoverTextContext::TextRun::computeSizeInCache() const {
+    size_t size = sizeof(TextRun) +
+               fGlyphPathsKey.size() +
+               fTotalGlyphCount * (sizeof(uint16_t) + 2 * sizeof(float));
     if (fDraw) {
         size += sizeof(GrPathRangeDraw);
     }
     if (fFallbackTextBlob) {
         size += sizeof(SkTextBlob);
     }
     return size;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 36 matching lines @@
     fBuffIdx = 0;
 }
 
 const SkTextBlob* GrStencilAndCoverTextContext::FallbackBlobBuilder::buildIfInitialized() {
     if (!this->isInitialized()) {
         return nullptr;
     }
     this->flush();
     return fBuilder->build();
 }