Fix double-accounting of SkPictureShader bitmap memory

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 "SkImage.h"
+#include "SkImageShader.h"
 #include "SkMatrixUtils.h"
 #include "SkPicture.h"
 #include "SkReadBuffer.h"
 #include "SkResourceCache.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCaps.h"
 #endif
 
@@ skipping 32 matching lines @@
     uint32_t           fPictureID;
     SkRect             fTile;
     SkShader::TileMode fTmx, fTmy;
     SkSize             fScale;
     SkScalar           fLocalMatrixStorage[9];
 
     SkDEBUGCODE(uint32_t fEndOfStruct;)
 };
 
 struct BitmapShaderRec : public SkResourceCache::Rec {
-    BitmapShaderRec(const BitmapShaderKey& key, SkShader* tileShader, size_t bitmapBytes)
+    BitmapShaderRec(const BitmapShaderKey& key, SkShader* tileShader)
         : fKey(key)
-        , fShader(SkRef(tileShader))
-        , fBitmapBytes(bitmapBytes) {}
+        , fShader(SkRef(tileShader)) {}
 
     BitmapShaderKey        fKey;
     SkAutoTUnref<SkShader> fShader;
     size_t                 fBitmapBytes;
 
     const Key& getKey() const override { return fKey; }
     size_t bytesUsed() const override {
-        return sizeof(fKey) + sizeof(SkShader) + fBitmapBytes;
+        // Just the record overhead -- the actual pixels are accounted by SkImageCacherator.
+        return sizeof(fKey) + sizeof(SkImageShader);
     }
     const char* getCategory() const override { return "bitmap-shader"; }
     SkDiscardableMemory* diagnostic_only_getDiscardable() const override { return nullptr; }
 
     static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextShader) {
         const BitmapShaderRec& rec = static_cast<const BitmapShaderRec&>(baseRec);
         SkAutoTUnref<SkShader>* result = reinterpret_cast<SkAutoTUnref<SkShader>*>(contextShader);
 
         result->reset(SkRef(rec.fShader.get()));
 
@@ skipping 138 matching lines @@
         sk_sp<SkImage> tileImage(
             SkImage::MakeFromPicture(fPicture, tileSize, &tileMatrix, nullptr));
         if (!tileImage) {
             return nullptr;
         }
 
         SkMatrix shaderMatrix = this->getLocalMatrix();
         shaderMatrix.preScale(1 / tileScale.width(), 1 / tileScale.height());
         tileShader = tileImage->makeShader(fTmx, fTmy, &shaderMatrix);
 
-        const SkImageInfo tileInfo = SkImageInfo::MakeN32Premul(tileSize);
-        SkResourceCache::Add(new BitmapShaderRec(key, tileShader.get(),
-                                                 tileInfo.getSafeSize(tileInfo.minRowBytes())));
+        SkResourceCache::Add(new BitmapShaderRec(key, tileShader.get()));
     }
 
     return tileShader;
 }
 
 size_t SkPictureShader::onContextSize(const ContextRec&) const {
     return sizeof(PictureShaderContext);
 }
 
 SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const {
@@ skipping 77 matching lines @@
     sk_sp<SkShader> bitmapShader(this->refBitmapShader(*args.fViewMatrix, args.fLocalMatrix,
                                                        maxTextureSize));
     if (!bitmapShader) {
         return nullptr;
     }
     return bitmapShader->asFragmentProcessor(SkShader::AsFPArgs(
         args.fContext, args.fViewMatrix, nullptr, args.fFilterQuality, args.fDstColorSpace,
         args.fGammaTreatment));
 }
 #endif