Fix caching of nvpr glyphs

src/gpu/batches/GrDrawPathBatch.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 GrDrawPathBatch_DEFINED
 #define GrDrawPathBatch_DEFINED
 
@@ skipping 77 matching lines @@
 };
 
 /**
  * This could be nested inside the batch class, but for now it must be declarable in a public
  * header (GrDrawContext)
  */
 class GrPathRangeDraw : public GrNonAtomicRef {
 public:
     typedef GrPathRendering::PathTransformType TransformType;
 
-    static GrPathRangeDraw* Create(GrPathRange* range, TransformType transformType,
-        int reserveCnt) {
-        return new GrPathRangeDraw(range, transformType, reserveCnt);
+    static GrPathRangeDraw* Create(TransformType transformType, int reserveCnt) {
+        return new GrPathRangeDraw(transformType, reserveCnt);
     }
 
     void append(uint16_t index, float transform[]) {
         fTransforms.push_back_n(GrPathRendering::PathTransformSize(fTransformType), transform);
         fIndices.push_back(index);
     }
 
     int count() const { return fIndices.count(); }
 
     TransformType transformType() const { return fTransformType; }
 
     const float* transforms() const { return fTransforms.begin(); }
 
     const uint16_t* indices() const { return fIndices.begin(); }
 
-    const GrPathRange* range() const { return fPathRange.get(); }
-
-    void loadGlyphPathsIfNeeded() {
-        fPathRange.get()->loadPathsIfNeeded<uint16_t>(fIndices.begin(), fIndices.count());
-    }
-
     static bool CanMerge(const GrPathRangeDraw& a, const GrPathRangeDraw& b) {
-        return a.transformType() == b.transformType() && a.range() == b.range();
+        return a.transformType() == b.transformType();
     }
 
 private:
-    GrPathRangeDraw(GrPathRange* range, TransformType transformType, int reserveCnt)
-        : fPathRange(range)
-        , fTransformType(transformType)
+    GrPathRangeDraw(TransformType transformType, int reserveCnt)
+        : fTransformType(transformType)
         , fIndices(reserveCnt)
         , fTransforms(reserveCnt * GrPathRendering::PathTransformSize(transformType)) {
         SkDEBUGCODE(fUsedInBatch = false;)
     }
 
     // Reserve space for 64 paths where indices are 16 bit and transforms are translations.
     static const int kIndexReserveCnt = 64;
     static const int kTransformBufferReserveCnt = 2 * 64;
 
-    GrPendingIOResource<const GrPathRange, kRead_GrIOType> fPathRange;
     GrPathRendering::PathTransformType                     fTransformType;
     SkSTArray<kIndexReserveCnt, uint16_t, true>            fIndices;
     SkSTArray<kTransformBufferReserveCnt, float, true>     fTransforms;
 
     // To ensure we don't reuse these across batches.
 #ifdef SK_DEBUG
     bool fUsedInBatch;
     friend class GrDrawPathRangeBatch;
 #endif
 
     typedef GrNonAtomicRef INHERITED;
 };
 
 // Template this if we decide to support index types other than 16bit
 class GrDrawPathRangeBatch final : public GrDrawPathBatchBase {
 public:
     DEFINE_BATCH_CLASS_ID
 
     // This can't return a more abstract type because we install the stencil settings late :(
     static GrDrawPathBatchBase* Create(const SkMatrix& viewMatrix, const SkMatrix& localMatrix,
-                                       GrColor color, GrPathRangeDraw* pathRangeDraw) {
-        return new GrDrawPathRangeBatch(viewMatrix, localMatrix, color, pathRangeDraw);
+                                       GrColor color, GrPathRange* range, GrPathRangeDraw* draw) {
+        return new GrDrawPathRangeBatch(viewMatrix, localMatrix, color, range, draw);
     }
 
     ~GrDrawPathRangeBatch() override;
 
     const char* name() const override { return "DrawPathRange"; }
 
     SkString dumpInfo() const override;
 
 private:
     inline bool isWinding() const;
 
     GrDrawPathRangeBatch(const SkMatrix& viewMatrix, const SkMatrix& localMatrix, GrColor color,
-                         GrPathRangeDraw* pathRangeDraw);
+                         GrPathRange* range, GrPathRangeDraw* draw);
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override;
 
     void onPrepare(GrBatchFlushState*) override {}
 
     void onDraw(GrBatchFlushState* state) override;
 
+    typedef GrPendingIOResource<const GrPathRange, kRead_GrIOType> PendingPathRange;
     typedef SkTLList<GrPathRangeDraw*> DrawList;
-    DrawList    fDraws;
-    int         fTotalPathCount;
-    SkMatrix    fLocalMatrix;
+    PendingPathRange    fPathRange;
+    DrawList            fDraws;
+    int                 fTotalPathCount;
+    SkMatrix            fLocalMatrix;
 
     typedef GrDrawPathBatchBase INHERITED;
 };
 
 #endif