Merge pull request #12997 from Snuffleupagus/metadata-worker

Move the Metadata parsing to the worker-thread

src/core/core_utils.js

@@ -316,8 +316,54 @@ function collectActions(xref, dict, eventType) {
   return objectSize(actions) > 0 ? actions : null;
 }
 
+const XMLEntities = {
+  /* < */ 0x3c: "&lt;",
+  /* > */ 0x3e: "&gt;",
+  /* & */ 0x26: "&amp;",
+  /* " */ 0x22: "&quot;",
+  /* ' */ 0x27: "&apos;",
+};
+
+function encodeToXmlString(str) {
+  const buffer = [];
+  let start = 0;
+  for (let i = 0, ii = str.length; i < ii; i++) {
+    const char = str.codePointAt(i);
+    if (0x20 <= char && char <= 0x7e) {
+      // ascii
+      const entity = XMLEntities[char];
+      if (entity) {
+        if (start < i) {
+          buffer.push(str.substring(start, i));
+        }
+        buffer.push(entity);
+        start = i + 1;
+      }
+    } else {
+      if (start < i) {
+        buffer.push(str.substring(start, i));
+      }
+      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
+      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
+        // char is represented by two u16
+        i++;
+      }
+      start = i + 1;
+    }
+  }
+
+  if (buffer.length === 0) {
+    return str;
+  }
+  if (start < str.length) {
+    buffer.push(str.substring(start, str.length));
+  }
+  return buffer.join("");
+}
+
 export {
   collectActions,
+  encodeToXmlString,
   escapePDFName,
   getArrayLookupTableFactory,
   getInheritableProperty,

src/core/metadata_parser.js

@@ -0,0 +1,146 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { SimpleXMLParser } from "./xml_parser.js";
+
+class MetadataParser {
+  constructor(data) {
+    // Ghostscript may produce invalid metadata, so try to repair that first.
+    data = this._repair(data);
+
+    // Convert the string to an XML document.
+    const parser = new SimpleXMLParser({ lowerCaseName: true });
+    const xmlDocument = parser.parseFromString(data);
+
+    this._metadataMap = new Map();
+    this._data = data;
+
+    if (xmlDocument) {
+      this._parse(xmlDocument);
+    }
+  }
+
+  _repair(data) {
+    // Start by removing any "junk" before the first tag (see issue 10395).
+    return data
+      .replace(/^[^<]+/, "")
+      .replace(/>\\376\\377([^<]+)/g, function (all, codes) {
+        const bytes = codes
+          .replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {
+            return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);
+          })
+          .replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) {
+            switch (name) {
+              case "amp":
+                return "&";
+              case "apos":
+                return "'";
+              case "gt":
+                return ">";
+              case "lt":
+                return "<";
+              case "quot":
+                return '"';
+            }
+            throw new Error(`_repair: ${name} isn't defined.`);
+          });
+
+        const charBuf = [];
+        for (let i = 0, ii = bytes.length; i < ii; i += 2) {
+          const code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);
+          if (
+            code >= /* Space = */ 32 &&
+            code < /* Delete = */ 127 &&
+            code !== /* '<' = */ 60 &&
+            code !== /* '>' = */ 62 &&
+            code !== /* '&' = */ 38
+          ) {
+            charBuf.push(String.fromCharCode(code));
+          } else {
+            charBuf.push(
+              "&#x" + (0x10000 + code).toString(16).substring(1) + ";"
+            );
+          }
+        }
+        return ">" + charBuf.join("");
+      });
+  }
+
+  _getSequence(entry) {
+    const name = entry.nodeName;
+    if (name !== "rdf:bag" && name !== "rdf:seq" && name !== "rdf:alt") {
+      return null;
+    }
+    return entry.childNodes.filter(node => node.nodeName === "rdf:li");
+  }
+
+  _parseArray(entry) {
+    if (!entry.hasChildNodes()) {
+      return;
+    }
+    // Child must be a Bag (unordered array) or a Seq.
+    const [seqNode] = entry.childNodes;
+    const sequence = this._getSequence(seqNode) || [];
+
+    this._metadataMap.set(
+      entry.nodeName,
+      sequence.map(node => node.textContent.trim())
+    );
+  }
+
+  _parse(xmlDocument) {
+    let rdf = xmlDocument.documentElement;
+
+    if (rdf.nodeName !== "rdf:rdf") {
+      // Wrapped in <xmpmeta>
+      rdf = rdf.firstChild;
+      while (rdf && rdf.nodeName !== "rdf:rdf") {
+        rdf = rdf.nextSibling;
+      }
+    }
+
+    if (!rdf || rdf.nodeName !== "rdf:rdf" || !rdf.hasChildNodes()) {
+      return;
+    }
+
+    for (const desc of rdf.childNodes) {
+      if (desc.nodeName !== "rdf:description") {
+        continue;
+      }
+
+      for (const entry of desc.childNodes) {
+        const name = entry.nodeName;
+        switch (name) {
+          case "#text":
+            continue;
+          case "dc:creator":
+          case "dc:subject":
+            this._parseArray(entry);
+            continue;
+        }
+        this._metadataMap.set(name, entry.textContent.trim());
+      }
+    }
+  }
+
+  get serializable() {
+    return {
+      parsedData: this._metadataMap,
+      rawData: this._data,
+    };
+  }
+}
+
+export { MetadataParser };

src/core/obj.js

@@ -59,6 +59,7 @@ import { Lexer, Parser } from "./parser.js";
 import { CipherTransformFactory } from "./crypto.js";
 import { ColorSpace } from "./colorspace.js";
 import { GlobalImageCache } from "./image_utils.js";
+import { MetadataParser } from "./metadata_parser.js";
 
 function fetchDestination(dest) {
   return isDict(dest) ? dest.get("D") : dest;
@@ -131,20 +132,22 @@ class Catalog {
       this.xref.encrypt && this.xref.encrypt.encryptMetadata
     );
     const stream = this.xref.fetch(streamRef, suppressEncryption);
-    let metadata;
+    let metadata = null;
 
-    if (stream && isDict(stream.dict)) {
+    if (isStream(stream) && isDict(stream.dict)) {
       const type = stream.dict.get("Type");
       const subtype = stream.dict.get("Subtype");
 
       if (isName(type, "Metadata") && isName(subtype, "XML")) {
         // XXX: This should examine the charset the XML document defines,
-        // however since there are currently no real means to decode
-        // arbitrary charsets, let's just hope that the author of the PDF
-        // was reasonable enough to stick with the XML default charset,
-        // which is UTF-8.
+        // however since there are currently no real means to decode arbitrary
+        // charsets, let's just hope that the author of the PDF was reasonable
+        // enough to stick with the XML default charset, which is UTF-8.
         try {
-          metadata = stringToUTF8String(bytesToString(stream.getBytes()));
+          const data = stringToUTF8String(bytesToString(stream.getBytes()));
+          if (data) {
+            metadata = new MetadataParser(data).serializable;
+          }
         } catch (e) {
           if (e instanceof MissingDataException) {
             throw e;

src/core/writer.js

@@ -16,7 +16,7 @@
 import { bytesToString, escapeString, warn } from "../shared/util.js";
 import { Dict, isDict, isName, isRef, isStream, Name } from "./primitives.js";
 import { escapePDFName, parseXFAPath } from "./core_utils.js";
-import { SimpleDOMNode, SimpleXMLParser } from "../shared/xml_parser.js";
+import { SimpleDOMNode, SimpleXMLParser } from "./xml_parser.js";
 import { calculateMD5 } from "./crypto.js";
 
 function writeDict(dict, buffer, transform) {

src/core/xfa/parser.js

@@ -14,7 +14,7 @@
  */
 
 import { $clean, $finalize, $onChild, $onText } from "./xfa_object.js";
-import { XMLParserBase, XMLParserErrorCode } from "../../shared/xml_parser.js";
+import { XMLParserBase, XMLParserErrorCode } from "../xml_parser.js";
 import { Builder } from "./builder.js";
 import { warn } from "../../shared/util.js";
 

src/core/xml_parser.js

@@ -16,7 +16,7 @@
 // The code for XMLParserBase copied from
 // https://github.com/mozilla/shumway/blob/16451d8836fa85f4b16eeda8b4bda2fa9e2b22b0/src/avm2/natives/xml.ts
 
-import { encodeToXmlString } from "./util.js";
+import { encodeToXmlString } from "./core_utils.js";
 
 const XMLParserErrorCode = {
   NoError: 0,

src/display/api.js

@@ -1655,8 +1655,24 @@ class LoopbackPort {
         cloned.set(value, result);
         return result;
       }
+      if (value instanceof Map) {
+        result = new Map();
+        cloned.set(value, result); // Adding to cache now for cyclic references.
+        for (const [key, val] of value) {
+          result.set(key, cloneValue(val));
+        }
+        return result;
+      }
+      if (value instanceof Set) {
+        result = new Set();
+        cloned.set(value, result); // Adding to cache now for cyclic references.
+        for (const val of value) {
+          result.add(cloneValue(val));
+        }
+        return result;
+      }
       result = Array.isArray(value) ? [] : {};
-      cloned.set(value, result); // adding to cache now for cyclic references
+      cloned.set(value, result); // Adding to cache now for cyclic references.
       // Cloning all value and object properties, however ignoring properties
       // defined via getter.
       for (const i in value) {

src/display/metadata.js

@@ -13,129 +13,12 @@
  * limitations under the License.
  */
 
-import { assert, objectFromEntries } from "../shared/util.js";
-import { SimpleXMLParser } from "../shared/xml_parser.js";
+import { objectFromEntries } from "../shared/util.js";
 
 class Metadata {
-  constructor(data) {
-    assert(typeof data === "string", "Metadata: input is not a string");
-
-    // Ghostscript may produce invalid metadata, so try to repair that first.
-    data = this._repair(data);
-
-    // Convert the string to an XML document.
-    const parser = new SimpleXMLParser({ lowerCaseName: true });
-    const xmlDocument = parser.parseFromString(data);
-
-    this._metadataMap = new Map();
-
-    if (xmlDocument) {
-      this._parse(xmlDocument);
-    }
-    this._data = data;
-  }
-
-  _repair(data) {
-    // Start by removing any "junk" before the first tag (see issue 10395).
-    return data
-      .replace(/^[^<]+/, "")
-      .replace(/>\\376\\377([^<]+)/g, function (all, codes) {
-        const bytes = codes
-          .replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {
-            return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);
-          })
-          .replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) {
-            switch (name) {
-              case "amp":
-                return "&";
-              case "apos":
-                return "'";
-              case "gt":
-                return ">";
-              case "lt":
-                return "<";
-              case "quot":
-                return '"';
-            }
-            throw new Error(`_repair: ${name} isn't defined.`);
-          });
-
-        let chars = "";
-        for (let i = 0, ii = bytes.length; i < ii; i += 2) {
-          const code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);
-          if (
-            code >= /* Space = */ 32 &&
-            code < /* Delete = */ 127 &&
-            code !== /* '<' = */ 60 &&
-            code !== /* '>' = */ 62 &&
-            code !== /* '&' = */ 38
-          ) {
-            chars += String.fromCharCode(code);
-          } else {
-            chars += "&#x" + (0x10000 + code).toString(16).substring(1) + ";";
-          }
-        }
-
-        return ">" + chars;
-      });
-  }
-
-  _getSequence(entry) {
-    const name = entry.nodeName;
-    if (name !== "rdf:bag" && name !== "rdf:seq" && name !== "rdf:alt") {
-      return null;
-    }
-
-    return entry.childNodes.filter(node => node.nodeName === "rdf:li");
-  }
-
-  _parseArray(entry) {
-    if (!entry.hasChildNodes()) {
-      return;
-    }
-    // Child must be a Bag (unordered array) or a Seq.
-    const [seqNode] = entry.childNodes;
-    const sequence = this._getSequence(seqNode) || [];
-
-    this._metadataMap.set(
-      entry.nodeName,
-      sequence.map(node => node.textContent.trim())
-    );
-  }
-
-  _parse(xmlDocument) {
-    let rdf = xmlDocument.documentElement;
-
-    if (rdf.nodeName !== "rdf:rdf") {
-      // Wrapped in <xmpmeta>
-      rdf = rdf.firstChild;
-      while (rdf && rdf.nodeName !== "rdf:rdf") {
-        rdf = rdf.nextSibling;
-      }
-    }
-
-    if (!rdf || rdf.nodeName !== "rdf:rdf" || !rdf.hasChildNodes()) {
-      return;
-    }
-
-    for (const desc of rdf.childNodes) {
-      if (desc.nodeName !== "rdf:description") {
-        continue;
-      }
-
-      for (const entry of desc.childNodes) {
-        const name = entry.nodeName;
-        switch (name) {
-          case "#text":
-            continue;
-          case "dc:creator":
-          case "dc:subject":
-            this._parseArray(entry);
-            continue;
-        }
-        this._metadataMap.set(name, entry.textContent.trim());
-      }
-    }
+  constructor({ parsedData, rawData }) {
+    this._metadataMap = parsedData;
+    this._data = rawData;
   }
 
   getRaw() {

src/shared/util.js

@@ -967,53 +967,6 @@ const createObjectURL = (function createObjectURLClosure() {
   };
 })();
 
-const XMLEntities = {
-  /* < */ 0x3c: "&lt;",
-  /* > */ 0x3e: "&gt;",
-  /* & */ 0x26: "&amp;",
-  /* " */ 0x22: "&quot;",
-  /* ' */ 0x27: "&apos;",
-};
-
-function encodeToXmlString(str) {
-  const buffer = [];
-  let start = 0;
-  for (let i = 0, ii = str.length; i < ii; i++) {
-    const char = str.codePointAt(i);
-    if (0x20 <= char && char <= 0x7e) {
-      // ascii
-      const entity = XMLEntities[char];
-      if (entity) {
-        if (start < i) {
-          buffer.push(str.substring(start, i));
-        }
-        buffer.push(entity);
-        start = i + 1;
-      }
-    } else {
-      if (start < i) {
-        buffer.push(str.substring(start, i));
-      }
-      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
-      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
-        // char is represented by two u16
-        i++;
-      }
-      start = i + 1;
-    }
-  }
-
-  if (buffer.length === 0) {
-    return str;
-  }
-
-  if (start < str.length) {
-    buffer.push(str.substring(start, str.length));
-  }
-
-  return buffer.join("");
-}
-
 export {
   AbortException,
   AnnotationActionEventType,
@@ -1035,7 +988,6 @@ export {
   createPromiseCapability,
   createValidAbsoluteUrl,
   DocumentActionEventType,
-  encodeToXmlString,
   escapeString,
   FONT_IDENTITY_MATRIX,
   FontType,