Implement SkPicture::bytesUsed() for SkRecord backend

src/utils/SkPictureUtils.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+#include "SkBBoxHierarchy.h"
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkNoSaveLayerCanvas.h"
 #include "SkPictureUtils.h"
 #include "SkPixelRef.h"
 #include "SkRRect.h"
+#include "SkRecord.h"
 #include "SkShader.h"
 
 class PixelRefSet {
 public:
     PixelRefSet(SkTDArray<SkPixelRef*>* array) : fArray(array) {}
 
     // This does a linear search on existing pixelrefs, so if this list gets big
     // we should use a more complex sorted/hashy thing.
     //
     void add(SkPixelRef* pr) {
@@ skipping 183 matching lines @@
     canvas.clipRect(area, SkRegion::kIntersect_Op, false);
     canvas.drawPicture(pict);
 
     SkData* data = NULL;
     int count = array.count();
     if (count > 0) {
         data = SkData::NewFromMalloc(array.detach(), count * sizeof(SkPixelRef*));
     }
     return data;
 }
+
+class MeasureRecords : SkNoncopyable {
+public:
+    MeasureRecords() : fSize(0) { }
+
+    template <typename T> void operator()(const T& op) {

[mtklein, 2014/11/18 21:38:32]

Maybe just this?

struct MeasureRecords {
  template <typename T> size_t operator()(const T&) { return 0; }
  size_t operator()(const DrawPicture& p) { return SPU::ABU(p.picture); }
};
... 
for (unsigned i = 0; i < pict->fRecord->count(); i++) {
  byteCount += pict->fRecord->visit<size_t>(i, MeasureRecords());
}

[mtklein, 2014/11/18 21:46:23]

Oh, sadly I think you have to do

MeasureRecords v;
for ( ... ) {
  byteCount += pict->fRecord->visit<size_t>(i,v);
}

:(  Non-const references don't get their lifetime extended, even if there's no
state to mutate.

[tomhudson, 2014/11/18 21:49:37]

Acknowledged. (I think you posted this at the same time I was compiling it...)

+        this->measure(op);
+    }
+
+    size_t measuredSize() const { return fSize; }
+private:
+    void measure(const SkRecords::DrawPicture& p) {
+        this->fSize += SkPictureUtils::ApproximateBytesUsed(p.picture);

[mtklein, 2014/11/18 21:38:32]

I applaud your adherence to the style guide, but this may be hypercorrection.  f
already means this->.  :)

+    }
+    template <typename T> void measure(const T&) { }
+
+    size_t fSize;
+};
+
+size_t SkPictureUtils::ApproximateBytesUsed(const SkPicture* pict) {
+    size_t byteCount = sizeof(*pict);
+
+    byteCount += pict->fRecord->bytesUsed();
+    if (pict->fBBH.get()) {
+        byteCount += pict->fBBH->bytesUsed();
+    }
+    byteCount +=
+        pict->fDeletionListeners.reserved() * sizeof(SkPicture::DeletionListener*) +
+        pict->fDeletionListeners.count() * sizeof(SkPicture::DeletionListener);
+
+    MeasureRecords visitor;
+    for (unsigned curOp = 0; curOp < pict->fRecord->count(); curOp++) {
+        pict->fRecord->visit<void>(curOp, visitor);
+    }
+    byteCount += visitor.measuredSize();
+
+    return byteCount;
+}