move common handler code to a shared file

Author: ryzokuken

src/core/document.js

@@ -128,11 +128,10 @@ class Page {
     };
   }
 
-  #createPartialEvaluator(handler, rendererHandler) {
+  #createPartialEvaluator(handler) {
     return new PartialEvaluator({
       xref: this.xref,
       handler,
-      rendererHandler,
       pageIndex: this.pageIndex,
       idFactory: this._localIdFactory,
       fontCache: this.fontCache,
@@ -473,10 +472,7 @@ class Page {
     const contentStreamPromise = this.getContentStream();
     const resourcesPromise = this.loadResources(RESOURCES_KEYS_OPERATOR_LIST);
 
-    const partialEvaluator = this.#createPartialEvaluator(
-      handler,
-      rendererHandler
-    );
+    const partialEvaluator = this.#createPartialEvaluator(handler);
 
     const newAnnotsByPage = !this.xfaFactory
       ? getNewAnnotationsMap(annotationStorage)
@@ -1315,7 +1311,7 @@ class PDFDocument {
     this.xfaFactory.setImages(xfaImages);
   }
 
-  async #loadXfaFonts(handler, task, rendererHandler) {
+  async #loadXfaFonts(handler, task) {
     const acroForm = await this.pdfManager.ensureCatalog("acroForm");
     if (!acroForm) {
       return;
@@ -1341,7 +1337,6 @@ class PDFDocument {
     const partialEvaluator = new PartialEvaluator({
       xref: this.xref,
       handler,
-      rendererHandler,
       pageIndex: -1,
       idFactory: this._globalIdFactory,
       fontCache,
@@ -1454,9 +1449,9 @@ class PDFDocument {
     this.xfaFactory.appendFonts(pdfFonts, reallyMissingFonts);
   }
 
-  loadXfaResources(handler, task, rendererHandler) {
+  loadXfaResources(handler, task) {
     return Promise.all([
-      this.#loadXfaFonts(handler, task, rendererHandler).catch(() => {
+      this.#loadXfaFonts(handler, task).catch(() => {
         // Ignore errors, to allow the document to load.
       }),
       this.#loadXfaImages(),

src/core/evaluator.js

@@ -226,7 +226,6 @@ class PartialEvaluator {
   constructor({
     xref,
     handler,
-    rendererHandler,
     pageIndex,
     idFactory,
     fontCache,
@@ -239,7 +238,6 @@ class PartialEvaluator {
   }) {
     this.xref = xref;
     this.handler = handler;
-    this.rendererHandler = rendererHandler;
     this.pageIndex = pageIndex;
     this.idFactory = idFactory;
     this.fontCache = fontCache;
@@ -559,19 +557,13 @@ class PartialEvaluator {
     const transfers = imgData ? [imgData.bitmap || imgData.data.buffer] : null;
 
     if (this.parsingType3Font || cacheGlobally) {
-      this.handler.send("commonobj", [objId, "Image", imgData], transfers);
-      return this.rendererHandler.send(
+      return this.handler.send(
         "commonobj",
         [objId, "Image", imgData],
         transfers
       );
     }
-    this.handler.send(
-      "obj",
-      [objId, this.pageIndex, "Image", imgData],
-      transfers
-    );
-    return this.rendererHandler.send(
+    return this.handler.send(
       "obj",
       [objId, this.pageIndex, "Image", imgData],
       transfers
@@ -799,10 +791,11 @@ class PartialEvaluator {
       // globally, check if the image is still cached locally on the main-thread
       // to avoid having to re-parse the image (since that can be slow).
       if (w * h > 250000 || hasMask) {
-        const localLength = await this.rendererHandler.sendWithPromise(
-          "commonobj",
-          [objId, "CopyLocalImage", { imageRef }]
-        );
+        const localLength = await this.sendWithPromise("commonobj", [
+          objId,
+          "CopyLocalImage",
+          { imageRef },
+        ]);
 
         if (localLength) {
           this.globalImageCache.setData(imageRef, globalCacheData);
@@ -1032,7 +1025,6 @@ class PartialEvaluator {
 
     state.font = translated.font;
     translated.send(this.handler);
-    translated.send(this.rendererHandler);
     return translated.loadedName;
   }
 
@@ -1053,7 +1045,7 @@ class PartialEvaluator {
         PartialEvaluator.buildFontPaths(
           font,
           glyphs,
-          this.rendererHandler,
+          this.handler,
           this.options
         );
       }
@@ -1534,19 +1526,8 @@ class PartialEvaluator {
       const patternBuffer = PatternInfo.write(patternIR);
       transfers.push(patternBuffer);
       this.handler.send("commonobj", [id, "Pattern", patternBuffer], transfers);
-      this.rendererHandler.send(
-        "commonobj",
-        [id, "Pattern", patternBuffer],
-        transfers
-      );
     } else {
       this.handler.send("obj", [id, this.pageIndex, "Pattern", patternIR]);
-      this.rendererHandler.send("obj", [
-        id,
-        this.pageIndex,
-        "Pattern",
-        patternIR,
-      ]);
     }
     return id;
   }

src/core/worker.js

@@ -964,6 +964,10 @@ class WorkerMessageHandler {
         .then(page => pdfManager.ensure(page, "getStructTree"));
     });
 
+    handler.on("FontFallback", function (data) {
+      return pdfManager.fontFallback(data.id, handler);
+    });
+
     rendererHandler.on("FontFallback", function (data) {
       return pdfManager.fontFallback(data.id, rendererHandler);
     });

src/display/api.js

@@ -47,12 +47,6 @@ import {
   RenderingCancelledException,
   StatTimer,
 } from "./display_utils.js";
-import { FontFaceObject, FontLoader } from "./font_loader.js";
-import {
-  FontInfo,
-  FontPathInfo,
-  PatternInfo,
-} from "../shared/obj-bin-transform.js";
 import {
   getDataProp,
   getFactoryUrlProp,
@@ -75,13 +69,15 @@ import { DOMCMapReaderFactory } from "display-cmap_reader_factory";
 import { DOMFilterFactory } from "./filter_factory.js";
 import { DOMStandardFontDataFactory } from "display-standard_fontdata_factory";
 import { DOMWasmFactory } from "display-wasm_factory";
+import { FontLoader } from "./font_loader.js";
 import { GlobalWorkerOptions } from "./worker_options.js";
 import { Metadata } from "./metadata.js";
 import { OptionalContentConfig } from "./optional_content_config.js";
 import { PDFDataTransportStream } from "./transport_stream.js";
 import { PDFFetchStream } from "display-fetch_stream";
 import { PDFNetworkStream } from "display-network";
 import { PDFNodeStream } from "display-node_stream";
+import { setupHandler } from "../shared/handle_objs.js";
 import { TextLayer } from "./text_layer.js";
 import { XfaText } from "./xfa_text.js";
 
@@ -2873,110 +2869,13 @@ class WorkerTransport {
       page._startRenderPage(data.transparency, data.cacheKey);
     });
 
-    messageHandler.on("commonobj", ([id, type, exportedData]) => {
-      if (this.destroyed) {
-        return null; // Ignore any pending requests if the worker was terminated.
-      }
-
-      if (this.commonObjs.has(id)) {
-        return null;
-      }
-
-      switch (type) {
-        case "Font":
-          if ("error" in exportedData) {
-            const exportedError = exportedData.error;
-            warn(`Error during font loading: ${exportedError}`);
-            this.commonObjs.resolve(id, exportedError);
-            break;
-          }
-
-          const fontData = new FontInfo(exportedData);
-          const inspectFont =
-            this._params.pdfBug && globalThis.FontInspector?.enabled
-              ? (font, url) => globalThis.FontInspector.fontAdded(font, url)
-              : null;
-          const font = new FontFaceObject(
-            fontData,
-            inspectFont,
-            exportedData.extra,
-            exportedData.charProcOperatorList
-          );
-
-          this.fontLoader
-            .bind(font)
-            .catch(() => messageHandler.sendWithPromise("FontFallback", { id }))
-            .finally(() => {
-              if (!font.fontExtraProperties && font.data) {
-                // Immediately release the `font.data` property once the font
-                // has been attached to the DOM, since it's no longer needed,
-                // rather than waiting for a `PDFDocumentProxy.cleanup` call.
-                // Since `font.data` could be very large, e.g. in some cases
-                // multiple megabytes, this will help reduce memory usage.
-                font.clearData();
-              }
-              this.commonObjs.resolve(id, font);
-            });
-          break;
-        case "CopyLocalImage":
-          const { imageRef } = exportedData;
-          assert(imageRef, "The imageRef must be defined.");
-
-          for (const pageProxy of this.#pageCache.values()) {
-            for (const [, data] of pageProxy.objs) {
-              if (data?.ref !== imageRef) {
-                continue;
-              }
-              if (!data.dataLen) {
-                return null;
-              }
-              this.commonObjs.resolve(id, structuredClone(data));
-              return data.dataLen;
-            }
-          }
-          break;
-        case "FontPath":
-          this.commonObjs.resolve(id, new FontPathInfo(exportedData));
-          break;
-        case "Image":
-          this.commonObjs.resolve(id, exportedData);
-          break;
-        case "Pattern":
-          const pattern = new PatternInfo(exportedData);
-          this.commonObjs.resolve(id, pattern.getIR());
-          break;
-        default:
-          throw new Error(`Got unknown common object type ${type}`);
-      }
-
-      return null;
-    });
-
-    messageHandler.on("obj", ([id, pageIndex, type, imageData]) => {
-      if (this.destroyed) {
-        // Ignore any pending requests if the worker was terminated.
-        return;
-      }
-
-      const pageProxy = this.#pageCache.get(pageIndex);
-      if (pageProxy.objs.has(id)) {
-        return;
-      }
-      // Don't store data *after* cleanup has successfully run, see bug 1854145.
-      if (pageProxy._intentStates.size === 0) {
-        imageData?.bitmap?.close(); // Release any `ImageBitmap` data.
-        return;
-      }
-
-      switch (type) {
-        case "Image":
-        case "Pattern":
-          pageProxy.objs.resolve(id, imageData);
-          break;
-        default:
-          throw new Error(`Got unknown object type ${type}`);
-      }
-    });
+    setupHandler(
+      messageHandler,
+      this.destroyed,
+      this.commonObjs,
+      this.#pageCache,
+      this.fontLoader
+    );
 
     messageHandler.on("DocProgress", data => {
       if (this.destroyed) {