SkDocument/PDF: new API

src/pdf/SkPDFDocument.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPDFCanon.h"
 #include "SkPDFCanvas.h"
 #include "SkPDFDevice.h"
@@ skipping 17 matching lines @@
     fObjNumMap.addObjectRecursively(object.get(), fSubstituteMap);
 }
 
 #define SKPDF_MAGIC "\xD3\xEB\xE9\xE1"
 #ifndef SK_BUILD_FOR_WIN32
 static_assert((SKPDF_MAGIC[0] & 0x7F) == "Skia"[0], "");
 static_assert((SKPDF_MAGIC[1] & 0x7F) == "Skia"[1], "");
 static_assert((SKPDF_MAGIC[2] & 0x7F) == "Skia"[2], "");
 static_assert((SKPDF_MAGIC[3] & 0x7F) == "Skia"[3], "");
 #endif
-void SkPDFObjectSerializer::serializeHeader(SkWStream* wStream, const SkPDFMetadata& md) {
+void SkPDFObjectSerializer::serializeHeader(SkWStream* wStream,
+                                            const SkDocument::PDFMetadata& md) {
     fBaseOffset = wStream->bytesWritten();
     static const char kHeader[] = "%PDF-1.4\n%" SKPDF_MAGIC "\n";
     wStream->write(kHeader, strlen(kHeader));
     // The PDF spec recommends including a comment with four
     // bytes, all with their high bits set.  "\xD3\xEB\xE9\xE1" is
     // "Skia" with the high bits set.
-    fInfoDict.reset(md.createDocumentInformationDict());
+    fInfoDict = SkPDFMetadata::MakeDocumentInformationDict(md);
     this->addObjectRecursively(fInfoDict);
     this->serializeObjects(wStream);
 }
 #undef SKPDF_MAGIC
 
 // Serialize all objects in the fObjNumMap that have not yet been serialized;
 void SkPDFObjectSerializer::serializeObjects(SkWStream* wStream) {
     const SkTArray<sk_sp<SkPDFObject>>& objects = fObjNumMap.objects();
     while (fNextToBeSerialized < objects.count()) {
         SkPDFObject* object = objects[fNextToBeSerialized].get();
@@ skipping 152 matching lines @@
     }
 }
 #endif
 
 template <typename T> static T* clone(const T* o) { return o ? new T(*o) : nullptr; }
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFDocument::SkPDFDocument(SkWStream* stream,
                              void (*doneProc)(SkWStream*, bool),
                              SkScalar rasterDpi,
-                             SkPixelSerializer* jpegEncoder,
+                             const SkDocument::PDFMetadata& metadata,
+                             sk_sp<SkPixelSerializer> jpegEncoder,
                              bool pdfa)
     : SkDocument(stream, doneProc)
     , fRasterDpi(rasterDpi)
+    , fMetadata(metadata)
     , fPDFA(pdfa) {
-    fCanon.setPixelSerializer(SkSafeRef(jpegEncoder));
+    fCanon.setPixelSerializer(std::move(jpegEncoder));
 }
 
 SkPDFDocument::~SkPDFDocument() {
     // subclasses of SkDocument must call close() in their destructors.
     this->close();
 }
 
 void SkPDFDocument::serialize(const sk_sp<SkPDFObject>& object) {
     fObjectSerializer.addObjectRecursively(object);
     fObjectSerializer.serializeObjects(this->getStream());
 }
 
 SkCanvas* SkPDFDocument::onBeginPage(SkScalar width, SkScalar height,
                                      const SkRect& trimBox) {
     SkASSERT(!fCanvas.get());  // endPage() was called before this.
     if (fPages.empty()) {
         // if this is the first page if the document.
         fObjectSerializer.serializeHeader(this->getStream(), fMetadata);
         fDests = sk_make_sp<SkPDFDict>();
         if (fPDFA) {
-            SkPDFMetadata::UUID uuid = fMetadata.uuid();
+            SkPDFMetadata::UUID uuid = SkPDFMetadata::CreateUUID(fMetadata);
             // 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.
-            fID.reset(SkPDFMetadata::CreatePdfId(uuid, uuid));
-            fXMP.reset(fMetadata.createXMPObject(uuid, uuid));
+            fID = SkPDFMetadata::MakePdfId(uuid, uuid);
+            fXMP = SkPDFMetadata::MakeXMPObject(fMetadata, uuid, uuid);
             fObjectSerializer.addObjectRecursively(fXMP);
             fObjectSerializer.serializeObjects(this->getStream());
         }
     }
     SkISize pageSize = SkISize::Make(
             SkScalarRoundToInt(width), SkScalarRoundToInt(height));
     fPageDevice.reset(
             SkPDFDevice::Create(pageSize, fRasterDpi, this));
     fCanvas = sk_make_sp<SkPDFCanvas>(fPageDevice);
     fCanvas->clipRect(trimBox);
@@ skipping 24 matching lines @@
     fPageDevice.reset(nullptr);
 }
 
 void SkPDFDocument::onAbort() {
     fCanvas.reset(nullptr);
     fPages.reset();
     fCanon.reset();
     renew(&fObjectSerializer);
 }
 
+#ifdef SK_SUPPORT_LEGACY_DOCUMENT_API
 void SkPDFDocument::setMetadata(const SkDocument::Attribute info[],
                                 int infoCount,
                                 const SkTime::DateTime* creationDate,
                                 const SkTime::DateTime* modifiedDate) {
-    fMetadata.fInfo.reset(info, infoCount);
-    fMetadata.fCreation.reset(clone(creationDate));
-    fMetadata.fModified.reset(clone(modifiedDate));
+    for (int i = 0; i < infoCount; ++i) {
+        const SkDocument::Attribute& kv = info[i];
+        SkPDFMetadata::SetMetadataByKey(kv.fKey, kv.fValue, &fMetadata);
+    }
+    if (creationDate) {
+        fMetadata.fCreation.fEnabled = true;
+        fMetadata.fCreation.fDateTime = *creationDate;
+    }
+    if (modifiedDate) {
+        fMetadata.fModified.fEnabled = true;
+        fMetadata.fModified.fDateTime = *modifiedDate;
+    }
 }
+#endif  // SK_SUPPORT_LEGACY_DOCUMENT_API
 
 static sk_sp<SkData> SkSrgbIcm() {
     // Source: http://www.argyllcms.com/icclibsrc.html
     static const char kProfile[] =
         "\0\0\14\214argl\2 \0\0mntrRGB XYZ \7\336\0\1\0\6\0\26\0\17\0:acspM"
         "SFT\0\0\0\0IEC sRGB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\366\326\0\1\0\0\0\0"
         "\323-argl\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
         "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\21desc\0\0\1P\0\0\0\231cprt\0"
         "\0\1\354\0\0\0gdmnd\0\0\2T\0\0\0pdmdd\0\0\2\304\0\0\0\210tech\0\0\3"
         "L\0\0\0\14vued\0\0\3X\0\0\0gview\0\0\3\300\0\0\0$lumi\0\0\3\344\0\0"
@@ skipping 172 matching lines @@
     fCanon.reset();
     renew(&fObjectSerializer);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream,
                                     void (*proc)(SkWStream*, bool),
                                     SkScalar dpi,
-                                    SkPixelSerializer* jpeg,
+                                    const SkDocument::PDFMetadata& metadata,
+                                    sk_sp<SkPixelSerializer> jpeg,
                                     bool pdfa) {
-    return stream ? sk_make_sp<SkPDFDocument>(stream, proc, dpi, jpeg, pdfa)
+    return stream ? sk_make_sp<SkPDFDocument>(stream, proc, dpi, metadata,
+                                              std::move(jpeg), pdfa)
                   : nullptr;
 }
 
-#ifdef SK_PDF_GENERATE_PDFA
-    static const bool kPDFA = true;
-#else
-    static const bool kPDFA = false;
-#endif
-
-SkDocument* SkDocument::CreatePDF(SkWStream* stream, SkScalar dpi) {
-    return SkPDFMakeDocument(stream, nullptr, dpi, nullptr, kPDFA).release();
-}
-
-SkDocument* SkDocument::CreatePDF(SkWStream* stream,
-                                  SkScalar dpi,
-                                  SkPixelSerializer* jpegEncoder) {
-    return SkPDFMakeDocument(stream, nullptr, dpi,
-                             jpegEncoder, kPDFA).release();
-}
-
-SkDocument* SkDocument::CreatePDF(const char path[], SkScalar dpi) {
+sk_sp<SkDocument> SkDocument::MakePDF(const char path[], SkScalar dpi) {
     auto delete_wstream = [](SkWStream* stream, bool) { delete stream; };
     std::unique_ptr<SkFILEWStream> stream(new SkFILEWStream(path));
     return stream->isValid()
-        ? SkPDFMakeDocument(stream.release(), delete_wstream, dpi,
-                            nullptr, kPDFA).release()
-        : nullptr;
+                   ? SkPDFMakeDocument(stream.release(), delete_wstream, dpi,
+                                       SkDocument::PDFMetadata(), nullptr,
+                                       false)
+                   : nullptr;
 }
+
+sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream,
+                                      SkScalar dpi,
+                                      const SkDocument::PDFMetadata& metadata,
+                                      sk_sp<SkPixelSerializer> jpegEncoder,
+                                      bool pdfa) {
+    return SkPDFMakeDocument(stream, nullptr, dpi, metadata,
+                             std::move(jpegEncoder), pdfa);
+}