[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 1664 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<Smi> type, Handle<Smi> id,
-                                              Handle<Smi> name) {
+MaybeHandle<Object> Debug::MakeAsyncTaskEvent(Handle<Smi> type,
+                                              Handle<Smi> id) {
   DCHECK(id->IsNumber());
   // Create the async task event object.
-  Handle<Object> argv[] = {type, id, name};
+  Handle<Object> argv[] = {type, id};
   return CallFunction("MakeAsyncTaskEvent", arraysize(argv), argv);
 }
 
 
 void Debug::OnThrow(Handle<Object> exception) {
   if (in_debug_scope() || ignore_events()) return;
   PrepareStepOnThrow();
   // Temporarily clear any scheduled_exception to allow evaluating
   // JavaScript from the debug event handler.
   HandleScope scope(isolate_);
@@ skipping 114 matching lines @@
   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::kDebugCancel, data->id,
-                                kDebugPromiseCollected);
+  data->debug->OnAsyncTaskEvent(debug::kDebugPromiseCollected, data->id);
 }
 
 void ResetPromiseHandle(const v8::WeakCallbackInfo<void>& info) {
   CollectedCallbackData* data =
       reinterpret_cast<CollectedCallbackData*>(info.GetParameter());
   GlobalHandles::Destroy(data->location);
   info.SetSecondPassCallback(&SendAsyncTaskEventCancel);
 }
 }  //  namespace
 
@@ skipping 17 matching lines @@
   // 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::OnAsyncTaskEvent(debug::PromiseDebugActionType type, int id,
-                             PromiseDebugActionName name) {
+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) {
   if (in_debug_scope() || ignore_events()) return;
 
+  if (async_task_listener_) {
+    async_task_listener_(type, id, async_task_listener_data_);
+    bool only_foreign_listener_present =

[jgruber, 2017/01/13 16:38:38]

Not sure this was what dgozman@ intended in his previous comment. The
'only_foreign_listener_present' name does not reflect the current semantics
(since it's also true if e.g. event_listener is null).

Also, please add the requested comment about why foreign listeners are ignored.

[kozy, 2017/01/13 17:05:08]

added comment and renamed variable.

+        message_handler_ == nullptr &&
+        (event_listener_.is_null() || event_listener_->IsForeign());
+    if (only_foreign_listener_present) 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_))
+                          handle(Smi::FromInt(id), isolate_))
            .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) {
@@ skipping 253 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() ||

[jgruber, 2017/01/13 16:38:38]

Nit: You could replace the other NULL here while you're at it.

[kozy, 2017/01/13 17:05:08]

Done.

+                   async_task_listener_ != nullptr;
   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