[ABANDONED] Implement Promises.

Source/core/dom/PromiseResolver.js

Index: Source/core/dom/PromiseResolver.js
diff --git a/Source/core/dom/PromiseResolver.js b/Source/core/dom/PromiseResolver.js
new file mode 100644
index 0000000000000000000000000000000000000000..a68c78cc0f74da17ce7d78179e799c0bffedbf7b
--- /dev/null
+++ b/Source/core/dom/PromiseResolver.js
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+(function(postTask) {
+    function fulfill(value, synchronous)
+    {
+        if (this.promise === undefined || this.promise.state !== 'pending') {

[abarth-chromium, 2013/06/14 05:07:08]

Do you mean

"promise" in this

?

+            return;
+        }
+        this.promise.state = 'fulfilled';
+        this.promise.result = value;
+        var fulfillCallbacks = this.promise.fulfillCallbacks;
+        this.promise.fulfillCallbacks = [];
+        this.promise.rejectCallbacks = [];
+        // Detach the associated information. We don't need it from now on.
+        this.promise = undefined;

[abarth-chromium, 2013/06/14 05:07:08]

Should we call "delete this.promise" instead?

+
+        if (synchronous) {
+            for (var i = 0; i < fulfillCallbacks.length; ++i) {
+                fulfillCallbacks[i](value);
+            }
+        } else {
+            for (var i = 0; i < fulfillCallbacks.length; ++i) {
+                postTask(fulfillCallbacks[i].bind(undefined, value));
+            }
+        }
+    }
+
+    function resolve(value, synchronous)
+    {
+        if (this.promise === undefined || this.promise.state !== 'pending') {
+            return;
+        }
+        var then = null;
+        if (typeof value === 'object') {
+            try {
+                then = value.then;
+            } catch (e) {
+                this.reject(e, synchronous);
+                return;
+            }
+        }
+        if (typeof then === 'function') {
+            try {
+                var self = this;
+                then.call(value, function(value) {
+                    self.resolve(value, true);
+                }, function(value) {
+                    self.reject(value, true);
+                });
+            } catch (e) {
+                this.reject(e, synchronous);
+            }
+            return;
+        }
+        this.fulfill(value, synchronous);
+    }
+
+    function reject(value, synchronous)
+    {
+        if (this.promise === undefined || this.promise.state !== 'pending') {
+            return;
+        }
+        this.promise.state = 'rejected';
+        this.promise.result = value;
+        var rejectCallbacks = this.promise.rejectCallbacks;
+        this.promise.fulfillCallbacks = [];
+        this.promise.rejectCallbacks = [];
+        // Detach the associated information. We don't need it from now on.
+        this.promise = undefined;
+
+        if (synchronous) {
+            for (var i = 0; i < rejectCallbacks.length; ++i) {
+                rejectCallbacks[i](value);
+            }
+        } else {
+            for (var i = 0; i < rejectCallbacks.length; ++i) {
+                postTask(rejectCallbacks[i].bind(undefined, value));
+            }
+        }
+    }
+
+    /**
+     * PromiseResolver constructor.
+     * @param promiseAssociated promise associated information
+     */
+    function $PromiseResolver(promiseAssociated)
+    {
+        this.promise = promiseAssociated;
+    }
+
+    $PromiseResolver.prototype = {
+        fulfill: fulfill,
+        resolve: resolve,
+        reject: reject
+    };
+
+    return Object.freeze($PromiseResolver);
+});