Don't store an SkMatrix in BitmapShaderKey.

src/core/SkPictureShader.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 "SkPictureShader.h"
 
 #include "SkBitmap.h"
 #include "SkBitmapProcShader.h"
 #include "SkCanvas.h"
 #include "SkMatrixUtils.h"
 #include "SkPicture.h"
 #include "SkReadBuffer.h"
 #include "SkResourceCache.h"
+#include "SkTypes.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #endif
 
 namespace {
 static unsigned gBitmapSkaderKeyNamespaceLabel;
 
 struct BitmapShaderKey : public SkResourceCache::Key {
 public:
     BitmapShaderKey(uint32_t pictureID,
                     const SkRect& tile,
                     SkShader::TileMode tmx,
                     SkShader::TileMode tmy,
                     const SkSize& scale,
                     const SkMatrix& localMatrix)
         : fPictureID(pictureID)
         , fTile(tile)
         , fTmx(tmx)
         , fTmy(tmy)
-        , fScale(scale)
-        , fLocalMatrix(localMatrix) {
+        , fScale(scale) {
+
+        size_t matrixSize = localMatrix.writeToMemory(fLocalMatrixStorage);
+        SkASSERT(matrixSize <= sizeof(fLocalMatrixStorage));
+        sk_bzero(fLocalMatrixStorage + matrixSize, sizeof(fLocalMatrixStorage) - matrixSize);
 
         static const size_t keySize = sizeof(fPictureID) +
                                       sizeof(fTile) +
                                       sizeof(fTmx) + sizeof(fTmy) +
                                       sizeof(fScale) +
-                                      sizeof(fLocalMatrix);
+                                      sizeof(fLocalMatrixStorage);
         // This better be packed.
         SkASSERT(sizeof(uint32_t) * (&fEndOfStruct - &fPictureID) == keySize);
         this->init(&gBitmapSkaderKeyNamespaceLabel, keySize);
     }
 
 private:
     uint32_t           fPictureID;
     SkRect             fTile;
     SkShader::TileMode fTmx, fTmy;
     SkSize             fScale;
-    SkMatrix           fLocalMatrix;
+    uint8_t            fLocalMatrixStorage[SkMatrix::kMaxFlattenSize];

[mtklein, 2014/12/10 19:52:47]

Let's be even more explicit?  This actually includes the type mask, which is a
little silly.

for (int i = 0; i < 9; i++) {
    fLocalMatrixStorage[i] = localMatrix[i];
}
SkScalar fLocalMatrixStorage[9];

[f(malita), 2014/12/10 20:03:29]

Done.

 
     SkDEBUGCODE(uint32_t fEndOfStruct;)
 };
 
 struct BitmapShaderRec : public SkResourceCache::Rec {
     BitmapShaderRec(const BitmapShaderKey& key, SkShader* tileShader, size_t bitmapBytes)
         : fKey(key)
         , fShader(SkRef(tileShader))
         , fBitmapBytes(bitmapBytes) {}
 
@@ skipping 222 matching lines @@
     }
     return bitmapShader->asFragmentProcessor(context, paint, NULL, paintColor, fp);
 }
 #else
 bool SkPictureShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix*, GrColor*,
                                           GrFragmentProcessor**) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 #endif