[tracing] Remove counter logic and just use address on glyph cache dumps

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"
 #include "SkOncePtr.h"
 #include "SkPath.h"
 #include "SkTemplates.h"
 #include "SkTraceMemoryDump.h"
 #include "SkTypeface.h"
 
 #include <cctype>
 
 //#define SPEW_PURGE_STATUS
 
 namespace {
-
 const char gGlyphCacheDumpName[] = "skia/sk_glyph_cache";
-
-// Used to pass context to the sk_trace_dump_visitor.
-struct SkGlyphCacheDumpContext {
-    int* counter;
-    SkTraceMemoryDump* dump;
-};
-
 }  // namespace
 
 // Returns the shared globals
 SK_DECLARE_STATIC_ONCE_PTR(SkGlyphCache_Globals, globals);
 static SkGlyphCache_Globals& get_globals() {
     return *globals.get([]{ return new SkGlyphCache_Globals; });
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 385 matching lines @@
     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);
 }
 
 static void sk_trace_dump_visitor(const SkGlyphCache& cache, void* context) {
-    SkGlyphCacheDumpContext* dumpContext = static_cast<SkGlyphCacheDumpContext*>(context);
-    SkTraceMemoryDump* dump = dumpContext->dump;
-    int* counter = dumpContext->counter;
-    int index = *counter;
-    *counter += 1;
+    SkTraceMemoryDump* dump = static_cast<SkTraceMemoryDump*>(context);
 
     const SkTypeface* face = cache.getScalerContext()->getTypeface();
     const SkScalerContextRec& rec = cache.getScalerContext()->getRec();
 
     SkString fontName;
     face->getFamilyName(&fontName);
     // Replace all special characters with '_'.
     for (size_t index = 0; index < fontName.size(); ++index) {
         if (!std::isalnum(fontName[index])) {
             fontName[index] = '_';
         }
     }
 
-    SkString dumpName = SkStringPrintf("%s/%s_%d/index_%d",
-                                       gGlyphCacheDumpName, fontName.c_str(), rec.fFontID, index);
+    SkString dumpName = SkStringPrintf("%s/%s_%d/%p",
+                                       gGlyphCacheDumpName, fontName.c_str(), rec.fFontID, &cache);
 
     dump->dumpNumericValue(dumpName.c_str(), "size", "bytes", cache.getMemoryUsed());
     dump->dumpNumericValue(dumpName.c_str(), "glyph_count", "objects", cache.countCachedGlyphs());
     dump->setMemoryBacking(dumpName.c_str(), "malloc", nullptr);
 }
 
 void SkGlyphCache::DumpMemoryStatistics(SkTraceMemoryDump* dump) {
     dump->dumpNumericValue(gGlyphCacheDumpName, "size", "bytes", SkGraphics::GetFontCacheUsed());
     dump->dumpNumericValue(gGlyphCacheDumpName, "budget_size", "bytes",
                            SkGraphics::GetFontCacheLimit());
     dump->dumpNumericValue(gGlyphCacheDumpName, "glyph_count", "objects",
                            SkGraphics::GetFontCacheCountUsed());
     dump->dumpNumericValue(gGlyphCacheDumpName, "budget_glyph_count", "objects",
                            SkGraphics::GetFontCacheCountLimit());
 
     if (dump->getRequestedDetails() == SkTraceMemoryDump::kLight_LevelOfDetail) {
         dump->setMemoryBacking(gGlyphCacheDumpName, "malloc", nullptr);
         return;
     }
 
-    int counter = 0;
-    SkGlyphCacheDumpContext context = { &counter, dump };
-    SkGlyphCache::VisitAll(sk_trace_dump_visitor, &context);
+    SkGlyphCache::VisitAll(sk_trace_dump_visitor, dump);
 }
 
 void SkGlyphCache::VisitAll(Visitor visitor, void* context) {
     SkGlyphCache_Globals& globals = get_globals();
     AutoAcquire           ac(globals.fLock);
     SkGlyphCache*         cache;
 
     globals.validate();
 
     for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
@@ skipping 171 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) { }