Fix GrAtlasTextBlob bounds management

src/gpu/text/GrAtlasTextBlob.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAtlasTextBlob_DEFINED
 #define GrAtlasTextBlob_DEFINED
 
@@ skipping 192 matching lines @@
 #ifdef CACHE_SANITY_CHECK
     static void AssertEqual(const GrAtlasTextBlob&, const GrAtlasTextBlob&);
     size_t fSize;
 #endif
 
     // The color here is the GrPaint color, and it is used to determine whether we
     // have to regenerate LCD text blobs.
     // We use this color vs the SkPaint color because it has the colorfilter applied.
     void initReusableBlob(GrColor color, const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
         fPaintColor = color;
-        fViewMatrix = viewMatrix;
-        fX = x;
-        fY = y;
+        this->setupViewMatrix(viewMatrix, x, y);
     }
 
-    void initThrowawayBlob(const SkMatrix& viewMatrix) {
-        fViewMatrix = viewMatrix;
+    void initThrowawayBlob(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
+        this->setupViewMatrix(viewMatrix, x, y);
     }
 
     GrDrawBatch* test_createBatch(int glyphCount, int run, int subRun,
                                   GrColor color, SkScalar transX, SkScalar transY,
                                   const SkPaint& skPaint, const SkSurfaceProps& props,
                                   const GrDistanceFieldAdjustTable* distanceAdjustTable,
                                   GrBatchFontCache* cache);
 
 private:
     void appendLargeGlyph(GrGlyph* glyph, GrFontScaler* scaler, const SkGlyph& skGlyph,
@@ skipping 12 matching lines @@
                         const SkIRect& clipBounds);
 
     void flushRunAsPaths(GrContext* context,
                          GrDrawContext* dc,
                          const SkSurfaceProps& props,
                          const SkTextBlobRunIterator& it,
                          const GrClip& clip, const SkPaint& skPaint,
                          SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
                          const SkIRect& clipBounds, SkScalar x, SkScalar y);
 
+    // This function will only be called when we are regenerating a blob from scratch. We record the
+    // initial view matrix and initial offsets(x,y), because we record vertex bounds relative to
+    // these numbers.  When blobs are reused with new matrices, we need to return to model space so
+    // we can update the vertex bounds appropriately.
+    void setupViewMatrix(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
+        fViewMatrix = viewMatrix;
+        if (!viewMatrix.invert(&fInitialViewMatrixInverse)) {
+            fInitialViewMatrixInverse = SkMatrix::I();
+            SkDebugf("Could not invert viewmatrix\n");
+        }
+        fX = fInitialX = x;
+        fY = fInitialY = y;
+    }
+
     /*
      * Each Run inside of the blob can have its texture coordinates regenerated if required.
      * To determine if regeneration is necessary, fAtlasGeneration is used.  If there have been
      * any evictions inside of the atlas, then we will simply regenerate Runs.  We could track
      * this at a more fine grained level, but its not clear if this is worth it, as evictions
      * should be fairly rare.
      *
      * One additional point, each run can contain glyphs with any of the three mask formats.
      * We call these SubRuns.  Because a subrun must be a contiguous range, we have to create
      * a new subrun each time the mask format changes in a run.  In theory, a run can have as
      * many SubRuns as it has glyphs, ie if a run alternates between color emoji and A8.  In
      * practice, the vast majority of runs have only a single subrun.
      *
      * Finally, for runs where the entire thing is too large for the GrAtlasTextContext to
      * handle, we have a bit to mark the run as flusahable via rendering as paths.  It is worth
      * pointing. It would be a bit expensive to figure out ahead of time whether or not a run
      * can flush in this manner, so we always allocate vertices for the run, regardless of
      * whether or not it is too large.  The benefit of this strategy is that we can always reuse
      * a blob allocation regardless of viewmatrix changes.  We could store positions for these
      * glyphs.  However, its not clear if this is a win because we'd still have to either go the
      * glyph cache to get the path at flush time, or hold onto the path in the cache, which
      * would greatly increase the memory of these cached items.
      */
     struct Run {
         Run()
             : fInitialized(false)
             , fDrawAsPaths(false) {
-            fVertexBounds.setLargestInverted();
             // To ensure we always have one subrun, we push back a fresh run here
             fSubRunInfo.push_back();
         }
         struct SubRunInfo {
             SubRunInfo()
                 : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
                 , fVertexStartIndex(0)
                 , fVertexEndIndex(0)
                 , fGlyphStartIndex(0)
                 , fGlyphEndIndex(0)
                 , fColor(GrColor_ILLEGAL)
                 , fMaskFormat(kA8_GrMaskFormat)
                 , fDrawAsDistanceFields(false)
-                , fUseLCDText(false) {}
+                , fUseLCDText(false) {
+                fVertexBounds.setLargestInverted();
+            }
             SubRunInfo(const SubRunInfo& that)
                 : fBulkUseToken(that.fBulkUseToken)
                 , fStrike(SkSafeRef(that.fStrike.get()))
+                , fVertexBounds(that.fVertexBounds)
                 , fAtlasGeneration(that.fAtlasGeneration)
                 , fVertexStartIndex(that.fVertexStartIndex)
                 , fVertexEndIndex(that.fVertexEndIndex)
                 , fGlyphStartIndex(that.fGlyphStartIndex)
                 , fGlyphEndIndex(that.fGlyphEndIndex)
                 , fColor(that.fColor)
                 , fMaskFormat(that.fMaskFormat)
                 , fDrawAsDistanceFields(that.fDrawAsDistanceFields)
                 , fUseLCDText(that.fUseLCDText) {
             }
@@ skipping 24 matching lines @@
             GrMaskFormat maskFormat() const { return fMaskFormat; }
 
             void setAsSuccessor(const SubRunInfo& prev) {
                 fGlyphStartIndex = prev.glyphEndIndex();
                 fGlyphEndIndex = prev.glyphEndIndex();
 
                 fVertexStartIndex = prev.vertexEndIndex();
                 fVertexEndIndex = prev.vertexEndIndex();
             }
 
+            const SkRect& vertexBounds() const { return fVertexBounds; }
+            void joinGlyphBounds(const SkRect& glyphBounds) {
+                fVertexBounds.joinNonEmptyArg(glyphBounds);
+            }
+
             // df properties
             void setUseLCDText(bool useLCDText) { fUseLCDText = useLCDText; }
             bool hasUseLCDText() const { return fUseLCDText; }
             void setDrawAsDistanceFields() { fDrawAsDistanceFields = true; }
             bool drawAsDistanceFields() const { return fDrawAsDistanceFields; }
 
         private:
             GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
             SkAutoTUnref<GrBatchTextStrike> fStrike;
+            SkRect fVertexBounds;
             uint64_t fAtlasGeneration;
             size_t fVertexStartIndex;
             size_t fVertexEndIndex;
             uint32_t fGlyphStartIndex;
             uint32_t fGlyphEndIndex;
             GrColor fColor;
             GrMaskFormat fMaskFormat;
             bool fDrawAsDistanceFields; // df property
             bool fUseLCDText; // df property
         };
 
         SubRunInfo& push_back() {
             // Forward glyph / vertex information to seed the new sub run
             SubRunInfo& newSubRun = fSubRunInfo.push_back();
             const SubRunInfo& prevSubRun = fSubRunInfo.fromBack(1);
 
             newSubRun.setAsSuccessor(prevSubRun);
             return newSubRun;
         }
         static const int kMinSubRuns = 1;
         SkAutoTUnref<SkTypeface> fTypeface;
-        SkRect fVertexBounds;
         SkSTArray<kMinSubRuns, SubRunInfo> fSubRunInfo;
         SkAutoDescriptor fDescriptor;
 
         // Distance field text cannot draw coloremoji, and so has to fall back.  However,
         // though the distance field text and the coloremoji may share the same run, they
         // will have different descriptors.  If fOverrideDescriptor is non-nullptr, then it
         // will be used in place of the run's descriptor to regen texture coords
         SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor; // df properties
         bool fInitialized;
         bool fDrawAsPaths;
@@ skipping 34 matching lines @@
     // all glyph / vertex offsets are into these pools.
     unsigned char* fVertices;
     GrGlyph** fGlyphs;
     Run* fRuns;
     GrMemoryPool* fPool;
     SkMaskFilter::BlurRec fBlurRec;
     StrokeInfo fStrokeInfo;
     SkTArray<BigGlyph> fBigGlyphs;
     Key fKey;
     SkMatrix fViewMatrix;
+    SkMatrix fInitialViewMatrixInverse;
     GrColor fPaintColor;
+    SkScalar fInitialX;
+    SkScalar fInitialY;
     SkScalar fX;
     SkScalar fY;
 
     // We can reuse distance field text, but only if the new viewmatrix would not result in
     // a mip change.  Because there can be multiple runs in a blob, we track the overall
     // maximum minimum scale, and minimum maximum scale, we can support before we need to regen
     SkScalar fMaxMinScale;
     SkScalar fMinMaxScale;
     int fRunCount;
     uint8_t fTextType;
 
     friend class GrAtlasTextBatch; // We might be able to get rid of this friending
     friend class GrTextBlobCache; // Needs to access the key
 };
 
 #endif