[tracing] Add support for skia caches to dump memory stats

src/core/SkGlyphCache.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
  */
 
 #ifndef SkGlyphCache_DEFINED
 #define SkGlyphCache_DEFINED
 
 #include "SkBitmap.h"
 #include "SkChunkAlloc.h"
 #include "SkDescriptor.h"
 #include "SkGlyph.h"
 #include "SkTHash.h"
 #include "SkScalerContext.h"
 #include "SkTemplates.h"
 #include "SkTDArray.h"
 
 class SkPaint;
+class SkTraceMemoryDump;
 
 class SkGlyphCache_Globals;
 
 /** \class SkGlyphCache
 
     This class represents a strike: a specific combination of typeface, size, matrix, etc., and
     holds the glyphs for that strike. Calling any of the getUnichar.../getGlyphID... methods will
     return the requested glyph, either instantly if it is already cached, or by first generating
     it and then adding it to the strike.
 
@@ skipping 60 matching lines @@
     const SkDescriptor& getDescriptor() const { return *fDesc; }
 
     SkMask::Format getMaskFormat() const {
         return fScalerContext->getMaskFormat();
     }
 
     bool isSubpixel() const {
         return fScalerContext->isSubpixel();
     }
 
+    /** Return the approx RAM usage for this cache. */
+    size_t getMemoryUsed() const { return fMemoryUsed; }
+
     void dump() const;
 
-    /*  AuxProc/Data allow a client to associate data with this cache entry. Multiple clients can
+    /** AuxProc/Data allow a client to associate data with this cache entry. Multiple clients can
         use this, as their data is keyed with a function pointer. In addition to serving as a
         key, the function pointer is called with the data when the glyphcache object is deleted,
         so the client can cleanup their data as well.
         NOTE: the auxProc must not try to access this glyphcache in any way, since it may be in
         the process of being deleted.
     */
 
     //! If the proc is found, return true and set *dataPtr to its data
     bool getAuxProcData(void (*auxProc)(void*), void** dataPtr) const;
 
@@ skipping 21 matching lines @@
         descriptor, a different strike will be generated. This is fine. It does mean we can have
         more than 1 strike for the same descriptor, but that will eventually get purged, and the
         win is that different thread will never block each other while a strike is being used.
     */
     static SkGlyphCache* DetachCache(SkTypeface* typeface, const SkDescriptor* desc) {
         return VisitCache(typeface, desc, DetachProc, NULL);
     }
 
     static void Dump();
 
+    /** Dump memory usage statistics of all the attaches caches in the process using the
+        SkTraceMemoryDump interface.
+    */
+    static void DumpMemoryStatistics(SkTraceMemoryDump* dump);
+
     typedef void (*Visitor)(const SkGlyphCache&, void* context);
     static void VisitAll(Visitor, void* context);
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 
     class AutoValidate : SkNoncopyable {
@@ skipping 152 matching lines @@
                             const SkMatrix* matrix) {
         fCache = paint.detachCache(surfaceProps, matrix, true);
     }
 
 private:
     SkAutoGlyphCacheNoGamma() : SkAutoGlyphCacheBase() {}
 };
 #define SkAutoGlyphCacheNoGamma(...) SK_REQUIRE_LOCAL_VAR(SkAutoGlyphCacheNoGamma)
 
 #endif