SkPDF: Memory improvements for PDF Streams

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 566 matching lines @@
     return new SkPDFStream(cmapData.get());
 }
 
 #if defined (SK_SFNTLY_SUBSETTER)
 static void sk_delete_array(const void* ptr, void*) {
     // Use C-style cast to cast away const and cast type simultaneously.
     delete[] (unsigned char*)ptr;
 }
 #endif
 
+#if defined(SK_SFNTLY_SUBSETTER)
 static size_t get_subset_font_stream(const char* fontName,
                                      const SkTypeface* typeface,
                                      const SkTDArray<uint32_t>& subset,
                                      SkPDFStream** fontStream) {
     int ttcIndex;
     SkAutoTDelete<SkStream> fontData(typeface->openStream(&ttcIndex));
     SkASSERT(fontData.get());
 
     size_t fontSize = fontData->getLength();
 
-#if defined (SK_SFNTLY_SUBSETTER)
     // Read font into buffer.
     SkPDFStream* subsetFontStream = NULL;
     SkTDArray<unsigned char> originalFont;
     originalFont.setCount(SkToInt(fontSize));
     if (fontData->read(originalFont.begin(), fontSize) == fontSize) {
         unsigned char* subsetFont = NULL;
         // sfntly requires unsigned int* to be passed in, as far as we know,
         // unsigned int is equivalent to uint32_t on all platforms.
         SK_COMPILE_ASSERT(sizeof(unsigned int) == sizeof(uint32_t),
                           unsigned_int_not_32_bits);
@@ skipping 10 matching lines @@
                                                      NULL));
             subsetFontStream = new SkPDFStream(data.get());
             fontSize = subsetFontSize;
         }
     }
     if (subsetFontStream) {
         *fontStream = subsetFontStream;
         return fontSize;
     }
     fontData->rewind();
-#else
-    sk_ignore_unused_variable(fontName);
-    sk_ignore_unused_variable(subset);
-#endif
 
     // Fail over: just embed the whole font.
     *fontStream = new SkPDFStream(fontData.get());
     return fontSize;
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFGlyphSet
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFGlyphSet::SkPDFGlyphSet() : fBitSet(SK_MaxU16 + 1) {
 }
 
 void SkPDFGlyphSet::set(const uint16_t* glyphIDs, int numGlyphs) {
     for (int i = 0; i < numGlyphs; ++i) {
@@ skipping 408 matching lines @@
         this->insertObjRef("FontDescriptor", descriptor.detach());
         return false;
     }
     if (!canEmbed()) {
         this->insertObjRef("FontDescriptor", descriptor.detach());
         return true;
     }
 
     switch (getType()) {
         case SkAdvancedTypefaceMetrics::kTrueType_Font: {
-            SkAutoTUnref<SkPDFStream> fontStream;
             size_t fontSize = 0;
-            if (canSubset()) {
+#if defined(SK_SFNTLY_SUBSETTER)
+            if (this->canSubset()) {
+                SkAutoTUnref<SkPDFStream> fontStream;
                 SkPDFStream* rawStream = NULL;
                 fontSize = get_subset_font_stream(fontInfo()->fFontName.c_str(),
                                                   typeface(),
                                                   *subset,
                                                   &rawStream);
-                fontStream.reset(rawStream);
-            } else {
-                int ttcIndex;
-                SkAutoTDelete<SkStream> fontData(
-                        typeface()->openStream(&ttcIndex));
-                fontStream.reset(new SkPDFStream(fontData.get()));
-                fontSize = fontData->getLength();
+                if (rawStream) {
+                    fontStream.reset(rawStream);
+                    fontStream->insertInt("Length1", fontSize);
+                    descriptor->insertObjRef("FontFile2", fontStream.detach());
+                    break;
+                }
             }
-            SkASSERT(fontSize);
-            SkASSERT(fontStream.get());
-
-            fontStream->insertInt("Length1", fontSize);
+#endif
+            SkAutoTUnref<SkPDFSharedStream> fontStream;
+            SkAutoTDelete<SkStreamAsset> fontData(
+                    this->typeface()->openStream(NULL));
+            SkASSERT(fontData);
+            fontSize = fontData->getLength();
+            SkASSERT(fontSize > 0);
+            fontStream.reset(new SkPDFSharedStream(fontData.detach()));
+            fontStream->dict()->insertInt("Length1", fontSize);
             descriptor->insertObjRef("FontFile2", fontStream.detach());
             break;
         }
         case SkAdvancedTypefaceMetrics::kCFF_Font:
         case SkAdvancedTypefaceMetrics::kType1CID_Font: {
-            int ttcIndex;
-            SkAutoTDelete<SkStream> fontData(typeface()->openStream(&ttcIndex));
-            SkAutoTUnref<SkPDFStream> fontStream(
-                new SkPDFStream(fontData.get()));
+            SkAutoTUnref<SkPDFSharedStream> fontStream(
+                    new SkPDFSharedStream(this->typeface()->openStream(NULL)));
 
             if (getType() == SkAdvancedTypefaceMetrics::kCFF_Font) {
-                fontStream->insertName("Subtype", "Type1C");
+                fontStream->dict()->insertName("Subtype", "Type1C");
             } else {
-                fontStream->insertName("Subtype", "CIDFontType0c");
+                fontStream->dict()->insertName("Subtype", "CIDFontType0c");
             }
             descriptor->insertObjRef("FontFile3", fontStream.detach());
             break;
         }
         default:
             SkASSERT(false);
     }
     this->insertObjRef("FontDescriptor", descriptor.detach());
     return true;
 }
@@ skipping 303 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;
 }