Fix caching of nvpr glyphs

src/gpu/GrPathRange.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPathRange_DEFINED
 #define GrPathRange_DEFINED
 
@@ skipping 54 matching lines @@
      * Initialize an eager-loaded path range. The subclass is responsible for ensuring all
      * the paths are initialized up front.
      */
     GrPathRange(GrGpu*, int numPaths);
 
     int getNumPaths() const { return fNumPaths; }
     const PathGenerator* getPathGenerator() const { return fPathGenerator.get(); }
 
     void loadPathsIfNeeded(const void* indices, PathIndexType, int count) const;
 
-    template<typename IndexType> void loadPathsIfNeeded(const void* indices, int count) const {
+    template<typename IndexType> void loadPathsIfNeeded(const IndexType* indices, int count) const {
         if (!fPathGenerator) {
             return;
         }
 
-        const IndexType* indexArray = reinterpret_cast<const IndexType*>(indices);
         bool didLoadPaths = false;
 
         for (int i = 0; i < count; ++i) {
-            SkASSERT(indexArray[i] < static_cast<uint32_t>(fNumPaths));
+            SkASSERT(indices[i] < static_cast<uint32_t>(fNumPaths));
 
-            const int groupIndex = indexArray[i] / kPathsPerGroup;
+            const int groupIndex = indices[i] / kPathsPerGroup;
             const int groupByte = groupIndex / 8;
             const uint8_t groupBit = 1 << (groupIndex % 8);
 
             const bool hasPath = SkToBool(fGeneratedPaths[groupByte] & groupBit);
             if (!hasPath) {
                 // We track which paths are loaded in groups of kPathsPerGroup. To
                 // mark a path as loaded we need to load the entire group.
                 const int groupFirstPath = groupIndex * kPathsPerGroup;
                 const int groupLastPath = SkTMin(groupFirstPath + kPathsPerGroup, fNumPaths) - 1;
 
                 SkPath path;
                 for (int pathIdx = groupFirstPath; pathIdx <= groupLastPath; ++pathIdx) {
                     fPathGenerator->generatePath(pathIdx, &path);
                     this->onInitPath(pathIdx, path);
                 }
 
                 fGeneratedPaths[groupByte] |= groupBit;
                 didLoadPaths = true;
             }
         }
 
         if (didLoadPaths) {
             this->didChangeGpuMemorySize();
         }
     }
 
 #ifdef SK_DEBUG
     void assertPathsLoaded(const void* indices, PathIndexType, int count) const;
 
-    template<typename IndexType> void assertPathsLoaded(const void* indices, int count) const {
+    template<typename IndexType> void assertPathsLoaded(const IndexType* indices, int count) const {
         if (!fPathGenerator) {
             return;
         }
 
-        const IndexType* indexArray = reinterpret_cast<const IndexType*>(indices);
+        for (int i = 0; i < count; ++i) {
+            SkASSERT(indices[i] < static_cast<uint32_t>(fNumPaths));
 
-        for (int i = 0; i < count; ++i) {
-            SkASSERT(indexArray[i] < static_cast<uint32_t>(fNumPaths));
-
-            const int groupIndex = indexArray[i] / kPathsPerGroup;
+            const int groupIndex = indices[i] / kPathsPerGroup;
             const int groupByte = groupIndex / 8;
             const uint8_t groupBit = 1 << (groupIndex % 8);
 
             SkASSERT(fGeneratedPaths[groupByte] & groupBit);
         }
     }
 
     virtual bool isEqualTo(const SkDescriptor& desc) const {
         return nullptr != fPathGenerator.get() && fPathGenerator->isEqualTo(desc);
     }
@@ skipping 10 matching lines @@
     };
 
     mutable SkAutoTUnref<PathGenerator> fPathGenerator;
     mutable SkTArray<uint8_t, true /*MEM_COPY*/> fGeneratedPaths;
     const int fNumPaths;
 
     typedef GrGpuResource INHERITED;
 };
 
 #endif