From 51d04d3c17954f9f8629e7d8a9fe870a7b19962f Mon Sep 17 00:00:00 2001 From: halcanary Date: Tue, 8 Mar 2016 13:03:55 -0800 Subject: Revert of SkPDF: Add sk_sp setters; .release() becomes std::move() (patchset #2 id:20001 of https://codereview.chromium.org/1775043002/ ) Reason for revert: https://build.chromium.org/p/client.skia/builders/Linux%20Builder/builds/6405/steps/compile/logs/stdio Original issue's description: > SkPDF: Add sk_sp setters; .release() becomes std::move() > > Note to reviewers: Start with changes to SkPDFTypes.h > > Many places that had a bare pointer owning a reference are refactored to > use a sk_sp. > > There remain several places where a non-owning pointer `T*` should be > replaced with `const sk_sp&` to eliminate the common pattern > `sk_sp(SkRef(x))`. > > Committed: https://skia.googlesource.com/skia/+/9904c9212074279380e21f96575078734dbbd308 TBR=bungeman@google.com # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true Review URL: https://codereview.chromium.org/1775143002 --- src/doc/SkDocument_PDF.cpp | 91 ++++++++++++++++++++++++------------------- src/pdf/SkPDFBitmap.cpp | 14 +++---- src/pdf/SkPDFDevice.cpp | 52 +++++++++++++------------ src/pdf/SkPDFDevice.h | 16 +++++--- src/pdf/SkPDFFont.cpp | 76 ++++++++++++++++++------------------ src/pdf/SkPDFFormXObject.cpp | 10 ++--- src/pdf/SkPDFGraphicState.cpp | 19 ++++----- src/pdf/SkPDFResourceDict.cpp | 10 ++--- src/pdf/SkPDFResourceDict.h | 2 +- src/pdf/SkPDFShader.cpp | 29 +++++++------- src/pdf/SkPDFTypes.cpp | 76 ++++++++++++++++++------------------ src/pdf/SkPDFTypes.h | 39 ++++++++++++------- src/pdf/SkPDFUtils.cpp | 10 +++-- src/pdf/SkPDFUtils.h | 4 +- 14 files changed, 236 insertions(+), 212 deletions(-) (limited to 'src') diff --git a/src/doc/SkDocument_PDF.cpp b/src/doc/SkDocument_PDF.cpp index 101214d7ca..7e5e1a8eba 100644 --- a/src/doc/SkDocument_PDF.cpp +++ b/src/doc/SkDocument_PDF.cpp @@ -31,17 +31,17 @@ static void emit_pdf_footer(SkWStream* stream, SkPDFObject* docCatalog, int64_t objCount, int32_t xRefFileOffset, - sk_sp info, - sk_sp id) { + SkPDFObject* info /* take ownership */, + SkPDFObject* id /* take ownership */) { SkPDFDict trailerDict; // TODO(http://crbug.com/80908): Linearized format will take a // Prev entry too. trailerDict.insertInt("Size", int(objCount)); - trailerDict.insertObjRef("Root", sk_sp(SkRef(docCatalog))); + trailerDict.insertObjRef("Root", SkRef(docCatalog)); SkASSERT(info); - trailerDict.insertObjRef("Info", std::move(info)); + trailerDict.insertObjRef("Info", info); if (id) { - trailerDict.insertObject("ID", std::move(id)); + trailerDict.insertObject("ID", id); } stream->writeText("trailer\n"); trailerDict.emitObject(stream, objNumMap, substitutes); @@ -51,13 +51,13 @@ static void emit_pdf_footer(SkWStream* stream, } static void perform_font_subsetting( - const SkTArray>& pageDevices, + const SkTDArray& pageDevices, SkPDFSubstituteMap* substituteMap) { SkASSERT(substituteMap); SkPDFGlyphSetMap usage; - for (const sk_sp& pageDevice : pageDevices) { - usage.merge(pageDevice->getFontGlyphUsage()); + for (int i = 0; i < pageDevices.count(); ++i) { + usage.merge(pageDevices[i]->getFontGlyphUsage()); } SkPDFGlyphSetMap::F2BIter iterator(usage); const SkPDFGlyphSetMap::FontGlyphSetPair* entry = iterator.next(); @@ -71,24 +71,27 @@ static void perform_font_subsetting( } } -static sk_sp create_pdf_page(const SkPDFDevice* pageDevice) { +static SkPDFObject* create_pdf_page_content(const SkPDFDevice* pageDevice) { + SkAutoTDelete content(pageDevice->content()); + return new SkPDFStream(content.get()); +} + +static SkPDFDict* create_pdf_page(const SkPDFDevice* pageDevice) { auto page = sk_make_sp("Page"); - page->insertObject("Resources", pageDevice->makeResourceDict()); + page->insertObject("Resources", pageDevice->createResourceDict()); page->insertObject("MediaBox", pageDevice->copyMediaBox()); auto annotations = sk_make_sp(); pageDevice->appendAnnotations(annotations.get()); if (annotations->size() > 0) { - page->insertObject("Annots", std::move(annotations)); + page->insertObject("Annots", annotations.release()); } - auto content = pageDevice->content(); - page->insertObjRef("Contents", sk_make_sp(content.get())); - return std::move(page); + page->insertObjRef("Contents", create_pdf_page_content(pageDevice)); + return page.release(); } -// return root node. -static sk_sp generate_page_tree( - const SkTDArray& pages, - SkTDArray* pageTree) { +static void generate_page_tree(const SkTDArray& pages, + SkTDArray* pageTree, + SkPDFDict** rootNode) { // PDF wants a tree describing all the pages in the document. We arbitrary // choose 8 (kNodeSize) as the number of allowed children. The internal // nodes have type "Pages" with an array of children, a parent pointer, and @@ -124,8 +127,8 @@ static sk_sp generate_page_tree( int count = 0; for (; i < curNodes.count() && count < kNodeSize; i++, count++) { - curNodes[i]->insertObjRef("Parent", newNode); - kids->appendObjRef(sk_sp(SkRef(curNodes[i]))); + curNodes[i]->insertObjRef("Parent", SkRef(newNode.get())); + kids->appendObjRef(SkRef(curNodes[i])); // TODO(vandebo): put the objects in strict access order. // Probably doesn't matter because they are so small. @@ -148,7 +151,7 @@ static sk_sp generate_page_tree( pageCount = ((pages.count() - 1) % treeCapacity) + 1; } newNode->insertInt("Count", pageCount); - newNode->insertObject("Kids", std::move(kids)); + newNode->insertObject("Kids", kids.release()); nextRoundNodes.push(newNode.release()); // Transfer reference. } @@ -158,30 +161,34 @@ static sk_sp generate_page_tree( } while (curNodes.count() > 1); pageTree->push(curNodes[0]); // Transfer reference. - return sk_sp(SkRef(curNodes[0])); + if (rootNode) { + *rootNode = curNodes[0]; + } } -static bool emit_pdf_document(const SkTArray>& pageDevices, +static bool emit_pdf_document(const SkTDArray& pageDevices, const SkPDFMetadata& metadata, SkWStream* stream) { - if (pageDevices.empty()) { + if (pageDevices.isEmpty()) { return false; } - SkTDArray pages; // TODO: SkTArray> + SkTDArray pages; auto dests = sk_make_sp(); - for (const sk_sp& pageDevice : pageDevices) { - SkASSERT(pageDevice); - SkASSERT(pageDevices[0]->getCanon() == pageDevice->getCanon()); - sk_sp page(create_pdf_page(pageDevice.get())); - pageDevice->appendDestinations(dests.get(), page.get()); + for (int i = 0; i < pageDevices.count(); i++) { + SkASSERT(pageDevices[i]); + SkASSERT(i == 0 || + pageDevices[i - 1]->getCanon() == pageDevices[i]->getCanon()); + sk_sp page(create_pdf_page(pageDevices[i])); + pageDevices[i]->appendDestinations(dests.get(), page.get()); pages.push(page.release()); } auto docCatalog = sk_make_sp("Catalog"); - sk_sp infoDict(metadata.createDocumentInformationDict()); + sk_sp infoDict( + metadata.createDocumentInformationDict()); sk_sp id, xmp; #ifdef SK_PDF_GENERATE_PDFA @@ -193,7 +200,7 @@ static bool emit_pdf_document(const SkTArray>& pageDevi // works best with reproducible outputs. id.reset(SkPDFMetadata::CreatePdfId(uuid, uuid)); xmp.reset(metadata.createXMPObject(uuid, uuid)); - docCatalog->insertObjRef("Metadata", std::move(xmp)); + docCatalog->insertObjRef("Metadata", xmp.release()); // sRGB is specified by HTML, CSS, and SVG. auto outputIntent = sk_make_sp("OutputIntent"); @@ -202,17 +209,19 @@ static bool emit_pdf_document(const SkTArray>& pageDevi outputIntent->insertString("OutputConditionIdentifier", "sRGB IEC61966-2.1"); auto intentArray = sk_make_sp(); - intentArray->appendObject(std::move(outputIntent)); + intentArray->appendObject(outputIntent.release()); // Don't specify OutputIntents if we are not in PDF/A mode since // no one has ever asked for this feature. - docCatalog->insertObject("OutputIntents", std::move(intentArray)); + docCatalog->insertObject("OutputIntents", intentArray.release()); #endif SkTDArray pageTree; - docCatalog->insertObjRef("Pages", generate_page_tree(pages, &pageTree)); + SkPDFDict* pageTreeRoot; + generate_page_tree(pages, &pageTree, &pageTreeRoot); + docCatalog->insertObjRef("Pages", SkRef(pageTreeRoot)); if (dests->size() > 0) { - docCatalog->insertObjRef("Dests", std::move(dests)); + docCatalog->insertObjRef("Dests", dests.release()); } // Build font subsetting info before proceeding. @@ -253,7 +262,7 @@ static bool emit_pdf_document(const SkTArray>& pageDevi stream->writeText(" 00000 n \n"); } emit_pdf_footer(stream, objNumMap, substitutes, docCatalog.get(), objCount, - xRefFileOffset, std::move(infoDict), std::move(id)); + xRefFileOffset, infoDict.release(), id.release()); // The page tree has both child and parent pointers, so it creates a // reference cycle. We must clear that cycle to properly reclaim memory. @@ -335,7 +344,7 @@ protected: sk_sp device( SkPDFDevice::Create(pageSize, fRasterDpi, &fCanon)); fCanvas.reset(new SkCanvas(device.get())); - fPageDevices.push_back(std::move(device)); + fPageDevices.push(device.release()); fCanvas->clipRect(trimBox); fCanvas->translate(trimBox.x(), trimBox.y()); return fCanvas.get(); @@ -351,13 +360,13 @@ protected: SkASSERT(!fCanvas.get()); bool success = emit_pdf_document(fPageDevices, fMetadata, stream); - fPageDevices.reset(); + fPageDevices.unrefAll(); fCanon.reset(); return success; } void onAbort() override { - fPageDevices.reset(); + fPageDevices.unrefAll(); fCanon.reset(); } @@ -372,7 +381,7 @@ protected: private: SkPDFCanon fCanon; - SkTArray> fPageDevices; + SkTDArray fPageDevices; sk_sp fCanvas; SkScalar fRasterDpi; SkPDFMetadata fMetadata; diff --git a/src/pdf/SkPDFBitmap.cpp b/src/pdf/SkPDFBitmap.cpp index 6c97fbbce0..1e2e26aa71 100644 --- a/src/pdf/SkPDFBitmap.cpp +++ b/src/pdf/SkPDFBitmap.cpp @@ -297,8 +297,8 @@ static void bitmap_alpha_to_a8(const SkBitmap& bitmap, SkWStream* out) { } } -static sk_sp make_indexed_color_space(const SkColorTable* table) { - auto result = sk_make_sp(); +static SkPDFArray* make_indexed_color_space(const SkColorTable* table) { + SkPDFArray* result = new SkPDFArray; result->reserve(4); result->appendName("Indexed"); result->appendName("DeviceRGB"); @@ -308,7 +308,7 @@ static sk_sp make_indexed_color_space(const SkColorTable* table) { char shortTableArray[3] = {0, 0, 0}; SkString tableString(shortTableArray, SK_ARRAY_COUNT(shortTableArray)); result->appendString(tableString); - return std::move(result); + return result; } result->appendInt(table->count() - 1); // maximum color index. @@ -324,13 +324,13 @@ static sk_sp make_indexed_color_space(const SkColorTable* table) { } SkString tableString(tableArray, 3 * table->count()); result->appendString(tableString); - return std::move(result); + return result; } static void emit_image_xobject(SkWStream* stream, const SkImage* image, bool alpha, - const sk_sp& smask, + SkPDFObject* smask, const SkPDFObjNumMap& objNumMap, const SkPDFSubstituteMap& substitutes) { SkBitmap bitmap; @@ -364,7 +364,7 @@ static void emit_image_xobject(SkWStream* stream, pdfDict.insertName("ColorSpace", "DeviceRGB"); } if (smask) { - pdfDict.insertObjRef("SMask", smask); + pdfDict.insertObjRef("SMask", SkRef(smask)); } pdfDict.insertInt("BitsPerComponent", 8); pdfDict.insertName("Filter", "FlateDecode"); @@ -404,7 +404,7 @@ public: void emitObject(SkWStream* stream, const SkPDFObjNumMap& objNumMap, const SkPDFSubstituteMap& subs) const override { - emit_image_xobject(stream, fImage.get(), false, fSMask, objNumMap, subs); + emit_image_xobject(stream, fImage.get(), false, fSMask.get(), objNumMap, subs); } void addResources(SkPDFObjNumMap* catalog, const SkPDFSubstituteMap& subs) const override { diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp index 9f7a3700ef..e988112f37 100644 --- a/src/pdf/SkPDFDevice.cpp +++ b/src/pdf/SkPDFDevice.cpp @@ -879,7 +879,7 @@ void SkPDFDevice::drawPoints(const SkDraw& d, } } -static sk_sp create_link_annotation(const SkRect& translatedRect) { +static SkPDFDict* create_link_annotation(const SkRect& translatedRect) { auto annotation = sk_make_sp("Annot"); annotation->insertName("Subtype", "Link"); @@ -888,7 +888,7 @@ static sk_sp create_link_annotation(const SkRect& translatedRect) { border->appendInt(0); // Horizontal corner radius. border->appendInt(0); // Vertical corner radius. border->appendInt(0); // Width, 0 = no border. - annotation->insertObject("Border", std::move(border)); + annotation->insertObject("Border", border.release()); auto rect = sk_make_sp(); rect->reserve(4); @@ -896,29 +896,30 @@ static sk_sp create_link_annotation(const SkRect& translatedRect) { rect->appendScalar(translatedRect.fTop); rect->appendScalar(translatedRect.fRight); rect->appendScalar(translatedRect.fBottom); - annotation->insertObject("Rect", std::move(rect)); + annotation->insertObject("Rect", rect.release()); - return std::move(annotation); + return annotation.release(); } -static sk_sp create_link_to_url(const SkData* urlData, const SkRect& r) { - auto annotation = create_link_annotation(r); +static SkPDFDict* create_link_to_url(const SkData* urlData, const SkRect& r) { + sk_sp annotation(create_link_annotation(r)); + SkString url(static_cast(urlData->data()), urlData->size() - 1); auto action = sk_make_sp("Action"); action->insertName("S", "URI"); action->insertString("URI", url); - annotation->insertObject("A", std::move(action)); - return std::move(annotation); + annotation->insertObject("A", action.release()); + return annotation.release(); } -static sk_sp create_link_named_dest(const SkData* nameData, - const SkRect& r) { - auto annotation = create_link_annotation(r); +static SkPDFDict* create_link_named_dest(const SkData* nameData, + const SkRect& r) { + sk_sp annotation(create_link_annotation(r)); SkString name(static_cast(nameData->data()), nameData->size() - 1); annotation->insertName("Dest", name); - return std::move(annotation); + return annotation.release(); } void SkPDFDevice::drawRect(const SkDraw& d, @@ -1506,13 +1507,13 @@ void SkPDFDevice::setDrawingArea(DrawingArea drawingArea) { fDrawingArea = drawingArea; } -sk_sp SkPDFDevice::makeResourceDict() const { +SkPDFDict* SkPDFDevice::createResourceDict() const { SkTDArray fonts; fonts.setReserve(fFontResources.count()); for (SkPDFFont* font : fFontResources) { fonts.push(font); } - return SkPDFResourceDict::Make( + return SkPDFResourceDict::Create( &fGraphicStateResources, &fShaderResources, &fXObjectResources, @@ -1523,23 +1524,24 @@ const SkTDArray& SkPDFDevice::getFontResources() const { return fFontResources; } -sk_sp SkPDFDevice::copyMediaBox() const { +SkPDFArray* SkPDFDevice::copyMediaBox() const { + // should this be a singleton? + auto mediaBox = sk_make_sp(); mediaBox->reserve(4); mediaBox->appendInt(0); mediaBox->appendInt(0); - mediaBox->appendInt(fPageSize.width()); - mediaBox->appendInt(fPageSize.height()); - return std::move(mediaBox); + mediaBox->appendInt(fPageSize.fWidth); + mediaBox->appendInt(fPageSize.fHeight); + return mediaBox.release(); } -skstd::unique_ptr SkPDFDevice::content() const { +SkStreamAsset* SkPDFDevice::content() const { SkDynamicMemoryWStream buffer; this->writeContent(&buffer); - return skstd::unique_ptr( - buffer.bytesWritten() > 0 - ? buffer.detachAsStream() - : new SkMemoryStream); + return buffer.bytesWritten() > 0 + ? buffer.detachAsStream() + : new SkMemoryStream; } void SkPDFDevice::copyContentEntriesToData(ContentEntry* entry, @@ -1711,14 +1713,14 @@ void SkPDFDevice::appendDestinations(SkPDFDict* dict, SkPDFObject* page) const { for (const NamedDestination& dest : fNamedDestinations) { auto pdfDest = sk_make_sp(); pdfDest->reserve(5); - pdfDest->appendObjRef(sk_sp(SkRef(page))); + pdfDest->appendObjRef(SkRef(page)); pdfDest->appendName("XYZ"); SkPoint p = fInitialTransform.mapXY(dest.point.x(), dest.point.y()); pdfDest->appendScalar(p.x()); pdfDest->appendScalar(p.y()); pdfDest->appendInt(0); // Leave zoom unchanged SkString name(static_cast(dest.nameData->data())); - dict->insertObject(name, std::move(pdfDest)); + dict->insertObject(name, pdfDest.release()); } } diff --git a/src/pdf/SkPDFDevice.h b/src/pdf/SkPDFDevice.h index b1345a8e3f..310807d86e 100644 --- a/src/pdf/SkPDFDevice.h +++ b/src/pdf/SkPDFDevice.h @@ -144,8 +144,9 @@ public: // PDF specific methods. - /** Create the resource dictionary for this device. */ - sk_sp makeResourceDict() const; + /** Create the resource dictionary for this device. + */ + SkPDFDict* createResourceDict() const; /** Get the fonts used on this device. */ @@ -163,12 +164,15 @@ public: */ void appendDestinations(SkPDFDict* dict, SkPDFObject* page) const; - /** Returns a copy of the media box for this device. */ - sk_sp copyMediaBox() const; + /** Returns a copy of the media box for this device. The caller is required + * to unref() this when it is finished. + */ + SkPDFArray* copyMediaBox() const; - /** Returns a SkStream with the page contents. + /** Returns a SkStream with the page contents. The caller is responsible + * for a deleting the returned value. */ - skstd::unique_ptr content() const; + SkStreamAsset* content() const; /** Writes the page contents to the stream. */ void writeContent(SkWStream*) const; diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp index f5fd410ad0..8615db99ec 100644 --- a/src/pdf/SkPDFFont.cpp +++ b/src/pdf/SkPDFFont.cpp @@ -297,35 +297,37 @@ void setGlyphWidthAndBoundingBox(SkScalar width, SkIRect box, content->writeText(" d1\n"); } -static sk_sp makeFontBBox(SkIRect glyphBBox, uint16_t emSize) { - auto bbox = sk_make_sp(); +SkPDFArray* makeFontBBox(SkIRect glyphBBox, uint16_t emSize) { + SkPDFArray* bbox = new SkPDFArray; bbox->reserve(4); bbox->appendScalar(scaleFromFontUnits(glyphBBox.fLeft, emSize)); bbox->appendScalar(scaleFromFontUnits(glyphBBox.fBottom, emSize)); bbox->appendScalar(scaleFromFontUnits(glyphBBox.fRight, emSize)); bbox->appendScalar(scaleFromFontUnits(glyphBBox.fTop, emSize)); - return std::move(bbox); + return bbox; } -static void appendWidth(const int16_t& width, uint16_t emSize, +SkPDFArray* appendWidth(const int16_t& width, uint16_t emSize, SkPDFArray* array) { array->appendScalar(scaleFromFontUnits(width, emSize)); + return array; } -static void appendVerticalAdvance( +SkPDFArray* appendVerticalAdvance( const SkAdvancedTypefaceMetrics::VerticalMetric& advance, uint16_t emSize, SkPDFArray* array) { appendWidth(advance.fVerticalAdvance, emSize, array); appendWidth(advance.fOriginXDisp, emSize, array); appendWidth(advance.fOriginYDisp, emSize, array); + return array; } template SkPDFArray* composeAdvanceData( SkAdvancedTypefaceMetrics::AdvanceMetric* advanceInfo, uint16_t emSize, - void (*appendAdvance)(const Data& advance, uint16_t emSize, - SkPDFArray* array), + SkPDFArray* (*appendAdvance)(const Data& advance, uint16_t emSize, + SkPDFArray* array), Data* defaultAdvance) { SkPDFArray* result = new SkPDFArray(); for (; advanceInfo != nullptr; advanceInfo = advanceInfo->fNext.get()) { @@ -341,7 +343,7 @@ SkPDFArray* composeAdvanceData( appendAdvance(advanceInfo->fAdvance[j], emSize, advanceArray.get()); result->appendInt(advanceInfo->fStartId); - result->appendObject(std::move(advanceArray)); + result->appendObject(advanceArray.release()); break; } case SkAdvancedTypefaceMetrics::WidthRange::kRun: { @@ -557,7 +559,7 @@ void append_cmap_sections(const SkTDArray& glyphToUnicode, append_bfrange_section(bfrangeEntries, cmap); } -static sk_sp generate_tounicode_cmap( +static SkPDFStream* generate_tounicode_cmap( const SkTDArray& glyphToUnicode, const SkPDFGlyphSet* subset, bool multiByteGlyphs, @@ -573,7 +575,7 @@ static sk_sp generate_tounicode_cmap( firstGlyphID, lastGlyphID); append_cmap_footer(&cmap); sk_sp cmapData(cmap.copyToData()); - return sk_make_sp(cmapData.get()); + return new SkPDFStream(cmapData.get()); } #if defined (SK_SFNTLY_SUBSETTER) @@ -1020,8 +1022,8 @@ bool SkPDFType0Font::populate(const SkPDFGlyphSet* subset) { sk_sp newCIDFont( new SkPDFCIDFont(fontInfo(), typeface(), subset)); auto descendantFonts = sk_make_sp(); - descendantFonts->appendObjRef(std::move(newCIDFont)); - this->insertObject("DescendantFonts", std::move(descendantFonts)); + descendantFonts->appendObjRef(newCIDFont.release()); + this->insertObject("DescendantFonts", descendantFonts.release()); this->populateToUnicodeTable(subset); @@ -1047,7 +1049,7 @@ bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth, auto descriptor = sk_make_sp("FontDescriptor"); setFontDescriptor(descriptor.get()); if (!addCommonFontDescriptorEntries(defaultWidth)) { - this->insertObjRef("FontDescriptor", std::move(descriptor)); + this->insertObjRef("FontDescriptor", descriptor.release()); return false; } SkASSERT(this->canEmbed()); @@ -1066,7 +1068,7 @@ bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth, if (rawStream) { fontStream.reset(rawStream); fontStream->insertInt("Length1", fontSize); - descriptor->insertObjRef("FontFile2", std::move(fontStream)); + descriptor->insertObjRef("FontFile2", fontStream.release()); break; } } @@ -1079,7 +1081,7 @@ bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth, SkASSERT(fontSize > 0); fontStream.reset(new SkPDFSharedStream(fontData.detach())); fontStream->dict()->insertInt("Length1", fontSize); - descriptor->insertObjRef("FontFile2", std::move(fontStream)); + descriptor->insertObjRef("FontFile2", fontStream.release()); break; } case SkAdvancedTypefaceMetrics::kCFF_Font: @@ -1092,13 +1094,13 @@ bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth, } else { fontStream->dict()->insertName("Subtype", "CIDFontType0c"); } - descriptor->insertObjRef("FontFile3", std::move(fontStream)); + descriptor->insertObjRef("FontFile3", fontStream.release()); break; } default: SkASSERT(false); } - this->insertObjRef("FontDescriptor", std::move(descriptor)); + this->insertObjRef("FontDescriptor", descriptor.release()); return true; } @@ -1145,7 +1147,7 @@ bool SkPDFCIDFont::populate(const SkPDFGlyphSet* subset) { sysInfo->insertString("Registry", "Adobe"); sysInfo->insertString("Ordering", "Identity"); sysInfo->insertInt("Supplement", 0); - this->insertObject("CIDSystemInfo", std::move(sysInfo)); + this->insertObject("CIDSystemInfo", sysInfo.release()); if (fontInfo()->fGlyphWidths.get()) { int16_t defaultWidth = 0; @@ -1154,7 +1156,7 @@ bool SkPDFCIDFont::populate(const SkPDFGlyphSet* subset) { fontInfo()->fEmSize, &appendWidth, &defaultWidth)); if (widths->size()) - this->insertObject("W", std::move(widths)); + this->insertObject("W", widths.release()); if (defaultWidth != 0) { this->insertScalar( "DW", @@ -1171,15 +1173,14 @@ bool SkPDFCIDFont::populate(const SkPDFGlyphSet* subset) { fontInfo()->fEmSize, &appendVerticalAdvance, &defaultAdvance)); if (advances->size()) - this->insertObject("W2", std::move(advances)); + this->insertObject("W2", advances.release()); if (defaultAdvance.fVerticalAdvance || defaultAdvance.fOriginXDisp || defaultAdvance.fOriginYDisp) { - auto array = sk_make_sp(); - appendVerticalAdvance(defaultAdvance, - fontInfo()->fEmSize, - array.get()); - this->insertObject("DW2", std::move(array)); + this->insertObject("DW2", + appendVerticalAdvance(defaultAdvance, + fontInfo()->fEmSize, + new SkPDFArray)); } } @@ -1202,8 +1203,7 @@ SkPDFType1Font::~SkPDFType1Font() {} bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) { if (SkPDFDict* descriptor = getFontDescriptor()) { - this->insertObjRef("FontDescriptor", - sk_sp(SkRef(descriptor))); + this->insertObjRef("FontDescriptor", SkRef(descriptor)); return true; } @@ -1225,9 +1225,9 @@ bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) { fontStream->insertInt("Length1", header); fontStream->insertInt("Length2", data); fontStream->insertInt("Length3", trailer); - descriptor->insertObjRef("FontFile", std::move(fontStream)); + descriptor->insertObjRef("FontFile", fontStream.release()); - this->insertObjRef("FontDescriptor", std::move(descriptor)); + this->insertObjRef("FontDescriptor", descriptor.release()); return addCommonFontDescriptorEntries(defaultWidth); } @@ -1276,8 +1276,8 @@ bool SkPDFType1Font::populate(int16_t glyphID) { } auto encoding = sk_make_sp("Encoding"); - encoding->insertObject("Differences", std::move(encDiffs)); - this->insertObject("Encoding", std::move(encoding)); + encoding->insertObject("Differences", encDiffs.release()); + this->insertObject("Encoding", encoding.release()); return true; } @@ -1307,7 +1307,7 @@ void SkPDFType1Font::addWidthInfoFromRange( } this->insertInt("FirstChar", firstChar); this->insertInt("LastChar", firstChar + widthArray->size() - 1); - this->insertObject("Widths", std::move(widthArray)); + this->insertObject("Widths", widthArray.release()); } /////////////////////////////////////////////////////////////////////////////// @@ -1376,19 +1376,19 @@ bool SkPDFType3Font::populate(uint16_t glyphID) { SkAutoTDelete glyphStream(new SkMemoryStream()); glyphStream->setData(content.copyToData())->unref(); - charProcs->insertObjRef( - characterName, sk_make_sp(glyphStream.get())); + charProcs->insertObjRef(characterName, + new SkPDFStream(glyphStream.get())); } - encoding->insertObject("Differences", std::move(encDiffs)); + encoding->insertObject("Differences", encDiffs.release()); - this->insertObject("CharProcs", std::move(charProcs)); - this->insertObject("Encoding", std::move(encoding)); + this->insertObject("CharProcs", charProcs.release()); + this->insertObject("Encoding", encoding.release()); this->insertObject("FontBBox", makeFontBBox(bbox, 1000)); this->insertInt("FirstChar", 1); this->insertInt("LastChar", lastGlyphID() - firstGlyphID() + 1); - this->insertObject("Widths", std::move(widthArray)); + this->insertObject("Widths", widthArray.release()); this->insertName("CIDToGIDMap", "Identity"); this->populateToUnicodeTable(nullptr); diff --git a/src/pdf/SkPDFFormXObject.cpp b/src/pdf/SkPDFFormXObject.cpp index d565ab81e1..abf331f544 100644 --- a/src/pdf/SkPDFFormXObject.cpp +++ b/src/pdf/SkPDFFormXObject.cpp @@ -19,9 +19,9 @@ SkPDFFormXObject::SkPDFFormXObject(SkPDFDevice* device) { // We don't want to keep around device because we'd have two copies // of content, so reference or copy everything we need (content and // resources). - auto resourceDict = device->makeResourceDict(); + sk_sp resourceDict(device->createResourceDict()); - auto content = device->content(); + SkAutoTDelete content(device->content()); this->setData(content.get()); sk_sp bboxArray(device->copyMediaBox()); @@ -60,8 +60,8 @@ void SkPDFFormXObject::init(const char* colorSpace, SkPDFDict* resourceDict, SkPDFArray* bbox) { this->insertName("Type", "XObject"); this->insertName("Subtype", "Form"); - this->insertObject("Resources", sk_sp(SkRef(resourceDict))); - this->insertObject("BBox", sk_sp(SkRef(bbox))); + this->insertObject("Resources", SkRef(resourceDict)); + this->insertObject("BBox", SkRef(bbox)); // Right now SkPDFFormXObject is only used for saveLayer, which implies // isolated blending. Do this conditionally if that changes. @@ -72,7 +72,7 @@ void SkPDFFormXObject::init(const char* colorSpace, group->insertName("CS", colorSpace); } group->insertBool("I", true); // Isolated. - this->insertObject("Group", std::move(group)); + this->insertObject("Group", group.release()); } SkPDFFormXObject::~SkPDFFormXObject() {} diff --git a/src/pdf/SkPDFGraphicState.cpp b/src/pdf/SkPDFGraphicState.cpp index 19e9a36d05..7c4c5e30eb 100644 --- a/src/pdf/SkPDFGraphicState.cpp +++ b/src/pdf/SkPDFGraphicState.cpp @@ -126,7 +126,7 @@ SkPDFGraphicState* SkPDFGraphicState::GetGraphicStateForPaint( return pdfGraphicState; } -static SkPDFStream* create_invert_function() { +static SkPDFObject* create_invert_function() { // Acrobat crashes if we use a type 0 function, kpdf crashes if we use // a type 2 function, so we use a type 4 function. auto domainAndRange = sk_make_sp(); @@ -141,17 +141,12 @@ static SkPDFStream* create_invert_function() { auto invertFunction = sk_make_sp(psInvertStream.get()); invertFunction->insertInt("FunctionType", 4); - invertFunction->insertObject("Domain", domainAndRange); - invertFunction->insertObject("Range", std::move(domainAndRange)); + invertFunction->insertObject("Domain", SkRef(domainAndRange.get())); + invertFunction->insertObject("Range", domainAndRange.release()); return invertFunction.release(); } -SK_DECLARE_STATIC_ONCE_PTR(SkPDFStream, invertFunction); - -static sk_sp make_invert_function() { - return sk_sp( - SkRef(invertFunction.get(create_invert_function))); -} +SK_DECLARE_STATIC_ONCE_PTR(SkPDFObject, invertFunction); // static SkPDFDict* SkPDFGraphicState::GetSMaskGraphicState(SkPDFFormXObject* sMask, @@ -165,13 +160,13 @@ SkPDFDict* SkPDFGraphicState::GetSMaskGraphicState(SkPDFFormXObject* sMask, } else if (sMaskMode == kLuminosity_SMaskMode) { sMaskDict->insertName("S", "Luminosity"); } - sMaskDict->insertObjRef("G", sk_sp(SkRef(sMask))); + sMaskDict->insertObjRef("G", SkRef(sMask)); if (invert) { - sMaskDict->insertObjRef("TR", make_invert_function()); + sMaskDict->insertObjRef("TR", SkRef(invertFunction.get(create_invert_function))); } auto result = sk_make_sp("ExtGState"); - result->insertObject("SMask", std::move(sMaskDict)); + result->insertObject("SMask", sMaskDict.release()); return result.release(); } diff --git a/src/pdf/SkPDFResourceDict.cpp b/src/pdf/SkPDFResourceDict.cpp index 6c7f019c15..d3f4a6d533 100644 --- a/src/pdf/SkPDFResourceDict.cpp +++ b/src/pdf/SkPDFResourceDict.cpp @@ -64,12 +64,12 @@ static void add_subdict( auto resources = sk_make_sp(); for (int i = 0; i < resourceList.count(); i++) { resources->insertObjRef(SkPDFResourceDict::getResourceName(type, i), - sk_sp(SkRef(resourceList[i]))); + SkRef(resourceList[i])); } - dst->insertObject(get_resource_type_name(type), std::move(resources)); + dst->insertObject(get_resource_type_name(type), resources.release()); } -sk_sp SkPDFResourceDict::Make( +SkPDFDict* SkPDFResourceDict::Create( const SkTDArray* gStateResources, const SkTDArray* patternResources, const SkTDArray* xObjectResources, @@ -83,7 +83,7 @@ sk_sp SkPDFResourceDict::Make( for (size_t i = 0; i < SK_ARRAY_COUNT(kProcs); i++) { procSets->appendName(kProcs[i]); } - dict->insertObject("ProcSets", std::move(procSets)); + dict->insertObject("ProcSets", procSets.release()); if (gStateResources) { add_subdict(*gStateResources, kExtGState_ResourceType, dict.get()); @@ -97,5 +97,5 @@ sk_sp SkPDFResourceDict::Make( if (fontResources) { add_subdict(*fontResources, kFont_ResourceType, dict.get()); } - return std::move(dict); + return dict.release(); } diff --git a/src/pdf/SkPDFResourceDict.h b/src/pdf/SkPDFResourceDict.h index c45b364adc..698823b36c 100644 --- a/src/pdf/SkPDFResourceDict.h +++ b/src/pdf/SkPDFResourceDict.h @@ -36,7 +36,7 @@ public: * * Any arguments can be nullptr. */ - static sk_sp Make( + static SkPDFDict* Create( const SkTDArray* gStateResources, const SkTDArray* patternResources, const SkTDArray* xObjectResources, diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp index d5f114ec0f..95ef9dcca0 100644 --- a/src/pdf/SkPDFShader.cpp +++ b/src/pdf/SkPDFShader.cpp @@ -523,7 +523,7 @@ SkPDFObject* SkPDFShader::GetPDFShader(SkPDFCanon* canon, return get_pdf_shader_by_state(canon, dpi, &state); } -static sk_sp get_gradient_resource_dict( +static SkPDFDict* get_gradient_resource_dict( SkPDFObject* functionShader, SkPDFObject* gState) { SkTDArray patterns; @@ -534,7 +534,7 @@ static sk_sp get_gradient_resource_dict( if (gState) { graphicStates.push(gState); } - return SkPDFResourceDict::Make(&graphicStates, &patterns, nullptr, nullptr); + return SkPDFResourceDict::Create(&graphicStates, &patterns, nullptr, nullptr); } static void populate_tiling_pattern_dict(SkPDFDict* pattern, @@ -552,7 +552,7 @@ static void populate_tiling_pattern_dict(SkPDFDict* pattern, pattern->insertObject("BBox", SkPDFUtils::RectToArray(bbox)); pattern->insertScalar("XStep", bbox.width()); pattern->insertScalar("YStep", bbox.height()); - pattern->insertObject("Resources", sk_sp(SkRef(resources))); + pattern->insertObject("Resources", SkRef(resources)); if (!matrix.isIdentity()) { pattern->insertObject("Matrix", SkPDFUtils::MatrixToArray(matrix)); } @@ -592,8 +592,8 @@ static SkPDFObject* create_smask_graphic_state( SkAutoTDelete alphaStream(create_pattern_fill_content(-1, bbox)); - auto resources = - get_gradient_resource_dict(luminosityShader.get(), nullptr); + sk_sp + resources(get_gradient_resource_dict(luminosityShader.get(), nullptr)); sk_sp alphaMask( new SkPDFFormXObject(alphaStream.get(), bbox, resources.get())); @@ -627,8 +627,8 @@ SkPDFAlphaFunctionShader* SkPDFAlphaFunctionShader::Create( SkPDFAlphaFunctionShader* alphaFunctionShader = new SkPDFAlphaFunctionShader(autoState->detach()); - auto resourceDict = - get_gradient_resource_dict(colorShader.get(), alphaGs.get()); + sk_sp resourceDict( + get_gradient_resource_dict(colorShader.get(), alphaGs.get())); SkAutoTDelete colorStream( create_pattern_fill_content(0, bbox)); @@ -697,8 +697,8 @@ static SkPDFStream* make_ps_function(const SkString& psCode, SkData::NewWithCopy(psCode.c_str(), psCode.size())); SkPDFStream* result = new SkPDFStream(funcData.get()); result->insertInt("FunctionType", 4); - result->insertObject("Domain", sk_sp(SkRef(domain))); - result->insertObject("Range", sk_sp(SkRef(rangeObject.get(create_range_object)))); + result->insertObject("Domain", SkRef(domain)); + result->insertObject("Range", SkRef(rangeObject.get(create_range_object))); return result; } @@ -802,18 +802,18 @@ SkPDFFunctionShader* SkPDFFunctionShader::Create( auto pdfShader = sk_make_sp(); pdfShader->insertInt("ShadingType", 1); pdfShader->insertName("ColorSpace", "DeviceRGB"); - pdfShader->insertObject("Domain", sk_sp(SkRef(domain.get()))); + pdfShader->insertObject("Domain", SkRef(domain.get())); sk_sp function( make_ps_function(functionCode, domain.get())); - pdfShader->insertObjRef("Function", std::move(function)); + pdfShader->insertObjRef("Function", function.release()); sk_sp pdfFunctionShader( new SkPDFFunctionShader(autoState->detach())); pdfFunctionShader->insertInt("PatternType", 2); pdfFunctionShader->insertObject("Matrix", SkPDFUtils::MatrixToArray(finalMatrix)); - pdfFunctionShader->insertObject("Shading", std::move(pdfShader)); + pdfFunctionShader->insertObject("Shading", pdfShader.release()); canon->addFunctionShader(pdfFunctionShader.get()); return pdfFunctionShader.release(); @@ -1019,12 +1019,13 @@ SkPDFImageShader* SkPDFImageShader::Create( } // Put the canvas into the pattern stream (fContent). - auto content = patternDevice->content(); + SkAutoTDelete content(patternDevice->content()); SkPDFImageShader* imageShader = new SkPDFImageShader(autoState->detach()); imageShader->setData(content.get()); - auto resourceDict = patternDevice->makeResourceDict(); + sk_sp resourceDict( + patternDevice->createResourceDict()); populate_tiling_pattern_dict(imageShader, patternBBox, resourceDict.get(), finalMatrix); diff --git a/src/pdf/SkPDFTypes.cpp b/src/pdf/SkPDFTypes.cpp index ced0e381f9..faa08372e5 100644 --- a/src/pdf/SkPDFTypes.cpp +++ b/src/pdf/SkPDFTypes.cpp @@ -1,3 +1,4 @@ + /* * Copyright 2011 Google Inc. * @@ -27,8 +28,7 @@ SkPDFUnion::~SkPDFUnion() { return; case Type::kObjRef: case Type::kObject: - SkASSERT(fObject); - fObject->unref(); + SkSafeUnref(fObject); return; default: return; @@ -38,7 +38,7 @@ SkPDFUnion::~SkPDFUnion() { SkPDFUnion& SkPDFUnion::operator=(SkPDFUnion&& other) { if (this != &other) { this->~SkPDFUnion(); - new (this) SkPDFUnion(std::move(other)); + new (this) SkPDFUnion(other.move()); } return *this; } @@ -56,14 +56,14 @@ SkPDFUnion SkPDFUnion::copy() const { switch (fType) { case Type::kNameSkS: case Type::kStringSkS: - new (pun(u.fSkString)) SkString(*pun(fSkString)); - return std::move(u); + new (pun(u.fSkString)) SkString (*pun(fSkString)); + return u.move(); case Type::kObjRef: case Type::kObject: SkRef(u.fObject); - return std::move(u); + return u.move(); default: - return std::move(u); + return u.move(); } } SkPDFUnion& SkPDFUnion::operator=(const SkPDFUnion& other) { @@ -191,19 +191,19 @@ void SkPDFUnion::addResources(SkPDFObjNumMap* objNumMap, SkPDFUnion SkPDFUnion::Int(int32_t value) { SkPDFUnion u(Type::kInt); u.fIntValue = value; - return std::move(u); + return u.move(); } SkPDFUnion SkPDFUnion::Bool(bool value) { SkPDFUnion u(Type::kBool); u.fBoolValue = value; - return std::move(u); + return u.move(); } SkPDFUnion SkPDFUnion::Scalar(SkScalar value) { SkPDFUnion u(Type::kScalar); u.fScalarValue = value; - return std::move(u); + return u.move(); } SkPDFUnion SkPDFUnion::Name(const char* value) { @@ -211,40 +211,40 @@ SkPDFUnion SkPDFUnion::Name(const char* value) { SkASSERT(value); SkASSERT(is_valid_name(value)); u.fStaticString = value; - return std::move(u); + return u.move(); } SkPDFUnion SkPDFUnion::String(const char* value) { SkPDFUnion u(Type::kString); SkASSERT(value); u.fStaticString = value; - return std::move(u); + return u.move(); } SkPDFUnion SkPDFUnion::Name(const SkString& s) { SkPDFUnion u(Type::kNameSkS); new (pun(u.fSkString)) SkString(s); - return std::move(u); + return u.move(); } SkPDFUnion SkPDFUnion::String(const SkString& s) { SkPDFUnion u(Type::kStringSkS); new (pun(u.fSkString)) SkString(s); - return std::move(u); + return u.move(); } -SkPDFUnion SkPDFUnion::ObjRef(sk_sp objSp) { +SkPDFUnion SkPDFUnion::ObjRef(SkPDFObject* ptr) { SkPDFUnion u(Type::kObjRef); - SkASSERT(objSp.get()); - u.fObject = objSp.release(); // take ownership into union{} - return std::move(u); + SkASSERT(ptr); + u.fObject = ptr; + return u.move(); } -SkPDFUnion SkPDFUnion::Object(sk_sp objSp) { +SkPDFUnion SkPDFUnion::Object(SkPDFObject* ptr) { SkPDFUnion u(Type::kObject); - SkASSERT(objSp.get()); - u.fObject = objSp.release(); // take ownership into union{} - return std::move(u); + SkASSERT(ptr); + u.fObject = ptr; + return u.move(); } //////////////////////////////////////////////////////////////////////////////// @@ -295,9 +295,7 @@ void SkPDFArray::addResources(SkPDFObjNumMap* catalog, } } -void SkPDFArray::append(SkPDFUnion&& value) { - new (fValues.append()) SkPDFUnion(std::move(value)); -} +void SkPDFArray::append(SkPDFUnion&& value) { new (fValues.append()) SkPDFUnion(value.move()); } void SkPDFArray::appendInt(int32_t value) { this->append(SkPDFUnion::Int(value)); @@ -327,12 +325,12 @@ void SkPDFArray::appendString(const char value[]) { this->append(SkPDFUnion::String(value)); } -void SkPDFArray::appendObject(sk_sp objSp) { - this->append(SkPDFUnion::Object(std::move(objSp))); +void SkPDFArray::appendObject(SkPDFObject* value) { + this->append(SkPDFUnion::Object(value)); } -void SkPDFArray::appendObjRef(sk_sp objSp) { - this->append(SkPDFUnion::ObjRef(std::move(objSp))); +void SkPDFArray::appendObjRef(SkPDFObject* value) { + this->append(SkPDFUnion::ObjRef(value)); } /////////////////////////////////////////////////////////////////////////////// @@ -375,24 +373,24 @@ void SkPDFDict::addResources(SkPDFObjNumMap* catalog, void SkPDFDict::set(SkPDFUnion&& name, SkPDFUnion&& value) { Record* rec = fRecords.append(); SkASSERT(name.isName()); - new (&rec->fKey) SkPDFUnion(std::move(name)); - new (&rec->fValue) SkPDFUnion(std::move(value)); + new (&rec->fKey) SkPDFUnion(name.move()); + new (&rec->fValue) SkPDFUnion(value.move()); } int SkPDFDict::size() const { return fRecords.count(); } -void SkPDFDict::insertObjRef(const char key[], sk_sp objSp) { - this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(std::move(objSp))); +void SkPDFDict::insertObjRef(const char key[], SkPDFObject* value) { + this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(value)); } -void SkPDFDict::insertObjRef(const SkString& key, sk_sp objSp) { - this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(std::move(objSp))); +void SkPDFDict::insertObjRef(const SkString& key, SkPDFObject* value) { + this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(value)); } -void SkPDFDict::insertObject(const char key[], sk_sp objSp) { - this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(std::move(objSp))); +void SkPDFDict::insertObject(const char key[], SkPDFObject* value) { + this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(value)); } -void SkPDFDict::insertObject(const SkString& key, sk_sp objSp) { - this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(std::move(objSp))); +void SkPDFDict::insertObject(const SkString& key, SkPDFObject* value) { + this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(value)); } void SkPDFDict::insertBool(const char key[], bool value) { diff --git a/src/pdf/SkPDFTypes.h b/src/pdf/SkPDFTypes.h index f93b030465..a6a3e12ee6 100644 --- a/src/pdf/SkPDFTypes.h +++ b/src/pdf/SkPDFTypes.h @@ -39,6 +39,7 @@ public: * @param catalog The object catalog to use. * @param stream The writable output stream to send the output to. */ + // TODO(halcanary): make this method const virtual void emitObject(SkWStream* stream, const SkPDFObjNumMap& objNumMap, const SkPDFSubstituteMap& substitutes) const = 0; @@ -64,6 +65,8 @@ private: */ class SkPDFUnion { public: + // u.move() is analogous to std::move(u). It returns an rvalue. + SkPDFUnion move() { return static_cast(*this); } // Move contstructor and assignemnt operator destroy the argument // and steal their references (if needed). SkPDFUnion(SkPDFUnion&& other); @@ -82,7 +85,7 @@ public: static SkPDFUnion Scalar(SkScalar); - /** These two functions do NOT take ownership of char*, and do NOT + /** These two functions do NOT take ownership of ptr, and do NOT copy the string. Suitable for passing in static const strings. For example: SkPDFUnion n = SkPDFUnion::Name("Length"); @@ -105,8 +108,17 @@ public: /** SkPDFUnion::String will encode the passed string. */ static SkPDFUnion String(const SkString&); - static SkPDFUnion Object(sk_sp); - static SkPDFUnion ObjRef(sk_sp); + /** This function DOES take ownership of the object. E.g. + auto dict = sk_make_sp(); + dict->insert(.....); + SkPDFUnion u = SkPDFUnion::Object(dict.detach()) */ + static SkPDFUnion Object(SkPDFObject*); + + /** This function DOES take ownership of the object. E.g. + sk_sp image( + SkPDFBitmap::Create(fCanon, bitmap)); + SkPDFUnion u = SkPDFUnion::ObjRef(image.detach()) */ + static SkPDFUnion ObjRef(SkPDFObject*); /** These two non-virtual methods mirror SkPDFObject's corresponding virtuals. */ @@ -162,7 +174,7 @@ public: const SkPDFObjNumMap& objNumMap, const SkPDFSubstituteMap& substitutes) final; void addResources(SkPDFObjNumMap*, const SkPDFSubstituteMap&) const final; - SkPDFAtom(SkPDFUnion&& v) : fValue(std::move(v) {} + SkPDFAtom(SkPDFUnion&& v) : fValue(v.move()) {} private: const SkPDFUnion fValue; @@ -211,8 +223,9 @@ public: void appendName(const SkString&); void appendString(const char[]); void appendString(const SkString&); - void appendObject(sk_sp); - void appendObjRef(sk_sp); + /** appendObject and appendObjRef take ownership of the passed object */ + void appendObject(SkPDFObject*); + void appendObjRef(SkPDFObject*); private: SkTDArray fValues; @@ -248,14 +261,15 @@ public: */ int size() const; - /** Add the value to the dictionary with the given key. + /** Add the value to the dictionary with the given key. Takes + * ownership of the object. * @param key The text of the key for this dictionary entry. * @param value The value for this dictionary entry. */ - void insertObject(const char key[], sk_sp); - void insertObject(const SkString& key, sk_sp); - void insertObjRef(const char key[], sk_sp); - void insertObjRef(const SkString& key, sk_sp); + void insertObject(const char key[], SkPDFObject* value); + void insertObject(const SkString& key, SkPDFObject* value); + void insertObjRef(const char key[], SkPDFObject* value); + void insertObjRef(const SkString& key, SkPDFObject* value); /** Add the value to the dictionary with the given key. * @param key The text of the key for this dictionary entry. @@ -303,8 +317,7 @@ private: class SkPDFSharedStream final : public SkPDFObject { public: // Takes ownership of asset. - SkPDFSharedStream(SkStreamAsset* data) - : fAsset(data), fDict(new SkPDFDict) { SkASSERT(data); } + SkPDFSharedStream(SkStreamAsset* data) : fAsset(data), fDict(new SkPDFDict) { SkASSERT(data); } SkPDFDict* dict() { return fDict.get(); } void emitObject(SkWStream*, const SkPDFObjNumMap&, diff --git a/src/pdf/SkPDFUtils.cpp b/src/pdf/SkPDFUtils.cpp index f305765389..30d6ee7d68 100644 --- a/src/pdf/SkPDFUtils.cpp +++ b/src/pdf/SkPDFUtils.cpp @@ -18,8 +18,9 @@ #include -sk_sp SkPDFUtils::RectToArray(const SkRect& rect) { - auto result = sk_make_sp(); +//static +SkPDFArray* SkPDFUtils::RectToArray(const SkRect& rect) { + SkPDFArray* result = new SkPDFArray(); result->reserve(4); result->appendScalar(rect.fLeft); result->appendScalar(rect.fTop); @@ -28,13 +29,14 @@ sk_sp SkPDFUtils::RectToArray(const SkRect& rect) { return result; } -sk_sp SkPDFUtils::MatrixToArray(const SkMatrix& matrix) { +// static +SkPDFArray* SkPDFUtils::MatrixToArray(const SkMatrix& matrix) { SkScalar values[6]; if (!matrix.asAffine(values)) { SkMatrix::SetAffineIdentity(values); } - auto result = sk_make_sp(); + SkPDFArray* result = new SkPDFArray; result->reserve(6); for (size_t i = 0; i < SK_ARRAY_COUNT(values); i++) { result->appendScalar(values[i]); diff --git a/src/pdf/SkPDFUtils.h b/src/pdf/SkPDFUtils.h index 0dec80077c..814d77193c 100644 --- a/src/pdf/SkPDFUtils.h +++ b/src/pdf/SkPDFUtils.h @@ -35,8 +35,8 @@ class SkWStream; class SkPDFUtils { public: - static sk_sp RectToArray(const SkRect& rect); - static sk_sp MatrixToArray(const SkMatrix& matrix); + static SkPDFArray* RectToArray(const SkRect& rect); + static SkPDFArray* MatrixToArray(const SkMatrix& matrix); static void AppendTransform(const SkMatrix& matrix, SkWStream* content); static void MoveTo(SkScalar x, SkScalar y, SkWStream* content); -- cgit v1.2.3