Align reference implementation of "wait for all" with latest Web IDL spec

The spec of "get a promise for waiting for all" changed slightly when it was moved from the promise guide to Web IDL. Notably, the successSteps and failureSteps arguments were removed, since you can already achieve the same thing by reacting to the returned promise.

This updates the reference implementation to align with the definitions from the Web IDL specification. No normative changes.

Author: MattiasBuelens

reference-implementation/lib/abstract-ops/readable-streams.js

@@ -164,7 +164,7 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             return promiseResolvedWith(undefined);
           });
         }
-        shutdownWithAction(() => waitForAllPromise(actions.map(action => action()), results => results), true, error);
+        shutdownWithAction(() => waitForAllPromise(actions.map(action => action())), true, error);
       };
 
       if (signal.aborted === true) {

reference-implementation/lib/helpers/webidl.js

@@ -8,7 +8,7 @@ const originalPromiseReject = Promise.reject;
 
 const promiseSideTable = new WeakMap();
 
-// https://heycam.github.io/webidl/#a-new-promise
+// https://webidl.spec.whatwg.org/#a-new-promise
 function newPromise() {
   // The stateIsPending tracking only works if we never resolve the promises with other promises.
   // In this spec, that happens to be true for the promises in question; they are always resolved with undefined.
@@ -22,7 +22,7 @@ function newPromise() {
   return promise;
 }
 
-// https://heycam.github.io/webidl/#resolve
+// https://webidl.spec.whatwg.org/#resolve
 function resolvePromise(p, value) {
   // We intend to only resolve or reject promises that are still pending.
   // When this is not the case, it usually means there's a bug in the specification that we want to fix.
@@ -33,22 +33,22 @@ function resolvePromise(p, value) {
   promiseSideTable.get(p).stateIsPending = false;
 }
 
-// https://heycam.github.io/webidl/#reject
+// https://webidl.spec.whatwg.org/#reject
 function rejectPromise(p, reason) {
   assert(stateIsPending(p) === true);
   promiseSideTable.get(p).reject(reason);
   promiseSideTable.get(p).stateIsPending = false;
 }
 
-// https://heycam.github.io/webidl/#a-promise-resolved-with
+// https://webidl.spec.whatwg.org/#a-promise-resolved-with
 function promiseResolvedWith(value) {
   // Cannot use original Promise.resolve since that will return value itself sometimes, unlike Web IDL.
   const promise = new originalPromise(resolve => resolve(value));
   promiseSideTable.set(promise, { stateIsPending: false });
   return promise;
 }
 
-// https://heycam.github.io/webidl/#a-promise-rejected-with
+// https://webidl.spec.whatwg.org/#a-promise-rejected-with
 function promiseRejectedWith(reason) {
   const promise = originalPromiseReject.call(originalPromise, reason);
   promiseSideTable.set(promise, { stateIsPending: false });
@@ -61,7 +61,7 @@ function PerformPromiseThen(promise, onFulfilled, onRejected) {
   return originalPromiseThen.call(promise, onFulfilled, onRejected);
 }
 
-// https://heycam.github.io/webidl/#dfn-perform-steps-once-promise-is-settled
+// https://webidl.spec.whatwg.org/#dfn-perform-steps-once-promise-is-settled
 function uponPromise(promise, onFulfilled, onRejected) {
   PerformPromiseThen(
     PerformPromiseThen(promise, onFulfilled, onRejected),
@@ -104,8 +104,9 @@ Object.assign(exports, {
   stateIsPending
 });
 
-// https://heycam.github.io/webidl/#wait-for-all
+// https://webidl.spec.whatwg.org/#wait-for-all
 function waitForAll(promises, successSteps, failureSteps) {
+  let fulfilledCount = 0;
   let rejected = false;
   const rejectionHandler = arg => {
     if (rejected === false) {
@@ -114,7 +115,6 @@ function waitForAll(promises, successSteps, failureSteps) {
     }
   };
   let index = 0;
-  let fulfilledCount = 0;
   const total = promises.length;
   const result = new Array(total);
   if (total === 0) {
@@ -135,35 +135,15 @@ function waitForAll(promises, successSteps, failureSteps) {
   }
 }
 
-// https://heycam.github.io/webidl/#waiting-for-all-promise
-exports.waitForAllPromise = (promises, successSteps, failureSteps = undefined) => {
-  let resolveP;
-  let rejectP;
-  const promise = new Promise((resolve, reject) => {
-    resolveP = resolve;
-    rejectP = reject;
-  });
-  if (failureSteps === undefined) {
-    failureSteps = arg => {
-      throw arg;
-    };
-  }
-  const successStepsWrapper = results => {
-    try {
-      const stepsResult = successSteps(results);
-      resolveP(stepsResult);
-    } catch (e) {
-      rejectP(e);
-    }
+// https://webidl.spec.whatwg.org/#waiting-for-all-promise
+exports.waitForAllPromise = promises => {
+  const promise = newPromise();
+  const successSteps = results => {
+    resolvePromise(promise, results);
   };
-  const failureStepsWrapper = reason => {
-    try {
-      const stepsResult = failureSteps(reason);
-      resolveP(stepsResult);
-    } catch (e) {
-      rejectP(e);
-    }
+  const failureSteps = reason => {
+    rejectPromise(promise, reason);
   };
-  waitForAll(promises, successStepsWrapper, failureStepsWrapper);
+  waitForAll(promises, successSteps, failureSteps);
   return promise;
 };