SkPDF: allow overriding Producer metadata

src/pdf/SkPDFMetadata.cpp

 /*
  * 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 "SkMD5.h"
 #include "SkMilestone.h"
 #include "SkPDFMetadata.h"
 #include "SkPDFTypes.h"
 #include <utility>
 
+#define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
+#define SKPDF_STRING_IMPL(X) #X
+#define SKPDF_PRODUCER "Skia/PDF m" SKPDF_STRING(SK_MILESTONE)
+#define SKPDF_CUSTOM_PRODUCER_KEY "ProductionLibrary"
+
 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);
 }
 
-#define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
-#define SKPDF_STRING_IMPL(X) #X
-
 namespace {
 static const struct {
     const char* const key;
     SkString SkDocument::PDFMetadata::*const valuePtr;
 } gMetadataKeys[] = {
         {"Title", &SkDocument::PDFMetadata::fTitle},
         {"Author", &SkDocument::PDFMetadata::fAuthor},
         {"Subject", &SkDocument::PDFMetadata::fSubject},
         {"Keywords", &SkDocument::PDFMetadata::fKeywords},
         {"Creator", &SkDocument::PDFMetadata::fCreator},
@@ skipping 15 matching lines @@
 
 sk_sp<SkPDFObject> SkPDFMetadata::MakeDocumentInformationDict(
         const SkDocument::PDFMetadata& metadata) {
     auto dict = sk_make_sp<SkPDFDict>();
     for (const auto keyValuePtr : gMetadataKeys) {
         const SkString& value = metadata.*(keyValuePtr.valuePtr);
         if (value.size() > 0) {
             dict->insertString(keyValuePtr.key, value);
         }
     }
-    dict->insertString("Producer", "Skia/PDF m" SKPDF_STRING(SK_MILESTONE));
+    if (metadata.fProducer.isEmpty()) {
+        dict->insertString("Producer", SKPDF_PRODUCER);
+    } else {
+        dict->insertString("Producer", metadata.fProducer);
+        dict->insertString(SKPDF_CUSTOM_PRODUCER_KEY, SKPDF_PRODUCER);
+    }
     if (metadata.fCreation.fEnabled) {
         dict->insertString("CreationDate",
                            pdf_date(metadata.fCreation.fDateTime));
     }
     if (metadata.fModified.fEnabled) {
         dict->insertString("ModDate", pdf_date(metadata.fModified.fDateTime));
     }
     return dict;
 }
 
@@ skipping 180 matching lines @@
             "%s"  // ModifyDate
             "%s"  // CreateDate
             "%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 m" SKPDF_STRING(SK_MILESTONE) "</pdf:Producer>\n"
+            "%s"  // pdf:Producer
             "%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;
     if (metadata.fCreation.fEnabled) {
         SkString tmp;
@@ skipping 20 matching lines @@
     // TODO: in theory, XMP can support multiple authors.  Split on a delimiter?
     SkString subject = escape_xml(
             metadata.fSubject,
             "<dc:description><rdf:Alt><rdf:li xml:lang=\"x-default\">",
             "</rdf:li></rdf:Alt></dc:description>\n");
     SkString keywords1 =
             escape_xml(metadata.fKeywords, "<dc:subject><rdf:Bag><rdf:li>",
                        "</rdf:li></rdf:Bag></dc:subject>\n");
     SkString keywords2 = escape_xml(metadata.fKeywords, "<pdf:Keywords>",
                                     "</pdf:Keywords>\n");
+    // TODO: in theory, keywords can be a list too.
 
-    // TODO: in theory, keywords can be a list too.
+    SkString producer("<pdf:Producer>SKPDF_PRODUCER</pdf:Producer>\n");
+    if (!metadata.fProducer.isEmpty()) {
+        // TODO: register a developer prefix to make
+        // <skia:SKPDF_CUSTOM_PRODUCER_KEY> a real XML tag.
+        producer = escape_xml(
+                metadata.fProducer, "<pdf:Producer>",
+                "</pdf:Producer>\n<!-- <skia:" SKPDF_CUSTOM_PRODUCER_KEY ">"
+                SKPDF_PRODUCER "</skia:" SKPDF_CUSTOM_PRODUCER_KEY "> -->\n");
+    }
+
     SkString creator = escape_xml(metadata.fCreator, "<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 sk_make_sp<PDFXMLObject>(SkStringPrintf(
             templateString, modificationDate.c_str(), creationDate.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()));
+            producer.c_str(), keywords2.c_str()));
 }
 
+#undef SKPDF_CUSTOM_PRODUCER_KEY
+#undef SKPDF_PRODUCER
 #undef SKPDF_STRING
 #undef SKPDF_STRING_IMPL