AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

remove SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER dead code

Browse Source 
Bug: skia:
Change-Id: Ia88f3e2fdf6d5c6e5128eaefda0d68c7042ae7a2
Reviewed-on: https://skia-review.googlesource.com/85500
Commit-Queue: Mike Reed <reed@google.com>
Reviewed-by: Hal Canary <halcanary@google.com>
This commit is contained in:
Mike Reed 2017-12-14 23:03:12 -05:00 committed by Skia Commit-Bot
parent a088365e2f
commit 7f846f273c
10 changed files with 11 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
bench/PDFBench.cpp
View File

@ -84,11 +84,7 @@ protected:
return; return;
} }
while (loops-- > 0) { while (loops-- > 0) {
auto object = SkPDFCreateBitmapObject(fImage, auto object = SkPDFCreateBitmapObject(fImage);
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
nullptr,
#endif
false);
SkASSERT(object); SkASSERT(object);
if (!object) { if (!object) {
return; return;
@ -125,11 +121,7 @@ protected:
return; return;
} }
while (loops-- > 0) { while (loops-- > 0) {
auto object = SkPDFCreateBitmapObject(fImage, auto object = SkPDFCreateBitmapObject(fImage);
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
nullptr,
#endif
false);
SkASSERT(object); SkASSERT(object);
if (!object) { if (!object) {
return; return;

46
include/core/SkDocument.h
View File

@ -10,9 +10,6 @@
#include "SkBitmap.h" #include "SkBitmap.h"
#include "SkPicture.h" #include "SkPicture.h"
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
#include "SkPixelSerializer.h"
#endif
#include "SkRect.h" #include "SkRect.h"
#include "SkRefCnt.h" #include "SkRefCnt.h"
#include "SkString.h" #include "SkString.h"
@ -115,49 +112,6 @@ public:
int fEncodingQuality = 101; int fEncodingQuality = 101;
}; };
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
/**
* Create a PDF-backed document, writing the results into a
* SkWStream.
*
* PDF pages are sized in point units. 1 pt == 1/72 inch ==
* 127/360 mm.
*
* @param stream A PDF document will be written to this
* stream. The document may write to the stream at
* anytime during its lifetime, until either close() is
* called or the document is deleted.
* @param dpi The DPI (pixels-per-inch) at which features without
* native PDF support will be rasterized (e.g. draw image
* with perspective, draw text with perspective, ...) A
* larger DPI would create a PDF that reflects the
* original intent with better fidelity, but it can make
* for larger PDF files too, which would use more memory
* while rendering, and it would be slower to be processed
* or sent online or to printer.
* @param metadata a PDFmetadata object. Any fields may be left
* empty.
* @param pdfa Iff true, include XMP metadata, a document UUID,
* and sRGB output intent information. This adds length
* to the document and makes it non-reproducable, but are
* necessary features for PDF/A-2b conformance
*
* @returns NULL if there is an error, otherwise a newly created
* PDF-backed SkDocument.
*/
static sk_sp<SkDocument> MakePDF(SkWStream* stream,
SkScalar dpi,
const PDFMetadata& metadata,
sk_sp<SkPixelSerializer> jpegEncoder,
bool pdfa);
/**
* Create a PDF-backed document, writing the results into a file.
*/
static sk_sp<SkDocument> MakePDF(const char outputFilePath[],
SkScalar dpi = SK_ScalarDefaultRasterDPI);
static sk_sp<SkDocument> MakePDF(SkWStream* stream, SkScalar dpi);
#endif
/** /**
* Create a PDF-backed document, writing the results into a * Create a PDF-backed document, writing the results into a
* SkWStream. * SkWStream.

1
public.bzl
View File

@ -586,7 +586,6 @@ def base_defines(os_conditions):
"SK_JUMPER_DISABLE_8BIT", "SK_JUMPER_DISABLE_8BIT",
# JPEG is in codec_limited # JPEG is in codec_limited
"SK_HAS_JPEG_LIBRARY", "SK_HAS_JPEG_LIBRARY",
"SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER",
] + skia_select( ] + skia_select(
os_conditions, os_conditions,
[ [

15
src/pdf/SkDocument_PDF_None.cpp
View File

@ -15,18 +15,3 @@ sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream) {
return nullptr; return nullptr;
} }
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream,
SkScalar dpi,
const PDFMetadata& metadata,
sk_sp<SkPixelSerializer> jpegEncoder,
bool pdfa) {
return nullptr;
}
sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream, SkScalar dpi) {
return nullptr;
}
sk_sp<SkDocument> SkDocument::MakePDF(const char path[], SkScalar dpi) {
return nullptr;
}
#endif

21
src/pdf/SkPDFBitmap.cpp
View File

@ -407,11 +407,7 @@ void PDFJpegBitmap::emitObject(SkWStream* stream,
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
sk_sp<SkPDFObject> SkPDFCreateBitmapObject(sk_sp<SkImage> image, sk_sp<SkPDFObject> SkPDFCreateBitmapObject(sk_sp<SkImage> image, int encodingQuality) {
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
SkPixelSerializer* pixelSerializer,
#endif
int encodingQuality) {
SkASSERT(image); SkASSERT(image);
SkASSERT(encodingQuality >= 0); SkASSERT(encodingQuality >= 0);
sk_sp<SkData> data = image->refEncodedData(); sk_sp<SkData> data = image->refEncodedData();
@ -427,21 +423,6 @@ sk_sp<SkPDFObject> SkPDFCreateBitmapObject(sk_sp<SkImage> image,
} }
} }
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
if (pixelSerializer) {
SkBitmap bm;
if (SkPDFUtils::ToBitmap(image.get(), &bm)) {
data = pixelSerializer->encodeToData(bm.pixmap());
if (data && SkIsJFIF(data.get(), &info)) {
bool yuv = info.fType == SkJFIFInfo::kYCbCr;
if (info.fSize == image->dimensions()) { // Sanity check.
return sk_make_sp<PDFJpegBitmap>(info.fSize, data.get(), yuv);
}
}
}
}
#endif
const bool isOpaque = image_compute_is_opaque(image.get()); const bool isOpaque = image_compute_is_opaque(image.get());
if (encodingQuality <= 100 && isOpaque) { if (encodingQuality <= 100 && isOpaque) {

11
src/pdf/SkPDFBitmap.h
View File

@ -10,20 +10,15 @@
#include "SkRefCnt.h" #include "SkRefCnt.h"
class SkImage; class SkImage;
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
class SkPixelSerializer;
#endif
class SkPDFObject; class SkPDFObject;
/** /**
* SkPDFBitmap wraps a SkImage and serializes it as an image Xobject. * SkPDFBitmap wraps a SkImage and serializes it as an image Xobject.
* It is designed to use a minimal amout of memory, aside from refing * It is designed to use a minimal amout of memory, aside from refing
* the image, and its emitObject() does not cache any data. * the image, and its emitObject() does not cache any data.
*
* quality > 100 means lossless
*/ */
sk_sp<SkPDFObject> SkPDFCreateBitmapObject(sk_sp<SkImage>, sk_sp<SkPDFObject> SkPDFCreateBitmapObject(sk_sp<SkImage>, int encodingQuality = 101);
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
SkPixelSerializer*,
#endif
int encodingQuality);
#endif // SkPDFBitmap_DEFINED #endif // SkPDFBitmap_DEFINED

6
src/pdf/SkPDFCanon.h
View File

@ -11,9 +11,6 @@
#include "SkPDFGradientShader.h" #include "SkPDFGradientShader.h"
#include "SkPDFGraphicState.h" #include "SkPDFGraphicState.h"
#include "SkPDFShader.h" #include "SkPDFShader.h"
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
#include "SkPixelSerializer.h"
#endif
#include "SkTDArray.h" #include "SkTDArray.h"
#include "SkTHash.h" #include "SkTHash.h"
#include "SkTypeface.h" #include "SkTypeface.h"
@ -45,9 +42,6 @@ public:
SkTHashMap<SkPDFStrokeGraphicState, sk_sp<SkPDFDict>> fStrokeGSMap; SkTHashMap<SkPDFStrokeGraphicState, sk_sp<SkPDFDict>> fStrokeGSMap;
SkTHashMap<SkPDFFillGraphicState, sk_sp<SkPDFDict>> fFillGSMap; SkTHashMap<SkPDFFillGraphicState, sk_sp<SkPDFDict>> fFillGSMap;
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
sk_sp<SkPixelSerializer> fPixelSerializer;
#endif
sk_sp<SkPDFStream> fInvertFunction; sk_sp<SkPDFStream> fInvertFunction;
sk_sp<SkPDFDict> fNoSmaskGraphicState; sk_sp<SkPDFDict> fNoSmaskGraphicState;
sk_sp<SkPDFArray> fRangeObject; sk_sp<SkPDFArray> fRangeObject;

3
src/pdf/SkPDFDevice.cpp
View File

@ -2512,9 +2512,6 @@ void SkPDFDevice::internalDrawImageRect(SkKeyedImage imageSubset,
if (!pdfimage) { if (!pdfimage) {
SkASSERT(imageSubset); SkASSERT(imageSubset);
pdfimage = SkPDFCreateBitmapObject(imageSubset.release(), pdfimage = SkPDFCreateBitmapObject(imageSubset.release(),
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
fDocument->canon()->fPixelSerializer.get(),
#endif
fDocument->metadata().fEncodingQuality); fDocument->metadata().fEncodingQuality);
if (!pdfimage) { if (!pdfimage) {
return; return;

52
src/pdf/SkPDFDocument.cpp
View File

@ -12,9 +12,6 @@
#include "SkPDFCanon.h" #include "SkPDFCanon.h"
#include "SkPDFDevice.h" #include "SkPDFDevice.h"
#include "SkPDFUtils.h" #include "SkPDFUtils.h"
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
#include "SkPixelSerializer.h"
#endif
#include "SkStream.h" #include "SkStream.h"
SkPDFObjectSerializer::SkPDFObjectSerializer() : fBaseOffset(0), fNextToBeSerialized(0) {} SkPDFObjectSerializer::SkPDFObjectSerializer() : fBaseOffset(0), fNextToBeSerialized(0) {}
@ -176,16 +173,9 @@ static sk_sp<SkPDFDict> generate_page_tree(SkTArray<sk_sp<SkPDFDict>>* pages) {
SkPDFDocument::SkPDFDocument(SkWStream* stream, SkPDFDocument::SkPDFDocument(SkWStream* stream,
void (*doneProc)(SkWStream*, bool), void (*doneProc)(SkWStream*, bool),
const SkDocument::PDFMetadata& metadata const SkDocument::PDFMetadata& metadata)
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
, sk_sp<SkPixelSerializer> jpegEncoder
#endif
)
: SkDocument(stream, doneProc) : SkDocument(stream, doneProc)
, fMetadata(metadata) { , fMetadata(metadata) {
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
fCanon.fPixelSerializer = std::move(jpegEncoder);
#endif
} }
SkPDFDocument::~SkPDFDocument() { SkPDFDocument::~SkPDFDocument() {
@ -436,11 +426,7 @@ void SkPDFDocument::onClose(SkWStream* stream) {
sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream, sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream,
void (*proc)(SkWStream*, bool), void (*proc)(SkWStream*, bool),
const SkDocument::PDFMetadata& metadata const SkDocument::PDFMetadata& metadata) {
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
, sk_sp<SkPixelSerializer> jpeg
#endif
) {
SkDocument::PDFMetadata meta = metadata; SkDocument::PDFMetadata meta = metadata;
if (meta.fRasterDPI <= 0) { if (meta.fRasterDPI <= 0) {
meta.fRasterDPI = 72.0f; meta.fRasterDPI = 72.0f;
@ -448,12 +434,7 @@ sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream,
if (meta.fEncodingQuality < 0) { if (meta.fEncodingQuality < 0) {
meta.fEncodingQuality = 0; meta.fEncodingQuality = 0;
} }
return stream ? sk_make_sp<SkPDFDocument>(stream, proc, meta return stream ? sk_make_sp<SkPDFDocument>(stream, proc, meta) : nullptr;
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
, std::move(jpeg)
#endif
)
: nullptr;
} }
sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream, const PDFMetadata& metadata) { sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream, const PDFMetadata& metadata) {
@ -464,30 +445,3 @@ sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream) {
return SkPDFMakeDocument(stream, nullptr, PDFMetadata()); return SkPDFMakeDocument(stream, nullptr, PDFMetadata());
} }
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream,
SkScalar dpi,
const PDFMetadata& metadata,
sk_sp<SkPixelSerializer> jpegEncoder,
bool pdfa) {
PDFMetadata meta = metadata;
meta.fRasterDPI = dpi;
meta.fPDFA = pdfa;
return SkPDFMakeDocument(stream, nullptr, meta, jpegEncoder);
}
sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream, SkScalar dpi) {
PDFMetadata meta;
meta.fRasterDPI = dpi;
return SkPDFMakeDocument(stream, nullptr, meta, nullptr);
}
sk_sp<SkDocument> SkDocument::MakePDF(const char path[], SkScalar dpi) {
auto delete_wstream = [](SkWStream* stream, bool) { delete stream; };
auto stream = skstd::make_unique<SkFILEWStream>(path);
if (!stream->isValid()) {
return nullptr;
}
PDFMetadata meta;
meta.fRasterDPI = dpi;
return SkPDFMakeDocument(stream.release(), delete_wstream, meta, nullptr);
}
#endif

15
src/pdf/SkPDFDocument.h
View File

@ -10,9 +10,6 @@
#include "SkDocument.h" #include "SkDocument.h"
#include "SkPDFCanon.h" #include "SkPDFCanon.h"
#include "SkPDFMetadata.h" #include "SkPDFMetadata.h"
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
#include "SkPixelSerializer.h"
#endif
#include "SkPDFFont.h" #include "SkPDFFont.h"
class SkPDFDevice; class SkPDFDevice;
@ -29,11 +26,7 @@ class SkPDFDevice;
*/ */
sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream, sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream,
void (*doneProc)(SkWStream*, bool), void (*doneProc)(SkWStream*, bool),
const SkDocument::PDFMetadata& const SkDocument::PDFMetadata&);
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
, sk_sp<SkPixelSerializer> = nullptr
#endif
);
// Logically part of SkPDFDocument (like SkPDFCanon), but separate to // Logically part of SkPDFDocument (like SkPDFCanon), but separate to
// keep similar functionality together. // keep similar functionality together.
@ -60,11 +53,7 @@ class SkPDFDocument : public SkDocument {
public: public:
SkPDFDocument(SkWStream*, SkPDFDocument(SkWStream*,
void (*)(SkWStream*, bool), void (*)(SkWStream*, bool),
const SkDocument::PDFMetadata& const SkDocument::PDFMetadata&);
#ifdef SK_SUPPORT_LEGACY_PDF_PIXELSERIALIZER
, sk_sp<SkPixelSerializer> = nullptr
#endif
);
~SkPDFDocument() override; ~SkPDFDocument() override;
SkCanvas* onBeginPage(SkScalar, SkScalar) override; SkCanvas* onBeginPage(SkScalar, SkScalar) override;
void onEndPage() override; void onEndPage() override;