[promises] Move async debug event creation to c++

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 3052 matching lines @@
     stack_trace = GetDetailedStackTrace(Handle<JSObject>::cast(value));
   }
   promise_reject_callback_(v8::PromiseRejectMessage(
       v8::Utils::PromiseToLocal(promise), event, v8::Utils::ToLocal(value),
       v8::Utils::StackTraceToLocal(stack_trace)));
 }
 
 namespace {
 class PromiseDebugEventScope {
  public:
-  PromiseDebugEventScope(Isolate* isolate, Object* before, Object* after)
+  PromiseDebugEventScope(Isolate* isolate, Object* id, Object* name)
       : isolate_(isolate),
-        after_(after, isolate_),
+        id_(id, isolate_),
+        name_(name, isolate_),
         is_debug_active_(isolate_->debug()->is_active() &&
-                         before->IsJSObject() && after->IsJSObject()) {
+                         !id_->IsUndefined(isolate_) &&
+                         !name_->IsUndefined(isolate_)) {
     if (is_debug_active_) {
+      static const char will_handle[] = "willHandle";

[adamk, 2016/10/13 15:59:10]

Rather than recreating a string for this every time, add this to the string list
in heap-symbols.h (same goes for didHandle).

[gsathya, 2016/10/13 21:27:30]

Done.

       isolate_->debug()->OnAsyncTaskEvent(
-          handle(JSObject::cast(before), isolate_));
+          isolate_->factory()->NewStringFromAsciiChecked(will_handle), id_,
+          name_);
     }
   }
 
   ~PromiseDebugEventScope() {
     if (is_debug_active_) {
-      isolate_->debug()->OnAsyncTaskEvent(Handle<JSObject>::cast(after_));
+      static const char did_handle[] = "didHandle";
+      isolate_->debug()->OnAsyncTaskEvent(
+          isolate_->factory()->NewStringFromAsciiChecked(did_handle), id_,
+          name_);
     }
   }
 
  private:
   Isolate* isolate_;
-  Handle<Object> after_;
+  Handle<Object> id_;
+  Handle<Object> name_;
   bool is_debug_active_;
 };
 }  // namespace
 
 void Isolate::PromiseReactionJob(Handle<PromiseReactionJobInfo> info,
                                  MaybeHandle<Object>* result,
                                  MaybeHandle<Object>* maybe_exception) {
-  PromiseDebugEventScope helper(this, info->before_debug_event(),
-                                info->after_debug_event());
+  PromiseDebugEventScope helper(this, info->id(), info->name());
 
   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();
 
   // If tasks is an array we have multiple onFulfilled/onRejected callbacks
   // associated with the promise. The deferred object for each callback
   // is attached to this array as well.
   // Otherwise, there is a single callback and the deferred object is attached
@@ skipping 20 matching lines @@
     Handle<Object> deferred(info->deferred(), this);
     Handle<Object> argv[] = {value, tasks, deferred};
     *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) {
-  PromiseDebugEventScope helper(this, info->before_debug_event(),
-                                info->after_debug_event());
+  PromiseDebugEventScope helper(this, info->id(), info->name());
 
   Handle<JSReceiver> thenable(info->thenable(), this);
   Handle<JSFunction> resolve(info->resolve(), this);
   Handle<JSFunction> reject(info->reject(), this);
   Handle<JSReceiver> then(info->then(), this);
   Handle<Object> argv[] = {resolve, reject};
   *result = Execution::TryCall(this, then, thenable, arraysize(argv), argv,
                                maybe_exception);
 
   Handle<Object> reason;
@@ skipping 297 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8