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

Revert of SkPDF: Optionally output PDF/A-2b archive format. (patchset #5 id:80001 of https://codereview.chromium.org/1394263003/ )

Browse Source 
Reason for revert:
SkMD5 is not really part of the Skia library. This is breaking the roll by using it, since Chromium doesn't build it.

Original issue's description:
> SkPDF: Optionally output PDF/A-2b  archive format.
>
> Note: this format does not yet pass validation tests.
>
> Add skia_pdf_generate_pdfa GYP flag.  Default to off for now.
> PDF/A files are not reproducable, so they make correctness
> testing harder.
>
> Turn the Metadata struct into te SkPDFMetadata struct.  This
> splits out a lot of functionality around both kinds of metadata.
>
> When PDF/A is used, add an ID entry to the trailer.
>
> Add SkPDFObjNumMap::addObjectRecursively.
>
> Test with
>
>     GYP_DEFINES=skia_pdf_generate_pdfa=1 bin/sync-and-gyp
>     ninja -C out/Release dm
>     out/Release/dm --config pdf --src skp gm -w /tmp/dm
>
> With skia_pdf_generate_pdfa=0, all PDFs generated from GMs and
> SKPs are identical.  With skia_pdf_generate_pdfa=1, all PDFs
> generated from GMs and SKPs render identically in Pdfium.
>
> BUG=skia:3110
>
> Committed: https://skia.googlesource.com/skia/+/939c0fe51f157104758bcb268643c8b6d317a530

TBR=tomhudson@google.com,halcanary@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:3110

Review URL: https://codereview.chromium.org/1398193002
This commit is contained in:
bungeman 2015-10-09 13:45:50 -07:00 committed by Commit bot
parent f276ac5c16
commit 21f99b7733
9 changed files with 78 additions and 448 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gyp/common_variables.gypi
View File

@ -225,7 +225,6 @@
'skia_win_ltcg%': 1,
'skia_osx_deployment_target%': '<(skia_osx_deployment_target)',
'skia_pdf%': '<(skia_pdf)',
'skia_pdf_generate_pdfa%': 0, # emit larger PDF/A-2b file
'skia_profile_enabled%': '<(skia_profile_enabled)',
'skia_shared_lib%': '<(skia_shared_lib)',
'skia_opencl%': '<(skia_opencl)',

1
gyp/pdf.gyp
View File

@ -40,7 +40,6 @@
skia_os in ["win", "android", "linux", "chromeos", "mac"]',
{ 'dependencies': [ 'sfntly.gyp:sfntly' ] }
],
[ 'skia_pdf_generate_pdfa', { 'defines': ['SK_PDF_GENERATE_PDFA'] } ],
[ 'skia_android_framework', {
# Add SFTNLY support for PDF (which in turns depends on ICU)
'include_dirs': [

2
gyp/pdf.gypi
View File

@ -29,8 +29,6 @@
'<(skia_src_path)/pdf/SkPDFFormXObject.h',
'<(skia_src_path)/pdf/SkPDFGraphicState.cpp',
'<(skia_src_path)/pdf/SkPDFGraphicState.h',
'<(skia_src_path)/pdf/SkPDFMetadata.cpp',
'<(skia_src_path)/pdf/SkPDFMetadata.h',
'<(skia_src_path)/pdf/SkPDFResourceDict.cpp',
'<(skia_src_path)/pdf/SkPDFResourceDict.h',
'<(skia_src_path)/pdf/SkPDFShader.cpp',

110
src/doc/SkDocument_PDF.cpp
View File

@ -13,7 +13,6 @@
#include "SkPDFTypes.h"
#include "SkPDFUtils.h"
#include "SkStream.h"
#include "SkPDFMetadata.h"
class SkPDFDict;
@ -31,18 +30,15 @@ static void emit_pdf_footer(SkWStream* stream,
SkPDFObject* docCatalog,
int64_t objCount,
int32_t xRefFileOffset,
SkPDFObject* info /* take ownership */,
SkPDFObject* id /* take ownership */) {
SkPDFDict* info) {
SkPDFDict trailerDict;
// TODO(http://crbug.com/80908): Linearized format will take a
// Prev entry too.
// TODO(vandebo): Linearized format will take a Prev entry too.
// TODO(vandebo): PDF/A requires an ID entry.
trailerDict.insertInt("Size", int(objCount));
trailerDict.insertObjRef("Root", SkRef(docCatalog));
SkASSERT(info);
trailerDict.insertObjRef("Info", info);
if (id) {
trailerDict.insertObject("ID", id);
}
trailerDict.insertObjRef("Info", SkRef(info));
stream->writeText("trailer\n");
trailerDict.emitObject(stream, objNumMap, substitutes);
stream->writeText("\nstartxref\n");
@ -166,8 +162,49 @@ static void generate_page_tree(const SkTDArray<SkPDFDict*>& pages,
}
}
struct Metadata {
SkTArray<SkDocument::Attribute> fInfo;
SkAutoTDelete<const SkTime::DateTime> fCreation;
SkAutoTDelete<const SkTime::DateTime> fModified;
};
static SkString pdf_date(const SkTime::DateTime& dt) {
int timeZoneMinutes = SkToInt(dt.fTimeZoneMinutes);
char timezoneSign = timeZoneMinutes >= 0 ? '+' : '-';
int timeZoneHours = SkTAbs(timeZoneMinutes) / 60;
timeZoneMinutes = SkTAbs(timeZoneMinutes) % 60;
return SkStringPrintf(
"D:%04u%02u%02u%02u%02u%02u%c%02d'%02d'",
static_cast<unsigned>(dt.fYear), static_cast<unsigned>(dt.fMonth),
static_cast<unsigned>(dt.fDay), static_cast<unsigned>(dt.fHour),
static_cast<unsigned>(dt.fMinute),
static_cast<unsigned>(dt.fSecond), timezoneSign, timeZoneHours,
timeZoneMinutes);
}
SkPDFDict* create_document_information_dict(const Metadata& metadata) {
SkAutoTUnref<SkPDFDict> dict(new SkPDFDict);
static const char* keys[] = {
"Title", "Author", "Subject", "Keywords", "Creator" };
for (const char* key : keys) {
for (const SkDocument::Attribute& keyValue : metadata.fInfo) {
if (keyValue.fKey.equals(key)) {
dict->insertString(key, keyValue.fValue);
}
}
}
dict->insertString("Producer", "Skia/PDF");
if (metadata.fCreation) {
dict->insertString("CreationDate", pdf_date(*metadata.fCreation.get()));
}
if (metadata.fModified) {
dict->insertString("ModDate", pdf_date(*metadata.fModified.get()));
}
return dict.detach();
}
static bool emit_pdf_document(const SkTDArray<const SkPDFDevice*>& pageDevices,
const SkPDFMetadata& metadata,
const Metadata& metadata,
SkWStream* stream) {
if (pageDevices.isEmpty()) {
return false;
@ -185,37 +222,9 @@ static bool emit_pdf_document(const SkTDArray<const SkPDFDevice*>& pageDevices,
pages.push(page.detach());
}
SkTDArray<SkPDFDict*> pageTree;
SkAutoTUnref<SkPDFDict> docCatalog(new SkPDFDict("Catalog"));
SkAutoTUnref<SkPDFObject> infoDict(
metadata.createDocumentInformationDict());
SkAutoTUnref<SkPDFObject> id, xmp;
#ifdef SK_PDF_GENERATE_PDFA
SkPDFMetadata::UUID uuid = metadata.uuid();
// We use the same UUID for Document ID and Instance ID since this
// is the first revision of this document (and Skia does not
// support revising existing PDF documents).
// If we are not in PDF/A mode, don't use a UUID since testing
// works best with reproducible outputs.
id.reset(SkPDFMetadata::CreatePdfId(uuid, uuid));
xmp.reset(metadata.createXMPObject(uuid, uuid));
docCatalog->insertObjRef("Metadata", xmp.detach());
// sRGB is specified by HTML, CSS, and SVG.
SkAutoTUnref<SkPDFDict> outputIntent(new SkPDFDict("OutputIntent"));
outputIntent->insertName("S", "GTS_PDFA1");
outputIntent->insertString("RegistryName", "http://www.color.org");
outputIntent->insertString("OutputConditionIdentifier",
"sRGB IEC61966-2.1");
SkAutoTUnref<SkPDFArray> intentArray(new SkPDFArray);
intentArray->appendObject(outputIntent.detach());
// Don't specify OutputIntents if we are not in PDF/A mode since
// no one has ever asked for this feature.
docCatalog->insertObject("OutputIntents", intentArray.detach());
#endif
SkTDArray<SkPDFDict*> pageTree;
SkPDFDict* pageTreeRoot;
generate_page_tree(pages, &pageTree, &pageTreeRoot);
docCatalog->insertObjRef("Pages", SkRef(pageTreeRoot));
@ -224,13 +233,28 @@ static bool emit_pdf_document(const SkTDArray<const SkPDFDevice*>& pageDevices,
docCatalog->insertObjRef("Dests", dests.detach());
}
/* TODO(vandebo): output intent
SkAutoTUnref<SkPDFDict> outputIntent = new SkPDFDict("OutputIntent");
outputIntent->insertName("S", "GTS_PDFA1");
outputIntent->insertString("OutputConditionIdentifier", "sRGB");
SkAutoTUnref<SkPDFArray> intentArray(new SkPDFArray);
intentArray->appendObject(SkRef(outputIntent.get()));
docCatalog->insertObject("OutputIntent", intentArray.detach());
*/
// Build font subsetting info before proceeding.
SkPDFSubstituteMap substitutes;
perform_font_subsetting(pageDevices, &substitutes);
SkAutoTUnref<SkPDFDict> infoDict(
create_document_information_dict(metadata));
SkPDFObjNumMap objNumMap;
objNumMap.addObjectRecursively(infoDict, substitutes);
objNumMap.addObjectRecursively(docCatalog.get(), substitutes);
if (objNumMap.addObject(infoDict)) {
infoDict->addResources(&objNumMap, substitutes);
}
if (objNumMap.addObject(docCatalog.get())) {
docCatalog->addResources(&objNumMap, substitutes);
}
size_t baseOffset = stream->bytesWritten();
emit_pdf_header(stream);
SkTDArray<int32_t> offsets;
@ -262,7 +286,7 @@ static bool emit_pdf_document(const SkTDArray<const SkPDFDevice*>& pageDevices,
stream->writeText(" 00000 n \n");
}
emit_pdf_footer(stream, objNumMap, substitutes, docCatalog.get(), objCount,
xRefFileOffset, infoDict.detach(), id.detach());
xRefFileOffset, infoDict);
// The page tree has both child and parent pointers, so it creates a
// reference cycle. We must clear that cycle to properly reclaim memory.
@ -380,7 +404,7 @@ private:
SkTDArray<const SkPDFDevice*> fPageDevices;
SkAutoTUnref<SkCanvas> fCanvas;
SkScalar fRasterDpi;
SkPDFMetadata fMetadata;
Metadata fMetadata;
};
} // namespace
///////////////////////////////////////////////////////////////////////////////

14
src/pdf/SkPDFBitmap.cpp
View File

@ -364,17 +364,19 @@ private:
namespace {
class PDFDefaultBitmap : public SkPDFObject {
public:
void emitObject(SkWStream* stream,
void emitObject(SkWStream* stream,
const SkPDFObjNumMap& objNumMap,
const SkPDFSubstituteMap& subs) const override {
emit_image_xobject(stream, fImage, false, fSMask, objNumMap, subs);
const SkPDFSubstituteMap& substitutes) const override {
emit_image_xobject(stream, fImage, false, fSMask, objNumMap, substitutes);
}
void addResources(SkPDFObjNumMap* catalog,
const SkPDFSubstituteMap& subs) const override {
const SkPDFSubstituteMap& substitutes) const override {
if (fSMask.get()) {
SkPDFObject* obj = subs.getSubstitute(fSMask.get());
SkPDFObject* obj = substitutes.getSubstitute(fSMask.get());
SkASSERT(obj);
catalog->addObjectRecursively(obj, subs);
if (catalog->addObject(obj)) {
obj->addResources(catalog, substitutes);
}
}
}
PDFDefaultBitmap(const SkImage* image, SkPDFObject* smask)

347
src/pdf/SkPDFMetadata.cpp
View File

@ -1,347 +0,0 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkPDFMetadata.h"
#include "SkMD5.h"
#include "SkPDFTypes.h"
SkPDFMetadata::UUID SkPDFMetadata::uuid() const {
// The main requirement is for the UUID to be unique; the exact
// format of the data that will be hashed is not important.
SkMD5 md5;
const char uuidNamespace[] = "org.skia.pdf\n";
md5.write(uuidNamespace, strlen(uuidNamespace));
SkMSec msec = SkTime::GetMSecs();
md5.write(&msec, sizeof(msec));
SkTime::DateTime dateTime;
SkTime::GetDateTime(&dateTime);
md5.write(&dateTime, sizeof(dateTime));
if (fCreation) {
md5.write(fCreation.get(), sizeof(fCreation));
}
if (fModified) {
md5.write(fModified.get(), sizeof(fModified));
}
for (const auto& kv : fInfo) {
md5.write(kv.fKey.c_str(), kv.fKey.size());
md5.write("\037", 1);
md5.write(kv.fValue.c_str(), kv.fValue.size());
md5.write("\036", 1);
}
SkMD5::Digest digest;
md5.finish(digest);
// See RFC 4122, page 6-7.
digest.data[6] = (digest.data[6] & 0x0F) | 0x30;
digest.data[8] = (digest.data[6] & 0x3F) | 0x80;
static_assert(sizeof(digest) == sizeof(UUID), "uuid_size");
SkPDFMetadata::UUID uuid;
memcpy(&uuid, &digest, sizeof(digest));
return uuid;
}
SkPDFObject* SkPDFMetadata::CreatePdfId(const UUID& doc, const UUID& instance) {
// /ID [ <81b14aafa313db63dbd6f981e49f94f4>
// <81b14aafa313db63dbd6f981e49f94f4> ]
SkAutoTUnref<SkPDFArray> array(new SkPDFArray);
static_assert(sizeof(UUID) == 16, "uuid_size");
array->appendString(
SkString(reinterpret_cast<const char*>(&doc), sizeof(UUID)));
array->appendString(
SkString(reinterpret_cast<const char*>(&instance), sizeof(UUID)));
return array.detach();
}
static SkString pdf_date(const SkTime::DateTime& dt) {
int timeZoneMinutes = SkToInt(dt.fTimeZoneMinutes);
char timezoneSign = timeZoneMinutes >= 0 ? '+' : '-';
int timeZoneHours = SkTAbs(timeZoneMinutes) / 60;
timeZoneMinutes = SkTAbs(timeZoneMinutes) % 60;
return SkStringPrintf(
"D:%04u%02u%02u%02u%02u%02u%c%02d'%02d'",
static_cast<unsigned>(dt.fYear), static_cast<unsigned>(dt.fMonth),
static_cast<unsigned>(dt.fDay), static_cast<unsigned>(dt.fHour),
static_cast<unsigned>(dt.fMinute),
static_cast<unsigned>(dt.fSecond), timezoneSign, timeZoneHours,
timeZoneMinutes);
}
SkPDFObject* SkPDFMetadata::createDocumentInformationDict() const {
SkAutoTUnref<SkPDFDict> dict(new SkPDFDict);
static const char* keys[] = {
"Title", "Author", "Subject", "Keywords", "Creator"};
for (const char* key : keys) {
for (const SkDocument::Attribute& keyValue : fInfo) {
if (keyValue.fKey.equals(key)) {
dict->insertString(key, keyValue.fValue);
}
}
}
dict->insertString("Producer", "Skia/PDF");
if (fCreation) {
dict->insertString("CreationDate", pdf_date(*fCreation.get()));
}
if (fModified) {
dict->insertString("ModDate", pdf_date(*fModified.get()));
}
return dict.detach();
}
#ifdef SK_PDF_GENERATE_PDFA
// Improvement on SkStringPrintf to allow for arbitrarily long output.
// TODO: replace SkStringPrintf.
static SkString sk_string_printf(const char* format, ...) {
#ifdef SK_BUILD_FOR_WIN
va_list args;
va_start(args, format);
char buffer[1024];
int length = _vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
va_end(args);
if (length >= 0 && length < (int)sizeof(buffer)) {
return SkString(buffer, length);
}
va_start(args, format);
length = _vscprintf(format, args);
va_end(args);
SkString string((size_t)length);
va_start(args, format);
SkDEBUGCODE(int check = ) _vsnprintf_s(string.writable_str(), length + 1,
_TRUNCATE, format, args);
va_end(args);
SkASSERT(check == length);
SkASSERT(string[length] == '\0');
return skstd::move(string);
#else // C99/C++11 standard vsnprintf
// TODO: When all compilers support this, remove windows-specific code.
va_list args;
va_start(args, format);
char buffer[1024];
int length = vsnprintf(buffer, sizeof(buffer), format, args);
va_end(args);
if (length < 0) {
return SkString();
}
if (length < (int)sizeof(buffer)) {
return SkString(buffer, length);
}
SkString string((size_t)length);
va_start(args, format);
SkDEBUGCODE(int check = )
vsnprintf(string.writable_str(), length + 1, format, args);
va_end(args);
SkASSERT(check == length);
SkASSERT(string[length] == '\0');
return skstd::move(string);
#endif
}
static const SkString get(const SkTArray<SkDocument::Attribute>& info,
const char* key) {
for (const auto& keyValue : info) {
if (keyValue.fKey.equals(key)) {
return keyValue.fValue;
}
}
return SkString();
}
#define HEXIFY(INPUT_PTR, OUTPUT_PTR, HEX_STRING, BYTE_COUNT) \
do { \
for (int i = 0; i < (BYTE_COUNT); ++i) { \
uint8_t value = *(INPUT_PTR)++; \
*(OUTPUT_PTR)++ = (HEX_STRING)[value >> 4]; \
*(OUTPUT_PTR)++ = (HEX_STRING)[value & 0xF]; \
} \
} while (false)
static SkString uuid_to_string(const SkPDFMetadata::UUID& uuid) {
// 8-4-4-4-12
char buffer[36]; // [32 + 4]
static const char gHex[] = "0123456789abcdef";
SkASSERT(strlen(gHex) == 16);
char* ptr = buffer;
const uint8_t* data = uuid.fData;
HEXIFY(data, ptr, gHex, 4);
*ptr++ = '-';
HEXIFY(data, ptr, gHex, 2);
*ptr++ = '-';
HEXIFY(data, ptr, gHex, 2);
*ptr++ = '-';
HEXIFY(data, ptr, gHex, 2);
*ptr++ = '-';
HEXIFY(data, ptr, gHex, 6);
SkASSERT(ptr == buffer + 36);
SkASSERT(data == uuid.fData + 16);
return SkString(buffer, 36);
}
#undef HEXIFY
namespace {
class PDFXMLObject : public SkPDFObject {
public:
PDFXMLObject(SkString xml) : fXML(skstd::move(xml)) {}
void emitObject(SkWStream* stream,
const SkPDFObjNumMap& omap,
const SkPDFSubstituteMap& smap) const override {
SkPDFDict dict("Metadata");
dict.insertName("Subtype", "XML");
dict.insertInt("Length", fXML.size());
dict.emitObject(stream, omap, smap);
static const char streamBegin[] = " stream\n";
stream->write(streamBegin, strlen(streamBegin));
// Do not compress this. The standard requires that a
// program that does not understand PDF can grep for
// "<?xpacket" and extracť the entire XML.
stream->write(fXML.c_str(), fXML.size());
static const char streamEnd[] = "\nendstream";
stream->write(streamEnd, strlen(streamEnd));
}
private:
const SkString fXML;
};
} // namespace
static int count_xml_escape_size(const SkString& input) {
int extra = 0;
for (size_t i = 0; i < input.size(); ++i) {
if (input[i] == '&') {
extra += 4; // strlen("&amp;") - strlen("&")
} else if (input[i] == '<') {
extra += 3; // strlen("&lt;") - strlen("<")
}
}
return extra;
}
const SkString escape_xml(const SkString& input,
const char* before = nullptr,
const char* after = nullptr) {
if (input.size() == 0) {
return input;
}
// "&" --> "&amp;" and "<" --> "&lt;"
// text is assumed to be in UTF-8
// all strings are xml content, not attribute values.
size_t beforeLen = before ? strlen(before) : 0;
size_t afterLen = after ? strlen(after) : 0;
int extra = count_xml_escape_size(input);
SkString output(input.size() + extra + beforeLen + afterLen);
char* out = output.writable_str();
if (before) {
strncpy(out, before, beforeLen);
out += beforeLen;
}
static const char kAmp[] = "&amp;";
static const char kLt[] = "&lt;";
for (size_t i = 0; i < input.size(); ++i) {
if (input[i] == '&') {
strncpy(out, kAmp, strlen(kAmp));
out += strlen(kAmp);
} else if (input[i] == '<') {
strncpy(out, kLt, strlen(kLt));
out += strlen(kLt);
} else {
*out++ = input[i];
}
}
if (after) {
strncpy(out, after, afterLen);
out += afterLen;
}
// Validate that we haven't written outside of our string.
SkASSERT(out == &output.writable_str()[output.size()]);
*out = '\0';
return skstd::move(output);
}
SkPDFObject* SkPDFMetadata::createXMPObject(const UUID& doc,
const UUID& instance) const {
static const char templateString[] =
"<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n"
"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"\n"
" x:xmptk=\"Adobe XMP Core 5.4-c005 78.147326, "
"2012/08/23-13:03:03\">\n"
"<rdf:RDF "
"xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n"
"<rdf:Description rdf:about=\"\"\n"
" xmlns:xmp=\"http://ns.adobe.com/xap/1.0/\"\n"
" xmlns:dc=\"http://purl.org/dc/elements/1.1/\"\n"
" xmlns:xmpMM=\"http://ns.adobe.com/xap/1.0/mm/\"\n"
" xmlns:pdf=\"http://ns.adobe.com/pdf/1.3/\"\n"
" xmlns:pdfaid=\"http://www.aiim.org/pdfa/ns/id/\">\n"
"<pdfaid:part>2</pdfaid:part>\n"
"<pdfaid:conformance>B</pdfaid:conformance>\n"
"%s" // ModifyDate
"%s" // CreateDate
"%s" // MetadataDate
"%s" // xmp:CreatorTool
"<dc:format>application/pdf</dc:format>\n"
"%s" // dc:title
"%s" // dc:description
"%s" // author
"%s" // keywords
"<xmpMM:DocumentID>uuid:%s</xmpMM:DocumentID>\n"
"<xmpMM:InstanceID>uuid:%s</xmpMM:InstanceID>\n"
"<pdf:Producer>Skia/PDF</pdf:Producer>\n"
"%s" // pdf:Keywords
"</rdf:Description>\n"
"</rdf:RDF>\n"
"</x:xmpmeta>\n" // Note: the standard suggests 4k of padding.
"<?xpacket end=\"w\"?>\n";
SkString creationDate;
SkString modificationDate;
SkString metadataDate;
if (fCreation) {
SkString tmp;
fCreation->toISO8601(&tmp);
SkASSERT(0 == count_xml_escape_size(tmp));
// YYYY-mm-ddTHH:MM:SS[+|-]ZZ:ZZ; no need to escape
creationDate = sk_string_printf("<xmp:CreateDate>%s</xmp:CreateDate>\n",
tmp.c_str());
}
if (fModified) {
SkString tmp;
fModified->toISO8601(&tmp);
SkASSERT(0 == count_xml_escape_size(tmp));
modificationDate = sk_string_printf(
"<xmp:ModifyDate>%s</xmp:ModifyDate>\n", tmp.c_str());
metadataDate = sk_string_printf(
"<xmp:MetadataDate>%s</xmp:MetadataDate>\n", tmp.c_str());
}
SkString title =
escape_xml(get(fInfo, "Title"), "<dc:title><rdf:Alt><rdf:li>",
"</rdf:li></rdf:Alt></dc:title>\n");
SkString author =
escape_xml(get(fInfo, "Author"), "<dc:creator><rdf:Bag><rdf:li>",
"</rdf:li></rdf:Bag></dc:creator>\n");
// TODO: in theory, XMP can support multiple authors. Split on a delimiter?
SkString subject = escape_xml(get(fInfo, "Subject"),
"<dc:description><rdf:Alt><rdf:li>",
"</rdf:li></rdf:Alt></dc:description>\n");
SkString keywords1 =
escape_xml(get(fInfo, "Keywords"), "<dc:subject><rdf:Bag><rdf:li>",
"</rdf:li></rdf:Bag></dc:subject>\n");
SkString keywords2 = escape_xml(get(fInfo, "Keywords"), "<pdf:Keywords>",
"</pdf:Keywords>\n");
// TODO: in theory, keywords can be a list too.
SkString creator = escape_xml(get(fInfo, "Creator"), "<xmp:CreatorTool>",
"</xmp:CreatorTool>\n");
SkString documentID = uuid_to_string(doc); // no need to escape
SkASSERT(0 == count_xml_escape_size(documentID));
SkString instanceID = uuid_to_string(instance);
SkASSERT(0 == count_xml_escape_size(instanceID));
return new PDFXMLObject(sk_string_printf(
templateString, modificationDate.c_str(), creationDate.c_str(),
metadataDate.c_str(), creator.c_str(), title.c_str(),
subject.c_str(), author.c_str(), keywords1.c_str(),
documentID.c_str(), instanceID.c_str(), keywords2.c_str()));
}
#endif // SK_PDF_GENERATE_PDFA

34
src/pdf/SkPDFMetadata.h
View File

@ -1,34 +0,0 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkPDFMetadata_DEFINED
#define SkPDFMetadata_DEFINED
#include "SkDocument.h"
#include "SkTime.h"
class SkPDFObject;
struct SkPDFMetadata {
SkTArray<SkDocument::Attribute> fInfo;
SkAutoTDelete<const SkTime::DateTime> fCreation;
SkAutoTDelete<const SkTime::DateTime> fModified;
SkPDFObject* createDocumentInformationDict() const;
struct UUID {
uint8_t fData[16];
};
UUID uuid() const;
static SkPDFObject* CreatePdfId(const UUID& doc, const UUID& instance);
#ifdef SK_PDF_GENERATE_PDFA
SkPDFObject* createXMPObject(const UUID& doc, const UUID& instance) const;
#endif // SK_PDF_GENERATE_PDFA
};
#endif // SkPDFMetadata_DEFINED

11
src/pdf/SkPDFTypes.cpp
View File

@ -177,7 +177,9 @@ void SkPDFUnion::addResources(SkPDFObjNumMap* objNumMap,
return; // These have no resources.
case Type::kObjRef: {
SkPDFObject* obj = substituteMap.getSubstitute(fObject);
objNumMap->addObjectRecursively(obj, substituteMap);
if (objNumMap->addObject(obj)) {
obj->addResources(objNumMap, substituteMap);
}
return;
}
case Type::kObject:
@ -498,13 +500,6 @@ bool SkPDFObjNumMap::addObject(SkPDFObject* obj) {
return true;
}
void SkPDFObjNumMap::addObjectRecursively(SkPDFObject* obj,
const SkPDFSubstituteMap& subs) {
if (obj && this->addObject(obj)) {
obj->addResources(this, subs);
}
}
int32_t SkPDFObjNumMap::getObjectNumber(SkPDFObject* obj) const {
int32_t* objectNumberFound = fObjectNumbers.find(obj);
SkASSERT(objectNumberFound);

6
src/pdf/SkPDFTypes.h
View File

@ -346,12 +346,6 @@ public:
*/
bool addObject(SkPDFObject* obj);
/** Add the passed object to the catalog, as well as all its dependencies.
* @param obj The object to add. If nullptr, this is a noop.
* @param subs Will be passed to obj->addResources().
*/
void addObjectRecursively(SkPDFObject* obj, const SkPDFSubstituteMap& subs);
/** Get the object number for the passed object.
* @param obj The object of interest.
*/