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

src/gpu/GrLayerHoister.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 "GrLayerCache.h"
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
 
 #include "SkCanvas.h"
 #include "SkGrPixelRef.h"
 #include "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkSurface.h"
 
 // Create the layer information for the hoisted layer and secure the
 // required texture/render target resources.
 static void prepare_for_hoisting(GrLayerCache* layerCache, 
                                  const SkPicture* topLevelPicture,
-                                 const SkMatrix& matrix,
+                                 const SkMatrix& initialMat,
                                  const SkLayerInfo::BlockInfo& info,
                                  const SkIRect& layerRect,
                                  SkTDArray<GrHoistedLayer>* needRendering,
                                  SkTDArray<GrHoistedLayer>* recycled,
                                  bool attemptToAtlas,
                                  int numSamples) {
     const SkPicture* pict = info.fPicture ? info.fPicture : topLevelPicture;
 
-    SkMatrix combined = matrix;
-    combined.preConcat(info.fPreMat);
-    combined.preConcat(info.fLocalMat);
-
-    GrCachedLayer* layer = layerCache->findLayerOrCreate(pict->uniqueID(),
+    GrCachedLayer* layer = layerCache->findLayerOrCreate(topLevelPicture->uniqueID(),
                                                          info.fSaveLayerOpID,
                                                          info.fRestoreOpID,
                                                          layerRect,
-                                                         combined,
+                                                         initialMat,
+                                                         info.fKey,
+                                                         info.fKeySize,
                                                          info.fPaint);
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = layerRect.width();
     desc.fHeight = layerRect.height();
     desc.fConfig = kSkia8888_GrPixelConfig;
     desc.fSampleCnt = numSamples;
 
     bool locked, needsRendering;
     if (attemptToAtlas) {
@@ skipping 19 matching lines @@
         hl = needRendering->append();
     } else {
         hl = recycled->append();
     }
     
     layerCache->addUse(layer);
     hl->fLayer = layer;
     hl->fPicture = pict;
     hl->fOffset = SkIPoint::Make(layerRect.fLeft, layerRect.fTop);
     hl->fLocalMat = info.fLocalMat;
-    hl->fPreMat = matrix;
+    hl->fInitialMat = initialMat;
+    hl->fPreMat = initialMat;
     hl->fPreMat.preConcat(info.fPreMat);
 }
 
 // Atlased layers must be small enough to fit in the atlas, not have a
 // paint with an image filter and be neither nested nor nesting.
 // TODO: allow leaf nested layers to appear in the atlas.
 void GrLayerHoister::FindLayersToAtlas(GrContext* context,
                                        const SkPicture* topLevelPicture,
                                        const SkMatrix& initialMat,
                                        const SkRect& query,
@@ skipping 95 matching lines @@
                              needRendering, recycled, false, numSamples);
     }
 }
 
 static void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
 }
 
-void GrLayerHoister::ConvertLayersToReplacements(const SkTDArray<GrHoistedLayer>& layers,
+void GrLayerHoister::ConvertLayersToReplacements(const SkPicture* topLevelPicture,
+                                                 const SkTDArray<GrHoistedLayer>& layers,
                                                  GrReplacements* replacements) {
     // TODO: just replace GrReplacements::ReplacementInfo with GrCachedLayer?
     for (int i = 0; i < layers.count(); ++i) {
         GrCachedLayer* layer = layers[i].fLayer;
-        const SkPicture* picture = layers[i].fPicture;
-
-        SkMatrix combined = SkMatrix::Concat(layers[i].fPreMat, layers[i].fLocalMat);
 
         GrReplacements::ReplacementInfo* layerInfo =
-                    replacements->newReplacement(picture->uniqueID(),
-                                                 layer->start(),
-                                                 combined);
+                    replacements->newReplacement(topLevelPicture->uniqueID(),
+                                                 layers[i].fInitialMat,
+                                                 layer->key(), layer->keySize());
         layerInfo->fStop = layer->stop();
         layerInfo->fPos = layers[i].fOffset;
 
         SkBitmap bm;
         wrap_texture(layers[i].fLayer->texture(),
                      !layers[i].fLayer->isAtlased() ? layers[i].fLayer->rect().width()
                                                     : layers[i].fLayer->texture()->width(),
                      !layers[i].fLayer->isAtlased() ? layers[i].fLayer->rect().height()
                                                     : layers[i].fLayer->texture()->height(),
                      &bm);
@@ skipping 120 matching lines @@
 void GrLayerHoister::PurgeCache(GrContext* context) {
 #if !GR_CACHE_HOISTED_LAYERS
     GrLayerCache* layerCache = context->getLayerCache();
 
     // This code completely clears out the atlas. It is required when
     // caching is disabled so the atlas doesn't fill up and force more
     // free floating layers
     layerCache->purgeAll();
 #endif
 }