Make onPrepareDraws const

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 113 matching lines @@
 typedef GrAtlasTextBlob Blob;
 typedef Blob::Run Run;
 typedef Run::SubRunInfo TextInfo;
 
 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) {
+                                        GrColor color, SkScalar transX, SkScalar transY) const {
     static_assert(!regenGlyphs || regenTexCoords, "must regenTexCoords along regenGlyphs");
     GrBatchTextStrike* strike = nullptr;
     if (regenTexCoords) {
         info->fBulkUseToken.reset();
 
         // 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() :
@@ skipping 146 matching lines @@
     kRegenPosTexGlyph = kRegenPos | kRegenGlyph,
     kRegenPosColTex = kRegenPos | kRegenCol | kRegenTex,
     kRegenPosColTexGlyph = kRegenPos | kRegenCol | kRegenGlyph,
     kRegenColTex = kRegenCol | kRegenTex,
     kRegenColTexGlyph = kRegenCol | kRegenGlyph,
 };
 
 #define REGEN_ARGS target, &flushInfo, blob, &run, &info, &cache, &typeface, &scaler, &desc, gp, \
                    glyphCount, vertexStride, args.fColor, args.fTransX, args.fTransY
 
-void GrAtlasTextBatch::onPrepareDraws(Target* target) {
+void GrAtlasTextBatch::onPrepareDraws(Target* target) const {
     // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
     // TODO actually only invert if we don't have RGBA
     SkMatrix localMatrix;
     if (this->usesLocalCoords() && !this->viewMatrix().invert(&localMatrix)) {
         SkDebugf("Cannot invert viewmatrix\n");
         return;
     }
 
     GrTexture* texture = fFontCache->getTexture(this->maskFormat());
     if (!texture) {
@@ skipping 45 matching lines @@
     unsigned char* currVertex = reinterpret_cast<unsigned char*>(vertices);
 
     // We cache some values to avoid going to the glyphcache for the same fontScaler twice
     // in a row
     const SkDescriptor* desc = nullptr;
     SkGlyphCache* cache = nullptr;
     GrFontScaler* scaler = nullptr;
     SkTypeface* typeface = nullptr;
 
     for (int i = 0; i < fGeoCount; i++) {
-        Geometry& args = fGeoData[i];
+        const Geometry& args = fGeoData[i];
         Blob* blob = args.fBlob;
         Run& run = blob->fRuns[args.fRun];
         TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
         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.
@@ skipping 50 matching lines @@
         currVertex += byteCount;
     }
 
     // Make sure to attach the last cache if applicable
     if (cache) {
         SkGlyphCache::AttachCache(cache);
     }
     this->flush(target, &flushInfo);
 }
 
-void GrAtlasTextBatch::flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) {
+void GrAtlasTextBatch::flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
     GrVertices vertices;
     int maxGlyphsPerDraw = flushInfo->fIndexBuffer->maxQuads();
     vertices.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
                            flushInfo->fIndexBuffer, flushInfo->fVertexOffset,
                            kVerticesPerGlyph, kIndicesPerGlyph, flushInfo->fGlyphsToFlush,
                            maxGlyphsPerDraw);
     target->draw(vertices);
     flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
     flushInfo->fGlyphsToFlush = 0;
 }
@@ skipping 63 matching lines @@
     fGeoCount = newGeoCount;
 
     this->joinBounds(that->bounds());
     return true;
 }
 
 // TODO just use class params
 // TODO trying to figure out why lcd is so whack
 GrGeometryProcessor* GrAtlasTextBatch::setupDfProcessor(const SkMatrix& viewMatrix,
                                                         SkColor filteredColor,
-                                                        GrColor color, GrTexture* texture) {
+                                                        GrColor color, GrTexture* texture) const {
     GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
     bool isLCD = this->isLCD();
     // set up any flags
     uint32_t flags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
 
     // see if we need to create a new effect
     if (isLCD) {
         flags |= kUseLCD_DistanceFieldEffectFlag;
         flags |= viewMatrix.rectStaysRect() ? kRectToRect_DistanceFieldEffectFlag : 0;
         flags |= fUseBGR ? kBGR_DistanceFieldEffectFlag : 0;
@@ skipping 34 matching lines @@
         return GrDistanceFieldA8TextGeoProc::Create(color,
                                                     viewMatrix,
                                                     texture,
                                                     params,
                                                     flags,
                                                     this->usesLocalCoords());
 #endif
     }
 
 }