Add request cache to SkFontHost_fontconfig.

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 11 matching lines @@
 //#define SK_USE_DISCARDABLE_SCALEDIMAGECACHE
 
 #ifndef SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT
 #   define SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT   1024
 #endif
 
 #ifndef SK_DEFAULT_IMAGE_CACHE_LIMIT
     #define SK_DEFAULT_IMAGE_CACHE_LIMIT     (32 * 1024 * 1024)
 #endif
 
-void SkResourceCache::Key::init(void* nameSpace, uint64_t sharedID, size_t length) {
-    SkASSERT(SkAlign4(length) == length);
+void SkResourceCache::Key::init(void* nameSpace, uint64_t sharedID, size_t dataSize) {
+    SkASSERT(SkAlign4(dataSize) == dataSize);
 
     // fCount32 and fHash are not hashed
     static const int kUnhashedLocal32s = 2; // fCache32 + fHash
     static const int kSharedIDLocal32s = 2; // fSharedID_lo + fSharedID_hi
     static const int kHashedLocal32s = kSharedIDLocal32s + (sizeof(fNamespace) >> 2);
     static const int kLocal32s = kUnhashedLocal32s + kHashedLocal32s;
 
     static_assert(sizeof(Key) == (kLocal32s << 2), "unaccounted_key_locals");
     static_assert(sizeof(Key) == offsetof(Key, fNamespace) + sizeof(fNamespace),
                  "namespace_field_must_be_last");
 
-    fCount32 = SkToS32(kLocal32s + (length >> 2));
+    fCount32 = SkToS32(kLocal32s + (dataSize >> 2));
     fSharedID_lo = (uint32_t)sharedID;
     fSharedID_hi = (uint32_t)(sharedID >> 32);
     fNamespace = nameSpace;
     // skip unhashed fields when computing the murmur
     fHash = SkChecksum::Murmur3(this->as32() + kUnhashedLocal32s,
                                 (fCount32 - kUnhashedLocal32s) << 2);
 }
 
 #include "SkTDynamicHash.h"
 
@@ skipping 644 matching lines @@
         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.
     VisitAll(sk_trace_dump_visitor, dump);
 }