Table blob leakage tracking

third_party/WebKit/Source/platform/fonts/shaping/HarfBuzzFace.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 249 matching lines @@
         hb_font_funcs_set_glyph_h_advance_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphHorizontalAdvance, 0, 0);
         hb_font_funcs_set_glyph_h_kerning_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphHorizontalKerning, 0, 0);
         hb_font_funcs_set_glyph_v_advance_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphVerticalAdvance, 0, 0);
         hb_font_funcs_set_glyph_v_origin_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphVerticalOrigin, 0, 0);
         hb_font_funcs_set_glyph_extents_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphExtents, 0, 0);
         hb_font_funcs_make_immutable(harfBuzzSkiaFontFuncs);
     }
     return harfBuzzSkiaFontFuncs;
 }
 
+
+struct HbAllocMeta {
+    unsigned int tableSize;
+    hb_tag_t tableTag;
+};
+
+typedef HashMap<hb_tag_t, unsigned int, WTF::IntHash<hb_tag_t>, WTF::UnsignedWithZeroKeyHashTraits<hb_tag_t>> TagTracking;
+
+TagTracking* tagTracker() {
+    DEFINE_STATIC_LOCAL(TagTracking, s_TagTracking, ());
+    return &s_TagTracking;
+}
+
+void reportTagTracking() {
+    LOG(INFO) << "\n";
+    char tagBuf[4] = { 0 };
+    unsigned int totalLeftover = 0;
+    for (auto tagTrackIterator = tagTracker()->begin(); tagTrackIterator != tagTracker()->end(); ++tagTrackIterator) {
+        hb_tag_to_string(tagTrackIterator->key, tagBuf);
+        LOG(INFO) << "Tag: " << tagBuf << " leftover kb " << tagTrackIterator->value / 1024.0;
+        totalLeftover += tagTrackIterator->value;
+    }
+    LOG(INFO) << "---------------------";
+    LOG(INFO) << "Total: kb " << totalLeftover / 1024.0 << "\n";
+}
+
+void subtractFromTagTracking(hb_tag_t tag, unsigned size) {
+    auto findResult = tagTracker()->find(tag);
+    ASSERT(findResult != tagTracker()->end());
+    findResult->value -= size;
+}
+
+void tableBlobfastFree(void* p) {
+    if (p) {
+        HbAllocMeta* allocMeta = reinterpret_cast<HbAllocMeta*>(p);
+        subtractFromTagTracking(allocMeta->tableTag, allocMeta->tableSize);
+    }
+    WTF::Partitions::fastFree(p);
+    reportTagTracking();
+}
+
+void addToTagTracking(hb_tag_t tag, unsigned size) {
+    unsigned newSize = size;
+    auto tagTrackerFindResult = tagTracker()->find(tag);
+    if (tagTrackerFindResult != tagTracker()->end()) {
+        newSize += tagTrackerFindResult->value;
+    }
+    auto tagEntry = tagTracker()->set(tag, newSize);
+}
+
 #if !OS(MACOSX)
 static hb_blob_t* harfBuzzSkiaGetTable(hb_face_t* face, hb_tag_t tag, void* userData)
 {
     SkTypeface* typeface = reinterpret_cast<SkTypeface*>(userData);
 
     const size_t tableSize = typeface->getTableSize(tag);
     if (!tableSize) {
         return nullptr;
     }
 
-    char* buffer = reinterpret_cast<char*>(WTF::Partitions::fastMalloc(tableSize, WTF_HEAP_PROFILER_TYPE_NAME(HarfBuzzFontData)));
+    char* buffer = reinterpret_cast<char*>(WTF::Partitions::fastMalloc(tableSize + sizeof(HbAllocMeta), WTF_HEAP_PROFILER_TYPE_NAME(HarfBuzzFontData)));
     if (!buffer)
         return nullptr;
-    size_t actualSize = typeface->getTableData(tag, 0, tableSize, buffer);
+    size_t actualSize = typeface->getTableData(tag, 0, tableSize, buffer + sizeof(HbAllocMeta));
     if (tableSize != actualSize) {
         WTF::Partitions::fastFree(buffer);
         return nullptr;
     }
-    return hb_blob_create(const_cast<char*>(buffer), tableSize, HB_MEMORY_MODE_WRITABLE, buffer, WTF::Partitions::fastFree);
+
+    HbAllocMeta* allocMeta = reinterpret_cast<HbAllocMeta*>(buffer);
+    allocMeta->tableSize = tableSize;
+    allocMeta->tableTag = tag;
+    addToTagTracking(tag, tableSize);
+
+    hb_blob_t* returnBlob = hb_blob_create(const_cast<char*>(buffer  + sizeof(HbAllocMeta)), tableSize, HB_MEMORY_MODE_WRITABLE, buffer, tableBlobfastFree);
+    LOG(INFO) << "Blob memory allocated: " << tableSize << " bytes.";
+    ASSERT(hb_blob_get_length(returnBlob) == tableSize);
+    return returnBlob;
 }
 #endif
 
 hb_face_t* HarfBuzzFace::createFace()
 {
 #if OS(MACOSX)
     hb_face_t* face = hb_coretext_face_create(m_platformData->cgFont());
 #else
     hb_face_t* face = hb_face_create_for_tables(harfBuzzSkiaGetTable, m_platformData->typeface(), 0);
 #endif
@@ skipping 18 matching lines @@
     m_platformData->setupPaint(&m_harfBuzzFontData->m_paint);
     m_harfBuzzFontData->m_rangeSet = rangeSet;
     m_harfBuzzFontData->m_simpleFontData = FontCache::fontCache()->fontDataFromFontPlatformData(m_platformData);
     ASSERT(m_harfBuzzFontData->m_simpleFontData);
     int scale = SkiaScalarToHarfBuzzPosition(m_platformData->size());
     hb_font_set_scale(m_unscaledFont, scale, scale);
     return m_unscaledFont;
 }
 
 } // namespace blink