[promisehook] Pass deferred promise to Before/After callback

src/isolate.cc

 // 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.
 
 #include "src/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 3277 matching lines @@
   PromiseDebugActionName name_;
   bool is_debug_active_;
 };
 }  // namespace
 
 void Isolate::PromiseReactionJob(Handle<PromiseReactionJobInfo> info,
                                  MaybeHandle<Object>* result,
                                  MaybeHandle<Object>* maybe_exception) {
   PromiseDebugEventScope helper(this, info->debug_id(), info->debug_name());
 
-  Handle<JSPromise> promise(info->promise(), this);
   Handle<Object> value(info->value(), this);
   Handle<Object> tasks(info->tasks(), this);
   Handle<JSFunction> promise_handle_fn = promise_handle();
   Handle<Object> undefined = factory()->undefined_value();
   Handle<Object> deferred_promise(info->deferred_promise(), this);
 
   if (deferred_promise->IsFixedArray()) {
     DCHECK(tasks->IsFixedArray());
     Handle<FixedArray> deferred_promise_arr =
         Handle<FixedArray>::cast(deferred_promise);
     Handle<FixedArray> deferred_on_resolve_arr(
         FixedArray::cast(info->deferred_on_resolve()), this);
     Handle<FixedArray> deferred_on_reject_arr(
         FixedArray::cast(info->deferred_on_reject()), this);
     Handle<FixedArray> tasks_arr = Handle<FixedArray>::cast(tasks);
     for (int i = 0; i < deferred_promise_arr->length(); i++) {
-      Handle<Object> argv[] = {promise,
-                               value,
-                               handle(tasks_arr->get(i), this),
+      Handle<Object> argv[] = {value, handle(tasks_arr->get(i), this),
                                handle(deferred_promise_arr->get(i), this),
                                handle(deferred_on_resolve_arr->get(i), this),
                                handle(deferred_on_reject_arr->get(i), this)};
       *result = Execution::TryCall(this, promise_handle_fn, undefined,
                                    arraysize(argv), argv, maybe_exception);
       // If execution is terminating, just bail out.
       if (result->is_null() && maybe_exception->is_null()) {
         return;
       }
     }
   } else {
-    Handle<Object> argv[] = {promise,
-                             value,
-                             tasks,
-                             deferred_promise,
+    Handle<Object> argv[] = {value, tasks, deferred_promise,
                              handle(info->deferred_on_resolve(), this),
                              handle(info->deferred_on_reject(), this)};
     *result = Execution::TryCall(this, promise_handle_fn, undefined,
                                  arraysize(argv), argv, maybe_exception);
   }
 }
 
 void Isolate::PromiseResolveThenableJob(
     Handle<PromiseResolveThenableJobInfo> info, MaybeHandle<Object>* result,
     MaybeHandle<Object>* maybe_exception) {
@@ skipping 320 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8