PDF: Canon now owns a reference to all interned objects

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>
 
 #include "SkData.h"
@@ skipping 729 matching lines @@
  *
  * Resources are canonicalized and uniqueified by pointer so there has to be
  * some additional state indicating which subset of the font is used.  It
  * must be maintained at the page granularity and then combined at the document
  * granularity. a) change SkPDFFont to fill in its state on demand, kind of
  * like SkPDFGraphicState.  b) maintain a per font glyph usage class in each
  * page/pdf device. c) in the document, retrieve the per font glyph usage
  * from each page and combine it and ask for a resource with that subset.
  */
 
-SkPDFFont::~SkPDFFont() { fCanon->removeFont(this); }
+SkPDFFont::~SkPDFFont() {}
 
 SkTypeface* SkPDFFont::typeface() {
     return fTypeface.get();
 }
 
 SkAdvancedTypefaceMetrics::FontType SkPDFFont::getType() {
     return fFontType;
 }
 
 bool SkPDFFont::canEmbed() const {
@@ skipping 94 matching lines @@
     SkPDFFont* font = SkPDFFont::Create(canon, fontMetrics.get(), typeface,
                                         glyphID, relatedFontDescriptor);
     canon->addFont(font, fontID, font->fFirstGlyphID);
     return font;
 }
 
 SkPDFFont* SkPDFFont::getFontSubset(const SkPDFGlyphSet*) {
     return NULL;  // Default: no support.
 }
 
-SkPDFFont::SkPDFFont(SkPDFCanon* canon,
-                     const SkAdvancedTypefaceMetrics* info,
+SkPDFFont::SkPDFFont(const SkAdvancedTypefaceMetrics* info,
                      SkTypeface* typeface,
                      SkPDFDict* relatedFontDescriptor)
     : SkPDFDict("Font")
-    , fCanon(canon)
     , fTypeface(ref_or_default(typeface))
     , fFirstGlyphID(1)
     , fLastGlyphID(info ? info->fLastGlyphID : 0)
     , fFontInfo(SkSafeRef(info))
     , fDescriptor(SkSafeRef(relatedFontDescriptor)) {
     if (info == NULL ||
             info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag) {
         fFontType = SkAdvancedTypefaceMetrics::kOther_Font;
     } else {
         fFontType = info->fType;
     }
 }
 
 // static
 SkPDFFont* SkPDFFont::Create(SkPDFCanon* canon,
                              const SkAdvancedTypefaceMetrics* info,
                              SkTypeface* typeface,
                              uint16_t glyphID,
                              SkPDFDict* relatedFontDescriptor) {
     SkAdvancedTypefaceMetrics::FontType type =
         info ? info->fType : SkAdvancedTypefaceMetrics::kOther_Font;
 
     if (info &&
             (info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)) {
         NOT_IMPLEMENTED(true, true);
-        return new SkPDFType3Font(canon, info, typeface, glyphID);
+        return new SkPDFType3Font(info, typeface, glyphID);
     }
     if (type == SkAdvancedTypefaceMetrics::kType1CID_Font ||
         type == SkAdvancedTypefaceMetrics::kTrueType_Font) {
         SkASSERT(relatedFontDescriptor == NULL);
-        return new SkPDFType0Font(canon, info, typeface);
+        return new SkPDFType0Font(info, typeface);
     }
     if (type == SkAdvancedTypefaceMetrics::kType1_Font) {
-        return new SkPDFType1Font(canon, info, typeface, glyphID,
+        return new SkPDFType1Font(info, typeface, glyphID,
                                   relatedFontDescriptor);
     }
 
     SkASSERT(type == SkAdvancedTypefaceMetrics::kCFF_Font ||
              type == SkAdvancedTypefaceMetrics::kOther_Font);
 
-    return new SkPDFType3Font(canon, info, typeface, glyphID);
+    return new SkPDFType3Font(info, typeface, glyphID);
 }
 
 const SkAdvancedTypefaceMetrics* SkPDFFont::fontInfo() {
     return fFontInfo.get();
 }
 
 void SkPDFFont::setFontInfo(const SkAdvancedTypefaceMetrics* info) {
     if (info == NULL || info == fFontInfo.get()) {
         return;
     }
@@ skipping 67 matching lines @@
         generate_tounicode_cmap(fFontInfo->fGlyphToUnicode, subset,
                                 multiByteGlyphs(), firstGlyphID(),
                                 lastGlyphID()));
     insert("ToUnicode", new SkPDFObjRef(pdfCmap.get()))->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType0Font
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPDFType0Font::SkPDFType0Font(SkPDFCanon* canon,
-                               const SkAdvancedTypefaceMetrics* info,
+SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface)
-    : SkPDFFont(canon, info, typeface, NULL) {
+    : SkPDFFont(info, typeface, NULL) {
     SkDEBUGCODE(fPopulated = false);
     if (!canSubset()) {
         populate(NULL);
     }
 }
 
 SkPDFType0Font::~SkPDFType0Font() {}
 
 SkPDFFont* SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) {
     if (!canSubset()) {
         return NULL;
     }
     SkPDFType0Font* newSubset =
-            new SkPDFType0Font(fCanon, fontInfo(), typeface());
+            new SkPDFType0Font(fontInfo(), typeface());
     newSubset->populate(subset);
     return newSubset;
 }
 
 #ifdef SK_DEBUG
 void SkPDFType0Font::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     SkASSERT(fPopulated);
     return INHERITED::emitObject(stream, catalog);
 }
 #endif
 
 bool SkPDFType0Font::populate(const SkPDFGlyphSet* subset) {
     insertName("Subtype", "Type0");
     insertName("BaseFont", fontInfo()->fFontName);
     insertName("Encoding", "Identity-H");
 
     SkAutoTUnref<SkPDFCIDFont> newCIDFont(
-            new SkPDFCIDFont(fCanon, fontInfo(), typeface(), subset));
+            new SkPDFCIDFont(fontInfo(), typeface(), subset));
     SkAutoTUnref<SkPDFArray> descendantFonts(new SkPDFArray());
     descendantFonts->append(new SkPDFObjRef(newCIDFont.get()))->unref();
     insert("DescendantFonts", descendantFonts.get());
 
     populateToUnicodeTable(subset);
 
     SkDEBUGCODE(fPopulated = true);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFCIDFont
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPDFCIDFont::SkPDFCIDFont(SkPDFCanon* canon,
-                           const SkAdvancedTypefaceMetrics* info,
+SkPDFCIDFont::SkPDFCIDFont(const SkAdvancedTypefaceMetrics* info,
                            SkTypeface* typeface,
                            const SkPDFGlyphSet* subset)
-    : SkPDFFont(canon, info, typeface, NULL) {
+    : SkPDFFont(info, typeface, NULL) {
     populate(subset);
 }
 
 SkPDFCIDFont::~SkPDFCIDFont() {}
 
 bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
                                      const SkTDArray<uint32_t>* subset) {
     SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
     setFontDescriptor(descriptor.get());
     insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref();
@@ skipping 130 matching lines @@
         }
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType1Font
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPDFType1Font::SkPDFType1Font(SkPDFCanon* canon,
-                               const SkAdvancedTypefaceMetrics* info,
+SkPDFType1Font::SkPDFType1Font(const SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface,
                                uint16_t glyphID,
                                SkPDFDict* relatedFontDescriptor)
-    : SkPDFFont(canon, info, typeface, relatedFontDescriptor) {
+    : SkPDFFont(info, typeface, relatedFontDescriptor) {
     populate(glyphID);
 }
 
 SkPDFType1Font::~SkPDFType1Font() {}
 
 bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) {
     if (getFontDescriptor() != NULL) {
         SkPDFDict* descriptor = getFontDescriptor();
         insert("FontDescriptor", new SkPDFObjRef(descriptor))->unref();
         return true;
@@ skipping 102 matching lines @@
     }
     insertInt("FirstChar", firstChar);
     insertInt("LastChar", firstChar + widthArray->size() - 1);
     insert("Widths", widthArray.get());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType3Font
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPDFType3Font::SkPDFType3Font(SkPDFCanon* canon,
-                               const SkAdvancedTypefaceMetrics* info,
+SkPDFType3Font::SkPDFType3Font(const SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface,
                                uint16_t glyphID)
-    : SkPDFFont(canon, info, typeface, NULL) {
+    : SkPDFFont(info, typeface, NULL) {
     populate(glyphID);
 }
 
 SkPDFType3Font::~SkPDFType3Font() {}
 
 bool SkPDFType3Font::populate(uint16_t glyphID) {
     SkPaint paint;
     paint.setTypeface(typeface());
     paint.setTextSize(1000);
     SkAutoGlyphCache autoCache(paint, NULL, NULL);
@@ skipping 77 matching lines @@
     }
     if (existingFont != NULL) {
         return (existingFont->fFirstGlyphID <= searchGlyphID &&
                 searchGlyphID <= existingFont->fLastGlyphID)
                        ? SkPDFFont::kExact_Match
                        : SkPDFFont::kRelated_Match;
     }
     return (existingGlyphID == searchGlyphID) ? SkPDFFont::kExact_Match
                                               : SkPDFFont::kRelated_Match;
 }