[promises] remove PromiseEnqueue

src/runtime/runtime-internal.cc

 // Copyright 2014 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 <memory>
 
 #include "src/arguments.h"
 #include "src/ast/prettyprinter.h"
 #include "src/bootstrapper.h"
 #include "src/conversions.h"
 #include "src/debug/debug.h"
+#include "src/elements.h"
 #include "src/frames-inl.h"
 #include "src/isolate-inl.h"
 #include "src/messages.h"
 #include "src/parsing/parse-info.h"
 #include "src/parsing/parser.h"
 #include "src/wasm/wasm-module.h"
 
 namespace v8 {
 namespace internal {
 
@@ skipping 542 matching lines @@
     if (args[0]->IsString())
       std::fclose(f);
     else
       std::fflush(f);
     return isolate->heap()->undefined_value();
   }
 }
 
 RUNTIME_FUNCTION(Runtime_EnqueuePromiseReactionJob) {
   HandleScope scope(isolate);
-  DCHECK(args.length() == 5);
+  DCHECK(args.length() == 4);
   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, debug_id, 3);
-  CONVERT_ARG_HANDLE_CHECKED(Object, debug_name, 4);
+  CONVERT_ARG_HANDLE_CHECKED(Object, status, 3);
+  Handle<Object> debug_id = isolate->factory()->undefined_value();
+  Handle<Object> debug_name = isolate->factory()->undefined_value();
+  if (isolate->debug()->is_active()) {
+    MaybeHandle<Object> maybe_result, maybe_exception;

[adamk, 2016/10/25 11:05:30]

Looks like you don't use maybe_exception, so I'd just leave it out.

[gsathya, 2016/10/25 11:12:30]

Done.

+    Handle<Object> argv[] = {deferred, status};
+    maybe_result =
+        Execution::TryCall(isolate, isolate->promise_debug_get_info(),
+                           isolate->factory()->undefined_value(),
+                           arraysize(argv), argv, &maybe_exception);
+    Handle<Object> result;
+    if ((maybe_result).ToHandle(&result) && result->IsJSArray()) {

[adamk, 2016/10/25 11:05:30]

No need for the parens around maybe_result.

Can we just CHECK(result->IsJSArray()) instead inside the if statement? If the
call succeeds it has to be an array.

[gsathya, 2016/10/25 11:12:31]

Done.

+      Handle<JSArray> array = Handle<JSArray>::cast(result);
+      ElementsAccessor* accessor = array->GetElementsAccessor();
+      DCHECK(accessor->HasElement(array, 0));
+      DCHECK(accessor->HasElement(array, 1));
+      debug_id = accessor->Get(array, 0);
+      debug_name = accessor->Get(array, 1);
+    }
+  }
   Handle<PromiseReactionJobInfo> info =
       isolate->factory()->NewPromiseReactionJobInfo(value, tasks, deferred,
                                                     debug_id, debug_name,
                                                     isolate->native_context());
   isolate->EnqueueMicrotask(info);
   return isolate->heap()->undefined_value();
 }
 
 RUNTIME_FUNCTION(Runtime_EnqueuePromiseResolveThenableJob) {
   HandleScope scope(isolate);
@@ skipping 57 matching lines @@
 
 RUNTIME_FUNCTION(Runtime_Typeof) {
   HandleScope scope(isolate);
   DCHECK_EQ(1, args.length());
   CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
   return *Object::TypeOf(isolate, object);
 }
 
 }  // namespace internal
 }  // namespace v8