Strip font name of special characters before dumping

src/core/SkResourceCache.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChecksum.h"
 #include "SkMessageBus.h"
 #include "SkMipMap.h"
@@ skipping 661 matching lines @@
 void SkResourceCache::TestDumpMemoryStatistics() {
     VisitAll(dump_visitor, nullptr);
 }
 
 static void sk_trace_dump_visitor(const SkResourceCache::Rec& rec, void* context) {
     SkTraceMemoryDump* dump = static_cast<SkTraceMemoryDump*>(context);
     SkString dumpName = SkStringPrintf("skia/sk_resource_cache/%s_%p", rec.getCategory(), &rec);
     SkDiscardableMemory* discardable = rec.diagnostic_only_getDiscardable();
     if (discardable) {
         dump->setDiscardableMemoryBacking(dumpName.c_str(), *discardable);
+        dump->dumpNumericValue(dumpName.c_str(), "discardable_size", "bytes", rec.bytesUsed());

[reed1, 2015/09/23 13:21:29]

Why is this needed? Can we not determine the size of the discardable allocation
object itself? The bytesUsed() method I've written combines all of the
allocations associated with the record, both discardable and malloc (typically
the malloc part is quite small).

[ssid, 2015/09/23 13:30:22]

The system works like this:
Skia tells discardable memory interface to dump the particular object allocated
-> Discardable memory dumps the size of the object only if the object is still
alive in discardable manager. If the object has been purged by the discardable
manager, then it records 0 for this object.

Now skia has no way to tell how much memory it potentially could have allocated
and wants to keep around if possible. This discardable_size is an extra
attribute to tell that skia cache would keep around so much of memory if there
was infinite memory available in the system.

Currently the size of the cache shown is coorelated with the discardable manager
and only displays memory which is alive.

     } else {
         dump->dumpNumericValue(dumpName.c_str(), "size", "bytes", rec.bytesUsed());
         dump->setMemoryBacking(dumpName.c_str(), "malloc", nullptr);
     }
 }
 
 void SkResourceCache::DumpMemoryStatistics(SkTraceMemoryDump* dump) {
     // Since resource could be backed by malloc or discardable, the cache always dumps detailed
     // stats to be accurate.
     if (dump->getRequestedDetails() & (SkTraceMemoryDump::kMemoryTotals |
             SkTraceMemoryDump::kDiscardableDetails | SkTraceMemoryDump::kMallocDetails)) {
         VisitAll(sk_trace_dump_visitor, dump);
     }
 }