66e0dd1b06
*Please note:* The majority of this patch was written by Yury, and it's simply been rebased and slightly extended to prevent issues when dealing with `RenderingCancelledException`. By leveraging streams this (finally) provides a simple way in which parsing can be aborted on the worker-thread, which will ultimately help save resources. With this patch worker-thread parsing will *only* be aborted when the document is destroyed, and not when rendering is cancelled. There's a couple of reasons for this: - The API currently expects the *entire* OperatorList to be extracted, or an Error to occur, once it's been started. Hence additional re-factoring/re-writing of the API code will be necessary to properly support cancelling and re-starting of OperatorList parsing in cases where the `lastChunk` hasn't yet been seen. - Even with the above addressed, immediately cancelling when encountering a `RenderingCancelledException` will lead to worse performance in e.g. the default viewer. When zooming and/or rotation of the document occurs it's very likely that `cancel` will be (almost) immediately followed by a new `render` call. In that case you'd obviously *not* want to abort parsing on the worker-thread, since then you'd risk throwing away a partially parsed Page and thus be forced to re-parse it again which will regress perceived performance. - This patch is already *somewhat* risky, given that it touches fundamentally important/critical code, and trying to keep it somewhat small should hopefully reduce the risk of regressions (and simplify reviewing as well). Time permitting, once this has landed and been in Nightly for awhile, I'll try to work on the remaining points outlined above. Co-Authored-By: Yury Delendik <ydelendik@mozilla.com> Co-Authored-By: Jonas Jenwald <jonas.jenwald@gmail.com>
342 lines
12 KiB
JavaScript
342 lines
12 KiB
JavaScript
/* Copyright 2017 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 { createIdFactory, XRefMock } from './test_utils';
|
|
import { Dict, Name } from '../../src/core/primitives';
|
|
import { FormatError, OPS } from '../../src/shared/util';
|
|
import { Stream, StringStream } from '../../src/core/stream';
|
|
import { OperatorList } from '../../src/core/operator_list';
|
|
import { PartialEvaluator } from '../../src/core/evaluator';
|
|
import { WorkerTask } from '../../src/core/worker';
|
|
|
|
describe('evaluator', function() {
|
|
function HandlerMock() {
|
|
this.inputs = [];
|
|
}
|
|
HandlerMock.prototype = {
|
|
send(name, data) {
|
|
this.inputs.push({ name, data, });
|
|
},
|
|
};
|
|
function ResourcesMock() { }
|
|
ResourcesMock.prototype = {
|
|
get(name) {
|
|
return this[name];
|
|
},
|
|
};
|
|
|
|
function runOperatorListCheck(evaluator, stream, resources, callback) {
|
|
var result = new OperatorList();
|
|
var task = new WorkerTask('OperatorListCheck');
|
|
evaluator.getOperatorList({
|
|
stream,
|
|
task,
|
|
resources,
|
|
operatorList: result,
|
|
}).then(function() {
|
|
callback(result);
|
|
}, function(reason) {
|
|
callback(reason);
|
|
});
|
|
}
|
|
|
|
var partialEvaluator;
|
|
|
|
beforeAll(function(done) {
|
|
partialEvaluator = new PartialEvaluator({
|
|
xref: new XRefMock(),
|
|
handler: new HandlerMock(),
|
|
pageIndex: 0,
|
|
idFactory: createIdFactory(/* pageIndex = */ 0),
|
|
});
|
|
done();
|
|
});
|
|
|
|
afterAll(function() {
|
|
partialEvaluator = null;
|
|
});
|
|
|
|
describe('splitCombinedOperations', function() {
|
|
it('should reject unknown operations', function(done) {
|
|
var stream = new StringStream('fTT');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function(result) {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(1);
|
|
expect(result.fnArray[0]).toEqual(OPS.fill);
|
|
expect(result.argsArray[0]).toEqual(null);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should handle one operation', function(done) {
|
|
var stream = new StringStream('Q');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function(result) {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(1);
|
|
expect(result.fnArray[0]).toEqual(OPS.restore);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should handle two glued operations', function(done) {
|
|
var resources = new ResourcesMock();
|
|
resources.Res1 = {};
|
|
var stream = new StringStream('/Res1 DoQ');
|
|
runOperatorListCheck(partialEvaluator, stream, resources,
|
|
function(result) {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(2);
|
|
expect(result.fnArray[0]).toEqual(OPS.paintXObject);
|
|
expect(result.fnArray[1]).toEqual(OPS.restore);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should handle three glued operations', function(done) {
|
|
var stream = new StringStream('fff');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function (result) {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(3);
|
|
expect(result.fnArray[0]).toEqual(OPS.fill);
|
|
expect(result.fnArray[1]).toEqual(OPS.fill);
|
|
expect(result.fnArray[2]).toEqual(OPS.fill);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should handle three glued operations #2', function(done) {
|
|
var resources = new ResourcesMock();
|
|
resources.Res1 = {};
|
|
var stream = new StringStream('B*Bf*');
|
|
runOperatorListCheck(partialEvaluator, stream, resources,
|
|
function(result) {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(3);
|
|
expect(result.fnArray[0]).toEqual(OPS.eoFillStroke);
|
|
expect(result.fnArray[1]).toEqual(OPS.fillStroke);
|
|
expect(result.fnArray[2]).toEqual(OPS.eoFill);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should handle glued operations and operands', function(done) {
|
|
var stream = new StringStream('f5 Ts');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function (result) {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(2);
|
|
expect(result.fnArray[0]).toEqual(OPS.fill);
|
|
expect(result.fnArray[1]).toEqual(OPS.setTextRise);
|
|
expect(result.argsArray.length).toEqual(2);
|
|
expect(result.argsArray[1].length).toEqual(1);
|
|
expect(result.argsArray[1][0]).toEqual(5);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should handle glued operations and literals', function(done) {
|
|
var stream = new StringStream('trueifalserinulln');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function (result) {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(3);
|
|
expect(result.fnArray[0]).toEqual(OPS.setFlatness);
|
|
expect(result.fnArray[1]).toEqual(OPS.setRenderingIntent);
|
|
expect(result.fnArray[2]).toEqual(OPS.endPath);
|
|
expect(result.argsArray.length).toEqual(3);
|
|
expect(result.argsArray[0].length).toEqual(1);
|
|
expect(result.argsArray[0][0]).toEqual(true);
|
|
expect(result.argsArray[1].length).toEqual(1);
|
|
expect(result.argsArray[1][0]).toEqual(false);
|
|
expect(result.argsArray[2]).toEqual(null);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('validateNumberOfArgs', function() {
|
|
it('should execute if correct number of arguments', function(done) {
|
|
var stream = new StringStream('5 1 d0');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function (result) {
|
|
expect(result.argsArray[0][0]).toEqual(5);
|
|
expect(result.argsArray[0][1]).toEqual(1);
|
|
expect(result.fnArray[0]).toEqual(OPS.setCharWidth);
|
|
done();
|
|
});
|
|
});
|
|
it('should execute if too many arguments', function(done) {
|
|
var stream = new StringStream('5 1 4 d0');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function (result) {
|
|
expect(result.argsArray[0][0]).toEqual(1);
|
|
expect(result.argsArray[0][1]).toEqual(4);
|
|
expect(result.fnArray[0]).toEqual(OPS.setCharWidth);
|
|
done();
|
|
});
|
|
});
|
|
it('should execute if nested commands', function(done) {
|
|
var stream = new StringStream('/F2 /GS2 gs 5.711 Tf');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function (result) {
|
|
expect(result.fnArray.length).toEqual(3);
|
|
expect(result.fnArray[0]).toEqual(OPS.setGState);
|
|
expect(result.fnArray[1]).toEqual(OPS.dependency);
|
|
expect(result.fnArray[2]).toEqual(OPS.setFont);
|
|
expect(result.argsArray.length).toEqual(3);
|
|
expect(result.argsArray[0].length).toEqual(1);
|
|
expect(result.argsArray[1].length).toEqual(1);
|
|
expect(result.argsArray[2].length).toEqual(2);
|
|
done();
|
|
});
|
|
});
|
|
it('should skip if too few arguments', function(done) {
|
|
var stream = new StringStream('5 d0');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function (result) {
|
|
expect(result.argsArray).toEqual([]);
|
|
expect(result.fnArray).toEqual([]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should error if (many) path operators have too few arguments ' +
|
|
'(bug 1443140)', function(done) {
|
|
const NUM_INVALID_OPS = 25;
|
|
const tempArr = new Array(NUM_INVALID_OPS + 1);
|
|
|
|
// Non-path operators, should be ignored.
|
|
const invalidMoveText = tempArr.join('10 Td\n');
|
|
const moveTextStream = new StringStream(invalidMoveText);
|
|
runOperatorListCheck(partialEvaluator, moveTextStream,
|
|
new ResourcesMock(), function(result) {
|
|
expect(result.argsArray).toEqual([]);
|
|
expect(result.fnArray).toEqual([]);
|
|
done();
|
|
});
|
|
|
|
// Path operators, should throw error.
|
|
const invalidLineTo = tempArr.join('20 l\n');
|
|
const lineToStream = new StringStream(invalidLineTo);
|
|
runOperatorListCheck(partialEvaluator, lineToStream, new ResourcesMock(),
|
|
function(error) {
|
|
expect(error instanceof FormatError).toEqual(true);
|
|
expect(error.message).toEqual(
|
|
'Invalid command l: expected 2 args, but received 1 args.');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should close opened saves', function(done) {
|
|
var stream = new StringStream('qq');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function (result) {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(4);
|
|
expect(result.fnArray[0]).toEqual(OPS.save);
|
|
expect(result.fnArray[1]).toEqual(OPS.save);
|
|
expect(result.fnArray[2]).toEqual(OPS.restore);
|
|
expect(result.fnArray[3]).toEqual(OPS.restore);
|
|
done();
|
|
});
|
|
});
|
|
it('should error on paintXObject if name is missing', function(done) {
|
|
var stream = new StringStream('/ Do');
|
|
runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(),
|
|
function(result) {
|
|
expect(result instanceof FormatError).toEqual(true);
|
|
expect(result.message).toEqual('XObject must be referred to by name.');
|
|
done();
|
|
});
|
|
});
|
|
it('should skip paintXObject if subtype is PS', function(done) {
|
|
var xobjStreamDict = new Dict();
|
|
xobjStreamDict.set('Subtype', Name.get('PS'));
|
|
var xobjStream = new Stream([], 0, 0, xobjStreamDict);
|
|
|
|
var xobjs = new Dict();
|
|
xobjs.set('Res1', xobjStream);
|
|
|
|
var resources = new Dict();
|
|
resources.set('XObject', xobjs);
|
|
|
|
var stream = new StringStream('/Res1 Do');
|
|
runOperatorListCheck(partialEvaluator, stream, resources,
|
|
function(result) {
|
|
expect(result.argsArray).toEqual([]);
|
|
expect(result.fnArray).toEqual([]);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('thread control', function() {
|
|
it('should abort operator list parsing', function (done) {
|
|
var stream = new StringStream('qqQQ');
|
|
var resources = new ResourcesMock();
|
|
var result = new OperatorList();
|
|
var task = new WorkerTask('OperatorListAbort');
|
|
task.terminate();
|
|
partialEvaluator.getOperatorList({
|
|
stream,
|
|
task,
|
|
resources,
|
|
operatorList: result,
|
|
}).catch(function() {
|
|
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
|
|
expect(result.fnArray.length).toEqual(0);
|
|
done();
|
|
});
|
|
});
|
|
it('should abort text parsing parsing', function (done) {
|
|
var resources = new ResourcesMock();
|
|
var stream = new StringStream('qqQQ');
|
|
var task = new WorkerTask('TextContentAbort');
|
|
task.terminate();
|
|
partialEvaluator.getTextContent({
|
|
stream,
|
|
task,
|
|
resources,
|
|
}).catch(function() {
|
|
expect(true).toEqual(true);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('operator list', function () {
|
|
class StreamSinkMock {
|
|
enqueue() { }
|
|
}
|
|
|
|
it('should get correct total length after flushing', function () {
|
|
var operatorList = new OperatorList(null, new StreamSinkMock());
|
|
operatorList.addOp(OPS.save, null);
|
|
operatorList.addOp(OPS.restore, null);
|
|
|
|
expect(operatorList.totalLength).toEqual(2);
|
|
expect(operatorList.length).toEqual(2);
|
|
|
|
operatorList.flush();
|
|
|
|
expect(operatorList.totalLength).toEqual(2);
|
|
expect(operatorList.length).toEqual(0);
|
|
});
|
|
});
|
|
});
|