Add an abstract BasePDFStream class, that all the old IPDFStream implementations inherit from

Given that there's no less than *five* different, but very similar, implementations this helps reduce code duplication and simplifies maintenance.

Also, spotted during rebasing, pass the `enableHWA` option "correctly" (i.e. as part of the existing `transportParams`) to the `WorkerTransport`-class to keep the constructor simpler.

Author: Snuffleupagus

src/core/chunked_stream.js

@@ -272,17 +272,17 @@ class ChunkedStreamManager {
 
   _requestsByChunk = new Map();
 
-  constructor(pdfNetworkStream, args) {
+  constructor(pdfStream, args) {
     this.length = args.length;
     this.chunkSize = args.rangeChunkSize;
     this.stream = new ChunkedStream(this.length, this.chunkSize, this);
-    this.pdfNetworkStream = pdfNetworkStream;
+    this.pdfStream = pdfStream;
     this.disableAutoFetch = args.disableAutoFetch;
     this.msgHandler = args.msgHandler;
   }
 
   sendRequest(begin, end) {
-    const rangeReader = this.pdfNetworkStream.getRangeReader(begin, end);
+    const rangeReader = this.pdfStream.getRangeReader(begin, end);
 
     let chunks = [];
     return new Promise((resolve, reject) => {
@@ -530,7 +530,7 @@ class ChunkedStreamManager {
 
   abort(reason) {
     this.aborted = true;
-    this.pdfNetworkStream?.cancelAllRequests(reason);
+    this.pdfStream?.cancelAllRequests(reason);
 
     for (const capability of this._promisesByRequest.values()) {
       capability.reject(reason);

src/core/worker.js

@@ -219,23 +219,23 @@ class WorkerMessageHandler {
 
         return new LocalPdfManager(pdfManagerArgs);
       }
-      const pdfStream = new PDFWorkerStream(handler),
-        fullRequest = pdfStream.getFullReader();
+      const pdfStream = new PDFWorkerStream({ msgHandler: handler }),
+        fullReader = pdfStream.getFullReader();
 
       const pdfManagerCapability = Promise.withResolvers();
       let newPdfManager,
         cachedChunks = [],
         loaded = 0;
 
-      fullRequest.headersReady
+      fullReader.headersReady
         .then(function () {
-          if (!fullRequest.isRangeSupported) {
+          if (!fullReader.isRangeSupported) {
             return;
           }
           pdfManagerArgs.source = pdfStream;
-          pdfManagerArgs.length = fullRequest.contentLength;
+          pdfManagerArgs.length = fullReader.contentLength;
           // We don't need auto-fetch when streaming is enabled.
-          pdfManagerArgs.disableAutoFetch ||= fullRequest.isStreamingSupported;
+          pdfManagerArgs.disableAutoFetch ||= fullReader.isStreamingSupported;
 
           newPdfManager = new NetworkPdfManager(pdfManagerArgs);
           // There may be a chance that `newPdfManager` is not initialized for
@@ -282,10 +282,10 @@ class WorkerMessageHandler {
             }
             loaded += value.byteLength;
 
-            if (!fullRequest.isStreamingSupported) {
+            if (!fullReader.isStreamingSupported) {
               handler.send("DocProgress", {
                 loaded,
-                total: Math.max(loaded, fullRequest.contentLength || 0),
+                total: Math.max(loaded, fullReader.contentLength || 0),
               });
             }
 
@@ -294,12 +294,12 @@ class WorkerMessageHandler {
             } else {
               cachedChunks.push(value);
             }
-            fullRequest.read().then(readChunk, reject);
+            fullReader.read().then(readChunk, reject);
           } catch (e) {
             reject(e);
           }
         };
-        fullRequest.read().then(readChunk, reject);
+        fullReader.read().then(readChunk, reject);
       }).catch(function (e) {
         pdfManagerCapability.reject(e);
         cancelXHRs = null;

src/core/worker_stream.js

@@ -13,55 +13,28 @@
  * limitations under the License.
  */
 
-import { assert } from "../shared/util.js";
+import { BasePDFStream } from "../shared/base_pdf_stream.js";
 
-/** @implements {IPDFStream} */
-class PDFWorkerStream {
-  constructor(msgHandler) {
-    this._msgHandler = msgHandler;
-    this._contentLength = null;
-    this._fullRequestReader = null;
-    this._rangeRequestReaders = [];
-  }
-
-  getFullReader() {
-    assert(
-      !this._fullRequestReader,
-      "PDFWorkerStream.getFullReader can only be called once."
-    );
-    this._fullRequestReader = new PDFWorkerStreamReader(this._msgHandler);
-    return this._fullRequestReader;
-  }
-
-  getRangeReader(begin, end) {
-    const reader = new PDFWorkerStreamRangeReader(begin, end, this._msgHandler);
-    this._rangeRequestReaders.push(reader);
-    return reader;
-  }
-
-  cancelAllRequests(reason) {
-    this._fullRequestReader?.cancel(reason);
-
-    for (const reader of this._rangeRequestReaders.slice(0)) {
-      reader.cancel(reason);
-    }
+class PDFWorkerStream extends BasePDFStream {
+  constructor(source) {
+    super(source, PDFWorkerStreamReader, PDFWorkerStreamRangeReader);
   }
 }
 
 /** @implements {IPDFStreamReader} */
 class PDFWorkerStreamReader {
-  constructor(msgHandler) {
-    this._msgHandler = msgHandler;
+  constructor(stream) {
+    const { msgHandler } = stream._source;
     this.onProgress = null;
 
     this._contentLength = null;
     this._isRangeSupported = false;
     this._isStreamingSupported = false;
 
-    const readableStream = this._msgHandler.sendWithStream("GetReader");
+    const readableStream = msgHandler.sendWithStream("GetReader");
     this._reader = readableStream.getReader();
 
-    this._headersReady = this._msgHandler
+    this._headersReady = msgHandler
       .sendWithPromise("ReaderHeadersReady")
       .then(data => {
         this._isStreamingSupported = data.isStreamingSupported;
@@ -103,10 +76,10 @@ class PDFWorkerStreamReader {
 
 /** @implements {IPDFStreamRangeReader} */
 class PDFWorkerStreamRangeReader {
-  constructor(begin, end, msgHandler) {
-    this._msgHandler = msgHandler;
+  constructor(stream, begin, end) {
+    const { msgHandler } = stream._source;
 
-    const readableStream = this._msgHandler.sendWithStream("GetRangeReader", {
+    const readableStream = msgHandler.sendWithStream("GetRangeReader", {
       begin,
       end,
     });

src/display/api.js

@@ -440,6 +440,7 @@ function getDocument(src = {}) {
     ownerDocument,
     pdfBug,
     styleElement,
+    enableHWA,
     loadingParams: {
       disableAutoFetch,
       enableXfa,
@@ -463,7 +464,8 @@ function getDocument(src = {}) {
 
       let networkStream;
       if (rangeTransport) {
-        networkStream = new PDFDataTransportStream(rangeTransport, {
+        networkStream = new PDFDataTransportStream({
+          pdfDataRangeTransport: rangeTransport,
           disableRange,
           disableStream,
         });
@@ -508,8 +510,7 @@ function getDocument(src = {}) {
           task,
           networkStream,
           transportParams,
-          transportFactory,
-          enableHWA
+          transportFactory
         );
         task._transport = transport;
         messageHandler.send("Ready", null);
@@ -2391,8 +2392,16 @@ class PDFWorker {
  * @ignore
  */
 class WorkerTransport {
+  downloadInfoCapability = Promise.withResolvers();
+
+  #fullReader = null;
+
+  #lastProgress = null;
+
   #methodPromises = new Map();
 
+  #networkStream = null;
+
   #pageCache = new Map();
 
   #pagePromises = new Map();
@@ -2403,21 +2412,17 @@ class WorkerTransport {
 
   #pagesMapper = PagesMapper.instance;
 
-  constructor(
-    messageHandler,
-    loadingTask,
-    networkStream,
-    params,
-    factory,
-    enableHWA
-  ) {
+  constructor(messageHandler, loadingTask, networkStream, params, factory) {
     this.messageHandler = messageHandler;
     this.loadingTask = loadingTask;
+    this.#networkStream = networkStream;
+
     this.commonObjs = new PDFObjects();
     this.fontLoader = new FontLoader({
       ownerDocument: params.ownerDocument,
       styleElement: params.styleElement,
     });
+    this.enableHWA = params.enableHWA;
     this.loadingParams = params.loadingParams;
     this._params = params;
 
@@ -2430,12 +2435,6 @@ class WorkerTransport {
     this.destroyed = false;
     this.destroyCapability = null;
 
-    this._networkStream = networkStream;
-    this._fullReader = null;
-    this._lastProgress = null;
-    this.downloadInfoCapability = Promise.withResolvers();
-    this.enableHWA = enableHWA;
-
     this.setupMessageHandler();
 
     this.#pagesMapper.addListener(this.#updateCaches.bind(this));
@@ -2604,7 +2603,7 @@ class WorkerTransport {
       this.filterFactory.destroy();
       TextLayer.cleanup();
 
-      this._networkStream?.cancelAllRequests(
+      this.#networkStream?.cancelAllRequests(
         new AbortException("Worker was terminated.")
       );
 
@@ -2621,18 +2620,18 @@ class WorkerTransport {
 
     messageHandler.on("GetReader", (data, sink) => {
       assert(
-        this._networkStream,
-        "GetReader - no `IPDFStream` instance available."
+        this.#networkStream,
+        "GetReader - no `BasePDFStream` instance available."
       );
-      this._fullReader = this._networkStream.getFullReader();
-      this._fullReader.onProgress = evt => {
-        this._lastProgress = {
+      this.#fullReader = this.#networkStream.getFullReader();
+      this.#fullReader.onProgress = evt => {
+        this.#lastProgress = {
           loaded: evt.loaded,
           total: evt.total,
         };
       };
       sink.onPull = () => {
-        this._fullReader
+        this.#fullReader
           .read()
           .then(function ({ value, done }) {
             if (done) {
@@ -2653,7 +2652,7 @@ class WorkerTransport {
       };
 
       sink.onCancel = reason => {
-        this._fullReader.cancel(reason);
+        this.#fullReader.cancel(reason);
 
         sink.ready.catch(readyReason => {
           if (this.destroyed) {
@@ -2665,18 +2664,18 @@ class WorkerTransport {
     });
 
     messageHandler.on("ReaderHeadersReady", async data => {
-      await this._fullReader.headersReady;
+      await this.#fullReader.headersReady;
 
       const { isStreamingSupported, isRangeSupported, contentLength } =
-        this._fullReader;
+        this.#fullReader;
 
       // If stream or range are disabled, it's our only way to report
       // loading progress.
       if (!isStreamingSupported || !isRangeSupported) {
-        if (this._lastProgress) {
-          loadingTask.onProgress?.(this._lastProgress);
+        if (this.#lastProgress) {
+          loadingTask.onProgress?.(this.#lastProgress);
         }
-        this._fullReader.onProgress = evt => {
+        this.#fullReader.onProgress = evt => {
           loadingTask.onProgress?.({
             loaded: evt.loaded,
             total: evt.total,
@@ -2689,24 +2688,24 @@ class WorkerTransport {
 
     messageHandler.on("GetRangeReader", (data, sink) => {
       assert(
-        this._networkStream,
-        "GetRangeReader - no `IPDFStream` instance available."
+        this.#networkStream,
+        "GetRangeReader - no `BasePDFStream` instance available."
       );
-      const rangeReader = this._networkStream.getRangeReader(
+      const rangeReader = this.#networkStream.getRangeReader(
         data.begin,
         data.end
       );
 
       // When streaming is enabled, it's possible that the data requested here
-      // has already been fetched via the `_fullRequestReader` implementation.
+      // has already been fetched via the `#fullReader` implementation.
       // However, given that the PDF data is loaded asynchronously on the
       // main-thread and then sent via `postMessage` to the worker-thread,
       // it may not have been available during parsing (hence the attempt to
       // use range requests here).
       //
       // To avoid wasting time and resources here, we'll thus *not* dispatch
       // range requests if the data was already loaded but has not been sent to
-      // the worker-thread yet (which will happen via the `_fullRequestReader`).
+      // the worker-thread yet (which will happen via the `#fullReader`).
       if (!rangeReader) {
         sink.close();
         return;
@@ -2950,7 +2949,7 @@ class WorkerTransport {
           isPureXfa: !!this._htmlForXfa,
           numPages: this._numPages,
           annotationStorage: map,
-          filename: this._fullReader?.filename ?? null,
+          filename: this.#fullReader?.filename ?? null,
         },
         transfer
       )
@@ -3118,8 +3117,8 @@ class WorkerTransport {
       .then(results => ({
         info: results[0],
         metadata: results[1] ? new Metadata(results[1]) : null,
-        contentDispositionFilename: this._fullReader?.filename ?? null,
-        contentLength: this._fullReader?.contentLength ?? null,
+        contentDispositionFilename: this.#fullReader?.filename ?? null,
+        contentLength: this.#fullReader?.contentLength ?? null,
         hasStructTree: results[2],
       }));
     this.#methodPromises.set(name, promise);