/usr/share/xul-ext/calendar-google-provider/modules/shim/Task.jsm is in calendar-google-provider 1:52.9.1-1~deb9u1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
this.EXPORTED_SYMBOLS = [
"Task"
];
var Cc = Components.classes;
var Ci = Components.interfaces;
var Cu = Components.utils;
var Cr = Components.results;
Cu.import("resource://gdata-provider/modules/shim/Promise.jsm");
// The following error types are considered programmer errors, which should be
// reported (possibly redundantly) so as to let programmers fix their code.
var ERRORS_TO_REPORT = ["EvalError", "RangeError", "ReferenceError", "TypeError"];
var gCurrentTask = null;
function linesOf(string) {
let reLine = /([^\r\n])+/g;
let match;
while ((match = reLine.exec(string))) {
yield [match[0], match.index];
}
};
function isGenerator(aValue) {
return Object.prototype.toString.call(aValue) == "[object Generator]";
}
this.Task = {
spawn: function Task_spawn(aTask) {
return createAsyncFunction(aTask).call(undefined);
},
async: function Task_async(aTask) {
if (typeof(aTask) != "function") {
throw new TypeError("aTask argument must be a function");
}
return createAsyncFunction(aTask);
},
Result: function Task_Result(aValue) {
this.value = aValue;
}
};
function createAsyncFunction(aTask) {
let asyncFunction = function () {
let result = aTask;
if (aTask && typeof(aTask) == "function") {
if (aTask.isAsyncFunction) {
throw new TypeError(
"Cannot use an async function in place of a promise. " +
"You should either invoke the async function first " +
"or use 'Task.spawn' instead of 'Task.async' to start " +
"the Task and return its promise.");
}
try {
// Let's call into the function ourselves.
result = aTask.apply(this, arguments);
} catch (ex) {
if (ex instanceof Task.Result) {
return Promise.resolve(ex.value);
} else {
return Promise.reject(ex);
}
}
}
if (isGenerator(result)) {
// This is an iterator resulting from calling a generator function.
return new TaskImpl(result).deferred.promise;
}
// Just propagate the given value to the caller as a resolved promise.
return Promise.resolve(result);
};
asyncFunction.isAsyncFunction = true;
return asyncFunction;
}
function TaskImpl(iterator) {
this.deferred = Promise.defer();
this._iterator = iterator;
this._run(true);
}
TaskImpl.prototype = {
deferred: null,
_iterator: null,
_run: function TaskImpl_run(aSendResolved, aSendValue) {
try {
gCurrentTask = this;
try {
let yielded = aSendResolved ? this._iterator.send(aSendValue)
: this._iterator.throw(aSendValue);
this._handleResultValue(yielded);
} catch (ex) {
if (ex instanceof Task.Result) {
this.deferred.resolve(ex.value);
} else if (ex instanceof StopIteration) {
this.deferred.resolve(undefined);
} else {
this._handleException(ex);
}
}
} finally {
if (gCurrentTask == this) {
gCurrentTask = null;
}
}
},
_handleResultValue: function TaskImpl_handleResultValue(aValue) {
if (isGenerator(aValue)) {
aValue = Task.spawn(aValue);
}
if (aValue && typeof(aValue.then) == "function") {
aValue.then(this._run.bind(this, true),
this._run.bind(this, false));
} else {
this._run(true, aValue);
}
},
_handleException: function TaskImpl_handleException(aException) {
gCurrentTask = this;
this.deferred.reject(aException);
}
};
|