Issue 3515 - Added polyfill for ES6 promises

lib/polyfill/promise.js

+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2015 Eyeo GmbH
+ *
+ * Adblock Plus is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Adblock Plus is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+function(global)
+{
+  if ("Promise" in global)
+    return;
+
+  var PENDING = 0;

[kzar, 2016/01/15 19:00:41]

Nit: const?

[Sebastian Noack, 2016/01/19 11:34:17]

const isn't supported in strict mode before Chrome 41. It causes a SyntaxError
in older versions. Even though it has been supported with non-standard semantics
in non-strict mode since Chrome 21.

[kzar, 2016/01/19 14:49:27]

Acknowledged.

+  var FULFILLED = 1;
+  var REJECTED = 2;
+
+  global.Promise = function(executor)
+  {
+    this._state = PENDING;
+    this._value = undefined;
+    this._subscriptions = [];
+
+    try
+    {
+      executor(this._emit.bind(this, FULFILLED),
+               this._emit.bind(this, REJECTED));
+    }
+    catch (reason)
+    {
+      this._emit(REJECTED, reason);
+    }
+  };
+
+  Promise.prototype = {

[kzar, 2016/01/15 19:00:41]

Should be `global.Promise.prototype = {`?

[Sebastian Noack, 2016/01/19 11:34:17]

As globals literally refers to the global scope, Promise is essentially the same
as global.Promise. But let's cache Promise into in local variable if it makes
the code less confusing. Also that way we avoid side-effects in the theoretical
scenario when using Promise in a function that is called after Promise has been
overridden in the global scope.

[kzar, 2016/01/19 14:49:27]

Acknowledged.

+    _dispatch: function(onFulfilled, onRejected, resolve, reject)
+    {
+      var callback = this._state == FULFILLED ? onFulfilled : onRejected;
+
+      if (typeof callback == "function")
+      {
+        var result;
+
+        try
+        {
+          result = callback(this._value);
+        }
+        catch (reason)
+        {
+          reject(reason);
+          return;
+        }
+
+        Promise.resolve(result).then(resolve, reject);
+      }
+      else if (this._state == FULFILLED)
+      {
+        resolve(this._value);
+      }
+      else if (this._state == REJECTED)
+      {
+        reject(this._value);
+      }
+    },
+    _dispatchSubscriptions: function()
+    {
+      if (this._state == REJECTED && this._subscriptions.length == 0)

[kzar, 2016/01/15 19:00:41]

What if there are subscriptions but only for resolve, not reject? Couldn't we
also have an uncaught rejection in that case?

[Sebastian Noack, 2016/01/19 11:34:17]

No, in that case the error will be delegated to the next promise, the one
returned by then(). In fact, if we would log the error here already we would
eventually log it twice, or it would be logged even if it is handled later.

For example with following code:

  fetch("http://example.com").then(
    response => response.text()
  ).then(
    text => { ... },
    error => { alert(error); ]
  );

There is no onRejected callback for the promise returned by fetch(). So errors
get delegated to the next promise in the chain, where an onRejected callback
handles all errors that might have occurred up the chain.

[kzar, 2016/01/19 14:49:27]

Acknowledged.

+        console.error('Uncaught (in promise)', this._value);
+
+      for (var i = 0; i < this._subscriptions.length; i++)
+        this._dispatch.apply(this, this._subscriptions[i]);
+
+      this._subscriptions = null;
+    },
+    _emit: function(state, value)
+    {
+      if (this._state != PENDING)
+        return;
+
+      this._state = state;
+      this._value = value;
+
+      setTimeout(this._dispatchSubscriptions.bind(this), 0);
+    },
+    then: function(onFulfilled, onRejected)
+    {
+      return new Promise(function(resolve, reject)
+      {
+        if (this._subscriptions)
+          this._subscriptions.push([onFulfilled, onRejected, resolve, reject]);
+        else
+          setTimeout(

[kzar, 2016/01/15 19:00:41]

How come you're using setTimeout here and above?

[Sebastian Noack, 2016/01/19 11:34:18]

The callbacks are supposed to be called asynchronous. Otherwise calling code
will experience inconsistent behavior dependent on whether resolve/reject is
called synchronously or later.

This is consistent with how native promises behave. Feel free to run following
code with native promises on Chrome, Safari or Firefox:

  new Promise(function(resolve, reject) {
    resolve(1);
    console.log(2)
  }).then(x => console.log(x));
  console.log(3);

It will log:

  2
  3
  1

[kzar, 2016/01/19 14:49:27]

Acknowledged.

+            this._dispatch.bind(this), 0,
+            onFulfilled, onRejected, resolve, reject
+          );
+      }.bind(this));
+    },
+    catch: function(onRejected)
+    {
+      return this.then(undefined, onRejected);
+    }
+  };
+

[kzar, 2016/01/15 19:00:41]

What about Promise.race?

[Sebastian Noack, 2016/01/19 11:34:17]

I rather don't introduce dead code and unnecessary complexity. But just
implement the APIs we eventually need. The same goes for the other polyfills. In
particular for fetch(), the poliyfill would be way more complex if it would be
complete. And the APIs we don't use would remain untested.

[kzar, 2016/01/19 14:49:27]

Acknowledged.

+  Promise.resolve = function(value)
+  {
+    if (value instanceof Promise)

[kzar, 2016/01/15 19:00:41]

The docs say that we should use the value straight if it has a `.then` method,
even if it's not an instance of Promise.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Obje...

[Sebastian Noack, 2016/01/19 11:34:22]

True, however this behavior isn't implemented in V8. And since we use native
Promises on modern Chrome versions, I think it's more important to be consistent
with the behavior there, in particular if the inconsistency would add additional
complexity.

[kzar, 2016/01/19 14:49:27]

Acknowledged.

+      return value;
+    return new Promise(function(resolve, reject) { resolve(value); });
+  };
+
+  Promise.reject = function(reason)
+  {
+    return new Promise(function(resolve, reject) { reject(reason); });
+  };
+
+  Promise.all = function(promises)
+  {
+    return new Promise(function(resolve, reject)
+    {
+      var count = promises.length;

[kzar, 2016/01/15 19:00:41]

Nit: Call this `remaining` instead of `count`?

[Sebastian Noack, 2016/01/19 11:34:18]

Since this variable is used as well to set the size of the resulting array and
to check whether the array is empty before resolving the promises, I think count
is more accurate.

+      var result = new Array(count);
+
+      promises.forEach(function(promise, i)
+      {
+        promise.then(
+          function(value)
+          {
+            result[i] = value;
+            if (--count == 0)
+              resolve(result);
+          },
+          reject
+        );
+      });
+    });
+  };
+}(this);