[inspector] introduced debug::SetAsyncTaskListener

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 1797 matching lines @@
   data->debug->OnAsyncTaskEvent(debug::kDebugCancel, data->id,
                                 kDebugPromiseCollected);
 }
 
 void ResetPromiseHandle(const v8::WeakCallbackInfo<void>& info) {
   CollectedCallbackData* data =
       reinterpret_cast<CollectedCallbackData*>(info.GetParameter());
   GlobalHandles::Destroy(data->location);
   info.SetSecondPassCallback(&SendAsyncTaskEventCancel);
 }
+
+debug::PromiseDebugActionName ToInterfaceDebugActionName(
+    PromiseDebugActionName name) {
+  switch (name) {
+    case kDebugAsyncFunction:
+      return debug::kDebugAsyncFunction;
+    case kDebugPromiseResolve:
+      return debug::kDebugPromiseResolve;
+    case kDebugPromiseReject:
+      return debug::kDebugPromiseReject;
+    case kDebugPromiseResolveThenableJob:
+      return debug::kDebugPromiseResolveThenableJob;
+    case kDebugPromiseCollected:
+      return debug::kDebugPromiseCollected;
+    case kDebugNotActive:
+      UNREACHABLE();
+      return debug::kDebugAsyncFunction;
+  }
+  UNREACHABLE();
+  return debug::kDebugAsyncFunction;
+}
 }  //  namespace
 
 int Debug::NextAsyncTaskId(Handle<JSObject> promise) {
   LookupIterator it(promise, isolate_->factory()->promise_async_id_symbol());
   Maybe<bool> maybe = JSReceiver::HasProperty(&it);
   if (maybe.ToChecked()) {
     MaybeHandle<Object> result = Object::GetProperty(&it);
     return Handle<Smi>::cast(result.ToHandleChecked())->value();
   }
   Handle<Smi> async_id =
       handle(Smi::FromInt(++thread_local_.async_task_count_), isolate_);
   Object::SetProperty(&it, async_id, SLOPPY, Object::MAY_BE_STORE_FROM_KEYED)
       .ToChecked();
   Handle<Object> global_handle = isolate_->global_handles()->Create(*promise);
   // We send EnqueueRecurring async task event when promise is fulfilled or
   // rejected, WillHandle and DidHandle for every scheduled microtask for this
   // promise.
   // We need to send a cancel event when no other microtasks can be
   // started for this promise and all current microtasks are finished.
   // Since we holding promise when at least one microtask is scheduled (inside
   // PromiseReactionJobInfo), we can send cancel event in weak callback.
   GlobalHandles::MakeWeak(
       global_handle.location(),
       new CollectedCallbackData(global_handle.location(), async_id->value(),
                                 this, isolate_),
       &ResetPromiseHandle, v8::WeakCallbackType::kParameter);
   return async_id->value();
 }
 
+void Debug::SetAsyncTaskListener(debug::AsyncTaskListener listener,
+                                 void* data) {
+  async_task_listener_ = listener;
+  async_task_listener_data_ = data;
+  UpdateState();
+}
+
 void Debug::OnAsyncTaskEvent(debug::PromiseDebugActionType type, int id,
                              PromiseDebugActionName name) {
   if (in_debug_scope() || ignore_events()) return;
 
+  if (async_task_listener_) {
+    async_task_listener_(type, id, ToInterfaceDebugActionName(name),
+                         async_task_listener_data_);
+    if (message_handler_ == NULL &&

[dgozman, 2017/01/13 00:01:48]

nullptr

[dgozman, 2017/01/13 00:01:48]

Let's extract variable |only_foreign_listener_present| or something like that.
And we can comment why we ignore the foreign one.

[kozy, 2017/01/13 15:59:13]

Done.

[kozy, 2017/01/13 15:59:13]

Done.

+        (event_listener_.is_null() || event_listener_->IsForeign())) {
+      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(handle(Smi::FromInt(type), isolate_),
                           handle(Smi::FromInt(id), isolate_),
                           handle(Smi::FromInt(name), isolate_))
@@ skipping 263 matching lines @@
   message_handler_ = handler;
   UpdateState();
   if (handler == NULL && in_debug_scope()) {
     // Send an empty command to the debugger if in a break to make JavaScript
     // run again if the debugger is closed.
     EnqueueCommandMessage(Vector<const uint16_t>::empty());
   }
 }
 
 void Debug::UpdateState() {
-  bool is_active = message_handler_ != NULL || !event_listener_.is_null();
+  bool is_active = message_handler_ != NULL || !event_listener_.is_null() ||
+                   async_task_listener_ != NULL;
   if (is_active || in_debug_scope()) {
     // Note that the debug context could have already been loaded to
     // bootstrap test cases.
     isolate_->compilation_cache()->Disable();
     is_active = Load();
   } else if (is_loaded()) {
     isolate_->compilation_cache()->Enable();
     Unload();
   }
   is_active_ = is_active;
@@ skipping 467 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8