[inspector] add async instrumentation for setTimeout in tests

test/inspector/task-runner.cc

 // Copyright 2016 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/task-runner.h"
 
+#include "test/inspector/inspector-impl.h"
+
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif               // !defined(_WIN32) && !defined(_WIN64)
 
 namespace {
 
 const int kTaskRunnerIndex = 2;
 
 void ReportUncaughtException(v8::Isolate* isolate,
                              const v8::TryCatch& try_catch) {
@@ skipping 110 matching lines @@
 
 v8::internal::Vector<uint16_t> ToVector(v8::Local<v8::String> str) {
   v8::internal::Vector<uint16_t> buffer =
       v8::internal::Vector<uint16_t>::New(str->Length());
   str->Write(buffer.start(), 0, str->Length());
   return buffer;
 }
 
 }  // namespace
 
+AsyncTask::AsyncTask(const char* task_name,
+                     v8_inspector::V8Inspector* inspector)
+    : inspector_(task_name ? inspector : nullptr) {
+  if (inspector_) {
+    inspector_->asyncTaskScheduled(
+        v8_inspector::StringView(reinterpret_cast<const uint8_t*>(task_name),
+                                 strlen(task_name)),
+        this, false);
+  }
+}
+
+void AsyncTask::Run(v8::Isolate* isolate,
+                    const v8::Global<v8::Context>& context) {
+  if (inspector_) inspector_->asyncTaskStarted(this);
+  AsyncRun(isolate, context);
+  if (inspector_) inspector_->asyncTaskFinished(this);
+}
+
 ExecuteStringTask::ExecuteStringTask(
     const v8::internal::Vector<uint16_t>& expression,
     v8::Local<v8::String> name, v8::Local<v8::Integer> line_offset,
-    v8::Local<v8::Integer> column_offset)
-    : expression_(expression),
+    v8::Local<v8::Integer> column_offset, const char* task_name,
+    v8_inspector::V8Inspector* inspector)
+    : AsyncTask(task_name, inspector),
+      expression_(expression),
       name_(ToVector(name)),
       line_offset_(line_offset.As<v8::Int32>()->Value()),
       column_offset_(column_offset.As<v8::Int32>()->Value()) {}
 
 ExecuteStringTask::ExecuteStringTask(
     const v8::internal::Vector<const char>& expression)
-    : expression_utf8_(expression), line_offset_(0), column_offset_(0) {}
+    : AsyncTask(nullptr, nullptr),
+      expression_utf8_(expression),
+      line_offset_(0),
+      column_offset_(0) {}
 
-void ExecuteStringTask::Run(v8::Isolate* isolate,
-                            const v8::Global<v8::Context>& context) {
+void ExecuteStringTask::AsyncRun(v8::Isolate* isolate,
+                                 const v8::Global<v8::Context>& context) {
   v8::MicrotasksScope microtasks_scope(isolate,
                                        v8::MicrotasksScope::kRunMicrotasks);
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> local_context = context.Get(isolate);
   v8::Context::Scope context_scope(local_context);
 
   v8::Local<v8::String> name =
       v8::String::NewFromTwoByte(isolate, name_.start(),
                                  v8::NewStringType::kNormal, name_.length())
           .ToLocalChecked();
@@ skipping 16 matching lines @@
   }
 
   v8::ScriptCompiler::Source scriptSource(source, origin);
   v8::Local<v8::Script> script;
   if (!v8::ScriptCompiler::Compile(local_context, &scriptSource)
            .ToLocal(&script))
     return;
   v8::MaybeLocal<v8::Value> result;
   result = script->Run(local_context);
 }