move most of SkFontHost to private (preceeding making it all private)

trunk/src/pdf/SkPDFFont.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include <ctype.h>
@@ skipping 13 matching lines @@
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 #include "SkTypes.h"
 #include "SkUtils.h"
 
 #if defined (SK_SFNTLY_SUBSETTER)
 #include SK_SFNTLY_SUBSETTER
 #endif
 
+class SkAutoDefaultTypeface {
+public:
+    SkAutoDefaultTypeface() : fFace(SkTypeface::RefDefault()) {
+        fCallUnref = true;
+    }
+    
+    SkAutoDefaultTypeface(SkTypeface* face) : fFace(face) {
+        if (face) {
+            fFace = SkTypeface::RefDefault();
+            fCallUnref = true;
+        } else {
+            fCallUnref = false;
+        }
+    }
+    
+    ~SkAutoDefaultTypeface() {
+        if (fCallUnref) {
+            fFace->unref();
+        }
+    }
+    
+    SkTypeface* get() const { return fFace; }
+    SkTypeface* operator->() { return fFace; }
+    operator SkTypeface*() { return fFace; }
+    
+private:
+    SkTypeface* fFace;
+    bool        fCallUnref;
+};
+
 namespace {
 
 ///////////////////////////////////////////////////////////////////////////////
 // File-Local Functions
 ///////////////////////////////////////////////////////////////////////////////
 
 bool parsePFBSection(const uint8_t** src, size_t* len, int sectionType,
                      size_t* size) {
     // PFB sections have a two or six bytes header. 0x80 and a one byte
     // section type followed by a four byte section length.  Type one is
@@ skipping 490 matching lines @@
 }
 
 #if defined (SK_SFNTLY_SUBSETTER)
 static void sk_delete_array(const void* ptr, size_t, void*) {
     // Use C-style cast to cast away const and cast type simultaneously.
     delete[] (unsigned char*)ptr;
 }
 #endif
 
 static int get_subset_font_stream(const char* fontName,
-                                  const SkTypeface* typeface,
+                                  SkTypeface* typeface,
                                   const SkTDArray<uint32_t>& subset,
                                   SkPDFStream** fontStream) {
-    SkAutoTUnref<SkStream> fontData(
-            SkFontHost::OpenStream(SkTypeface::UniqueID(typeface)));
+    int ttcIndex;
+    SkAutoTUnref<SkStream> fontData(typeface->openStream(&ttcIndex));
 
     int fontSize = fontData->getLength();
 
 #if defined (SK_SFNTLY_SUBSETTER)
     // Read font into buffer.
     SkPDFStream* subsetFontStream = NULL;
     SkTDArray<unsigned char> originalFont;
     originalFont.setCount(fontSize);
     if (fontData->read(originalFont.begin(), fontSize) == (size_t)fontSize) {
         unsigned char* subsetFont = NULL;
@@ skipping 143 matching lines @@
     SkAutoMutexAcquire lock(CanonicalFontsMutex());
     int index = -1;
     for (int i = 0 ; i < CanonicalFonts().count() ; i++) {
         if (CanonicalFonts()[i].fFont == this) {
             index = i;
         }
     }
 
     SkDEBUGCODE(int indexFound;)
     SkASSERT(index == -1 ||
-             (Find(SkTypeface::UniqueID(fTypeface.get()),
+             (Find(fTypeface->uniqueID(),
                    fFirstGlyphID,
                    &indexFound) &&
              index == indexFound));
     if (index >= 0) {
         CanonicalFonts().removeShuffle(index);
     }
     fResources.unrefAll();
 }
 
 void SkPDFFont::getResources(SkTDArray<SkPDFObject*>* resourceList) {
@@ skipping 28 matching lines @@
         }
         glyphIDs[i] -= (fFirstGlyphID - 1);
     }
 
     return numGlyphs;
 }
 
 // static
 SkPDFFont* SkPDFFont::GetFontResource(SkTypeface* typeface, uint16_t glyphID) {
     SkAutoMutexAcquire lock(CanonicalFontsMutex());
-    const uint32_t fontID = SkTypeface::UniqueID(typeface);
+
+    SkAutoDefaultTypeface autoFace(typeface);

[bungeman-skia, 2013/03/12 21:07:23]

Is this less verbose and achieve the same ends?

SkAutoTUnref<SkTypeface> autoTypeface;
if (NULL == typeface) {
    autoTypeface.reset(SkTypeface::RefDefault())
    typeface = autoTypeface.get();
}

+    typeface = autoFace.get();
+
     int relatedFontIndex;
-    if (Find(fontID, glyphID, &relatedFontIndex)) {
+    if (Find(typeface->uniqueID(), glyphID, &relatedFontIndex)) {
         CanonicalFonts()[relatedFontIndex].fFont->ref();
         return CanonicalFonts()[relatedFontIndex].fFont;
     }
 
     SkAutoTUnref<SkAdvancedTypefaceMetrics> fontMetrics;
     SkPDFDict* relatedFontDescriptor = NULL;
     if (relatedFontIndex >= 0) {
         SkPDFFont* relatedFont = CanonicalFonts()[relatedFontIndex].fFont;
         fontMetrics.reset(relatedFont->fontInfo());
         SkSafeRef(fontMetrics.get());
@@ skipping 14 matching lines @@
     } else {
         SkAdvancedTypefaceMetrics::PerGlyphInfo info;
         info = SkAdvancedTypefaceMetrics::kGlyphNames_PerGlyphInfo;
         info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
                   info, SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo);
 #if !defined (SK_SFNTLY_SUBSETTER)
         info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
                   info, SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo);
 #endif
         fontMetrics.reset(
-            SkFontHost::GetAdvancedTypefaceMetrics(fontID, info, NULL, 0));
+            typeface->getAdvancedTypefaceMetrics(info, NULL, 0));
 #if defined (SK_SFNTLY_SUBSETTER)
         if (fontMetrics.get() &&
             fontMetrics->fType != SkAdvancedTypefaceMetrics::kTrueType_Font) {
             // Font does not support subsetting, get new info with advance.
             info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
                       info, SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo);
             fontMetrics.reset(
-                SkFontHost::GetAdvancedTypefaceMetrics(fontID, info, NULL, 0));
+                typeface->getAdvancedTypefaceMetrics(info, NULL, 0));
         }
 #endif
     }
 
     SkPDFFont* font = Create(fontMetrics.get(), typeface, glyphID,
                              relatedFontDescriptor);
-    FontRec newEntry(font, fontID, font->fFirstGlyphID);
+    FontRec newEntry(font, typeface->uniqueID(), font->fFirstGlyphID);
     CanonicalFonts().push(newEntry);
     return font;  // Return the reference new SkPDFFont() created.
 }
 
 SkPDFFont* SkPDFFont::getFontSubset(const SkPDFGlyphSet*) {
     return NULL;  // Default: no support.
 }
 
 // static
 SkTDArray<SkPDFFont::FontRec>& SkPDFFont::CanonicalFonts() {
@@ skipping 19 matching lines @@
         return true;
     }
     search.fGlyphID = 0;
     *index = CanonicalFonts().find(search);
     return false;
 }
 
 SkPDFFont::SkPDFFont(SkAdvancedTypefaceMetrics* info, SkTypeface* typeface,
                      SkPDFDict* relatedFontDescriptor)
         : SkPDFDict("Font"),
           fTypeface(typeface),

[bungeman-skia, 2013/03/12 21:07:23]

Because fTypeface is an SkAutoTUnref<SkTypeface> this change should technically
be written

fTypeface(typeface ? SkRef(typeface) : SkTypeface::RefDefault()),

because Auto things should be written so that they do the right thing should
there be a failure latter in the initializer list. Another reason is that it's a
bit shorter.

[reed1, 2013/03/13 21:18:17]

Done.

           fFirstGlyphID(1),
           fLastGlyphID(info ? info->fLastGlyphID : 0),
           fFontInfo(info),

[bungeman-skia, 2013/03/12 21:07:23]

For the same reason this should have been

fFontInfo(SkSafeRef(info))

and remove the ref in the body, since this is an
SkAutoTUnref<SkAdvancedTypefaceMetrics>.

           fDescriptor(relatedFontDescriptor) {
-    SkSafeRef(typeface);
     SkSafeRef(info);
     if (info == NULL) {
         fFontType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
     } else if (info->fMultiMaster) {
         fFontType = SkAdvancedTypefaceMetrics::kOther_Font;
     } else {
         fFontType = info->fType;
     }
+
+    // we want fTypeface to always ref a valid typeface, so if the caller
+    // gave us null, we ref the default.
+    if (typeface) {
+        typeface->ref();
+    } else {
+        fTypeface.reset(SkTypeface::RefDefault());
+    }
 }
 
 // static
 SkPDFFont* SkPDFFont::Create(SkAdvancedTypefaceMetrics* info,
                              SkTypeface* typeface, uint16_t glyphID,
                              SkPDFDict* relatedFontDescriptor) {
     SkAdvancedTypefaceMetrics::FontType type =
         info ? info->fType : SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
 
     if (info && info->fMultiMaster) {
@@ skipping 210 matching lines @@
             SkAutoTUnref<SkPDFStream> fontStream(rawStream);
             addResource(fontStream.get());
 
             fontStream->insertInt("Length1", fontSize);
             descriptor->insert("FontFile2",
                                new SkPDFObjRef(fontStream.get()))->unref();
             break;
         }
         case SkAdvancedTypefaceMetrics::kCFF_Font:
         case SkAdvancedTypefaceMetrics::kType1CID_Font: {
-            SkAutoTUnref<SkStream> fontData(
-                SkFontHost::OpenStream(SkTypeface::UniqueID(typeface())));
+            int ttcIndex;
+            SkAutoTUnref<SkStream> fontData(typeface()->openStream(&ttcIndex));
             SkAutoTUnref<SkPDFStream> fontStream(
                 new SkPDFStream(fontData.get()));
             addResource(fontStream.get());
 
             if (getType() == SkAdvancedTypefaceMetrics::kCFF_Font) {
                 fontStream->insertName("Subtype", "Type1C");
             } else {
                 fontStream->insertName("Subtype", "CIDFontType0c");
             }
             descriptor->insert("FontFile3",
@@ skipping 18 matching lines @@
             subset->exportTo(&glyphIDs);
         }
 
         SkAdvancedTypefaceMetrics::PerGlyphInfo info;
         info = SkAdvancedTypefaceMetrics::kGlyphNames_PerGlyphInfo;
         info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
                   info, SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo);
         uint32_t* glyphs = (glyphIDs.count() == 1) ? NULL : glyphIDs.begin();
         uint32_t glyphsCount = glyphs ? glyphIDs.count() : 0;
         SkAutoTUnref<SkAdvancedTypefaceMetrics> fontMetrics(
-            SkFontHost::GetAdvancedTypefaceMetrics(
-                    SkTypeface::UniqueID(typeface()),
-                    info,
-                    glyphs,
-                    glyphsCount));
+            typeface()->getAdvancedTypefaceMetrics(info, glyphs, glyphsCount));
         setFontInfo(fontMetrics.get());
         addFontDescriptor(0, &glyphIDs);
     } else {
         // Other CID fonts
         addFontDescriptor(0, NULL);
     }
 
     insertName("BaseFont", fontInfo()->fFontName);
 
     if (getType() == SkAdvancedTypefaceMetrics::kType1CID_Font) {
@@ skipping 68 matching lines @@
         insert("FontDescriptor", new SkPDFObjRef(descriptor))->unref();
         return true;
     }
 
     SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
     setFontDescriptor(descriptor.get());
 
     size_t header SK_INIT_TO_AVOID_WARNING;
     size_t data SK_INIT_TO_AVOID_WARNING;
     size_t trailer SK_INIT_TO_AVOID_WARNING;
-    SkAutoTUnref<SkStream> rawFontData(
-        SkFontHost::OpenStream(SkTypeface::UniqueID(typeface())));
+    int ttcIndex;
+    SkAutoTUnref<SkStream> rawFontData(typeface()->openStream(&ttcIndex));
     SkStream* fontData = handleType1Stream(rawFontData.get(), &header, &data,
                                            &trailer);
     if (fontData == NULL) {
         return false;
     }
     SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData));
     addResource(fontStream.get());
     fontStream->insertInt("Length1", header);
     fontStream->insertInt("Length2", data);
     fontStream->insertInt("Length3", trailer);
@@ skipping 162 matching lines @@
 
     insert("FontBBox", makeFontBBox(bbox, 1000))->unref();
     insertInt("FirstChar", firstGlyphID());
     insertInt("LastChar", lastGlyphID());
     insert("Widths", widthArray.get());
     insertName("CIDToGIDMap", "Identity");
 
     populateToUnicodeTable(NULL);
     return true;
 }