Replace SimplePromise with native Promises

This PR replaces usage of SimplePromise with native Promises. The API shape
is slightly different, requiring some logic changes.

The biggest change is that `Stage.initialize()` is now async, which
lets us remove `waitUntilRead()`, and `_runBenchmarkAndRecordResults()`
is also async.

modified:   MotionMark/resources/debug-runner/debug-runner.js: Fix a bug that broke clicking some controls.
modified:   MotionMark/resources/extensions.js
modified:   MotionMark/resources/runner/benchmark-runner.js
modified:   MotionMark/resources/runner/motionmark.js
modified:   MotionMark/tests/3d/resources/webgl.js
modified:   MotionMark/tests/3d/resources/webgpu.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-canvas-images.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-canvas-particles.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-canvas-shapes.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-css-images.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-css-shapes.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-particles.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-svg-images.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-svg-shapes.js
modified:   MotionMark/tests/bouncing-particles/resources/bouncing-tagged-images.js
modified:   MotionMark/tests/core/resources/canvas-stage.js
modified:   MotionMark/tests/core/resources/canvas-tests.js
modified:   MotionMark/tests/core/resources/design.js
modified:   MotionMark/tests/core/resources/focus.js
modified:   MotionMark/tests/core/resources/image-data.js
modified:   MotionMark/tests/core/resources/leaves.js
modified:   MotionMark/tests/core/resources/multiply.js
modified:   MotionMark/tests/core/resources/suits.js
modified:   MotionMark/tests/dom/resources/compositing-transforms.js
modified:   MotionMark/tests/dom/resources/dom-particles.js
modified:   MotionMark/tests/dom/resources/focus.js
modified:   MotionMark/tests/resources/main.js
modified:   MotionMark/tests/simple/resources/simple-canvas-paths.js
modified:   MotionMark/tests/simple/resources/tiled-canvas-image.js
modified:   MotionMark/tests/template/resources/template-canvas.js
modified:   MotionMark/tests/template/resources/template-css.js
modified:   MotionMark/tests/template/resources/template-svg.js

Author: smfr

MotionMark/resources/extensions.js

@@ -434,44 +434,6 @@ class UnitBezier {
     }
 }
 
-class SimplePromise {
-    constructor()
-    {
-        this._chainedPromise = null;
-        this._callback = null;
-    }
-
-    then (callback)
-    {
-        if (this._callback)
-            throw "SimplePromise doesn't support multiple calls to then";
-
-        this._callback = callback;
-        this._chainedPromise = new SimplePromise;
-
-        if (this._resolved)
-            this.resolve(this._resolvedValue);
-
-        return this._chainedPromise;
-    }
-
-    resolve (value)
-    {
-        if (!this._callback) {
-            this._resolved = true;
-            this._resolvedValue = value;
-            return;
-        }
-
-        var result = this._callback(value);
-        if (result instanceof SimplePromise) {
-            var chainedPromise = this._chainedPromise;
-            result.then(function (result) { chainedPromise.resolve(result); });
-        } else
-            this._chainedPromise.resolve(result);
-    }
-}
-
 class Heap {
 
     static createMinHeap(maxSize)

MotionMark/resources/runner/benchmark-runner.js

@@ -64,12 +64,12 @@ class BenchmarkRunnerState {
 
     prepareCurrentTest(runner, frame)
     {
-        var test = this.currentTest();
-        var promise = new SimplePromise;
-
-        frame.onload = function() {
-            promise.resolve();
-        };
+        const test = this.currentTest();
+        const promise = new Promise(resolve => {
+            frame.onload = function() {
+                resolve();
+            };
+        });
 
         frame.src = "tests/" + test.url;
         return promise;
@@ -102,86 +102,80 @@ class BenchmarkRunner {
         }
     }
 
-    _runBenchmarkAndRecordResults(state)
+    async _runBenchmarkAndRecordResults(state)
     {
-        var promise = new SimplePromise;
-        var suite = state.currentSuite();
-        var test = state.currentTest();
+        const suite = state.currentSuite();
+        const test = state.currentTest();
 
         if (this._client && this._client.willRunTest)
             this._client.willRunTest(suite, test);
 
-        var contentWindow = this._frame.contentWindow;
-        var self = this;
+        const contentWindow = this._frame.contentWindow;
 
-        var options = { complexity: test.complexity };
+        const options = { complexity: test.complexity };
         Utilities.extendObject(options, this._client.options);
         Utilities.extendObject(options, Utilities.parseParameters(contentWindow.location));
 
-        var benchmark = new contentWindow.benchmarkClass(options);
-        document.body.style.backgroundColor = benchmark.backgroundColor();
-        benchmark.run().then(function(testData) {
-            var suiteResults = self._suitesResults[suite.name] || {};
-            suiteResults[test.name] = testData;
-            self._suitesResults[suite.name] = suiteResults;
+        const benchmark = new contentWindow.benchmarkClass(options);
+        document.body.style.backgroundColor = benchmark.backgroundColor(); // FIXME: Do this via a selector.
+        
+        await benchmark.initialize(options);
+        const testData = await benchmark.run();
+        const suiteResults = this._suitesResults[suite.name] || {};
+        suiteResults[test.name] = testData;
+        this._suitesResults[suite.name] = suiteResults;
 
-            if (self._client && self._client.didRunTest)
-                self._client.didRunTest(testData);
+        if (this._client && this._client.didRunTest)
+            this._client.didRunTest(testData);
 
-            state.next();
-            if (state.currentSuite() != suite)
-                self._removeFrame();
-            promise.resolve(state);
-        });
+        state.next();
+        if (state.currentSuite() != suite)
+            this._removeFrame();
 
-        return promise;
+        return state;
     }
 
-    step(state)
+    async step(state)
     {
         if (!state) {
             state = new BenchmarkRunnerState(this._suites);
             this._suitesResults = {};
         }
 
-        var suite = state.currentSuite();
+        const suite = state.currentSuite();
         if (!suite) {
             this._finalize();
-            var promise = new SimplePromise;
-            promise.resolve();
-            return promise;
+            return;
         }
 
-        if (state.isFirstTest()) {
+        if (state.isFirstTest())
             this._appendFrame();
-        }
 
-        return state.prepareCurrentTest(this, this._frame).then(function(prepareReturnValue) {
-            return this._runBenchmarkAndRecordResults(state);
-        }.bind(this));
+        await state.prepareCurrentTest(this, this._frame);
+        const nextState = await this._runBenchmarkAndRecordResults(state);
+        return nextState;
     }
 
     runAllSteps(startingState)
     {
-        var nextCallee = this.runAllSteps.bind(this);
-        this.step(startingState).then(function(nextState) {
-            if (nextState)
-                nextCallee(nextState);
+        this.step(startingState).then(nextState => {
+            if (!nextState)
+                return;
+            this.runAllSteps(nextState);
         });
     }
 
     runMultipleIterations()
     {
-        var self = this;
-        var currentIteration = 0;
+        let currentIteration = 0;
 
-        this._runNextIteration = function() {
-            currentIteration++;
-            if (currentIteration < self._client.iterationCount)
-                self.runAllSteps();
+        this._runNextIteration = () => {
+            ++currentIteration;
+            if (currentIteration < this._client.iterationCount)
+                this.runAllSteps();
             else if (this._client && this._client.didFinishLastIteration) {
-                document.body.style.backgroundColor = "";
-                self._client.didFinishLastIteration();
+                document.body.style.backgroundColor = ""; // FIXME: Do this via a selector.
+                this._client.didFinishLastIteration();
             }
         }
 

MotionMark/tests/3d/resources/webgl.js

@@ -24,10 +24,9 @@
  */
 
 class WebGLStage extends Stage {
-    initialize(benchmark, options)
+    async initialize(benchmark, options)
     {
-        super.initialize(benchmark, options);
-
+        await super.initialize(benchmark, options);
         this._numTriangles = 0;
         this._bufferSize = 0;