Calculate translations to apply to vertices in batch

src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextBlob.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 217 matching lines @@
 
 #define REGEN_ARGS target, fontCache, helper, &run, &info, cache, typeface, scaler, desc, \
                    *glyphCount, vertexStride, color, transX, transY
 
 void GrAtlasTextBlob::regenInBatch(GrDrawBatch::Target* target,
                                    GrBatchFontCache* fontCache,
                                    GrBlobRegenHelper *helper,
                                    int runIndex, int subRunIndex, SkGlyphCache** cache,
                                    SkTypeface** typeface, GrFontScaler** scaler,
                                    const SkDescriptor** desc, size_t vertexStride,
-                                   GrColor color, SkScalar transX,
-                                   SkScalar transY,
+                                   const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
+                                   GrColor color,
                                    void** vertices, size_t* byteCount, int* glyphCount) {
     Run& run = fRuns[runIndex];
     Run::SubRunInfo& info = run.fSubRunInfo[subRunIndex];
 
     uint64_t currentAtlasGen = fontCache->atlasGeneration(info.maskFormat());
 
+    // Compute translation if any
+    SkScalar transX, transY;
+    info.computeTranslation(viewMatrix, x, y, &transX, &transY);
+
     // 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.strike()->isAbandoned();
     bool regenerateTextureCoords = info.atlasGeneration() != currentAtlasGen ||
@@ skipping 30 matching lines @@
             // set use tokens for all of the glyphs in our subrun.  This is only valid if we
             // have a valid atlas generation
             fontCache->setUseTokenBulk(*info.bulkUseToken(), target->currentToken(),
                                         info.maskFormat());
             break;
     }
 
     *byteCount = info.byteCount();
     *vertices = fVertices + info.vertexStartIndex();
 }