[inspector] merged type and name of async task event

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 {
@@ skipping 26 matching lines @@
   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
   CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
 
   Handle<Object> rejected_promise = promise;
   if (isolate->debug()->is_active()) {
     // If the Promise.reject call is caught, then this will return
     // undefined, which will be interpreted by PromiseRejectEvent
     // as being a caught exception event.
     rejected_promise = isolate->GetPromiseOnStackOnThrow();
     isolate->debug()->OnAsyncTaskEvent(
-        debug::kDebugEnqueueRecurring,
-        isolate->debug()->NextAsyncTaskId(promise), kDebugPromiseReject);
+        debug::kDebugEnqueuePromiseReject,
+        isolate->debug()->NextAsyncTaskId(promise));
   }
   PromiseRejectEvent(isolate, promise, rejected_promise, value, true);
   return isolate->heap()->undefined_value();
 }
 
 RUNTIME_FUNCTION(Runtime_PromiseRevokeReject) {
   DCHECK_EQ(1, args.length());
   HandleScope scope(isolate);
   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
   // At this point, no revocation has been issued before
@@ skipping 46 matching lines @@
   if (!id->IsSmi()) {
     return false;
   }
 
   *debug_id = Handle<Smi>::cast(id)->value();
   return true;
 }
 
 void SetDebugInfo(Isolate* isolate, Handle<JSPromise> promise,
                   Handle<PromiseReactionJobInfo> info, int status) {
-  int id;
-  PromiseDebugActionName name;
-
-  if (GetDebugIdForAsyncFunction(isolate, info, &id)) {
-    name = kDebugAsyncFunction;
-  } else {
+  int id = kDebugPromiseNoID;
+  if (!GetDebugIdForAsyncFunction(isolate, info, &id)) {
     id = isolate->debug()->NextAsyncTaskId(promise);
     DCHECK(status != v8::Promise::kPending);
-    name = status == v8::Promise::kFulfilled ? kDebugPromiseResolve
-                                             : kDebugPromiseReject;
   }
-
   info->set_debug_id(id);
-  info->set_debug_name(name);
 }
 
 void EnqueuePromiseReactionJob(Isolate* isolate, Handle<JSPromise> promise,
                                Handle<PromiseReactionJobInfo> info,
                                int status) {
   if (isolate->debug()->is_active()) {
     SetDebugInfo(isolate, promise, info, status);
   }
 
   isolate->EnqueueMicrotask(info);
 }
 
 void PromiseSet(Isolate* isolate, Handle<JSPromise> promise, int status,
                 Handle<Object> result) {
   promise->set_status(status);
   promise->set_result(*result);
   promise->set_deferred_promise(isolate->heap()->undefined_value());
   promise->set_deferred_on_resolve(isolate->heap()->undefined_value());
   promise->set_deferred_on_reject(isolate->heap()->undefined_value());
   promise->set_fulfill_reactions(isolate->heap()->undefined_value());
   promise->set_reject_reactions(isolate->heap()->undefined_value());
 }
 
 void PromiseFulfill(Isolate* isolate, Handle<JSPromise> promise, int status,
                     Handle<Object> value) {
   if (isolate->debug()->is_active()) {
     isolate->debug()->OnAsyncTaskEvent(
-        debug::kDebugEnqueueRecurring,
-        isolate->debug()->NextAsyncTaskId(promise),
-        status == v8::Promise::kFulfilled ? kDebugPromiseResolve
-                                          : kDebugPromiseReject);
+        status == v8::Promise::kFulfilled ? debug::kDebugEnqueuePromiseResolve
+                                          : debug::kDebugEnqueuePromiseReject,
+        isolate->debug()->NextAsyncTaskId(promise));
   }
   // Check if there are any callbacks.
   if (!promise->deferred_promise()->IsUndefined(isolate)) {
     Handle<Object> tasks((status == v8::Promise::kFulfilled)
                              ? promise->fulfill_reactions()
                              : promise->reject_reactions(),
                          isolate);
     Handle<PromiseReactionJobInfo> info =
         isolate->factory()->NewPromiseReactionJobInfo(
             value, tasks, handle(promise->deferred_promise(), isolate),
@@ skipping 118 matching lines @@
   HandleScope scope(isolate);
   DCHECK_EQ(1, args.length());
   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
   isolate->RunPromiseHook(PromiseHookType::kAfter, promise,
                           isolate->factory()->undefined_value());
   return isolate->heap()->undefined_value();
 }
 
 }  // namespace internal
 }  // namespace v8