Add onMemoryDump to GrContext

include/gpu/GrGpuResource.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpuResource_DEFINED
 #define GrGpuResource_DEFINED
 
 #include "GrResourceKey.h"
 #include "GrTypesPriv.h"
 #include "SkData.h"
 
 class GrContext;
 class GrGpu;
 class GrResourceCache;
+class SkTraceMemoryDump;
 
 /**
  * Base class for GrGpuResource. Handles the various types of refs we need. Separated out as a base
  * class to isolate the ref-cnting behavior and provide friendship without exposing all of
  * GrGpuResource.
  *
  * Gpu resources can have three types of refs:
  *   1) Normal ref (+ by ref(), - by unref()): These are used by code that is issuing draw calls
  *      that read and write the resource via GrDrawTarget and by any object that must own a
  *      GrGpuResource and is itself owned (directly or indirectly) by Skia-client code.
@@ skipping 103 matching lines @@
     friend class GrResourceCache; // to check IO ref counts.
 
     template <typename, GrIOType> friend class GrPendingIOResource;
 };
 
 /**
  * Base class for objects that can be kept in the GrResourceCache.
  */
 class SK_API GrGpuResource : public GrIORef<GrGpuResource> {
 public:
-    
-
     enum LifeCycle {
         /**
          * The resource is cached and owned by Skia. Resources with this status may be kept alive
          * by the cache as either scratch or unique resources even when there are no refs to them.
          * The cache may release them whenever there are no refs.
          */
         kCached_LifeCycle,
 
         /**
          * The resource is uncached. As soon as there are no more refs to it, it is released. Under
@@ skipping 92 matching lines @@
     /**
      * Removes references to objects in the underlying 3D API without freeing them.
      * Called by CacheAccess.
      * In general this method should not be called outside of skia. It was
      * made by public for a special case where it needs to be called in Blink
      * when a texture becomes unsafe to use after having been shared through
      * a texture mailbox.
      */
     void abandon();
 
+    /**
+     * Dumps memory usage information for this GrGpuResource to traceMemoryDump.
+     **/
+    void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
+
 protected:
     // This must be called by every GrGpuObject. It should be called once the object is fully
     // initialized (i.e. not in a base class constructor).
     void registerWithCache();
 
     GrGpuResource(GrGpu*, LifeCycle);
     virtual ~GrGpuResource();
 
     GrGpu* getGpu() const { return fGpu; }
 
@@ skipping 16 matching lines @@
      * The cache will call gpuMemorySize() to update the current size of the resource.
      */
     void didChangeGpuMemorySize() const;
 
     /**
      * Optionally called by the GrGpuResource subclass if the resource can be used as scratch.
      * By default resources are not usable as scratch. This should only be called once.
      **/
     void setScratchKey(const GrScratchKey& scratchKey);
 
+    /**
+     * Allows subclasses to add additional backing information to the SkTraceMemoryDump. Called by
+     * onMemoryDump. The default implementation adds no backing information.
+     **/
+    virtual void setMemoryBacking(SkTraceMemoryDump* traceMemoryDump,
+                                  const SkString& dumpName) const {}
+
 private:
     /**
      * Frees the object in the underlying 3D API. Called by CacheAccess.
      */
     void release();
 
     virtual size_t onGpuMemorySize() const = 0;
 
     // See comments in CacheAccess and ResourcePriv.
     void setUniqueKey(const GrUniqueKey&);
@@ skipping 29 matching lines @@
     LifeCycle                   fLifeCycle;
     const uint32_t              fUniqueID;
 
     SkAutoTUnref<const SkData>  fData;
 
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyAllCntsAreZero and notifyRefCntIsZero.
 };
 
 #endif