[inspector] avoid cloning of async call chains

test/inspector/inspector-impl.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/inspector-impl.h"
 
 #include "include/v8.h"
 
 #include "src/vector.h"
 
@@ skipping 67 matching lines @@
     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);
 }
 
+v8::Local<v8::String> ToString(v8::Isolate* isolate,
+                               const v8_inspector::StringView& string) {
+  if (string.is8Bit())
+    return v8::String::NewFromOneByte(isolate, string.characters8(),
+                                      v8::NewStringType::kNormal,
+                                      static_cast<int>(string.length()))
+        .ToLocalChecked();
+  else
+    return v8::String::NewFromTwoByte(isolate, string.characters16(),
+                                      v8::NewStringType::kNormal,
+                                      static_cast<int>(string.length()))
+        .ToLocalChecked();
+}
+
+void Print(v8::Isolate* isolate, const v8_inspector::StringView& string) {
+  v8::Local<v8::String> v8_string = ToString(isolate, string);
+  v8::String::Utf8Value utf8_string(v8_string);
+  fwrite(*utf8_string, sizeof(**utf8_string), utf8_string.length(), stdout);
+}
 }  //  namespace
 
 class ConnectTask : public TaskRunner::Task {
  public:
   ConnectTask(InspectorClientImpl* client, v8::base::Semaphore* ready_semaphore)
       : client_(client), ready_semaphore_(ready_semaphore) {}
   virtual ~ConnectTask() = default;
 
   bool is_inspector_task() final { return true; }
 
@@ skipping 160 matching lines @@
 double InspectorClientImpl::currentTimeMS() {
   if (current_time_set_for_test_) return current_time_;
   return v8::base::OS::TimeCurrentMillis();
 }
 
 void InspectorClientImpl::setMemoryInfoForTest(
     v8::Local<v8::Value> memory_info) {
   memory_info_.Reset(isolate_, memory_info);
 }
 
+void InspectorClientImpl::setLogConsoleApiMessageCalls(bool log) {
+  log_console_api_message_calls_ = log;
+}
+
 v8::MaybeLocal<v8::Value> InspectorClientImpl::memoryInfo(
     v8::Isolate* isolate, v8::Local<v8::Context>) {
   if (memory_info_.IsEmpty()) return v8::MaybeLocal<v8::Value>();
   return memory_info_.Get(isolate);
 }
 
 void InspectorClientImpl::runMessageLoopOnPause(int) {
   task_runner_->RunMessageLoop(true);
 }
 
 void InspectorClientImpl::quitMessageLoopOnPause() {
   task_runner_->QuitMessageLoop();
 }
 
+void InspectorClientImpl::consoleAPIMessage(
+    int contextGroupId, v8::Isolate::MessageErrorLevel level,
+    const v8_inspector::StringView& message,
+    const v8_inspector::StringView& url, 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");
+}
+
 v8_inspector::V8Inspector* InspectorClientImpl::InspectorFromContext(
     v8::Local<v8::Context> context) {
   return InspectorClientFromContext(context)->inspector_.get();
 }
 
 v8_inspector::V8InspectorSession* InspectorClientImpl::SessionFromContext(
     v8::Local<v8::Context> context) {
   int context_group_id = TaskRunner::GetContextGroupId(context);
   return InspectorClientFromContext(context)->sessions_[context_group_id].get();
 }
@@ skipping 49 matching lines @@
 }
 
 void SendMessageToBackendExtension::SendMessageToBackend(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(backend_task_runner_);
   CHECK(args.Length() == 2 && args[0]->IsString() && args[1]->IsInt32());
   v8::Local<v8::String> message = args[0].As<v8::String>();
   backend_task_runner_->Append(new SendMessageToBackendTask(
       ToVector(message), args[1].As<v8::Int32>()->Value()));
 }