Add onMemoryDump to GrContext

src/gpu/gl/GrGLRenderTarget.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 "GrGLRenderTarget.h"
 
 #include "GrGLGpu.h"
+#include "SkTraceMemoryDump.h"
 
 #define GPUGL static_cast<GrGLGpu*>(this->getGpu())
 #define GL_CALL(X) GR_GL_CALL(GPUGL->glInterface(), X)
 
 // Because this class is virtually derived from GrSurface we must explicitly call its constructor.
 GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc)
     : GrSurface(gpu, idDesc.fLifeCycle, desc)
     , INHERITED(gpu, idDesc.fLifeCycle, desc, idDesc.fSampleConfig) {
     this->init(desc, idDesc);
     this->registerWithCache();
@@ skipping 56 matching lines @@
     fMSColorRenderbufferID  = 0;
     INHERITED::onRelease();
 }
 
 void GrGLRenderTarget::onAbandon() {
     fRTFBOID                = 0;
     fTexFBOID               = 0;
     fMSColorRenderbufferID  = 0;
     INHERITED::onAbandon();
 }
+
+void GrGLRenderTarget::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
+    // Don't log the backing texture's contribution to the memory size. This will be handled by the
+    // texture object.
+
+    // If we have a renderbuffer and it is not auto-resolving, dump it.
+    if (fMSColorRenderbufferID && fRTFBOID != 0) {

[bsalomon, 2015/09/08 15:00:49]

A bug in similar logic was fixed recently in GrGLRenderTaret::init(). Can we add
a private method on GrGLRT to get the number of color color values per pixel to
share implementation? Or maybe a method that computes the memory size of the RT
if that can be shared?

[ericrk, 2015/09/14 21:55:54]

This isn't quite what we want to do here... we only want to log the MSAA buffer
if it exists, not log the size of the entire object (MSAA buffer + texture
resolve target), so this logic doesn't match the logic in init. It doesn't even
match the number of samples calculated in init (intentionally).

I've factored this into a couple helper functions, which I think makes things
clearer... let me know what you think.

+        size_t colorBytes = GrBytesPerPixel(fDesc.fConfig);
+        size_t size = SkTMax(1, fDesc.fSampleCnt) * fDesc.fWidth * fDesc.fHeight * colorBytes;
+
+        // Due to this resource having both a texture and a renderbuffer component, dump as
+        // skia/gpu_resources/resource_#/renderbuffer
+        SkString dumpName("skia/gpu_resources/resource_");
+        dumpName.appendS32(this->getUniqueID());
+        dumpName.append("/renderbuffer");
+
+        traceMemoryDump->dumpNumericValue(dumpName.c_str(), "size", "bytes", size);
+
+        if (this->isPurgeable()) {
+            traceMemoryDump->dumpNumericValue(dumpName.c_str(), "purgeable_size", "bytes", size);
+        }
+
+        SkString renderbuffer_id;
+        renderbuffer_id.appendU32(fMSColorRenderbufferID);
+        traceMemoryDump->setMemoryBacking(dumpName.c_str(), "gl_renderbuffer",
+                                          renderbuffer_id.c_str());
+    }
+}