[inspector] Support multiple sessions per context group

test/inspector/isolate-data.cc

 // Copyright 2017 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 "test/inspector/isolate-data.h"
 
 #include "src/inspector/test-interface.h"
 #include "test/inspector/task-runner.h"
 
 namespace {
@@ skipping 36 matching lines @@
     : task_runner_(task_runner),
       setup_global_tasks_(std::move(setup_global_tasks)) {
   v8::Isolate::CreateParams params;
   params.array_buffer_allocator =
       v8::ArrayBuffer::Allocator::NewDefaultAllocator();
   params.snapshot_blob = startup_data;
   isolate_ = v8::Isolate::New(params);
   isolate_->SetMicrotasksPolicy(v8::MicrotasksPolicy::kScoped);
   if (with_inspector) {
     isolate_->AddMessageListener(&IsolateData::MessageHandler);
+    isolate_->SetPromiseRejectCallback(&IsolateData::PromiseRejectHandler);
     inspector_ = v8_inspector::V8Inspector::create(isolate_, this);
   }
 }
 
 IsolateData* IsolateData::FromContext(v8::Local<v8::Context> context) {
   return static_cast<IsolateData*>(
       context->GetAlignedPointerFromEmbedderData(kIsolateDataIndex));
 }
 
 int IsolateData::CreateContextGroup() {
@@ skipping 117 matching lines @@
 
 void IsolateData::SetMaxAsyncTaskStacksForTest(int limit) {
   v8_inspector::SetMaxAsyncTaskStacksForTest(inspector_.get(), limit);
 }
 
 void IsolateData::DumpAsyncTaskStacksStateForTest() {
   v8_inspector::DumpAsyncTaskStacksStateForTest(inspector_.get());
 }
 
 // static
-void IsolateData::MessageHandler(v8::Local<v8::Message> message,
-                                 v8::Local<v8::Value> exception) {
+int IsolateData::HandleMessage(v8::Local<v8::Message> message,
+                               v8::Local<v8::Value> exception) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::Local<v8::Context> context = isolate->GetEnteredContext();
-  if (context.IsEmpty()) return;
+  if (context.IsEmpty()) return 0;
   v8_inspector::V8Inspector* inspector =
       IsolateData::FromContext(context)->inspector_.get();
 
   v8::Local<v8::StackTrace> stack = message->GetStackTrace();
   int script_id =
       static_cast<int>(message->GetScriptOrigin().ScriptID()->Value());
   if (!stack.IsEmpty() && stack->GetFrameCount() > 0) {
     int top_script_id = stack->GetFrame(0)->GetScriptId();
     if (top_script_id == script_id) script_id = 0;
   }
   int line_number = message->GetLineNumber(context).FromMaybe(0);
   int column_number = 0;
   if (message->GetStartColumn(context).IsJust())
     column_number = message->GetStartColumn(context).FromJust() + 1;
 
   v8_inspector::StringView detailed_message;
   v8::internal::Vector<uint16_t> message_text_string = ToVector(message->Get());
   v8_inspector::StringView message_text(message_text_string.start(),
                                         message_text_string.length());
   v8::internal::Vector<uint16_t> url_string;
   if (message->GetScriptOrigin().ResourceName()->IsString()) {
     url_string =
         ToVector(message->GetScriptOrigin().ResourceName().As<v8::String>());
   }
   v8_inspector::StringView url(url_string.start(), url_string.length());
 
-  inspector->exceptionThrown(context, message_text, exception, detailed_message,
-                             url, line_number, column_number,
-                             inspector->createStackTrace(stack), script_id);
+  return inspector->exceptionThrown(
+      context, message_text, exception, detailed_message, url, line_number,
+      column_number, inspector->createStackTrace(stack), script_id);
+}
+
+// static
+void IsolateData::MessageHandler(v8::Local<v8::Message> message,
+                                 v8::Local<v8::Value> exception) {
+  HandleMessage(message, exception);
+}
+
+// static
+void IsolateData::PromiseRejectHandler(v8::PromiseRejectMessage data) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Local<v8::Context> context = isolate->GetEnteredContext();
+  if (context.IsEmpty()) return;
+  v8::Local<v8::Promise> promise = data.GetPromise();
+  v8::Local<v8::Private> id_private = v8::Private::ForApi(
+      isolate,
+      v8::String::NewFromUtf8(isolate, "id", v8::NewStringType::kNormal)
+          .ToLocalChecked());
+
+  if (data.GetEvent() == v8::kPromiseHandlerAddedAfterReject) {
+    v8::Local<v8::Value> id;
+    if (!promise->GetPrivate(context, id_private).ToLocal(&id)) return;
+    if (!id->IsInt32()) return;
+    v8_inspector::V8Inspector* inspector =
+        IsolateData::FromContext(context)->inspector_.get();
+    const char* reason_str = "Handler added to rejected promise";
+    inspector->exceptionRevoked(
+        context, id.As<v8::Int32>()->Value(),
+        v8_inspector::StringView(reinterpret_cast<const uint8_t*>(reason_str),
+                                 strlen(reason_str)));
+    return;
+  }
+
+  v8::Local<v8::Value> exception = data.GetValue();
+  int exception_id = HandleMessage(
+      v8::Exception::CreateMessage(isolate, exception), exception);
+  if (exception_id) {
+    promise
+        ->SetPrivate(isolate->GetCurrentContext(), id_private,
+                     v8::Int32::New(isolate, exception_id))
+        .ToChecked();
+  }
 }
 
 void IsolateData::FireContextCreated(v8::Local<v8::Context> context,
                                      int context_group_id) {
   v8_inspector::V8ContextInfo info(context, context_group_id,
                                    v8_inspector::StringView());
   info.hasMemoryOnConsole = true;
   inspector_->contextCreated(info);
 }
 
@@ skipping 65 matching lines @@
                                     unsigned lineNumber, unsigned columnNumber,
                                     v8_inspector::V8StackTrace* stack) {
   if (!log_console_api_message_calls_) return;
   Print(isolate_, message);
   fprintf(stdout, " (");
   Print(isolate_, url);
   fprintf(stdout, ":%d:%d)", lineNumber, columnNumber);
   Print(isolate_, stack->toString()->string());
   fprintf(stdout, "\n");
 }