private iterator to visit all resource cache entries

src/core/SkGlyphCache.cpp

 /*
  * 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.
  */
 
 #include "SkGlyphCache.h"
 #include "SkGlyphCache_Globals.h"
 #include "SkGraphics.h"
@@ skipping 86 matching lines @@
         return SkGlyph::ID2Code(rec.fPackedGlyphID);
     } else {
         return fScalerContext->charToGlyphID(charCode);
     }
 }
 
 SkUnichar SkGlyphCache::glyphToUnichar(uint16_t glyphID) {
     return fScalerContext->glyphIDToChar(glyphID);
 }
 
-unsigned SkGlyphCache::getGlyphCount() {
+unsigned SkGlyphCache::getGlyphCount() const {
     return fScalerContext->getGlyphCount();
 }
 
+int SkGlyphCache::countCachedGlyphs() const {
+    return fGlyphMap.count();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 const SkGlyph& SkGlyphCache::getUnicharAdvance(SkUnichar charCode) {
     VALIDATE();
     return *this->lookupByChar(charCode, kJustAdvance_MetricsType);
 }
 
 const SkGlyph& SkGlyphCache::getGlyphIDAdvance(uint16_t glyphID) {
     VALIDATE();
     PackedGlyphID packedGlyphID = SkGlyph::MakeID(glyphID);
@@ skipping 274 matching lines @@
     return cache;
 }
 
 void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
     SkASSERT(cache);
     SkASSERT(cache->fNext == NULL);
 
     get_globals().attachCacheToHead(cache);
 }
 
+static void dump_visitor(const SkGlyphCache& cache, void* context) {
+    int* counter = (int*)context;
+    int index = *counter;
+    *counter += 1;
+
+    const SkScalerContextRec& rec = cache.getScalerContext()->getRec();
+
+    SkDebugf("[%3d] ID %3d, glyphs %3d, size %g, scale %g, skew %g, [%g %g %g %g]\n",
+             index, rec.fFontID, cache.countCachedGlyphs(),
+             rec.fTextSize, rec.fPreScaleX, rec.fPreSkewX,
+             rec.fPost2x2[0][0], rec.fPost2x2[0][1], rec.fPost2x2[1][0], rec.fPost2x2[1][1]);
+}
+
 void SkGlyphCache::Dump() {
+    SkDebugf("GlyphCache [     used    budget ]\n");

[ssid, 2015/08/07 23:42:11]

We are looking to add these memory statistics to chrome://tracing. Tracing can
trigger periodic dumps and also dumps on-request.

But, I am not clear how this data can be hooked into tracing.

The dump functions added here seem to add data to logs (SkDebugf). Is there a
way to retrieve the log and add it to tracing? Or should we duplicate this code
to add these data to traces?

Even if it can be taken from logs to traces, this format seems very difficult to
parse and add this data to trace json. Could the dump format be made json?

[reed1, 2015/08/11 13:44:19]

SkGlyphCache::Dump() exists just as a client of the private iterators (and as a
test for them). My suggestion is to create an public function for chrome to
call, that will pass in your tracing-callback-objects, and it will perform a
similar iteration, but dump its info into your API object instead of printf.

+    SkDebugf("    bytes  [ %8zu  %8zu ]\n",
+             SkGraphics::GetFontCacheUsed(), SkGraphics::GetFontCacheLimit());
+    SkDebugf("    count  [ %8zu  %8zu ]\n",
+             SkGraphics::GetFontCacheCountUsed(), SkGraphics::GetFontCacheCountLimit());
+
+    int counter = 0;
+    SkGlyphCache::VisitAll(dump_visitor, &counter);
+}
+
+void SkGlyphCache::VisitAll(Visitor visitor, void* context) {
     SkGlyphCache_Globals& globals = get_globals();
     AutoAcquire           ac(globals.fLock);
     SkGlyphCache*         cache;
 
     globals.validate();
 
-    SkDebugf("SkGlyphCache strikes:%d memory:%d\n",
-             globals.getCacheCountUsed(), (int)globals.getTotalMemoryUsed());
-
     for (cache = globals.internalGetHead(); cache != NULL; cache = cache->fNext) {
-        cache->dump();
+        visitor(*cache, context);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGlyphCache_Globals::attachCacheToHead(SkGlyphCache* cache) {
     AutoAcquire ac(fLock);
 
     this->validate();
     cache->validate();
@@ skipping 160 matching lines @@
 }
 
 void SkGraphics::PurgeFontCache() {
     get_globals().purgeAll();
     SkTypefaceCache::PurgeAll();
 }
 
 // TODO(herb): clean up TLS apis.
 size_t SkGraphics::GetTLSFontCacheLimit() { return 0; }
 void SkGraphics::SetTLSFontCacheLimit(size_t bytes) { }