Switch SkPDFStream's internal storage from SkStream to SkData

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 132 matching lines @@
     } else if (c <= '9') {
         return c - '0';
     } else if (c <= 'F') {
         return c - 'A' + 10;
     } else if (c <= 'f') {
         return c - 'a' + 10;
     }
     return -1;
 }
 
-SkStream* handleType1Stream(SkStream* srcStream, size_t* headerLen,
-                            size_t* dataLen, size_t* trailerLen) {
+static SkData* handleType1Stream(SkStream* srcStream, size_t* headerLen,

[mtklein, 2014/06/25 18:12:31]

-> handle_type1_stream

[hal.canary, 2014/06/25 18:56:26]

Done.

+                                 size_t* dataLen, size_t* trailerLen) {
     // srcStream may be backed by a file or a unseekable fd, so we may not be
     // able to use skip(), rewind(), or getMemoryBase().  read()ing through
     // the input only once is doable, but very ugly. Furthermore, it'd be nice
     // if the data was NUL terminated so that we can use strstr() to search it.
     // Make as few copies as possible given these constraints.
     SkDynamicMemoryWStream dynamicStream;
     SkAutoTUnref<SkMemoryStream> staticStream;
     SkData* data = NULL;
     const uint8_t* src;
     size_t srcLen;
@@ skipping 27 matching lines @@
         data = dynamicStream.copyToData();
         src = data->bytes();
         srcLen = data->size() - 1;
     }
 
     // this handles releasing the data we may have gotten from dynamicStream.
     // if data is null, it is a no-op
     SkAutoDataUnref aud(data);
 
     if (parsePFB(src, srcLen, headerLen, dataLen, trailerLen)) {
-        SkMemoryStream* result =
-            new SkMemoryStream(*headerLen + *dataLen + *trailerLen);
-        memcpy((char*)result->getAtPos(), src + 6, *headerLen);
-        result->seek(*headerLen);
-        memcpy((char*)result->getAtPos(), src + 6 + *headerLen + 6, *dataLen);
-        result->seek(*headerLen + *dataLen);
-        memcpy((char*)result->getAtPos(), src + 6 + *headerLen + 6 + *dataLen,
+        const size_t length = *headerLen + *dataLen + *trailerLen;
+        SkASSERT(length > 0);
+        SkAutoMalloc buffer(length);
+        char* const result = static_cast<char*>(buffer.get());
+        memcpy(result, src + 6, *headerLen);

[mtklein, 2014/06/25 18:12:31]

Just pass buffer.get() into each of these?

+        memcpy(result + *headerLen, src + 6 + *headerLen + 6, *dataLen);
+        memcpy(result + (*headerLen + *dataLen),

[mtklein, 2014/06/25 18:12:31]

This whole area is really hard to follow.   Diagram and some structuring to make
it clear that what we're doing here with 6s is intentional?

+               src + 6 + *headerLen + 6 + *dataLen,
                *trailerLen);
-        result->rewind();
-        return result;
+        return SkData::NewFromMalloc(buffer.detach(), length);
     }
 
     // A PFA has to be converted for PDF.
     size_t hexDataLen;
     if (parsePFA((const char*)src, srcLen, headerLen, &hexDataLen, dataLen,
                  trailerLen)) {
-        SkMemoryStream* result =
-            new SkMemoryStream(*headerLen + *dataLen + *trailerLen);
-        memcpy((char*)result->getAtPos(), src, *headerLen);
-        result->seek(*headerLen);
+        const size_t length = *headerLen + *dataLen + *trailerLen;
+        SkASSERT(length > 0);
+        SkAutoMalloc buffer(length);

[mtklein, 2014/06/25 18:12:31]

Just start with SkAutoTMalloc<char> if you want chars?

[hal.canary, 2014/06/25 18:56:26]

SkAutoTMalloc uses SK_MALLOC_TEMP, which is not what we want.

[mtklein, 2014/06/26 13:21:59]

Let's ignore that.  SK_MALLOC_TEMP doesn't do anything, and it looks like a
copy-and-paste bug that SkAutoTMalloc sets it.  (SkAutoSTMalloc makes a little
sense that it sets it, but really I think this is a dangerously designed feature
if the implication is we might use alloca instead of malloc...)

+        char* const result = static_cast<char*>(buffer.get());
+        memcpy(result, src, *headerLen);
+        char* const resultData = &(result[*headerLen]);
 
         const uint8_t* hexData = src + *headerLen;
         const uint8_t* trailer = hexData + hexDataLen;
         size_t outputOffset = 0;
         uint8_t dataByte = 0;  // To hush compiler.
         bool highNibble = true;
         for (; hexData < trailer; hexData++) {
             int8_t curNibble = hexToBin(*hexData);
             if (curNibble < 0) {
                 continue;
             }
             if (highNibble) {
                 dataByte = curNibble << 4;
                 highNibble = false;
             } else {
                 dataByte |= curNibble;
                 highNibble = true;
-                ((char *)result->getAtPos())[outputOffset++] = dataByte;
+                resultData[outputOffset++] = dataByte;
             }
         }
         if (!highNibble) {
-            ((char *)result->getAtPos())[outputOffset++] = dataByte;
+            resultData[outputOffset++] = dataByte;
         }
         SkASSERT(outputOffset == *dataLen);
-        result->seek(*headerLen + outputOffset);
 
-        memcpy((char *)result->getAtPos(), src + *headerLen + hexDataLen,
-               *trailerLen);
-        result->rewind();
-        return result;
+        char* const resultTrailer = &(result[*headerLen + outputOffset]);
+        memcpy(resultTrailer, src + *headerLen + hexDataLen, *trailerLen);
+
+        return SkData::NewFromMalloc(buffer.detach(), length);
     }
-
     return NULL;
 }
 
 // scale from em-units to base-1000, returning as a SkScalar
 SkScalar scaleFromFontUnits(int16_t val, uint16_t emSize) {
     SkScalar scaled = SkIntToScalar(val);
     if (emSize == 1000) {
         return scaled;
     } else {
         return SkScalarMulDiv(scaled, 1000, emSize);
@@ skipping 285 matching lines @@
         uint16_t lastGlyphID) {
     SkDynamicMemoryWStream cmap;
     if (multiByteGlyphs) {
         append_tounicode_header(&cmap, firstGlyphID, lastGlyphID);
     } else {
         append_tounicode_header(&cmap, 1, lastGlyphID - firstGlyphID + 1);
     }
     append_cmap_sections(glyphToUnicode, subset, &cmap, multiByteGlyphs,
                          firstGlyphID, lastGlyphID);
     append_cmap_footer(&cmap);
-    SkAutoTUnref<SkMemoryStream> cmapStream(new SkMemoryStream());
-    cmapStream->setData(cmap.copyToData())->unref();
-    return new SkPDFStream(cmapStream.get());
+    SkAutoTUnref<SkData> cmapData(cmap.copyToData());
+    return new SkPDFStream(cmapData.get());

[mtklein, 2014/06/25 18:12:31]

Remind me why this is not

return new SkPDFStream(cmap.copyToData());

?

[hal.canary, 2014/06/25 18:56:26]

The SkPDFStream constructor refs the data.

[mtklein, 2014/06/26 13:21:59]

Add a comment?

 }
 
 #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 size_t get_subset_font_stream(const char* fontName,
                                      const SkTypeface* typeface,
                                      const SkTDArray<uint32_t>& subset,
                                      SkPDFStream** fontStream) {
     int ttcIndex;
     SkAutoTUnref<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;
@@ skipping 701 matching lines @@
     }
 
     SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
     setFontDescriptor(descriptor.get());
 
     int ttcIndex;
     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(typeface()->openStream(&ttcIndex));
-    SkStream* fontData = handleType1Stream(rawFontData.get(), &header, &data,
-                                           &trailer);
+    SkData* fontData = handleType1Stream(rawFontData.get(), &header, &data,
+                                         &trailer);
     if (fontData == NULL) {
         return false;
     }
     if (canEmbed()) {
         SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData));
         addResource(fontStream.get());
         fontStream->insertInt("Length1", header);
         fontStream->insertInt("Length2", data);
         fontStream->insertInt("Length3", trailer);
         descriptor->insert("FontFile",
@@ skipping 163 matching lines @@
 
     insert("FontBBox", makeFontBBox(bbox, 1000))->unref();
     insertInt("FirstChar", 1);
     insertInt("LastChar", lastGlyphID() - firstGlyphID() + 1);
     insert("Widths", widthArray.get());
     insertName("CIDToGIDMap", "Identity");
 
     populateToUnicodeTable(NULL);
     return true;
 }