Fixing leaky handling of SkImage in SkDeferredCanvas.

src/pipe/SkGPipeWrite.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAnnotation.h"
 #include "SkBitmapDevice.h"
@@ skipping 210 matching lines @@
             // Break them all by destroying the final link to this SkGPipeCanvas.
             fBitmapShuttle->removeCanvas();
         }
         fDone = true;
     }
 
     void flushRecording(bool detachCurrentBlock);
     size_t freeMemoryIfPossible(size_t bytesToFree);
 
     size_t storageAllocatedForRecording() {
-        return (NULL == fBitmapHeap) ? 0 : fBitmapHeap->bytesAllocated();
+        size_t bytesAllocated = 0;
+        if (NULL != fBitmapHeap) {
+            bytesAllocated += fBitmapHeap->bytesAllocated();
+        }
+        if (NULL != fImageHeap) {
+            bytesAllocated += fImageHeap->bytesInCache();
+        }
+        return bytesAllocated;
     }
 
     void beginCommentGroup(const char* description) override;
     void addComment(const char* kywd, const char* value) override;
     void endCommentGroup() override;
 
     /**
      * Flatten an SkBitmap to send to the reader, where it will be referenced
      * according to slot.
      */
     bool shuttleBitmap(const SkBitmap&, int32_t slot);
 
+    void resetImageHeap();
+
 protected:
     void willSave() override;
     SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) override;
     void willRestore() override;
 
     void didConcat(const SkMatrix&) override;
     void didSetMatrix(const SkMatrix&) override;
 
     void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
     void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
@@ skipping 896 matching lines @@
 }
 
 void SkGPipeCanvas::flushRecording(bool detachCurrentBlock) {
     this->doNotify();
     if (detachCurrentBlock) {
         // force a new block to be requested for the next recorded command
         fBlockSize = 0;
     }
 }
 
+void SkGPipeCanvas::resetImageHeap() {
+    if (fImageHeap) {
+        fImageHeap->reset();
+    }
+}
+
 size_t SkGPipeCanvas::freeMemoryIfPossible(size_t bytesToFree) {
     return (NULL == fBitmapHeap) ? 0 : fBitmapHeap->freeMemoryIfPossible(bytesToFree);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename T> uint32_t castToU32(T value) {
     union {
         T           fSrc;
         uint32_t    fDst;
@@ skipping 143 matching lines @@
 #include "SkGPipe.h"
 
 SkGPipeController::~SkGPipeController() {
     SkSafeUnref(fCanvas);
 }
 
 void SkGPipeController::setCanvas(SkGPipeCanvas* canvas) {
     SkRefCnt_SafeAssign(fCanvas, canvas);
 }
 
+void SkGPipeController::purgeCaches()
+{
+    fCanvas->resetImageHeap();
+    // Other caches are self-purging with a small MRU pool
+    // We could purge them as well, but it is not clear whether
+    // that would be a win.
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGPipeWriter::SkGPipeWriter()
 : fWriter(0) {
     fCanvas = NULL;
 }
 
 SkGPipeWriter::~SkGPipeWriter() {
     this->endRecording();
 }
@@ skipping 53 matching lines @@
 void BitmapShuttle::removeCanvas() {
     if (NULL == fCanvas) {
         return;
     }
     fCanvas->unref();
     fCanvas = NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkImageHeap::SkImageHeap() {}
+SkImageHeap::SkImageHeap() : fBytesInCache (0) {}
 
 SkImageHeap::~SkImageHeap() {
     fArray.unrefAll();
 }
 
+void SkImageHeap::reset() {
+    fArray.unrefAll();
+    fArray.rewind();
+    fBytesInCache = 0;
+}
+
 const SkImage* SkImageHeap::get(int32_t slot) const {
     SkASSERT(slot > 0);
     return fArray[slot - 1];
 }
 
 int32_t SkImageHeap::find(const SkImage* img) const {
     int index = fArray.find(img);
     if (index >= 0) {
         return index + 1;   // found
     }
     return 0;   // not found
 }
 
 int32_t SkImageHeap::insert(const SkImage* img) {
     int32_t slot = this->find(img);
     if (slot) {
         return slot;
     }
+    // TODO: SkImage does not expose bytes per pixel, 4 is just a best guess.
+    fBytesInCache += img->width() * img->height() * 4;
     *fArray.append() = SkRef(img);
+    printf("Images reff'ed: %d \n", fArray.count());

[reed1, 2015/06/04 13:20:39]

EEEEK!

     return fArray.count();  // slot is always index+1
 }