Tagged PDF annotations must appear in the Parent Tree as well.

In order for a tagged PDF to validate, each annotation (such as
a hyperlink) must have a /StructParent entry that links back to
the Parent Tree object, which in turn links that annotation to
its corresponding struct tree node.

The parent tree also contains one entry per page. Both the page
entries and the annotation entries need IDs.

Since we don't know in advance how many pages will be in the
doc at the time we start processing annotations, we start the
annotation IDs with a large number (100,000) which effectively
serves as the maximum number of pages in a document that we can
handle.

Bug: chromium:1100712
Change-Id: I5df84c4249ed6a4d21222cfc86b2c0c9b17d6efb
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/300254
Auto-Submit: Dominic Mazzoni <[email protected]>
Commit-Queue: Ben Wagner <[email protected]>
Reviewed-by: Ben Wagner <[email protected]>

Author: minorninth

src/pdf/SkPDFDevice.cpp

@@ -75,7 +75,7 @@ class ScopedOutputMarkedContentTags {
         : fOut(out)
         , fMarkId(-1) {
         if (nodeId) {
-            fMarkId = document->getMarkIdForNodeId(nodeId);
+            fMarkId = document->createMarkIdForNodeId(nodeId);
         }
 
         if (fMarkId != -1) {

src/pdf/SkPDFDocument.cpp

@@ -334,10 +334,17 @@ std::unique_ptr<SkPDFArray> SkPDFDocument::getAnnotations() {
             SkDEBUGFAIL("Unknown link type.");
         }
 
+        if (link->fNodeId) {
+            int structParentKey = createStructParentKeyForNodeId(link->fNodeId);
+            if (structParentKey != -1) {
+                annotation.insertInt("StructParent", structParentKey);
+            }
+        }
+
         SkPDFIndirectReference annotationRef = emit(annotation);
         array->appendRef(annotationRef);
         if (link->fNodeId) {
-            fTagTree.addNodeAnnotation(link->fNodeId, annotationRef);
+            fTagTree.addNodeAnnotation(link->fNodeId, annotationRef, SkToUInt(this->currentPageIndex()));
         }
     }
     return array;
@@ -519,8 +526,12 @@ const SkMatrix& SkPDFDocument::currentPageTransform() const {
     return fPageDevice->initialTransform();
 }
 
-int SkPDFDocument::getMarkIdForNodeId(int nodeId) {
-    return fTagTree.getMarkIdForNodeId(nodeId, SkToUInt(this->currentPageIndex()));
+int SkPDFDocument::createMarkIdForNodeId(int nodeId) {
+    return fTagTree.createMarkIdForNodeId(nodeId, SkToUInt(this->currentPageIndex()));
+}
+
+int SkPDFDocument::createStructParentKeyForNodeId(int nodeId) {
+    return fTagTree.createStructParentKeyForNodeId(nodeId, SkToUInt(this->currentPageIndex()));
 }
 
 static std::vector<const SkPDFFont*> get_fonts(const SkPDFDocument& canon) {

src/pdf/SkPDFDocumentPriv.h

@@ -116,8 +116,14 @@ class SkPDFDocument : public SkDocument {
     SkPDFIndirectReference currentPage() const {
         return SkASSERT(!fPageRefs.empty()), fPageRefs.back();
     }
-    // Returns -1 if no mark ID.
-    int getMarkIdForNodeId(int nodeId);
+    // Used to allow marked content to refer to its corresponding structure
+    // tree node, via a page entry in the parent tree. Returns -1 if no
+    // mark ID.
+    int createMarkIdForNodeId(int nodeId);
+    // Used to allow annotations to refer to their corresponding structure
+    // tree node, via the struct parent tree. Returns -1 if no struct parent
+    // key.
+    int createStructParentKeyForNodeId(int nodeId);
 
     std::unique_ptr<SkPDFArray> getAnnotations();
 

src/pdf/SkPDFTag.cpp

@@ -66,6 +66,18 @@ static const char* tag_name_from_type(SkPDF::DocumentStructureType type) {
     SK_ABORT("bad tag");
 }
 
+// The struct parent tree consists of one entry per page, followed by
+// entries for individual struct tree nodes corresponding to
+// annotations.  Each entry is a key/value pair with an integer key
+// and an indirect reference key.
+//
+// The page entries get consecutive keys starting at 0. Since we don't
+// know the total number of pages in the document at the time we start
+// processing annotations, start the key for annotations with a large
+// number, which effectively becomes the maximum number of pages in a
+// PDF we can handle.
+const int kFirstAnnotationStructParentKey = 100000;
+
 struct SkPDFTagNode {
     // Structure element nodes need a unique alphanumeric ID,
     // and we need to be able to output them sorted in lexicographic
@@ -97,7 +109,11 @@ struct SkPDFTagNode {
         kNo,
     } fCanDiscard = kUnknown;
     std::unique_ptr<SkPDFArray> fAttributes;
-    std::vector<SkPDFIndirectReference> fAnnotations;
+    struct AnnotationInfo {
+        unsigned fPageIndex;
+        SkPDFIndirectReference fAnnotationRef;
+    };
+    std::vector<AnnotationInfo> fAnnotations;
 };
 
 SkPDF::AttributeList::AttributeList() = default;
@@ -238,7 +254,7 @@ void SkPDFTagTree::reset() {
     fRoot = nullptr;
 }
 
-int SkPDFTagTree::getMarkIdForNodeId(int nodeId, unsigned pageIndex) {
+int SkPDFTagTree::createMarkIdForNodeId(int nodeId, unsigned pageIndex) {
     if (!fRoot) {
         return -1;
     }
@@ -258,6 +274,25 @@ int SkPDFTagTree::getMarkIdForNodeId(int nodeId, unsigned pageIndex) {
     return markId;
 }
 
+int SkPDFTagTree::createStructParentKeyForNodeId(int nodeId, unsigned pageIndex) {
+    if (!fRoot) {
+        return -1;
+    }
+    SkPDFTagNode** tagPtr = fNodeMap.find(nodeId);
+    if (!tagPtr) {
+        return -1;
+    }
+    SkPDFTagNode* tag = *tagPtr;
+    SkASSERT(tag);
+
+    tag->fCanDiscard = SkPDFTagNode::kNo;
+
+    int nextStructParentKey = kFirstAnnotationStructParentKey +
+        static_cast<int>(fParentTreeAnnotationNodeIds.size());
+    fParentTreeAnnotationNodeIds.push_back(nodeId);
+    return nextStructParentKey;
+}
+
 static bool can_discard(SkPDFTagNode* node) {
     if (node->fCanDiscard == SkPDFTagNode::kYes) {
         return true;
@@ -298,9 +333,10 @@ SkPDFIndirectReference SkPDFTagTree::PrepareTagTreeToEmit(SkPDFIndirectReference
         mcr->insertInt("MCID", info.fMarkId);
         kids->appendObject(std::move(mcr));
     }
-    for (SkPDFIndirectReference annotationRef : node->fAnnotations) {
+    for (const SkPDFTagNode::AnnotationInfo& annotationInfo : node->fAnnotations) {
         std::unique_ptr<SkPDFDict> annotationDict = SkPDFMakeDict("OBJR");
-        annotationDict->insertRef("Obj", annotationRef);
+        annotationDict->insertRef("Obj", annotationInfo.fAnnotationRef);
+        annotationDict->insertRef("Pg", doc->getPage(annotationInfo.fPageIndex));
         kids->appendObject(std::move(annotationDict));
     }
     node->fRef = ref;
@@ -333,7 +369,7 @@ SkPDFIndirectReference SkPDFTagTree::PrepareTagTreeToEmit(SkPDFIndirectReference
     return doc->emit(dict, ref);
 }
 
-void SkPDFTagTree::addNodeAnnotation(int nodeId, SkPDFIndirectReference annotationRef) {
+void SkPDFTagTree::addNodeAnnotation(int nodeId, SkPDFIndirectReference annotationRef, unsigned pageIndex) {
     if (!fRoot) {
         return;
     }
@@ -343,9 +379,10 @@ void SkPDFTagTree::addNodeAnnotation(int nodeId, SkPDFIndirectReference annotati
     }
     SkPDFTagNode* tag = *tagPtr;
     SkASSERT(tag);
-    tag->fAnnotations.push_back(annotationRef);
-}
 
+    SkPDFTagNode::AnnotationInfo annotationInfo = {pageIndex, annotationRef};
+    tag->fAnnotations.push_back(annotationInfo);
+}
 
 SkPDFIndirectReference SkPDFTagTree::makeStructTreeRoot(SkPDFDocument* doc) {
     if (!fRoot) {
@@ -363,11 +400,15 @@ SkPDFIndirectReference SkPDFTagTree::makeStructTreeRoot(SkPDFDocument* doc) {
     structTreeRoot.insertRef("K", PrepareTagTreeToEmit(ref, fRoot, doc));
     structTreeRoot.insertInt("ParentTreeNextKey", SkToInt(pageCount));
 
-    // Build the parent tree, which is a mapping from the marked
-    // content IDs on each page to their corressponding tags.
+    // Build the parent tree, which consists of two things:
+    // (1) For each page, a mapping from the marked content IDs on
+    // each page to their corresponding tags
+    // (2) For each annotation, an indirect reference to that
+    // annotation's struct tree element.
     SkPDFDict parentTree("ParentTree");
     auto parentTreeNums = SkPDFMakeArray();
 
+    // First, one entry per page.
     SkASSERT(fMarksPerPage.size() <= pageCount);
     for (size_t j = 0; j < fMarksPerPage.size(); ++j) {
         const SkTArray<SkPDFTagNode*>& pageMarks = fMarksPerPage[j];
@@ -379,6 +420,21 @@ SkPDFIndirectReference SkPDFTagTree::makeStructTreeRoot(SkPDFDocument* doc) {
         parentTreeNums->appendInt(j);
         parentTreeNums->appendRef(doc->emit(markToTagArray));
     }
+
+    // Then, one entry per annotation.
+    for (size_t j = 0; j < fParentTreeAnnotationNodeIds.size(); ++j) {
+        int nodeId = fParentTreeAnnotationNodeIds[j];
+        int structParentKey = kFirstAnnotationStructParentKey + static_cast<int>(j);
+
+        SkPDFTagNode** tagPtr = fNodeMap.find(nodeId);
+        if (!tagPtr) {
+            continue;
+        }
+        SkPDFTagNode* tag = *tagPtr;
+        parentTreeNums->appendInt(structParentKey);
+        parentTreeNums->appendRef(tag->fRef);
+    }
+
     parentTree.insertObject("Nums", std::move(parentTreeNums));
     structTreeRoot.insertRef("ParentTree", doc->emit(parentTree));
 

src/pdf/SkPDFTag.h

@@ -23,8 +23,16 @@ class SkPDFTagTree {
     ~SkPDFTagTree();
     void init(SkPDF::StructureElementNode*);
     void reset();
-    int getMarkIdForNodeId(int nodeId, unsigned pageIndex);
-    void addNodeAnnotation(int nodeId, SkPDFIndirectReference annotationRef);
+    // Used to allow marked content to refer to its corresponding structure
+    // tree node, via a page entry in the parent tree. Returns -1 if no
+    // mark ID.
+    int createMarkIdForNodeId(int nodeId, unsigned pageIndex);
+    // Used to allow annotations to refer to their corresponding structure
+    // tree node, via the struct parent tree. Returns -1 if no struct parent
+    // key.
+    int createStructParentKeyForNodeId(int nodeId, unsigned pageIndex);
+
+    void addNodeAnnotation(int nodeId, SkPDFIndirectReference annotationRef, unsigned pageIndex);
     SkPDFIndirectReference makeStructTreeRoot(SkPDFDocument* doc);
 
 private:
@@ -48,6 +56,7 @@ class SkPDFTagTree {
     SkPDFTagNode* fRoot = nullptr;
     SkTArray<SkTArray<SkPDFTagNode*>> fMarksPerPage;
     std::vector<IDTreeEntry> fIdTreeEntries;
+    std::vector<int> fParentTreeAnnotationNodeIds;
 
     SkPDFTagTree(const SkPDFTagTree&) = delete;
     SkPDFTagTree& operator=(const SkPDFTagTree&) = delete;