Store null font lookup result into font cache

src/ports/SkFontHost_fontconfig.cpp

 /*
  * Copyright 2008 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontConfigInterface.h"
 #include "SkFontConfigTypeface.h"
 #include "SkFontDescriptor.h"
@@ skipping 113 matching lines @@
 
         const Key& getKey() const override { return *fRequest; }
         size_t bytesUsed() const override { return fRequest->size() + sizeof(fFace); }
         const char* getCategory() const override { return "request_cache"; }
         SkDiscardableMemory* diagnostic_only_getDiscardable() const override { return nullptr; }
 
         SkAutoTDelete<Request> fRequest;
         SkAutoTUnref<SkTypeface> fFace;
     };
 
+    struct LookUpContext {
+        bool found;
+        SkTypeface* face;
+    };
+
     SkResourceCache fCachedResults;
 
 public:
     SkFontHostRequestCache(size_t maxSize) : fCachedResults(maxSize) {}
 
     /** Takes ownership of request. It will be deleted when no longer needed. */
     void add(SkTypeface* face, Request* request) {
         fCachedResults.add(new Result(request, face));
     }
     /** Does not take ownership of request. */
-    SkTypeface* findAndRef(Request* request) {
-        SkTypeface* face = nullptr;
+    bool findAndRef(Request* request, SkTypeface** face) {
+        LookUpContext lookup_context = {false, nullptr};
         fCachedResults.find(*request, [](const SkResourceCache::Rec& rec, void* context) -> bool {
             const Result& result = static_cast<const Result&>(rec);
-            SkTypeface** face = static_cast<SkTypeface**>(context);
+            LookUpContext* lookup_context = static_cast<LookUpContext*>(context);
 
-            *face = result.fFace;
+            lookup_context->found = true;
+            lookup_context->face = result.fFace;
             return true;
-        }, &face);
-        return SkSafeRef(face);
+        }, &lookup_context);
+        *face = SkSafeRef(lookup_context.face);
+        return lookup_context.found;
     }
 
     /** Takes ownership of request. It will be deleted when no longer needed. */
     static void Add(SkTypeface* face, Request* request) {
         SkAutoMutexAcquire ama(gSkFontHostRequestCacheMutex);
         Get().add(face, request);
     }
 
     /** Does not take ownership of request. */
-    static SkTypeface* FindAndRef(Request* request) {
+    static bool FindAndRef(Request* request, SkTypeface** face) {
         SkAutoMutexAcquire ama(gSkFontHostRequestCacheMutex);
-        return Get().findAndRef(request);
+        return Get().findAndRef(request, face);
     }
 };
 
 SkTypeface* FontConfigTypeface::LegacyCreateTypeface(const char requestedFamilyName[],
                                                      SkFontStyle requestedStyle)
 {
     SkAutoTUnref<SkFontConfigInterface> fci(RefFCI());
     if (nullptr == fci.get()) {
         return nullptr;
     }
 
     // Check if this request is already in the request cache.
     using Request = SkFontHostRequestCache::Request;
     SkAutoTDelete<Request> request(Request::Create(requestedFamilyName, requestedStyle));
-    SkTypeface* face = SkFontHostRequestCache::FindAndRef(request);
-    if (face) {
+    SkTypeface* face;
+    if (SkFontHostRequestCache::FindAndRef(request, &face)) {
         return face;
     }
 
     SkFontConfigInterface::FontIdentity identity;
     SkString outFamilyName;
     SkFontStyle outStyle;
     if (!fci->matchFamilyName(requestedFamilyName, requestedStyle,
                               &identity, &outFamilyName, &outStyle))
     {
+        SkFontHostRequestCache::Add(nullptr, request.release());
         return nullptr;
     }
 
     // Check if a typeface with this FontIdentity is already in the FontIdentity cache.
     face = SkTypefaceCache::FindByProcAndRef(find_by_FontIdentity, &identity);
     if (!face) {
         face = FontConfigTypeface::Create(outStyle, identity, outFamilyName);
         // Add this FontIdentity to the FontIdentity cache.
         SkTypefaceCache::Add(face);
     }
@@ skipping 26 matching lines @@
     *familyName = fFamilyName;
 }
 
 void FontConfigTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
                                              bool* isLocalStream) const {
     SkString name;
     this->getFamilyName(&name);
     desc->setFamilyName(name.c_str());
     *isLocalStream = SkToBool(this->getLocalStream());
 }