Use variable length key (rather than accumulated matrix) as save layer hoisting key

src/gpu/GrLayerCache.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlas.h"
 #include "GrGpu.h"
 #include "GrLayerCache.h"
@@ skipping 108 matching lines @@
     fLayerHash.rewind();
 
     // The atlas only lets go of its texture when the atlas is deleted.
     fAtlas.free();
 }
 
 GrCachedLayer* GrLayerCache::createLayer(uint32_t pictureID,
                                          int start, int stop,
                                          const SkIRect& bounds,
                                          const SkMatrix& ctm,
+                                         const int* key,
+                                         int keySize,
                                          const SkPaint* paint) {
     SkASSERT(pictureID != SK_InvalidGenID && start >= 0 && stop > 0);
 
-    GrCachedLayer* layer = SkNEW_ARGS(GrCachedLayer, (pictureID, start, stop, bounds, ctm, paint));
+    GrCachedLayer* layer = SkNEW_ARGS(GrCachedLayer, (pictureID, start, stop, bounds, ctm, key, keySize, paint));
     fLayerHash.add(layer);
     return layer;
 }
 
 GrCachedLayer* GrLayerCache::findLayer(uint32_t pictureID,
                                        int start,
                                        const SkIRect& bounds,
-                                       const SkMatrix& ctm) {
+                                       const SkMatrix& ctm,
+                                       const int* key,
+                                       int keySize) {
     SkASSERT(pictureID != SK_InvalidGenID && start > 0);
-    return fLayerHash.find(GrCachedLayer::Key(pictureID, start, bounds, ctm));
+    return fLayerHash.find(GrCachedLayer::Key(pictureID, start, bounds, ctm, key, keySize));
 }
 
 GrCachedLayer* GrLayerCache::findLayerOrCreate(uint32_t pictureID,
                                                int start, int stop,
                                                const SkIRect& bounds,
                                                const SkMatrix& ctm,
+                                               const int* key,
+                                               int keySize,
                                                const SkPaint* paint) {
     SkASSERT(pictureID != SK_InvalidGenID && start >= 0 && stop > 0);
-    GrCachedLayer* layer = fLayerHash.find(GrCachedLayer::Key(pictureID, start, bounds, ctm));
+    GrCachedLayer* layer = fLayerHash.find(GrCachedLayer::Key(pictureID, start, bounds, ctm, key, keySize));
     if (NULL == layer) {
-        layer = this->createLayer(pictureID, start, stop, bounds, ctm, paint);
+        layer = this->createLayer(pictureID, start, stop, bounds, ctm, key, keySize, paint);
     }
 
     return layer;
 }
 
 bool GrLayerCache::tryToAtlas(GrCachedLayer* layer,
                               const GrSurfaceDesc& desc,
                               bool* needsRendering) {
     SkDEBUGCODE(GrAutoValidateLayer avl(fAtlas ? fAtlas->getTexture() : NULL, layer);)
 
@@ skipping 320 matching lines @@
             continue;
         }
 
         SkString fileName(dirName);
         fileName.appendf("\\%d-%d.png", layer->fKey.pictureID(), layer->fKey.start());
 
         layer->texture()->surfacePriv().savePixels(fileName.c_str());
     }
 }
 #endif