[promises] Remove one runtime call to create_resolving_functions

src/runtime/runtime-promise.cc

 // Copyright 2016 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/runtime/runtime-utils.h"
 
 #include "src/debug/debug.h"
 #include "src/elements.h"
+#include "src/promise-utils.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 void PromiseRejectEvent(Isolate* isolate, Handle<JSReceiver> promise,
                         Handle<Object> rejected_promise, Handle<Object> value,
                         bool debug_event) {
   if (isolate->debug()->is_active() && debug_event) {
@@ skipping 113 matching lines @@
   CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);
   CONVERT_ARG_HANDLE_CHECKED(Object, tasks, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, deferred, 2);
   CONVERT_ARG_HANDLE_CHECKED(Object, status, 3);
   EnqueuePromiseReactionJob(isolate, value, tasks, deferred, status);
   return isolate->heap()->undefined_value();
 }
 
 RUNTIME_FUNCTION(Runtime_EnqueuePromiseResolveThenableJob) {
   HandleScope scope(isolate);
-  DCHECK(args.length() == 4);
-  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, resolution, 0);
-  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, then, 1);
-  CONVERT_ARG_HANDLE_CHECKED(JSFunction, resolve, 2);
-  CONVERT_ARG_HANDLE_CHECKED(JSFunction, reject, 3);
-  Handle<Object> debug_id;
-  Handle<Object> debug_name;
+  DCHECK(args.length() == 3);
+  CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
+  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, resolution, 1);
+  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, then, 2);
+
+  // TODO(gsathya): Add fast path for native promises with unmodified
+  // PromiseThen (which don't need these resolving functions, but
+  // instead can just call resolve/reject directly).
+  Handle<JSFunction> resolve, reject;
+  PromiseUtils::CreateResolvingFunctions(
+      isolate, promise, isolate->factory()->false_value(), &resolve, &reject);
+
+  Handle<Object> debug_id, debug_name;
   if (isolate->debug()->is_active()) {
     debug_id =
         handle(Smi::FromInt(isolate->GetNextDebugMicrotaskId()), isolate);
     debug_name = isolate->factory()->PromiseResolveThenableJob_string();
     isolate->debug()->OnAsyncTaskEvent(isolate->factory()->enqueue_string(),
                                        debug_id,
                                        Handle<String>::cast(debug_name));
   } else {
     debug_id = isolate->factory()->undefined_value();
     debug_name = isolate->factory()->undefined_value();
   }
+
   Handle<PromiseResolveThenableJobInfo> info =
       isolate->factory()->NewPromiseResolveThenableJobInfo(
-          resolution, then, resolve, reject, debug_id, debug_name);
+          resolution, then, resolve, reject, debug_id, debug_name,
+          isolate->native_context());
   isolate->EnqueueMicrotask(info);
+
   return isolate->heap()->undefined_value();
 }
 
 RUNTIME_FUNCTION(Runtime_EnqueueMicrotask) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, microtask, 0);
   isolate->EnqueueMicrotask(microtask);
   return isolate->heap()->undefined_value();
 }
 
 RUNTIME_FUNCTION(Runtime_RunMicrotasks) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 0);
   isolate->RunMicrotasks();
   return isolate->heap()->undefined_value();
 }
 
 }  // namespace internal
 }  // namespace v8