halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 8 | #include "SkMD5.h" |
halcanary | ffe5400 | 2016-03-29 09:09:29 -0700 | [diff] [blame] | 9 | #include "SkMilestone.h" |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 10 | #include "SkPDFMetadata.h" |
| 11 | #include "SkPDFTypes.h" |
Hal Canary | d6e6e66 | 2017-06-17 10:38:13 -0400 | [diff] [blame^] | 12 | #include "SkUtils.h" |
| 13 | |
bungeman | 221524d | 2016-01-05 14:59:40 -0800 | [diff] [blame] | 14 | #include <utility> |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 15 | |
halcanary | 9f4b332 | 2016-06-30 08:22:04 -0700 | [diff] [blame] | 16 | #define SKPDF_STRING(X) SKPDF_STRING_IMPL(X) |
| 17 | #define SKPDF_STRING_IMPL(X) #X |
| 18 | #define SKPDF_PRODUCER "Skia/PDF m" SKPDF_STRING(SK_MILESTONE) |
| 19 | #define SKPDF_CUSTOM_PRODUCER_KEY "ProductionLibrary" |
| 20 | |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 21 | static SkString pdf_date(const SkTime::DateTime& dt) { |
| 22 | int timeZoneMinutes = SkToInt(dt.fTimeZoneMinutes); |
| 23 | char timezoneSign = timeZoneMinutes >= 0 ? '+' : '-'; |
| 24 | int timeZoneHours = SkTAbs(timeZoneMinutes) / 60; |
| 25 | timeZoneMinutes = SkTAbs(timeZoneMinutes) % 60; |
| 26 | return SkStringPrintf( |
| 27 | "D:%04u%02u%02u%02u%02u%02u%c%02d'%02d'", |
| 28 | static_cast<unsigned>(dt.fYear), static_cast<unsigned>(dt.fMonth), |
| 29 | static_cast<unsigned>(dt.fDay), static_cast<unsigned>(dt.fHour), |
| 30 | static_cast<unsigned>(dt.fMinute), |
| 31 | static_cast<unsigned>(dt.fSecond), timezoneSign, timeZoneHours, |
| 32 | timeZoneMinutes); |
| 33 | } |
| 34 | |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 35 | namespace { |
| 36 | static const struct { |
| 37 | const char* const key; |
| 38 | SkString SkDocument::PDFMetadata::*const valuePtr; |
| 39 | } gMetadataKeys[] = { |
| 40 | {"Title", &SkDocument::PDFMetadata::fTitle}, |
| 41 | {"Author", &SkDocument::PDFMetadata::fAuthor}, |
| 42 | {"Subject", &SkDocument::PDFMetadata::fSubject}, |
| 43 | {"Keywords", &SkDocument::PDFMetadata::fKeywords}, |
| 44 | {"Creator", &SkDocument::PDFMetadata::fCreator}, |
| 45 | }; |
| 46 | } // namespace |
| 47 | |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 48 | sk_sp<SkPDFObject> SkPDFMetadata::MakeDocumentInformationDict( |
| 49 | const SkDocument::PDFMetadata& metadata) { |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 50 | auto dict = sk_make_sp<SkPDFDict>(); |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 51 | for (const auto keyValuePtr : gMetadataKeys) { |
| 52 | const SkString& value = metadata.*(keyValuePtr.valuePtr); |
| 53 | if (value.size() > 0) { |
| 54 | dict->insertString(keyValuePtr.key, value); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 55 | } |
| 56 | } |
halcanary | 9f4b332 | 2016-06-30 08:22:04 -0700 | [diff] [blame] | 57 | if (metadata.fProducer.isEmpty()) { |
| 58 | dict->insertString("Producer", SKPDF_PRODUCER); |
| 59 | } else { |
| 60 | dict->insertString("Producer", metadata.fProducer); |
| 61 | dict->insertString(SKPDF_CUSTOM_PRODUCER_KEY, SKPDF_PRODUCER); |
| 62 | } |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 63 | if (metadata.fCreation.fEnabled) { |
| 64 | dict->insertString("CreationDate", |
| 65 | pdf_date(metadata.fCreation.fDateTime)); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 66 | } |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 67 | if (metadata.fModified.fEnabled) { |
| 68 | dict->insertString("ModDate", pdf_date(metadata.fModified.fDateTime)); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 69 | } |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 70 | return dict; |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 71 | } |
| 72 | |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 73 | SkPDFMetadata::UUID SkPDFMetadata::CreateUUID( |
| 74 | const SkDocument::PDFMetadata& metadata) { |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 75 | // The main requirement is for the UUID to be unique; the exact |
| 76 | // format of the data that will be hashed is not important. |
| 77 | SkMD5 md5; |
| 78 | const char uuidNamespace[] = "org.skia.pdf\n"; |
| 79 | md5.write(uuidNamespace, strlen(uuidNamespace)); |
benjaminwagner | ec4d4d7 | 2016-03-25 12:59:53 -0700 | [diff] [blame] | 80 | double msec = SkTime::GetMSecs(); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 81 | md5.write(&msec, sizeof(msec)); |
| 82 | SkTime::DateTime dateTime; |
| 83 | SkTime::GetDateTime(&dateTime); |
| 84 | md5.write(&dateTime, sizeof(dateTime)); |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 85 | if (metadata.fCreation.fEnabled) { |
| 86 | md5.write(&metadata.fCreation.fDateTime, |
| 87 | sizeof(metadata.fCreation.fDateTime)); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 88 | } |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 89 | if (metadata.fModified.fEnabled) { |
| 90 | md5.write(&metadata.fModified.fDateTime, |
| 91 | sizeof(metadata.fModified.fDateTime)); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 92 | } |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 93 | |
| 94 | for (const auto keyValuePtr : gMetadataKeys) { |
| 95 | md5.write(keyValuePtr.key, strlen(keyValuePtr.key)); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 96 | md5.write("\037", 1); |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 97 | const SkString& value = metadata.*(keyValuePtr.valuePtr); |
| 98 | md5.write(value.c_str(), value.size()); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 99 | md5.write("\036", 1); |
| 100 | } |
| 101 | SkMD5::Digest digest; |
| 102 | md5.finish(digest); |
| 103 | // See RFC 4122, page 6-7. |
| 104 | digest.data[6] = (digest.data[6] & 0x0F) | 0x30; |
| 105 | digest.data[8] = (digest.data[6] & 0x3F) | 0x80; |
| 106 | static_assert(sizeof(digest) == sizeof(UUID), "uuid_size"); |
| 107 | SkPDFMetadata::UUID uuid; |
| 108 | memcpy(&uuid, &digest, sizeof(digest)); |
| 109 | return uuid; |
| 110 | } |
| 111 | |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 112 | sk_sp<SkPDFObject> SkPDFMetadata::MakePdfId(const UUID& doc, |
| 113 | const UUID& instance) { |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 114 | // /ID [ <81b14aafa313db63dbd6f981e49f94f4> |
| 115 | // <81b14aafa313db63dbd6f981e49f94f4> ] |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 116 | auto array = sk_make_sp<SkPDFArray>(); |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 117 | static_assert(sizeof(SkPDFMetadata::UUID) == 16, "uuid_size"); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 118 | array->appendString( |
| 119 | SkString(reinterpret_cast<const char*>(&doc), sizeof(UUID))); |
| 120 | array->appendString( |
| 121 | SkString(reinterpret_cast<const char*>(&instance), sizeof(UUID))); |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 122 | return array; |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 123 | } |
| 124 | |
Hal Canary | d6e6e66 | 2017-06-17 10:38:13 -0400 | [diff] [blame^] | 125 | // Convert a block of memory to hexadecimal. Input and output pointers will be |
| 126 | // moved to end of the range. |
| 127 | static void hexify(const uint8_t** inputPtr, char** outputPtr, int count) { |
| 128 | SkASSERT(inputPtr && *inputPtr); |
| 129 | SkASSERT(outputPtr && *outputPtr); |
| 130 | while (count-- > 0) { |
| 131 | uint8_t value = *(*inputPtr)++; |
| 132 | *(*outputPtr)++ = SkHexadecimalDigits::gLower[value >> 4]; |
| 133 | *(*outputPtr)++ = SkHexadecimalDigits::gLower[value & 0xF]; |
| 134 | } |
| 135 | } |
| 136 | |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 137 | static SkString uuid_to_string(const SkPDFMetadata::UUID& uuid) { |
| 138 | // 8-4-4-4-12 |
| 139 | char buffer[36]; // [32 + 4] |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 140 | char* ptr = buffer; |
| 141 | const uint8_t* data = uuid.fData; |
Hal Canary | d6e6e66 | 2017-06-17 10:38:13 -0400 | [diff] [blame^] | 142 | hexify(&data, &ptr, 4); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 143 | *ptr++ = '-'; |
Hal Canary | d6e6e66 | 2017-06-17 10:38:13 -0400 | [diff] [blame^] | 144 | hexify(&data, &ptr, 2); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 145 | *ptr++ = '-'; |
Hal Canary | d6e6e66 | 2017-06-17 10:38:13 -0400 | [diff] [blame^] | 146 | hexify(&data, &ptr, 2); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 147 | *ptr++ = '-'; |
Hal Canary | d6e6e66 | 2017-06-17 10:38:13 -0400 | [diff] [blame^] | 148 | hexify(&data, &ptr, 2); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 149 | *ptr++ = '-'; |
Hal Canary | d6e6e66 | 2017-06-17 10:38:13 -0400 | [diff] [blame^] | 150 | hexify(&data, &ptr, 6); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 151 | SkASSERT(ptr == buffer + 36); |
| 152 | SkASSERT(data == uuid.fData + 16); |
| 153 | return SkString(buffer, 36); |
| 154 | } |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 155 | |
| 156 | namespace { |
halcanary | 70d1554 | 2015-11-22 12:55:04 -0800 | [diff] [blame] | 157 | class PDFXMLObject final : public SkPDFObject { |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 158 | public: |
bungeman | 221524d | 2016-01-05 14:59:40 -0800 | [diff] [blame] | 159 | PDFXMLObject(SkString xml) : fXML(std::move(xml)) {} |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 160 | void emitObject(SkWStream* stream, |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 161 | const SkPDFObjNumMap& omap) const override { |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 162 | SkPDFDict dict("Metadata"); |
| 163 | dict.insertName("Subtype", "XML"); |
| 164 | dict.insertInt("Length", fXML.size()); |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 165 | dict.emitObject(stream, omap); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 166 | static const char streamBegin[] = " stream\n"; |
| 167 | stream->write(streamBegin, strlen(streamBegin)); |
| 168 | // Do not compress this. The standard requires that a |
| 169 | // program that does not understand PDF can grep for |
Hal Canary | 55325b7 | 2017-01-03 10:36:17 -0500 | [diff] [blame] | 170 | // "<?xpacket" and extract the entire XML. |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 171 | stream->write(fXML.c_str(), fXML.size()); |
| 172 | static const char streamEnd[] = "\nendstream"; |
| 173 | stream->write(streamEnd, strlen(streamEnd)); |
| 174 | } |
| 175 | |
| 176 | private: |
| 177 | const SkString fXML; |
| 178 | }; |
| 179 | } // namespace |
| 180 | |
| 181 | static int count_xml_escape_size(const SkString& input) { |
| 182 | int extra = 0; |
| 183 | for (size_t i = 0; i < input.size(); ++i) { |
| 184 | if (input[i] == '&') { |
| 185 | extra += 4; // strlen("&") - strlen("&") |
| 186 | } else if (input[i] == '<') { |
| 187 | extra += 3; // strlen("<") - strlen("<") |
| 188 | } |
| 189 | } |
| 190 | return extra; |
| 191 | } |
| 192 | |
| 193 | const SkString escape_xml(const SkString& input, |
| 194 | const char* before = nullptr, |
| 195 | const char* after = nullptr) { |
| 196 | if (input.size() == 0) { |
| 197 | return input; |
| 198 | } |
| 199 | // "&" --> "&" and "<" --> "<" |
| 200 | // text is assumed to be in UTF-8 |
| 201 | // all strings are xml content, not attribute values. |
| 202 | size_t beforeLen = before ? strlen(before) : 0; |
| 203 | size_t afterLen = after ? strlen(after) : 0; |
| 204 | int extra = count_xml_escape_size(input); |
| 205 | SkString output(input.size() + extra + beforeLen + afterLen); |
| 206 | char* out = output.writable_str(); |
| 207 | if (before) { |
| 208 | strncpy(out, before, beforeLen); |
| 209 | out += beforeLen; |
| 210 | } |
| 211 | static const char kAmp[] = "&"; |
| 212 | static const char kLt[] = "<"; |
| 213 | for (size_t i = 0; i < input.size(); ++i) { |
| 214 | if (input[i] == '&') { |
| 215 | strncpy(out, kAmp, strlen(kAmp)); |
| 216 | out += strlen(kAmp); |
| 217 | } else if (input[i] == '<') { |
| 218 | strncpy(out, kLt, strlen(kLt)); |
| 219 | out += strlen(kLt); |
| 220 | } else { |
| 221 | *out++ = input[i]; |
| 222 | } |
| 223 | } |
| 224 | if (after) { |
| 225 | strncpy(out, after, afterLen); |
| 226 | out += afterLen; |
| 227 | } |
| 228 | // Validate that we haven't written outside of our string. |
| 229 | SkASSERT(out == &output.writable_str()[output.size()]); |
| 230 | *out = '\0'; |
halcanary | 78daeff | 2016-04-07 12:34:59 -0700 | [diff] [blame] | 231 | return output; |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 232 | } |
| 233 | |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 234 | sk_sp<SkPDFObject> SkPDFMetadata::MakeXMPObject( |
| 235 | const SkDocument::PDFMetadata& metadata, |
| 236 | const UUID& doc, |
| 237 | const UUID& instance) { |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 238 | static const char templateString[] = |
| 239 | "<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n" |
| 240 | "<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"\n" |
| 241 | " x:xmptk=\"Adobe XMP Core 5.4-c005 78.147326, " |
| 242 | "2012/08/23-13:03:03\">\n" |
| 243 | "<rdf:RDF " |
| 244 | "xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n" |
| 245 | "<rdf:Description rdf:about=\"\"\n" |
| 246 | " xmlns:xmp=\"http://ns.adobe.com/xap/1.0/\"\n" |
| 247 | " xmlns:dc=\"http://purl.org/dc/elements/1.1/\"\n" |
| 248 | " xmlns:xmpMM=\"http://ns.adobe.com/xap/1.0/mm/\"\n" |
| 249 | " xmlns:pdf=\"http://ns.adobe.com/pdf/1.3/\"\n" |
| 250 | " xmlns:pdfaid=\"http://www.aiim.org/pdfa/ns/id/\">\n" |
| 251 | "<pdfaid:part>2</pdfaid:part>\n" |
| 252 | "<pdfaid:conformance>B</pdfaid:conformance>\n" |
| 253 | "%s" // ModifyDate |
| 254 | "%s" // CreateDate |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 255 | "%s" // xmp:CreatorTool |
| 256 | "<dc:format>application/pdf</dc:format>\n" |
| 257 | "%s" // dc:title |
| 258 | "%s" // dc:description |
| 259 | "%s" // author |
| 260 | "%s" // keywords |
| 261 | "<xmpMM:DocumentID>uuid:%s</xmpMM:DocumentID>\n" |
| 262 | "<xmpMM:InstanceID>uuid:%s</xmpMM:InstanceID>\n" |
halcanary | 9f4b332 | 2016-06-30 08:22:04 -0700 | [diff] [blame] | 263 | "%s" // pdf:Producer |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 264 | "%s" // pdf:Keywords |
| 265 | "</rdf:Description>\n" |
| 266 | "</rdf:RDF>\n" |
| 267 | "</x:xmpmeta>\n" // Note: the standard suggests 4k of padding. |
| 268 | "<?xpacket end=\"w\"?>\n"; |
| 269 | |
| 270 | SkString creationDate; |
| 271 | SkString modificationDate; |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 272 | if (metadata.fCreation.fEnabled) { |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 273 | SkString tmp; |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 274 | metadata.fCreation.fDateTime.toISO8601(&tmp); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 275 | SkASSERT(0 == count_xml_escape_size(tmp)); |
| 276 | // YYYY-mm-ddTHH:MM:SS[+|-]ZZ:ZZ; no need to escape |
halcanary | d51bdae | 2016-04-25 09:25:35 -0700 | [diff] [blame] | 277 | creationDate = SkStringPrintf("<xmp:CreateDate>%s</xmp:CreateDate>\n", |
| 278 | tmp.c_str()); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 279 | } |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 280 | if (metadata.fModified.fEnabled) { |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 281 | SkString tmp; |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 282 | metadata.fModified.fDateTime.toISO8601(&tmp); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 283 | SkASSERT(0 == count_xml_escape_size(tmp)); |
halcanary | d51bdae | 2016-04-25 09:25:35 -0700 | [diff] [blame] | 284 | modificationDate = SkStringPrintf( |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 285 | "<xmp:ModifyDate>%s</xmp:ModifyDate>\n", tmp.c_str()); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 286 | } |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 287 | SkString title = |
| 288 | escape_xml(metadata.fTitle, |
| 289 | "<dc:title><rdf:Alt><rdf:li xml:lang=\"x-default\">", |
| 290 | "</rdf:li></rdf:Alt></dc:title>\n"); |
| 291 | SkString author = |
| 292 | escape_xml(metadata.fAuthor, "<dc:creator><rdf:Bag><rdf:li>", |
| 293 | "</rdf:li></rdf:Bag></dc:creator>\n"); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 294 | // TODO: in theory, XMP can support multiple authors. Split on a delimiter? |
halcanary | 78daeff | 2016-04-07 12:34:59 -0700 | [diff] [blame] | 295 | SkString subject = escape_xml( |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 296 | metadata.fSubject, |
halcanary | 78daeff | 2016-04-07 12:34:59 -0700 | [diff] [blame] | 297 | "<dc:description><rdf:Alt><rdf:li xml:lang=\"x-default\">", |
| 298 | "</rdf:li></rdf:Alt></dc:description>\n"); |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 299 | SkString keywords1 = |
| 300 | escape_xml(metadata.fKeywords, "<dc:subject><rdf:Bag><rdf:li>", |
| 301 | "</rdf:li></rdf:Bag></dc:subject>\n"); |
| 302 | SkString keywords2 = escape_xml(metadata.fKeywords, "<pdf:Keywords>", |
| 303 | "</pdf:Keywords>\n"); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 304 | // TODO: in theory, keywords can be a list too. |
halcanary | 9f4b332 | 2016-06-30 08:22:04 -0700 | [diff] [blame] | 305 | |
halcanary | 492d6b5 | 2016-07-07 12:28:30 -0700 | [diff] [blame] | 306 | SkString producer("<pdf:Producer>" SKPDF_PRODUCER "</pdf:Producer>\n"); |
halcanary | 9f4b332 | 2016-06-30 08:22:04 -0700 | [diff] [blame] | 307 | if (!metadata.fProducer.isEmpty()) { |
| 308 | // TODO: register a developer prefix to make |
| 309 | // <skia:SKPDF_CUSTOM_PRODUCER_KEY> a real XML tag. |
| 310 | producer = escape_xml( |
| 311 | metadata.fProducer, "<pdf:Producer>", |
| 312 | "</pdf:Producer>\n<!-- <skia:" SKPDF_CUSTOM_PRODUCER_KEY ">" |
| 313 | SKPDF_PRODUCER "</skia:" SKPDF_CUSTOM_PRODUCER_KEY "> -->\n"); |
| 314 | } |
| 315 | |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 316 | SkString creator = escape_xml(metadata.fCreator, "<xmp:CreatorTool>", |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 317 | "</xmp:CreatorTool>\n"); |
| 318 | SkString documentID = uuid_to_string(doc); // no need to escape |
| 319 | SkASSERT(0 == count_xml_escape_size(documentID)); |
| 320 | SkString instanceID = uuid_to_string(instance); |
| 321 | SkASSERT(0 == count_xml_escape_size(instanceID)); |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 322 | return sk_make_sp<PDFXMLObject>(SkStringPrintf( |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 323 | templateString, modificationDate.c_str(), creationDate.c_str(), |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 324 | creator.c_str(), title.c_str(), subject.c_str(), author.c_str(), |
| 325 | keywords1.c_str(), documentID.c_str(), instanceID.c_str(), |
halcanary | 9f4b332 | 2016-06-30 08:22:04 -0700 | [diff] [blame] | 326 | producer.c_str(), keywords2.c_str())); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 327 | } |
| 328 | |
halcanary | 9f4b332 | 2016-06-30 08:22:04 -0700 | [diff] [blame] | 329 | #undef SKPDF_CUSTOM_PRODUCER_KEY |
| 330 | #undef SKPDF_PRODUCER |
halcanary | 8cd4a24 | 2016-04-07 08:56:15 -0700 | [diff] [blame] | 331 | #undef SKPDF_STRING |
| 332 | #undef SKPDF_STRING_IMPL |