Fix Google3 fonts.

src/ports/SkFontConfigInterface_direct.cpp

 /*
  * Copyright 2009 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /* migrated from chrome/src/skia/ext/SkFontHost_fontconfig_direct.cpp */
 
 #include "SkBuffer.h"
 #include "SkDataTable.h"
 #include "SkFontConfigInterface.h"
 #include "SkFontStyle.h"
 #include "SkMutex.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkTArray.h"
 #include "SkTDArray.h"
 #include "SkTemplates.h"
 #include "SkTypeface.h"
 #include "SkTypes.h"
 
 #include <fontconfig/fontconfig.h>
 #include <unistd.h>
 
+#if defined(GOOGLE3)

[bungeman-skia, 2015/11/23 19:04:54]

I would very much like to minimize this craziness. The issue being that if
there's precedent here, it's much more likely that we'll end up with requests
for more of it. All of this seems a bit hacky, but isn't GOOGLE_BUFFERED_FONTS
what this really cares about? 

+#include "google_font_file_buffering.h"
+#endif
+
 size_t SkFontConfigInterface::FontIdentity::writeToMemory(void* addr) const {
     size_t size = sizeof(fID) + sizeof(fTTCIndex);
     size += sizeof(int32_t) + sizeof(int32_t) + sizeof(uint8_t); // weight, width, italic
     size += sizeof(int32_t) + fString.size();    // store length+data
     if (addr) {
         SkWBuffer buffer(addr, size);
 
         buffer.write32(fID);
         buffer.write32(fTTCIndex);
         buffer.write32(fString.size());
@@ skipping 64 matching lines @@
     SkASSERT(iden0 != iden1);
 
     make_iden(&iden1);
     SkASSERT(iden0 == iden1);
 
     test_writeToMemory(iden0, 0);
     test_writeToMemory(iden0, 0);
 }
 #endif
 
 class SkFontConfigInterfaceDirect : public SkFontConfigInterface {

[bungeman-skia, 2015/11/23 21:39:59]

So here's a plan. Take this definition and put it in a header somewhere. Create
a

class SkFontConfigInterfaceDirectForGoogle : public SkFontConfigInterfaceDirect
{
    SkStreamAsset* openStream(const FontIdentity&) override {
        const char* c_filename = identity.fString.c_str();
        const char* buffer;
        int length = GoogleFreeType::GoogleFt2ReadFontFromMemory(c_filename,
&buffer);
        if (length >= 0) return new SkMemoryStream(buffer, length);
        return SkFontConfigInterfaceDirect::openStream(buffer, length);
    }
}

 public:
             SkFontConfigInterfaceDirect();
     virtual ~SkFontConfigInterfaceDirect();
 
     virtual bool matchFamilyName(const char familyName[],
                                  SkTypeface::Style requested,
                                  FontIdentity* outFontIdentifier,
                                  SkString* outFamilyName,
                                  SkTypeface::Style* outStyle) override;
     SkStreamAsset* openStream(const FontIdentity&) override;
 
     // new APIs
     SkDataTable* getFamilyNames() override;
     virtual bool matchFamilySet(const char inFamilyName[],
                                 SkString* outFamilyName,
                                 SkTArray<FontIdentity>*) override;
 
 private:
     SkMutex mutex_;
 };
 
 SkFontConfigInterface* SkFontConfigInterface::GetSingletonDirectInterface(SkBaseMutex* mutex) {

[bungeman-skia, 2015/11/23 21:39:59]

Then, since this is a factory, put this in a separate compilation unit in Skia.
Skia would normally compile it, but internally there could be another one which
creates a SkFontConfigInterfaceDirectForGoogle instead of
SkFontConfigInterfaceDirect.

     SkAutoMutexAcquire ac(mutex);
     static SkFontConfigInterfaceDirect* singleton = nullptr;
     if (singleton == nullptr) {
         singleton = new SkFontConfigInterfaceDirect;
     }
     return singleton;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 198 matching lines @@
         || !is_scalable) {
         return false;
     }
 #endif
 
     // fontconfig can also return fonts which are unreadable
     const char* c_filename = get_name(pattern, FC_FILE);
     if (!c_filename) {
         return false;
     }
+
+#if defined(GOOGLE3)

[bungeman-skia, 2015/11/23 21:39:59]

This block is harder to remove, but since it wasn't here before I'm not sure
it's really needed.

[bungeman-skia, 2015/11/24 21:56:36]

This block is needed, or at least the 'access' code below needs to go. Otherwise
this method will return false for all fonts.

+    // Check if this font has been pre-loaded into memory.
+    const char* unused;
+    if (GoogleFreeType::GoogleFt2ReadFontFromMemory(c_filename, &unused) >= 0) {
+        return true;
+    }
+#endif
+
     if (access(c_filename, R_OK) != 0) {
         return false;
     }
+
     return true;
 }
 
 // Find matching font from |font_set| for the given font family.
 FcPattern* MatchFont(FcFontSet* font_set,
                      const char* post_config_family,
                      const SkString& family) {
   // Older versions of fontconfig have a bug where they cannot select
   // only scalable fonts so we have to manually filter the results.
   FcPattern* match = nullptr;
@@ skipping 188 matching lines @@
     if (outFamilyName) {
         outFamilyName->set(post_config_family);
     }
     if (outStyle) {
         *outStyle = GetFontStyle(match);
     }
     return true;
 }
 
 SkStreamAsset* SkFontConfigInterfaceDirect::openStream(const FontIdentity& identity) {
-    return SkStream::NewFromFile(identity.fString.c_str());
+    const char* c_filename = identity.fString.c_str();
+#if defined(GOOGLE3)
+    // Read the system fonts from the fonts we've pre-loaded into memory.
+    const char* buffer;
+    int length = GoogleFreeType::GoogleFt2ReadFontFromMemory(
+        c_filename, &buffer);
+    if (length >= 0) return new SkMemoryStream(buffer, length);
+#endif
+    return SkStream::NewFromFile(c_filename);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool find_name(const SkTDArray<const char*>& list, const char* str) {
     int count = list.count();
     for (int i = 0; i < count; ++i) {
         if (!strcmp(list[i], str)) {
             return true;
         }
@@ skipping 157 matching lines @@
             const char* justName = find_just_name(get_name(match[i], FC_FILE));
             if (!is_lower(*justName)) {
                 *trimmedMatches.append() = match[i];
             }
         }
 
         SkFontStyleSet_FC* sset = new SkFontStyleSet_FC                                               (trimmedMatches.begin(),                                               trimmedMatches.count());
 #endif
     return false;
 }