Merge pull request #6879 from yurydelendik/streams

Makes PDF data reading Streams API friendly.

test/unit/api_spec.js

@@ -8,6 +8,7 @@
 describe('api', function() {
   var basicApiUrl = combineUrl(window.location.href, '../pdfs/basicapi.pdf');
   var basicApiFileLength = 105779; // bytes
+  var TEST_TIMEOUT = 20000;
   function waitsForPromiseResolved(promise, successCallback) {
     var resolved = false;
     promise.then(function(val) {
@@ -20,7 +21,7 @@ describe('api', function() {
     });
     waitsFor(function() {
       return resolved;
-    }, 20000);
+    }, TEST_TIMEOUT);
   }
   function waitsForPromiseRejected(promise, failureCallback) {
     var rejected = false;
@@ -34,7 +35,13 @@ describe('api', function() {
     });
     waitsFor(function() {
       return rejected;
-    }, 20000);
+    }, TEST_TIMEOUT);
+  }
+  function waitSome(callback) {
+    var WAIT_TIMEOUT = 10;
+    setTimeout(function () {
+      callback();
+    }, WAIT_TIMEOUT);
   }
 
   describe('PDFJS', function() {
@@ -710,4 +717,86 @@ describe('api', function() {
       waitsForPromiseResolved(promiseDone, function() {});
     });
   });
+  describe('PDFDataRangeTransport', function () {
+    var pdfPath = combineUrl(window.location.href, '../pdfs/tracemonkey.pdf');
+    var loadPromise;
+    function getDocumentData() {
+      if (loadPromise) {
+        return loadPromise;
+      }
+      loadPromise = new Promise(function (resolve, reject) {
+        var xhr = new XMLHttpRequest(pdfPath);
+        xhr.open('GET', pdfPath);
+        xhr.responseType = 'arraybuffer';
+        xhr.onload = function () { resolve(new Uint8Array(xhr.response)); };
+        xhr.onerror = function () { reject(new Error('PDF is not loaded')); };
+        xhr.send();
+      });
+      return loadPromise;
+    }
+    it('should fetch document info and page using ranges', function () {
+      var transport;
+      var initialDataLength = 4000;
+      var fetches = 0;
+      var getDocumentPromise = getDocumentData().then(function (data) {
+        var initialData = data.subarray(0, initialDataLength);
+        transport = new PDFJS.PDFDataRangeTransport(data.length, initialData);
+        transport.requestDataRange = function (begin, end) {
+          fetches++;
+          waitSome(function () {
+            transport.onDataProgress(4000);
+            transport.onDataRange(begin, data.subarray(begin, end));
+          });
+        };
+        var loadingTask = PDFJS.getDocument(transport);
+        return loadingTask.promise;
+      });
+      var pdfDocument;
+      var getPagePromise = getDocumentPromise.then(function (pdfDocument_) {
+        pdfDocument = pdfDocument_;
+        var pagePromise = pdfDocument.getPage(10);
+        return pagePromise;
+      });
+
+      waitsForPromiseResolved(getPagePromise, function (page) {
+        expect(pdfDocument.numPages).toEqual(14);
+        expect(page.rotate).toEqual(0);
+        expect(fetches).toBeGreaterThan(2);
+      });
+    });
+    it('should fetch document info and page using range and streaming',
+        function () {
+      var transport;
+      var initialDataLength = 4000;
+      var fetches = 0;
+      var getDocumentPromise = getDocumentData().then(function (data) {
+        var initialData = data.subarray(0, initialDataLength);
+        transport = new PDFJS.PDFDataRangeTransport(data.length, initialData);
+        transport.requestDataRange = function (begin, end) {
+          fetches++;
+          if (fetches === 1) {
+            // send rest of the data on first range request.
+            transport.onDataProgressiveRead(data.subarray(initialDataLength));
+          }
+          waitSome(function () {
+            transport.onDataRange(begin, data.subarray(begin, end));
+          });
+        };
+        var loadingTask = PDFJS.getDocument(transport);
+        return loadingTask.promise;
+      });
+      var pdfDocument;
+      var getPagePromise = getDocumentPromise.then(function (pdfDocument_) {
+        pdfDocument = pdfDocument_;
+        var pagePromise = pdfDocument.getPage(10);
+        return pagePromise;
+      });
+
+      waitsForPromiseResolved(getPagePromise, function (page) {
+        expect(pdfDocument.numPages).toEqual(14);
+        expect(page.rotate).toEqual(0);
+        expect(fetches).toEqual(1);
+      });
+    });
+  });
 });

test/unit/network_spec.js

@@ -0,0 +1,169 @@
+/* globals expect, it, describe, waitsFor, combineUrl, PDFNetworkStream */
+
+'use strict';
+
+describe('network', function() {
+  var pdf1 = combineUrl(window.location.href, '../pdfs/tracemonkey.pdf');
+  var pdf1Length = 1016315;
+  var pdf2 = combineUrl(window.location.href, '../pdfs/pdf.pdf');
+  var pdf2Length = 32472771;
+
+  function waitsForPromiseResolved(promise, successCallback) {
+    var TEST_TIMEOUT = 20000;
+    var resolved = false;
+    promise.then(function(val) {
+        resolved = true;
+        successCallback(val);
+      },
+      function(error) {
+        // Shouldn't get here.
+        expect(error).toEqual('the promise should not have been rejected');
+      });
+    waitsFor(function() {
+      return resolved;
+    }, TEST_TIMEOUT);
+  }
+
+  it('read without stream and range', function() {
+    var stream = new PDFNetworkStream({
+      source: {
+        url: pdf1,
+        rangeChunkSize: 65536,
+        disableStream: true,
+      },
+      disableRange: true
+    });
+
+    var fullReader = stream.getFullReader();
+
+    var isStreamingSupported, isRangeSupported;
+    var promise = fullReader.headersReady.then(function () {
+      isStreamingSupported = fullReader.isStreamingSupported;
+      isRangeSupported = fullReader.isRangeSupported;
+    });
+
+    var len = 0, count = 0;
+    var read = function () {
+      return fullReader.read().then(function (result) {
+        if (result.done) {
+          return;
+        }
+        count++;
+        len += result.value.byteLength;
+        return read();
+      });
+    };
+
+    var readPromise = read();
+
+    waitsForPromiseResolved(readPromise, function (page) {
+      expect(len).toEqual(pdf1Length);
+      expect(count).toEqual(1);
+      expect(isStreamingSupported).toEqual(false);
+      expect(isRangeSupported).toEqual(false);
+    });
+  });
+
+  it('read with streaming', function() {
+    var userAgent = window.navigator.userAgent;
+    // The test is valid for FF only: the XHR has support of the
+    // 'moz-chunked-array' response type.
+    // TODO enable for other browsers, e.g. when fetch/streams API is supported.
+    var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(userAgent);
+    if (!m || m[1] < 9) {
+      return;
+    }
+
+    var stream = new PDFNetworkStream({
+      source: {
+        url: pdf2,
+        rangeChunkSize: 65536,
+        disableStream: false,
+      },
+      disableRange: false
+    });
+
+    var fullReader = stream.getFullReader();
+
+    var isStreamingSupported, isRangeSupported;
+    var promise = fullReader.headersReady.then(function () {
+      isStreamingSupported = fullReader.isStreamingSupported;
+      isRangeSupported = fullReader.isRangeSupported;
+    });
+
+    var len = 0, count = 0;
+    var read = function () {
+      return fullReader.read().then(function (result) {
+        if (result.done) {
+          return;
+        }
+        count++;
+        len += result.value.byteLength;
+        return read();
+      });
+    };
+
+    var readPromise = read();
+
+    waitsForPromiseResolved(readPromise, function (page) {
+      expect(len).toEqual(pdf2Length);
+      expect(count).toBeGreaterThan(1);
+      expect(isStreamingSupported).toEqual(true);
+    });
+  });
+
+  it('read custom ranges', function () {
+    // We don't test on browsers that don't support range request, so
+    // requiring this test to pass.
+    var rangeSize = 32768;
+    var stream = new PDFNetworkStream({
+      source: {
+        url: pdf1,
+        length: pdf1Length,
+        rangeChunkSize: rangeSize,
+        disableStream: true,
+      },
+      disableRange: false
+    });
+
+    var fullReader = stream.getFullReader();
+
+    var isStreamingSupported, isRangeSupported, fullReaderCancelled;
+    var promise = fullReader.headersReady.then(function () {
+      isStreamingSupported = fullReader.isStreamingSupported;
+      isRangeSupported = fullReader.isRangeSupported;
+      // we shall be able to close the full reader without issues
+      fullReader.cancel('Don\'t need full reader');
+      fullReaderCancelled = true;
+    });
+
+    // Skipping fullReader results, requesting something from the PDF end.
+    var tailSize = (pdf1Length % rangeSize) || rangeSize;
+
+    var range1Reader = stream.getRangeReader(pdf1Length - tailSize - rangeSize,
+                                             pdf1Length - tailSize);
+    var range2Reader = stream.getRangeReader(pdf1Length - tailSize, pdf1Length);
+
+    var result1 = {value: 0}, result2 = {value: 0};
+    var read = function (reader, lenResult) {
+      return reader.read().then(function (result) {
+        if (result.done) {
+          return;
+        }
+        lenResult.value += result.value.byteLength;
+        return read(reader, lenResult);
+      });
+    };
+
+    var readPromises = Promise.all([read(range1Reader, result1),
+                                    read(range2Reader, result2),
+                                    promise]);
+
+    waitsForPromiseResolved(readPromises, function (page) {
+      expect(result1.value).toEqual(rangeSize);
+      expect(result2.value).toEqual(tailSize);
+      expect(isRangeSupported).toEqual(true);
+      expect(fullReaderCancelled).toEqual(true);
+    });
+  });
+});

test/unit/unit_test.html

@@ -36,6 +36,7 @@
   <script src="util_spec.js"></script>
   <script src="cmap_spec.js"></script>
   <script src="annotation_layer_spec.js"></script>
+  <script src="network_spec.js"></script>
 
   <script>
     'use strict';
@@ -48,11 +49,12 @@
           'pdfjs/core/annotation', 'pdfjs/core/crypto', 'pdfjs/core/stream',
           'pdfjs/core/fonts', 'pdfjs/core/ps_parser', 'pdfjs/core/function',
           'pdfjs/core/parser', 'pdfjs/core/evaluator', 'pdfjs/core/cmap',
-          'pdfjs/core/worker', 'pdfjs/display/api', 'pdfjs/display/metadata'],
+          'pdfjs/core/worker', 'pdfjs/core/network', 'pdfjs/display/api',
+          'pdfjs/display/metadata'],
           function (sharedUtil, sharedGlobal, corePrimitives, coreAnnotation,
                     coreCrypto, coreStream, coreFonts, corePsParser, coreFunction,
-                    coreParser, coreEvaluator, coreCMap, coreWorker, displayAPI,
-                    displayMetadata) {
+                    coreParser, coreEvaluator, coreCMap, coreWorker,
+                    coreNetwork, displayAPI, displayMetadata) {
 
         pdfjsLibs = {
           sharedUtil: sharedUtil,
@@ -68,6 +70,7 @@
           coreEvaluator: coreEvaluator,
           coreCMap: coreCMap,
           coreWorker: coreWorker,
+          coreNetwork: coreNetwork,
           displayAPI: displayAPI,
           displayMetadata: displayMetadata
         };