Promises: Remove additional array for storing deferred objects

src/js/promise.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 97 matching lines @@
   // a new callback --
   // 1) UNDEFINED -- This is the zero state where there is no callback
   // registered. When we see this state, we directly attach the callbacks to
   // the symbol.
   // 2) !IS_ARRAY -- There is a single callback directly attached to the
   // symbols. We need to create a new array to store additional callbacks.
   // 3) IS_ARRAY -- There are multiple callbacks already registered,
   // therefore we can just push the new callback to the existing array.
   SET_PRIVATE(promise, promiseFulfillReactionsSymbol, UNDEFINED);
   SET_PRIVATE(promise, promiseRejectReactionsSymbol, UNDEFINED);
+
+  // There are 2 possible states for this symbol --
+  // 1) UNDEFINED -- This is the zero state, no deferred object is
+  // attached to this symbol. When we want to add a new deferred we
+  // directly attach it to this symbol.
+  // 2) symbol with attached deferred object -- New deferred objects
+  // are not attached to this symbol, but instead they are directly
+  // attached to the resolve, reject callback arrays. At this point,
+  // the deferred symbol's state is stale, and the deferreds should be
+  // read from the reject, resolve callbacks.
   SET_PRIVATE(promise, promiseDeferredReactionsSymbol, UNDEFINED);
+
   return promise;
 }
 
 function PromiseCreateAndSet(status, value) {
   var promise = new GlobalPromise(promiseRawSymbol);
   // If debug is active, notify about the newly created promise first.
   if (DEBUG_IS_ACTIVE) PromiseSet(promise, kPending, UNDEFINED);
   return PromiseSet(promise, status, value);
 }
 
@@ skipping 27 matching lines @@
   }
 }
 
 function PromiseEnqueue(value, tasks, deferreds, status) {
   var id, name, instrumenting = DEBUG_IS_ACTIVE;
   %EnqueueMicrotask(function() {
     if (instrumenting) {
       %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
     }
     if (IS_ARRAY(tasks)) {
-      for (var i = 0; i < tasks.length; i += 1) {
-        PromiseHandle(value, tasks[i], deferreds[i]);
+      for (var i = 0; i < tasks.length; i += 2) {
+        PromiseHandle(value, tasks[i], tasks[i + 1]);
       }
     } else {
       PromiseHandle(value, tasks, deferreds);
     }
     if (instrumenting) {
       %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name });
     }
   });
   if (instrumenting) {
     id = ++lastMicrotaskId;
     name = status === kFulfilled ? "Promise.resolve" : "Promise.reject";
     %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
   }
 }
 
 function PromiseAttachCallbacks(promise, deferred, onResolve, onReject) {
   var maybeResolveCallbacks =
       GET_PRIVATE(promise, promiseFulfillReactionsSymbol);
   if (IS_UNDEFINED(maybeResolveCallbacks)) {
     SET_PRIVATE(promise, promiseFulfillReactionsSymbol, onResolve);
     SET_PRIVATE(promise, promiseRejectReactionsSymbol, onReject);
     SET_PRIVATE(promise, promiseDeferredReactionsSymbol, deferred);
   } else if (!IS_ARRAY(maybeResolveCallbacks)) {
     var resolveCallbacks = new InternalArray();
     var rejectCallbacks = new InternalArray();
-    var deferreds = new InternalArray();
+    var existingDeferred = GET_PRIVATE(promise, promiseDeferredReactionsSymbol);
 
-    resolveCallbacks.push(maybeResolveCallbacks);
-    rejectCallbacks.push(GET_PRIVATE(promise, promiseRejectReactionsSymbol));
-    deferreds.push(GET_PRIVATE(promise, promiseDeferredReactionsSymbol));
-
-    resolveCallbacks.push(onResolve);
-    rejectCallbacks.push(onReject);
-    deferreds.push(deferred);
+    resolveCallbacks.push(
+        maybeResolveCallbacks, existingDeferred, onResolve, deferred);
+    rejectCallbacks.push(GET_PRIVATE(promise, promiseRejectReactionsSymbol),
+                         existingDeferred,
+                         onReject,
+                         deferred);
 
     SET_PRIVATE(promise, promiseFulfillReactionsSymbol, resolveCallbacks);
     SET_PRIVATE(promise, promiseRejectReactionsSymbol, rejectCallbacks);
-    SET_PRIVATE(promise, promiseDeferredReactionsSymbol, deferreds);
   } else {
-    maybeResolveCallbacks.push(onResolve);
-    GET_PRIVATE(promise, promiseRejectReactionsSymbol).push(onReject);
-    GET_PRIVATE(promise, promiseDeferredReactionsSymbol).push(deferred);
+    maybeResolveCallbacks.push(onResolve, deferred);
+    GET_PRIVATE(promise, promiseRejectReactionsSymbol).push(onReject, deferred);
   }
 }
 
 function PromiseIdResolveHandler(x) { return x }
 function PromiseIdRejectHandler(r) { throw r }
 
 function PromiseNopResolver() {}
 
 // -------------------------------------------------------------------
 // Define exported functions.
@@ skipping 285 matching lines @@
   return false;
 }
 
 function PromiseHasUserDefinedRejectHandlerRecursive(promise) {
   var queue = GET_PRIVATE(promise, promiseRejectReactionsSymbol);
   var deferreds = GET_PRIVATE(promise, promiseDeferredReactionsSymbol);
   if (IS_UNDEFINED(queue)) return false;
   if (!IS_ARRAY(queue)) {
     return PromiseHasUserDefinedRejectHandlerCheck(queue, deferreds);
   } else {
-    for (var i = 0; i < queue.length; i += 1) {
-      if (PromiseHasUserDefinedRejectHandlerCheck(queue[i], deferreds[i])) {
+    for (var i = 0; i < queue.length; i += 2) {
+      if (PromiseHasUserDefinedRejectHandlerCheck(queue[i], queue[i + 1])) {
         return true;
       }
     }
   }
   return false;
 }
 
 // Return whether the promise will be handled by a user-defined reject
 // handler somewhere down the promise chain. For this, we do a depth-first
 // search for a reject handler that's not the default PromiseIdRejectHandler.
@@ skipping 49 matching lines @@
   to.PromiseChain = PromiseChain;
   to.PromiseDefer = PromiseDefer;
   to.PromiseAccept = PromiseAccept;
 
   to.PromiseCreateRejected = PromiseCreateRejected;
   to.PromiseCreateResolved = PromiseCreateResolved;
   to.PromiseThen = PromiseThen;
 });
 
 })