SkPDF: Optionally output PDF/A-2b archive format.

src/pdf/SkPDFMetadata.cpp

Index: src/pdf/SkPDFMetadata.cpp
diff --git a/src/pdf/SkPDFMetadata.cpp b/src/pdf/SkPDFMetadata.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d78b71a62944942c4b297016abe9145e8e10b7ae
--- /dev/null
+++ b/src/pdf/SkPDFMetadata.cpp
@@ -0,0 +1,351 @@
+/*
+ * 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 {
+    SkMD5 md5;
+    const char uuidNamespace[] = "org.skia.pdf\n";

[tomhudson, 2015/10/09 15:31:37]

The require newline-termination of the namespace? really? Eww.

[hal.canary, 2015/10/09 19:13:27]

    // The main requirement is for the UUID to be unique; the exact
    // format of the data that will be hashed is not important.

+    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);
+    digest.data[6] = (digest.data[6] & 0x0F) | 0x40;
+    digest.data[8] = (digest.data[6] & 0x3F) | 0x80;

[tomhudson, 2015/10/09 15:31:37]

Where do these magic numbers come from, the spec?

[hal.canary, 2015/10/09 19:13:27]

    // See RFC 4122, page 6-7.

[tomhudson, 2015/10/09 19:21:37]

Acknowledged.

+    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.

[tomhudson, 2015/10/09 15:31:37]

Nit: how far are we from being able to get rid of the Windows-specific version?
I thought we had C++11 everywhere now?

[hal.canary, 2015/10/09 19:13:27]

We have C++11 *semantics* everywhere.  The version of the C standard library I
have on my windows workstation has vsnprintf, but it does not behave according
to the standard.

[tomhudson, 2015/10/09 19:21:37]

Oh, ouch.

+    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)

[tomhudson, 2015/10/09 15:31:37]

Nit: if you already have a for() statement with everything scoped inside, is the
do-while() necessary?

[hal.canary, 2015/10/09 19:13:27]

It means nothing, but allows me to put a semi-colon after
  HEXIFY(data, ptr, gHex, 4)

[tomhudson, 2015/10/09 19:21:37]

Acknowledged.

+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.

[tomhudson, 2015/10/09 15:31:37]

WHY, OH, WHY?

(And why is compression even a topic? Is it going on somewhere nearby
unobviously? (I could easily have missed it if it isn't in code that is part of
this review.))

[hal.canary, 2015/10/09 19:13:27]

The standard requires that a program that does not understand PDF can grep for
"<?xpacket" and extracť the entire XML.
If I wanted to compress, I'd use SkPDFStream.

[tomhudson, 2015/10/09 19:21:37]

Just trying to understand why the comment was there and how a future maintainer
is supposed to be driven to act/understand based on it.

[hal.canary, 2015/10/09 19:28:49]

Comment fixed:

    // 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("<")

[tomhudson, 2015/10/09 15:31:37]

Nit: not obvious why we don't also have to escape &gt to preserve correctness

[hal.canary, 2015/10/09 19:13:27]

    <dc:description>
      <rdf:Alt>
        <rdf:li>
          My Document is called <<, aka "very much less than"
        </rdf:li>
      </rdf:Alt>
    </dc:description>

is not valid XML.

[tomhudson, 2015/10/09 19:21:37]

I think the key question is: XML never has user-generated text inside tags <>?
(The way HTML can have <foo bar="baz">)
Or, we assume that this is valid XML.

[hal.canary, 2015/10/09 19:28:49]

We don't use that aspect of XML here  everywhere we have user-provided or
client-provided text, it is in the form:

    <tag>user-provided plain text</tag>

+        }
+    }
+    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 {
+    // A PDF-1a file should have
+    // the integer value 1 for pdfaid:part and

[tomhudson, 2015/10/09 15:31:37]

Yet you write '2' and 'B' below in templateString?

[hal.canary, 2015/10/09 19:13:27]

The spec was confusing me.  But I think I have it correct in the code now. 
Comment removed.

+    // the value "A" for pdfaid:conformance.
+    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