Improve IE8 compatibility and expand test coverage

- Rewrite Promise implementation (promises.js) to a single state-machine queue so rejections propagate through then() calls without a rejection handler to a trailing catch()
- RSA key usage filtering uses IE8-safe loops and msrcryptoUtilities.indexOf instead of Array.prototype.filter/indexOf
- Add modern Wrap Key QUnit module (AES-KW, AES-CBC, AES-GCM raw/jwk, RSA-OAEP round-trips) replacing the legacy IE11-only interop file
- Add Test.Promise.js coverage
- getRandomValues error tests guard TypedArray usage with regular-array fallbacks for IE8
- Add IE8-safe 'tail -f' auto-scroll to SubtleTests.html runner
- Rebuild dist bundles

Author: ljoy913

dist/msrcrypto.js

@@ -477,9 +477,28 @@ if (typeof operations !== "undefined") {
         // Honor the caller's requested usages (like the other algorithms do),
         // routing each requested usage to the key half it applies to. When no
         // usages are requested, default to all usages valid for the algorithm.
+        // Note: Array.prototype.filter/indexOf are ES5 (unavailable on IE8), so
+        // use plain loops and the IE8-safe msrcryptoUtilities.indexOf helper.
         if (p.usages) {
-            publicUsage = publicUsage.filter(function(usage) { return p.usages.indexOf(usage) >= 0; });
-            privateUsage = privateUsage.filter(function(usage) { return p.usages.indexOf(usage) >= 0; });
+            var requestedUsages = p.usages;
+            var filteredPublic = [];
+            var filteredPrivate = [];
+            var usageIndex;
+
+            for (usageIndex = 0; usageIndex < publicUsage.length; usageIndex += 1) {
+                if (msrcryptoUtilities.indexOf(requestedUsages, publicUsage[usageIndex]) >= 0) {
+                    filteredPublic.push(publicUsage[usageIndex]);
+                }
+            }
+
+            for (usageIndex = 0; usageIndex < privateUsage.length; usageIndex += 1) {
+                if (msrcryptoUtilities.indexOf(requestedUsages, privateUsage[usageIndex]) >= 0) {
+                    filteredPrivate.push(privateUsage[usageIndex]);
+                }
+            }
+
+            publicUsage = filteredPublic;
+            privateUsage = filteredPrivate;
         }
 
         return {

dist/msrcrypto.min.js

@@ -63,158 +63,141 @@
             throw new Error("use 'new' keyword with Promise constructor");
         }
 
-        var successResult = null,
-            failReason = null,
-            thenResolved = [],
-            thenRejected = [],
-            rejectThenPromise = [],
-            resolveThenPromise = [];
-
-        this.then = function(onCompleted, onRejected) {
-
-            var thenFunctionResult;
-
-            // If we already have a result because resolveFunction was synchronous,
-            // then just call onCompleted with the result.
-            if (successResult) {
-                thenFunctionResult = onCompleted(successResult.result);
-
-                if (thenFunctionResult && thenFunctionResult.then) {
-                    return thenFunctionResult;
-                }
-
-                // Create a new promise; resolve with the result;
-                // return the resolved promise.
-                return Promise.resolve(thenFunctionResult);
+        // State: 0 = pending, 1 = fulfilled, 2 = rejected.
+        var state = 0,
+            settledValue = null,
+            // Queue of handlers registered while pending. Each entry is
+            // { onCompleted, onRejected, resolveNext, rejectNext } so a single
+            // list keeps each handler aligned with its chained promise's
+            // resolve/reject. This lets rejections propagate through then()
+            // calls that omit a rejection handler so a trailing catch() still
+            // receives the error. (The previous implementation tracked these in
+            // separate arrays that fell out of alignment and dropped such
+            // rejections, silently swallowing errors.)
+            handlers = [];
+
+        // Invoke a single registered handler against the settled value and
+        // route the outcome to its chained promise. A missing handler passes
+        // the value through (fulfilled -> resolveNext, rejected -> rejectNext)
+        // so a later catch() still sees an earlier rejection. A throwing
+        // handler rejects the chained promise.
+        function runHandler(handler) {
+
+            var callback = (state === 1) ? handler.onCompleted : handler.onRejected;
+
+            if (!callback) {
+                (state === 1 ? handler.resolveNext : handler.rejectNext)(settledValue);
+                return;
             }
 
-            // If we already have a fail reason from a rejected promise
-            if (failReason) {
-                thenFunctionResult = onRejected ? onRejected(failReason.result) : failReason.result;
-
-                if (thenFunctionResult && thenFunctionResult.then) {
-                    return thenFunctionResult;
-                }
-
-                // Create a new promise; reject with the result;
-                // return the resolved promise.
-                return Promise.resolve(thenFunctionResult);
+            var result;
+            try {
+                result = callback(settledValue);
+            } catch (handlerError) {
+                handler.rejectNext(handlerError);
+                return;
             }
 
-            // If we do not have a result, store the onCompleted/onRejected functions
-            // to call when we do get a result.
-            thenResolved.push(onCompleted);
-            if (onRejected) {
-                thenRejected.push(onRejected);
-            }
-
-            // Return a new promise object. This will allow chaining with then/catch().
-            // tslint:disable-next-line: no-shadowed-variable
-            return new Promise(function(resolve, reject) {
-                resolveThenPromise.push(resolve);
-                rejectThenPromise.push(reject);
-            });
-        };
+            handler.resolveNext(result);
+        }
 
-        // tslint:disable-next-line: no-string-literal
-        this["catch"] = function(onRejected) {
+        // Move the promise to its final state and flush any queued handlers.
+        // When fulfilled with a thenable, adopt that thenable's eventual state
+        // so returning a promise from then() chains as expected.
+        function settle(newState, value) {
 
-            var catchFunctionResult;
+            if (state !== 0) {
+                return;
+            }
 
-            // If we already have a result because resolveFunction was synchronous,
-            // then just call onRejected with the result.
-            if (failReason) {
-                catchFunctionResult = onRejected(failReason.result);
+            if (newState === 1 && value && (typeof value === "object" || typeof value === "function")) {
 
-                if (catchFunctionResult && catchFunctionResult.then) {
-                    return catchFunctionResult;
+                var thenFunction;
+                try {
+                    thenFunction = value.then;
+                } catch (accessError) {
+                    settle(2, accessError);
+                    return;
                 }
 
-                return Promise.resolve(catchFunctionResult);
+                if (typeof thenFunction === "function") {
+                    var handled = false;
+                    try {
+                        thenFunction.call(
+                            value,
+                            function(result) { if (!handled) { handled = true; settle(1, result); } },
+                            function(reason) { if (!handled) { handled = true; settle(2, reason); } });
+                    } catch (thenableError) {
+                        if (!handled) { handled = true; settle(2, thenableError); }
+                    }
+                    return;
+                }
             }
 
-            // If we do not have a result, store the onRejected function
-            // to call when we do get a result.
-            thenRejected.push(onRejected);
+            state = newState;
+            settledValue = value;
 
-            // Return a new promise object. This will allow chaining with then/catch().
-            // tslint:disable-next-line: no-shadowed-variable
-            return new Promise(function(resolve, reject) {
-                resolveThenPromise.push(resolve);
-                rejectThenPromise.push(reject);
-            });
-        };
+            for (var i = 0; i < handlers.length; i += 1) {
+                runHandler(handlers[i]);
+            }
+            handlers = [];
+        }
 
         function resolve(param) {
             /// <summary>
-            /// Called by the executor function when the function has succeeded.
+            /// Called by the executor function when the operation has succeeded.
             /// </summary>
-            /// <param name="param">A result value that will be passed to the then() function.</param>
-
-            var result, i;
-
-            // Call each attached Then function with the result
-            for (i = 0; i < thenResolved.length; i += 1) {
-
-                result = thenResolved[i](param);
-
-                // If the result of the then() function is a Promise,
-                // set then() to call the chained resolve function.
-                if (result && result.then) {
-                    result.then(resolveThenPromise[i]);
-
-                    // Also set catch() if present
-                    if (rejectThenPromise[i]) {
-                        // tslint:disable-next-line: no-string-literal
-                        result["catch"](rejectThenPromise[i]);
-                    }
-
-                } else {
-
-                    // If a then() promise was chained to this promise, call its resolve
-                    // function.
-                    if (resolveThenPromise[i]) {
-                        resolveThenPromise[i](result);
-                    }
-                }
-            }
-
-            // If the onCompleted function has not yet been assigned, store the result.
-            successResult = { result: param };
-
-            return;
+            /// <param name="param">A result value passed to the then() function.</param>
+            settle(1, param);
         }
 
         function reject(param) {
+            /// <summary>
+            /// Called by the executor function when the operation has failed.
+            /// </summary>
+            /// <param name="param">A reason value passed to the catch() function.</param>
+            settle(2, param);
+        }
 
-            var reason, i;
+        this.then = function(onCompleted, onRejected) {
 
-            // Call each catch function on this promise
-            for (i = 0; i < thenRejected.length; i += 1) {
+            var resolveNext, rejectNext;
 
-                reason = thenRejected[i](param);
+            // tslint:disable-next-line: no-shadowed-variable
+            var nextPromise = new Promise(function(resolve, reject) {
+                resolveNext = resolve;
+                rejectNext = reject;
+            });
 
-                // If the result of the catch() function is a Promise,
-                // set then() to call the chained resolve function.
-                if (reason && reason.then) {
-                    reason.then(resolveThenPromise[i], rejectThenPromise[i]);
+            var handler = {
+                onCompleted: (typeof onCompleted === "function") ? onCompleted : null,
+                onRejected: (typeof onRejected === "function") ? onRejected : null,
+                resolveNext: resolveNext,
+                rejectNext: rejectNext
+            };
 
-                } else {
-                    if (resolveThenPromise[i]) {
-                        resolveThenPromise[i](reason);
-                    }
-                }
+            // Run immediately if already settled, otherwise queue until it is.
+            if (state === 0) {
+                handlers.push(handler);
+            } else {
+                runHandler(handler);
             }
 
-            // If the onCompleted function has not yet been assigned, store the result.
-            failReason = { result: param };
+            return nextPromise;
+        };
 
-            return;
-        }
+        // tslint:disable-next-line: no-string-literal
+        this["catch"] = function(onRejected) {
+            return this.then(null, onRejected);
+        };
 
         // Call the executor function passing the resolve & reject functions of
-        // this instance.
-        executor(resolve, reject);
+        // this instance. A throw from the executor rejects the promise.
+        try {
+            executor(resolve, reject);
+        } catch (executorError) {
+            reject(executorError);
+        }
 
         return;
     };

src/rsa.js

@@ -466,7 +466,7 @@ var publicMethods = {
         return new Promise(function(resolve, reject) {
 
             if (key.extractable === false ||
-                wrappingKey.usages.indexOf("wrapKey") < 0 ||
+                utils.indexOf(wrappingKey.usages, "wrapKey") < 0 ||
                 wrappingKey.algorithm.name.toUpperCase() !== wrappingKeyAlgorithm.name) {
                 reject(utils.error("InvalidAccessError", "key cannot be wrapped with the supplied wrapping key"));
                 return;
@@ -519,7 +519,7 @@ var publicMethods = {
 
         return new Promise(function(resolve, reject) {
 
-            if (unwrappingKey.usages.indexOf("unwrapKey") < 0 ||
+            if (utils.indexOf(unwrappingKey.usages, "unwrapKey") < 0 ||
                 unwrappingKey.algorithm.name.toUpperCase() !== unwrapAlgorithm.name) {
                 reject(utils.error("InvalidAccessError", "key cannot be unwrapped with the supplied unwrapping key"));
                 return;