Start objectifying GrAtlasTextBlob

src/gpu/batches/GrAtlasTextBatch.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextBatch.h"
 
 #include "GrBatchFontCache.h"
@@ skipping 117 matching lines @@
 template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs>
 inline void GrAtlasTextBatch::regenBlob(Target* target, FlushInfo* flushInfo, Blob* blob, Run* run,
                                         TextInfo* info, SkGlyphCache** cache,
                                         SkTypeface** typeface, GrFontScaler** scaler,
                                         const SkDescriptor** desc, const GrGeometryProcessor* gp,
                                         int glyphCount, size_t vertexStride,
                                         GrColor color, SkScalar transX, SkScalar transY) const {
     static_assert(!regenGlyphs || regenTexCoords, "must regenTexCoords along regenGlyphs");
     GrBatchTextStrike* strike = nullptr;
     if (regenTexCoords) {
-        info->fBulkUseToken.reset();
+        info->resetBulkUseToken();
 
         // We can reuse if we have a valid strike and our descriptors / typeface are the
         // same.  The override descriptor is only for the non distance field text within
         // a run
         const SkDescriptor* newDesc = (run->fOverrideDescriptor && !this->usesDistanceFields()) ?
                                       run->fOverrideDescriptor->getDesc() :
                                       run->fDescriptor.getDesc();
         if (!*cache || !SkTypeface::Equal(*typeface, run->fTypeface) ||
                        !((*desc)->equals(*newDesc))) {
             if (*cache) {
                 SkGlyphCache::AttachCache(*cache);
             }
             *desc = newDesc;
             *cache = SkGlyphCache::DetachCache(run->fTypeface, *desc);
             *scaler = GrTextContext::GetGrFontScaler(*cache);
-            strike = info->fStrike;
+            strike = info->strike();
             *typeface = run->fTypeface;
         }
 
         if (regenGlyphs) {
             strike = fFontCache->getStrike(*scaler);
         } else {
-            strike = info->fStrike;
+            strike = info->strike();
         }
     }
 
     bool brokenRun = false;
     for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
         GrGlyph* glyph = nullptr;
         if (regenTexCoords) {
-            size_t glyphOffset = glyphIdx + info->fGlyphStartIndex;
+            size_t glyphOffset = glyphIdx + info->glyphStartIndex();
 
             if (regenGlyphs) {
                 // Get the id from the old glyph, and use the new strike to lookup
                 // the glyph.
                 GrGlyph::PackedID id = blob->fGlyphs[glyphOffset]->fPackedID;
                 blob->fGlyphs[glyphOffset] = strike->getGlyph(id, this->maskFormat(), *scaler);
                 SkASSERT(id == blob->fGlyphs[glyphOffset]->fPackedID);
             }
             glyph = blob->fGlyphs[glyphOffset];
             SkASSERT(glyph && glyph->fMaskFormat == this->maskFormat());
 
             if (!fFontCache->hasGlyph(glyph) &&
                 !strike->addGlyphToAtlas(target, glyph, *scaler, this->maskFormat())) {
                 this->flush(target, flushInfo);
                 target->initDraw(gp, this->pipeline());
                 brokenRun = glyphIdx > 0;
 
                 SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(target,
                                                                     glyph,
                                                                     *scaler,
                                                                     this->maskFormat());
                 SkASSERT(success);
             }
-            fFontCache->addGlyphToBulkAndSetUseToken(&info->fBulkUseToken, glyph,
+            fFontCache->addGlyphToBulkAndSetUseToken(info->bulkUseToken(), glyph,
                                                      target->currentToken());
         }
 
         intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
-        vertex += info->fVertexStartIndex;
+        vertex += info->vertexStartIndex();
         vertex += vertexStride * glyphIdx * GrAtlasTextBatch::kVerticesPerGlyph;
         regen_vertices<regenPos, regenCol, regenTexCoords>(vertex, glyph, vertexStride,
                                                            this->usesDistanceFields(), transX,
                                                            transY, color);
         flushInfo->fGlyphsToFlush++;
     }
 
     // We my have changed the color so update it here
     run->fColor = color;
     if (regenTexCoords) {
         if (regenGlyphs) {
-            info->fStrike.reset(SkRef(strike));
+            info->setStrike(strike);
         }
-        info->fAtlasGeneration = brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
-                                             fFontCache->atlasGeneration(this->maskFormat());
+        info->setAtlasGeneration(brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
+                                             fFontCache->atlasGeneration(this->maskFormat()));
     }
 }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static inline GrColor skcolor_to_grcolor_nopremultiply(SkColor c) {
     unsigned r = SkColorGetR(c);
     unsigned g = SkColorGetG(c);
     unsigned b = SkColorGetB(c);
     return GrColorPackRGBA(r, g, b, 0xff);
 }
@@ skipping 147 matching lines @@
         uint64_t currentAtlasGen = fFontCache->atlasGeneration(maskFormat);
 
         // Because the GrBatchFontCache may evict the strike a blob depends on using for
         // generating its texture coords, we have to track whether or not the strike has
         // been abandoned.  If it hasn't been abandoned, then we can use the GrGlyph*s as is
         // otherwise we have to get the new strike, and use that to get the correct glyphs.
         // Because we do not have the packed ids, and thus can't look up our glyphs in the
         // new strike, we instead keep our ref to the old strike and use the packed ids from
         // it.  These ids will still be valid as long as we hold the ref.  When we are done
         // updating our cache of the GrGlyph*s, we drop our ref on the old strike
-        bool regenerateGlyphs = info.fStrike->isAbandoned();
-        bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen ||
+        bool regenerateGlyphs = info.strike()->isAbandoned();
+        bool regenerateTextureCoords = info.atlasGeneration() != currentAtlasGen ||
                                        regenerateGlyphs;
         bool regenerateColors;
         if (usesDistanceFields) {
             regenerateColors = !isLCD && run.fColor != args.fColor;
         } else {
             regenerateColors = kA8_GrMaskFormat == maskFormat && run.fColor != args.fColor;
         }
         bool regeneratePositions = args.fTransX != 0.f || args.fTransY != 0.f;
-        int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
+        int glyphCount = info.glyphCount();
 
         uint32_t regenMaskBits = kNoRegen;
         regenMaskBits |= regeneratePositions ? kRegenPos : 0;
         regenMaskBits |= regenerateColors ? kRegenCol : 0;
         regenMaskBits |= regenerateTextureCoords ? kRegenTex : 0;
         regenMaskBits |= regenerateGlyphs ? kRegenGlyph : 0;
         RegenMask regenMask = (RegenMask)regenMaskBits;
 
         switch (regenMask) {
             case kRegenPos: this->regenBlob<true, false, false, false>(REGEN_ARGS); break;
             case kRegenCol: this->regenBlob<false, true, false, false>(REGEN_ARGS); break;
             case kRegenTex: this->regenBlob<false, false, true, false>(REGEN_ARGS); break;
             case kRegenGlyph: this->regenBlob<false, false, true, true>(REGEN_ARGS); break;
 
             // combinations
             case kRegenPosCol: this->regenBlob<true, true, false, false>(REGEN_ARGS); break;
             case kRegenPosTex: this->regenBlob<true, false, true, false>(REGEN_ARGS); break;
             case kRegenPosTexGlyph: this->regenBlob<true, false, true, true>(REGEN_ARGS); break;
             case kRegenPosColTex: this->regenBlob<true, true, true, false>(REGEN_ARGS); break;
             case kRegenPosColTexGlyph: this->regenBlob<true, true, true, true>(REGEN_ARGS); break;
             case kRegenColTex: this->regenBlob<false, true, true, false>(REGEN_ARGS); break;
             case kRegenColTexGlyph: this->regenBlob<false, true, true, true>(REGEN_ARGS); break;
             case kNoRegen:
                 flushInfo.fGlyphsToFlush += glyphCount;
 
                 // set use tokens for all of the glyphs in our subrun.  This is only valid if we
                 // have a valid atlas generation
-                fFontCache->setUseTokenBulk(info.fBulkUseToken, target->currentToken(), maskFormat);
+                fFontCache->setUseTokenBulk(*info.bulkUseToken(), target->currentToken(),
+                                            maskFormat);
                 break;
         }
 
         // now copy all vertices
-        size_t byteCount = info.fVertexEndIndex - info.fVertexStartIndex;
-        memcpy(currVertex, blob->fVertices + info.fVertexStartIndex, byteCount);
+        size_t byteCount = info.byteCount();
+        memcpy(currVertex, blob->fVertices + info.vertexStartIndex(), byteCount);
 
         currVertex += byteCount;
     }
 
     // Make sure to attach the last cache if applicable
     if (cache) {
         SkGlyphCache::AttachCache(cache);
     }
     this->flush(target, &flushInfo);
 }
@@ skipping 130 matching lines @@
         return GrDistanceFieldA8TextGeoProc::Create(color,
                                                     viewMatrix,
                                                     texture,
                                                     params,
                                                     flags,
                                                     this->usesLocalCoords());
 #endif
     }
 
 }