[inspector] async stacks for Promise.then calls...

src/debug/debug.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/debug/debug.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 383 matching lines @@
 // Threading support.
 void Debug::ThreadInit() {
   thread_local_.break_count_ = 0;
   thread_local_.break_id_ = 0;
   thread_local_.break_frame_id_ = StackFrame::NO_ID;
   thread_local_.last_step_action_ = StepNone;
   thread_local_.last_statement_position_ = kNoSourcePosition;
   thread_local_.last_fp_ = 0;
   thread_local_.target_fp_ = 0;
   thread_local_.return_value_ = Handle<Object>();
+  thread_local_.async_task_count_ = 0;
   clear_suspended_generator();
   // TODO(isolates): frames_are_dropped_?
   base::NoBarrier_Store(&thread_local_.current_debug_scope_,
                         static_cast<base::AtomicWord>(0));
 }
 
 
 char* Debug::ArchiveDebug(char* storage) {
   // Simply reset state. Don't archive anything.
   ThreadInit();
@@ skipping 1235 matching lines @@
 
 MaybeHandle<Object> Debug::MakeCompileEvent(Handle<Script> script,
                                             v8::DebugEvent type) {
   // Create the compile event object.
   Handle<Object> script_wrapper = Script::GetWrapper(script);
   Handle<Object> argv[] = { script_wrapper,
                             isolate_->factory()->NewNumberFromInt(type) };
   return CallFunction("MakeCompileEvent", arraysize(argv), argv);
 }
 
-MaybeHandle<Object> Debug::MakeAsyncTaskEvent(Handle<String> type,
+MaybeHandle<Object> Debug::MakeAsyncTaskEvent(Handle<Smi> type,
                                               Handle<Object> id,
                                               Handle<String> name) {
   DCHECK(id->IsNumber());
   // Create the async task event object.
   Handle<Object> argv[] = {type, id, name};
   return CallFunction("MakeAsyncTaskEvent", arraysize(argv), argv);
 }
 
 
 void Debug::OnThrow(Handle<Object> exception) {
@@ skipping 102 matching lines @@
 void Debug::OnCompileError(Handle<Script> script) {
   ProcessCompileEvent(v8::CompileError, script);
 }
 
 
 // Handle debugger actions when a new script is compiled.
 void Debug::OnAfterCompile(Handle<Script> script) {
   ProcessCompileEvent(v8::AfterCompile, script);
 }
 
-void Debug::OnAsyncTaskEvent(Handle<String> type, Handle<Object> id,
+namespace {
+struct CollectedCallbackData {
+  Object** location;
+  int id;
+  Debug* debug;
+  Isolate* isolate;
+
+  CollectedCallbackData(Object** location, int id, Debug* debug,
+                        Isolate* isolate)
+      : location(location), id(id), debug(debug), isolate(isolate) {}
+};
+
+void SendAsyncTaskEventCancel(const v8::WeakCallbackInfo<void>& info) {
+  std::unique_ptr<CollectedCallbackData> data(
+      reinterpret_cast<CollectedCallbackData*>(info.GetParameter()));
+  if (!data->debug->is_active()) return;
+  HandleScope scope(data->isolate);
+  data->debug->OnAsyncTaskEvent(debug::Cancel,

[Yang, 2016/12/16 17:10:26]

Can you add a comment explaining why we need a weak callback?

[kozy, 2016/12/16 17:47:15]

Done.

+                                handle(Smi::FromInt(data->id), data->isolate),
+                                data->isolate->factory()->collected_string());
+}
+
+void ResetPromiseHandle(const v8::WeakCallbackInfo<void>& info) {
+  CollectedCallbackData* data =
+      reinterpret_cast<CollectedCallbackData*>(info.GetParameter());
+  GlobalHandles::Destroy(data->location);
+  info.SetSecondPassCallback(&SendAsyncTaskEventCancel);
+}
+}  //  namespace
+
+Handle<Object> Debug::NextAsyncTaskId(Handle<JSObject> promise) {

[gsathya, 2016/12/16 15:37:11]

Can this be a non JSPromise? If not, you can make this private symbol be a flag
in JSPromise

[kozy, 2016/12/16 16:29:26]

I double checked that we always get JSPromise here and replace private symbol
with debug_id on promise object. If it's fine to have additional int per promise
object then updated CL is here. :)

+  LookupIterator it(promise, isolate_->factory()->promise_async_id_symbol());
+  Maybe<bool> maybe = JSReceiver::HasProperty(&it);
+  Handle<Smi> async_id;
+  if (!maybe.ToChecked()) {
+    async_id =
+        handle(Smi::FromInt(thread_local_.async_task_count_++), isolate_);
+    Object::SetProperty(&it, async_id, SLOPPY, Object::MAY_BE_STORE_FROM_KEYED)
+        .ToChecked();
+  } else {
+    MaybeHandle<Object> result = Object::GetProperty(&it);
+    async_id = Handle<Smi>::cast(result.ToHandleChecked());
+  }
+  Handle<Object> global_handle = isolate_->global_handles()->Create(*promise);
+  GlobalHandles::MakeWeak(
+      global_handle.location(),
+      new CollectedCallbackData(global_handle.location(), async_id->value(),
+                                this, isolate_),
+      &ResetPromiseHandle, v8::WeakCallbackType::kParameter);
+  return async_id;
+}
+
+void Debug::OnAsyncTaskEvent(debug::AsyncTaskEventType type, Handle<Object> id,
                              Handle<String> name) {
   DCHECK(id->IsNumber());
   if (in_debug_scope() || ignore_events()) return;
 
   HandleScope scope(isolate_);
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
   // Create the script collected state object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
-  if (!MakeAsyncTaskEvent(type, id, name).ToHandle(&event_data)) return;
+  Handle<Smi> type_smi(Smi::FromInt(type), isolate_);
+  if (!MakeAsyncTaskEvent(type_smi, id, name).ToHandle(&event_data)) return;
 
   // Process debug event.
   ProcessDebugEvent(v8::AsyncTaskEvent, Handle<JSObject>::cast(event_data),
                     true);
 }
 
 void Debug::ProcessDebugEvent(v8::DebugEvent event, Handle<JSObject> event_data,
                               bool auto_continue) {
   HandleScope scope(isolate_);
 
@@ skipping 689 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8