more work on pdf fonts, more to come

experimental/PdfViewer/SkPdfFont.cpp

 #include "SkPdfFont.h"
 #include "SkPdfParser.h"
 
 #include "SkStream.h"
 #include "SkTypeface.h"
 
 std::map<std::string, SkPdfStandardFontEntry>& getStandardFonts() {
     static std::map<std::string, SkPdfStandardFontEntry> gPdfStandardFonts;
 
     // TODO (edisonn): , vs - ? what does it mean?
@@ skipping 130 matching lines @@
             fontName,
             SkTypeface::kNormal);
     }
 
     if (typeface) {
         typeface->ref();
     }
     return typeface;
 }
 
-static SkPdfFont* fontFromFontDescriptor(SkPdfFontDescriptorDictionary* fd) {
+SkPdfFont* SkPdfFont::fontFromFontDescriptor(SkPdfFontDescriptorDictionary* fd, bool loadFromName) {
+    // TODO(edisonn): partial implementation
     // Only one, at most be available
+    SkPdfStream* pdfStream = NULL;
     if (fd->has_FontFile()) {
-
+        pdfStream = fd->FontFile();
     } else if (fd->has_FontFile2()) {
-        SkPdfStream* pdfStream = fd->FontFile2();
-
-        if (!pdfStream->podofo()->GetStream()) {
-            // TODO(edisonn): report warning to be used in testing.
-            return NULL;
+        pdfStream = fd->FontFile2();
+    } if (fd->has_FontFile3()) {
+        pdfStream = fd->FontFile3();
+    } else {
+        if (loadFromName) {
+            return fontFromName(fd, fd->FontName().c_str());
         }
-
-        char* uncompressedStream = NULL;
-        pdf_long uncompressedStreamLength = 0;
-
-        // TODO(edisonn): get rid of try/catch exceptions! We should not throw on user data!
-        try {
-            pdfStream->podofo()->GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
-        } catch (PdfError& e) {
-            // TODO(edisonn): report warning to be used in testing.
-            return NULL;
-        }
-        SkMemoryStream* skStream = new SkMemoryStream(uncompressedStream, uncompressedStreamLength);
-        SkTypeface* face = SkTypeface::CreateFromStream(skStream);
-
-        if (face == NULL) {
-            // TODO(edisonn): report warning to be used in testing.
-            return NULL;
-        }
-
-        face->ref();
-
-        return new SkPdfStandardFont(face);
-    } if (fd->has_FontFile3()) {
-
-    } else {
-
     }
 
-    return NULL;
+    if (!pdfStream || !pdfStream->podofo()->GetStream()) {
+        // TODO(edisonn): report warning to be used in testing.
+        return NULL;
+    }
+
+    char* uncompressedStream = NULL;
+    pdf_long uncompressedStreamLength = 0;
+
+    // TODO(edisonn): get rid of try/catch exceptions! We should not throw on user data!
+    try {
+        pdfStream->podofo()->GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
+    } catch (PdfError& e) {
+        // TODO(edisonn): report warning to be used in testing.
+        return NULL;
+    }
+    SkMemoryStream* skStream = new SkMemoryStream(uncompressedStream, uncompressedStreamLength);
+    SkTypeface* face = SkTypeface::CreateFromStream(skStream);
+
+    if (face == NULL) {
+        // TODO(edisonn): report warning to be used in testing.
+        return NULL;
+    }
+
+    face->ref();
+
+    return new SkPdfStandardFont(face);
 }
 
-SkPdfFont* SkPdfFontFromName(SkPdfObject* obj, const char* fontName) {
+SkPdfFont* fontFromName(SkPdfObject* obj, const char* fontName) {
     SkTypeface* typeface = SkTypefaceFromPdfStandardFont(fontName, false, false);
     if (typeface != NULL) {
         return new SkPdfStandardFont(typeface);
     }
 
     // TODO(edisonn): perf - make a map
     for (int i = 0 ; i < obj->doc()->GetObjects().GetSize(); i++) {
         PdfVecObjects& objects = (PdfVecObjects&)obj->doc()->GetObjects();
         const PdfObject* podofoFont = objects[i];
         SkPdfFontDescriptorDictionary* fd = NULL;
         if (mapFontDescriptorDictionary(*obj->doc(), *podofoFont, &fd)) {
             if (fd->has_FontName() && fd->FontName() == fontName) {
-                SkPdfFont* font = fontFromFontDescriptor(fd);
+                SkPdfFont* font = SkPdfFont::fontFromFontDescriptor(fd, false);
                 if (font) {
                     return font;
                 } else {
                     // failed to load font descriptor
                     break;
                 }
             }
         }
     }
 
     // TODO(edisonn): warning/report issue
     return SkPdfFont::Default();
 }
 
 SkPdfFont* SkPdfFont::fontFromPdfDictionary(SkPdfFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // TODO(edisonn): report default one?
     }
 
     switch (dict->getType()) {
         case kType0FontDictionary_SkPdfObjectType:
             return fontFromType0FontDictionary(dict->asType0FontDictionary());
 
         case kTrueTypeFontDictionary_SkPdfObjectType:
             return fontFromTrueTypeFontDictionary(dict->asTrueTypeFontDictionary());
 
         case kType1FontDictionary_SkPdfObjectType:
             return fontFromType1FontDictionary(dict->asType1FontDictionary());
 
-        case kCIDFontDictionary_SkPdfObjectType:
-            return fontFromCIDFontDictionary(dict->asCIDFontDictionary());
-
         case kMultiMasterFontDictionary_SkPdfObjectType:
             return fontFromMultiMasterFontDictionary(dict->asMultiMasterFontDictionary());
 
         case kType3FontDictionary_SkPdfObjectType:
             return fontFromType3FontDictionary(dict->asType3FontDictionary());
     }
     return NULL;  // TODO(edisonn): report error?
 }
 
 SkPdfType0Font* SkPdfFont::fontFromType0FontDictionary(SkPdfType0FontDictionary* dict) {
@@ skipping 23 matching lines @@
 }
 
 SkPdfTrueTypeFont* SkPdfFont::fontFromTrueTypeFontDictionary(SkPdfTrueTypeFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfTrueTypeFont(dict);
 }
 
-SkPdfCIDFont* SkPdfFont::fontFromCIDFontDictionary(SkPdfCIDFontDictionary* dict) {
-    if (dict == NULL) {
-        return NULL;  // default one?
-    }
-
-    return new SkPdfCIDFont(dict);
-}
-
 SkPdfMultiMasterFont* SkPdfFont::fontFromMultiMasterFontDictionary(SkPdfMultiMasterFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfMultiMasterFont(dict);
 }
 
 static int skstoi(const SkPdfString* str) {
     int ret = 0;
@@ skipping 89 matching lines @@
                     //fCMapEncodingFlag[from] = 1;
                     //fCMapEncoding[from] = to;
                 }
             }
         }
     }
 }
 
 
 SkPdfType0Font::SkPdfType0Font(SkPdfType0FontDictionary* dict) {
-    fBaseFont = SkPdfFontFromName(dict, dict->BaseFont().c_str());
+    fBaseFont = fontFromName(dict, dict->BaseFont().c_str());
     fEncoding = NULL;
 
     if (dict->has_Encoding()) {
         if (dict->isEncodingAName()) {
             fEncoding = SkPdfEncoding::fromName(dict->getEncodingAsName().c_str());
         } else if (dict->isEncodingAStream()) {
             //fEncoding = loadEncodingFromStream(dict->getEncodingAsStream());
         } else {
             // TODO(edisonn): error ... warning .. assert?
         }
@@ skipping 17 matching lines @@
 SkPdfEncoding* SkPdfEncoding::fromName(const char* name) {
     SkPdfEncoding* encoding = getStandardEncodings()[name];
 
 #ifdef PDF_TRACE
     if (encoding == NULL) {
         printf("Encoding not found: %s\n", name);
     }
 #endif
     return encoding;
 }