| // 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 { |
| |
| const int kIsolateDataIndex = 2; |
| const int kContextGroupIdIndex = 3; |
| |
| 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; |
| } |
| |
| 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(isolate, v8_string); |
| fwrite(*utf8_string, sizeof(**utf8_string), utf8_string.length(), stdout); |
| } |
| |
| class Inspectable : public v8_inspector::V8InspectorSession::Inspectable { |
| public: |
| Inspectable(v8::Isolate* isolate, v8::Local<v8::Value> object) |
| : object_(isolate, object) {} |
| ~Inspectable() override {} |
| v8::Local<v8::Value> get(v8::Local<v8::Context> context) override { |
| return object_.Get(context->GetIsolate()); |
| } |
| |
| private: |
| v8::Global<v8::Value> object_; |
| }; |
| |
| } // namespace |
| |
| IsolateData::IsolateData(TaskRunner* task_runner, |
| IsolateData::SetupGlobalTasks setup_global_tasks, |
| v8::StartupData* startup_data, bool with_inspector) |
| : 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_.reset(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_.get(), this); |
| } |
| v8::HandleScope handle_scope(isolate_.get()); |
| not_inspectable_private_.Reset( |
| isolate_.get(), |
| v8::Private::ForApi(isolate_.get(), v8::String::NewFromUtf8( |
| isolate_.get(), "notInspectable", |
| v8::NewStringType::kNormal) |
| .ToLocalChecked())); |
| } |
| |
| IsolateData* IsolateData::FromContext(v8::Local<v8::Context> context) { |
| return static_cast<IsolateData*>( |
| context->GetAlignedPointerFromEmbedderData(kIsolateDataIndex)); |
| } |
| |
| int IsolateData::CreateContextGroup() { |
| v8::HandleScope handle_scope(isolate_.get()); |
| v8::Local<v8::ObjectTemplate> global_template = |
| v8::ObjectTemplate::New(isolate_.get()); |
| for (auto it = setup_global_tasks_.begin(); it != setup_global_tasks_.end(); |
| ++it) { |
| (*it)->Run(isolate_.get(), global_template); |
| } |
| v8::Local<v8::Context> context = |
| v8::Context::New(isolate_.get(), nullptr, global_template); |
| context->SetAlignedPointerInEmbedderData(kIsolateDataIndex, this); |
| int context_group_id = ++last_context_group_id_; |
| // Should be 2-byte aligned. |
| context->SetAlignedPointerInEmbedderData( |
| kContextGroupIdIndex, reinterpret_cast<void*>(context_group_id * 2)); |
| contexts_[context_group_id].Reset(isolate_.get(), context); |
| if (inspector_) FireContextCreated(context, context_group_id); |
| return context_group_id; |
| } |
| |
| v8::Local<v8::Context> IsolateData::GetContext(int context_group_id) { |
| return contexts_[context_group_id].Get(isolate_.get()); |
| } |
| |
| int IsolateData::GetContextGroupId(v8::Local<v8::Context> context) { |
| return static_cast<int>( |
| reinterpret_cast<intptr_t>( |
| context->GetAlignedPointerFromEmbedderData(kContextGroupIdIndex)) / |
| 2); |
| } |
| |
| void IsolateData::RegisterModule(v8::Local<v8::Context> context, |
| v8::internal::Vector<uint16_t> name, |
| v8::ScriptCompiler::Source* source) { |
| v8::Local<v8::Module> module; |
| if (!v8::ScriptCompiler::CompileModule(isolate(), source).ToLocal(&module)) |
| return; |
| if (!module->InstantiateModule(context, &IsolateData::ModuleResolveCallback) |
| .FromMaybe(false)) { |
| return; |
| } |
| v8::Local<v8::Value> result; |
| if (!module->Evaluate(context).ToLocal(&result)) return; |
| modules_[name] = v8::Global<v8::Module>(isolate_.get(), module); |
| } |
| |
| // static |
| v8::MaybeLocal<v8::Module> IsolateData::ModuleResolveCallback( |
| v8::Local<v8::Context> context, v8::Local<v8::String> specifier, |
| v8::Local<v8::Module> referrer) { |
| IsolateData* data = IsolateData::FromContext(context); |
| std::string str = *v8::String::Utf8Value(data->isolate(), specifier); |
| return data->modules_[ToVector(specifier)].Get(data->isolate()); |
| } |
| |
| int IsolateData::ConnectSession(int context_group_id, |
| const v8_inspector::StringView& state, |
| v8_inspector::V8Inspector::Channel* channel) { |
| int session_id = ++last_session_id_; |
| sessions_[session_id] = inspector_->connect(context_group_id, channel, state); |
| context_group_by_session_[sessions_[session_id].get()] = context_group_id; |
| return session_id; |
| } |
| |
| std::unique_ptr<v8_inspector::StringBuffer> IsolateData::DisconnectSession( |
| int session_id) { |
| auto it = sessions_.find(session_id); |
| CHECK(it != sessions_.end()); |
| context_group_by_session_.erase(it->second.get()); |
| std::unique_ptr<v8_inspector::StringBuffer> result = it->second->stateJSON(); |
| sessions_.erase(it); |
| return result; |
| } |
| |
| void IsolateData::SendMessage(int session_id, |
| const v8_inspector::StringView& message) { |
| auto it = sessions_.find(session_id); |
| if (it != sessions_.end()) it->second->dispatchProtocolMessage(message); |
| } |
| |
| void IsolateData::BreakProgram(int context_group_id, |
| const v8_inspector::StringView& reason, |
| const v8_inspector::StringView& details) { |
| for (int session_id : GetSessionIds(context_group_id)) { |
| auto it = sessions_.find(session_id); |
| if (it != sessions_.end()) it->second->breakProgram(reason, details); |
| } |
| } |
| |
| void IsolateData::SchedulePauseOnNextStatement( |
| int context_group_id, const v8_inspector::StringView& reason, |
| const v8_inspector::StringView& details) { |
| for (int session_id : GetSessionIds(context_group_id)) { |
| auto it = sessions_.find(session_id); |
| if (it != sessions_.end()) |
| it->second->schedulePauseOnNextStatement(reason, details); |
| } |
| } |
| |
| void IsolateData::CancelPauseOnNextStatement(int context_group_id) { |
| for (int session_id : GetSessionIds(context_group_id)) { |
| auto it = sessions_.find(session_id); |
| if (it != sessions_.end()) it->second->cancelPauseOnNextStatement(); |
| } |
| } |
| |
| void IsolateData::AsyncTaskScheduled(const v8_inspector::StringView& name, |
| void* task, bool recurring) { |
| inspector_->asyncTaskScheduled(name, task, recurring); |
| } |
| |
| void IsolateData::AsyncTaskStarted(void* task) { |
| inspector_->asyncTaskStarted(task); |
| } |
| |
| void IsolateData::AsyncTaskFinished(void* task) { |
| inspector_->asyncTaskFinished(task); |
| } |
| |
| v8_inspector::V8StackTraceId IsolateData::StoreCurrentStackTrace( |
| const v8_inspector::StringView& description) { |
| return inspector_->storeCurrentStackTrace(description); |
| } |
| |
| void IsolateData::ExternalAsyncTaskStarted( |
| const v8_inspector::V8StackTraceId& parent) { |
| inspector_->externalAsyncTaskStarted(parent); |
| } |
| |
| void IsolateData::ExternalAsyncTaskFinished( |
| const v8_inspector::V8StackTraceId& parent) { |
| inspector_->externalAsyncTaskFinished(parent); |
| } |
| |
| void IsolateData::AddInspectedObject(int session_id, |
| v8::Local<v8::Value> object) { |
| auto it = sessions_.find(session_id); |
| if (it == sessions_.end()) return; |
| std::unique_ptr<Inspectable> inspectable( |
| new Inspectable(isolate_.get(), object)); |
| it->second->addInspectedObject(std::move(inspectable)); |
| } |
| |
| void IsolateData::SetMaxAsyncTaskStacksForTest(int limit) { |
| v8_inspector::SetMaxAsyncTaskStacksForTest(inspector_.get(), limit); |
| } |
| |
| void IsolateData::DumpAsyncTaskStacksStateForTest() { |
| v8_inspector::DumpAsyncTaskStacksStateForTest(inspector_.get()); |
| } |
| |
| // static |
| 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 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()); |
| |
| 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); |
| } |
| |
| void IsolateData::FireContextDestroyed(v8::Local<v8::Context> context) { |
| inspector_->contextDestroyed(context); |
| } |
| |
| void IsolateData::FreeContext(v8::Local<v8::Context> context) { |
| int context_group_id = GetContextGroupId(context); |
| auto it = contexts_.find(context_group_id); |
| if (it == contexts_.end()) return; |
| contexts_.erase(it); |
| } |
| |
| std::vector<int> IsolateData::GetSessionIds(int context_group_id) { |
| std::vector<int> result; |
| for (auto& it : sessions_) { |
| if (context_group_by_session_[it.second.get()] == context_group_id) |
| result.push_back(it.first); |
| } |
| return result; |
| } |
| |
| bool IsolateData::formatAccessorsAsProperties(v8::Local<v8::Value> object) { |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| v8::Local<v8::Context> context = isolate->GetCurrentContext(); |
| v8::Local<v8::Private> shouldFormatAccessorsPrivate = v8::Private::ForApi( |
| isolate, v8::String::NewFromUtf8(isolate, "allowAccessorFormatting", |
| v8::NewStringType::kNormal) |
| .ToLocalChecked()); |
| CHECK(object->IsObject()); |
| return object.As<v8::Object>() |
| ->HasPrivate(context, shouldFormatAccessorsPrivate) |
| .FromMaybe(false); |
| } |
| |
| bool IsolateData::isInspectableHeapObject(v8::Local<v8::Object> object) { |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| v8::Local<v8::Context> context = isolate->GetCurrentContext(); |
| v8::MicrotasksScope microtasks_scope( |
| isolate, v8::MicrotasksScope::kDoNotRunMicrotasks); |
| return !object->HasPrivate(context, not_inspectable_private_.Get(isolate)) |
| .FromMaybe(false); |
| } |
| |
| v8::Local<v8::Context> IsolateData::ensureDefaultContextInGroup( |
| int context_group_id) { |
| return GetContext(context_group_id); |
| } |
| |
| void IsolateData::SetCurrentTimeMS(double time) { |
| current_time_ = time; |
| current_time_set_ = true; |
| } |
| |
| double IsolateData::currentTimeMS() { |
| if (current_time_set_) return current_time_; |
| return v8::internal::V8::GetCurrentPlatform()->CurrentClockTimeMillis(); |
| } |
| |
| void IsolateData::SetMemoryInfo(v8::Local<v8::Value> memory_info) { |
| memory_info_.Reset(isolate_.get(), memory_info); |
| } |
| |
| void IsolateData::SetLogConsoleApiMessageCalls(bool log) { |
| log_console_api_message_calls_ = log; |
| } |
| |
| void IsolateData::SetLogMaxAsyncCallStackDepthChanged(bool log) { |
| log_max_async_call_stack_depth_changed_ = log; |
| } |
| |
| v8::MaybeLocal<v8::Value> IsolateData::memoryInfo(v8::Isolate* isolate, |
| v8::Local<v8::Context>) { |
| if (memory_info_.IsEmpty()) return v8::MaybeLocal<v8::Value>(); |
| return memory_info_.Get(isolate); |
| } |
| |
| void IsolateData::runMessageLoopOnPause(int) { |
| task_runner_->RunMessageLoop(true); |
| } |
| |
| void IsolateData::quitMessageLoopOnPause() { task_runner_->QuitMessageLoop(); } |
| |
| void IsolateData::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_.get(), message); |
| fprintf(stdout, " ("); |
| Print(isolate_.get(), url); |
| fprintf(stdout, ":%d:%d)", lineNumber, columnNumber); |
| Print(isolate_.get(), stack->toString()->string()); |
| fprintf(stdout, "\n"); |
| } |
| |
| void IsolateData::maxAsyncCallStackDepthChanged(int depth) { |
| if (!log_max_async_call_stack_depth_changed_) return; |
| fprintf(stdout, "maxAsyncCallStackDepthChanged: %d\n", depth); |
| } |