blob: f9b4733286f63244312ec39727baedf9636d41e6 [file] [log] [blame]
// Copyright 2018 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "cobalt/script/v8c/v8c_script_debugger.h"
#include <memory>
#include <sstream>
#include <string>
#include <utility>
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/base/polymorphic_downcast.h"
#include "cobalt/script/v8c/conversion_helpers.h"
#include "cobalt/script/v8c/v8c_tracing_controller.h"
#include "include/inspector/Runtime.h" // generated
#include "v8/include/libplatform/v8-tracing.h"
#include "v8/include/v8-inspector.h"
#include "v8/third_party/inspector_protocol/crdtp/json.h"
#include "v8/third_party/inspector_protocol/crdtp/protocol_core.h"
namespace v8_crdtp {
template <typename T>
struct ProtocolTypeTraits<
std::unique_ptr<T>,
typename std::enable_if<
std::is_base_of<v8_inspector::protocol::Exported, T>::value>::type> {
static bool Deserialize(DeserializerState* state, std::unique_ptr<T>* value) {
if (state->tokenizer()->TokenTag() != cbor::CBORTokenTag::ENVELOPE) {
state->RegisterError(Error::CBOR_INVALID_ENVELOPE);
return false;
}
span<uint8_t> env = state->tokenizer()->GetEnvelope();
auto res = T::fromBinary(env.data(), env.size());
if (!res) {
// TODO(caseq): properly plumb an error rather than returning a bogus
// code.
state->RegisterError(Error::MESSAGE_MUST_BE_AN_OBJECT);
return false;
}
*value = std::move(res);
return true;
}
static void Serialize(const std::unique_ptr<T>& value,
std::vector<uint8_t>* bytes) {
// Use virtual method, so that outgoing protocol objects could be retained
// by a pointer to ProtocolObject.
value->AppendSerialized(bytes);
}
};
template <typename T>
struct ProtocolTypeTraits<
T, typename std::enable_if<
std::is_base_of<v8_inspector::protocol::Exported, T>::value>::type> {
static void Serialize(const T& value, std::vector<uint8_t>* bytes) {
// Use virtual method, so that outgoing protocol objects could be retained
// by a pointer to ProtocolObject.
value.AppendSerialized(bytes);
}
};
} // namespace v8_crdtp
namespace cobalt {
namespace script {
namespace v8c {
namespace {
constexpr const char* kInspectorDomains[] = {
"Runtime",
"Debugger",
"Profiler",
};
constexpr int kContextGroupId = 1;
constexpr char kContextName[] = "Cobalt";
V8cTracingController* GetTracingController() {
return base::polymorphic_downcast<V8cTracingController*>(
IsolateFellowship::GetInstance()->platform->GetTracingController());
}
// Inspired by |CopyCharsUnsigned| in v8/src/utils.h
std::string FromStringView(const v8_inspector::StringView& string_view) {
std::string string;
if (string_view.is8Bit()) {
string.assign(reinterpret_cast<const char*>(string_view.characters8()),
string_view.length());
} else {
string.reserve(string_view.length());
const uint16_t* chars =
reinterpret_cast<const uint16_t*>(string_view.characters16());
for (int i = 0; i < string_view.length(); i++) {
string += chars[i];
}
}
return string;
}
v8_inspector::StringView ToStringView(const std::string& string) {
return v8_inspector::StringView(
reinterpret_cast<const uint8_t*>(string.c_str()), string.length());
}
} // namespace
V8cScriptDebugger::V8cScriptDebugger(
V8cGlobalEnvironment* v8c_global_environment, Delegate* delegate)
: global_environment_(v8c_global_environment),
delegate_(delegate),
supported_domains_(std::begin(kInspectorDomains),
std::end(kInspectorDomains)),
ALLOW_THIS_IN_INITIALIZER_LIST(
inspector_(v8_inspector::V8Inspector::create(
global_environment_->isolate(), /* client */ this))),
pause_on_exception_state_(kAll) {
// Register our one-and-only context with the inspector.
v8::Isolate* isolate = global_environment_->isolate();
EntryScope entry_scope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
inspector_->contextCreated(v8_inspector::V8ContextInfo(
context, kContextGroupId,
v8_inspector::StringView(reinterpret_cast<const uint8_t*>(kContextName),
sizeof(kContextName) - 1)));
}
void V8cScriptDebugger::Attach(const std::string& state) {
DCHECK(!inspector_session_);
inspector_session_ =
inspector_->connect(kContextGroupId, this, ToStringView(state));
}
std::string V8cScriptDebugger::Detach() {
// First inform the inspector that the context is destroyed. This will send
// an event to inform the DevTools frontend just before we kill the session.
v8::Isolate* isolate = global_environment_->isolate();
EntryScope entry_scope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
inspector_->contextDestroyed(context);
// After the frontend knows the context is destroyed we can kill the session.
// If/when we re-attach we'll connect a new session and the V8 inspector will
// then inform the frontend about the sources, etc. in the new context.
DCHECK(inspector_session_);
std::vector<uint8_t> state = inspector_session_->state();
inspector_session_.reset();
std::string state_str;
// TODO: there might be an opportunity to utilize the already encoded json to
// reduce network traffic size on the wire.
v8_crdtp::Status status = v8_crdtp::json::ConvertCBORToJSON(
v8_crdtp::span<uint8_t>(state.data(), state.size()), &state_str);
CHECK(status.ok()) << status.Message();
return state_str;
}
bool V8cScriptDebugger::EvaluateDebuggerScript(const std::string& js_code,
std::string* out_result_utf8) {
TRACE_EVENT0("cobalt::script", "V8cScriptDebugger::EvaluateDebuggerScript()");
v8::Isolate* isolate = global_environment_->isolate();
EntryScope entry_scope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
v8::TryCatch try_catch(isolate);
v8::MicrotasksScope microtasksScope(isolate,
v8::MicrotasksScope::kDoNotRunMicrotasks);
v8::Local<v8::String> source;
if (!v8::String::NewFromUtf8(isolate, js_code.c_str(),
v8::NewStringType::kNormal, js_code.length())
.ToLocal(&source)) {
LOG(ERROR) << "Failed to convert source code to V8 UTF-8 string.";
return false;
}
v8::Local<v8::Value> result;
if (!inspector_->compileAndRunInternalScript(context, source)
.ToLocal(&result)) {
v8::String::Utf8Value exception(isolate, try_catch.Exception());
std::string string(*exception, exception.length());
if (string.empty()) string.assign("Unknown error");
LOG(ERROR) << "Debugger script error: " << string;
if (out_result_utf8) {
out_result_utf8->assign(std::move(string));
}
return false;
}
if (out_result_utf8) {
V8cExceptionState exception_state(isolate);
FromJSValue(isolate, result, kNoConversionFlags, &exception_state,
out_result_utf8);
}
return true;
}
ScriptDebugger::PauseOnExceptionsState V8cScriptDebugger::SetPauseOnExceptions(
ScriptDebugger::PauseOnExceptionsState state) {
DCHECK(inspector_session_);
auto previous_state = pause_on_exception_state_;
pause_on_exception_state_ = state;
inspector_session_->setSkipAllPauses(state == kNone);
return previous_state;
}
bool V8cScriptDebugger::DispatchProtocolMessage(const std::string& method,
const std::string& message) {
DCHECK(inspector_session_);
if (!inspector_session_->canDispatchMethod(ToStringView(method))) {
return false;
}
inspector_session_->dispatchProtocolMessage(v8_inspector::StringView(
reinterpret_cast<const uint8_t*>(message.c_str()), message.length()));
return true;
}
std::string V8cScriptDebugger::CreateRemoteObject(
const ValueHandleHolder& object, const std::string& group) {
DCHECK(inspector_session_);
const V8cValueHandleHolder* v8_value_handle_holder =
base::polymorphic_downcast<const V8cValueHandleHolder*>(&object);
v8::Isolate* isolate = v8_value_handle_holder->isolate();
EntryScope entry_scope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
v8::Local<v8::Value> v8_value = v8_value_handle_holder->v8_value();
std::unique_ptr<v8_inspector::protocol::Runtime::API::RemoteObject>
remote_object = inspector_session_->wrapObject(
context, v8_value, ToStringView(group), false /*generatePreview*/);
std::vector<uint8_t> out;
remote_object->AppendSerialized(&out);
std::string remote_object_str;
v8_crdtp::Status status = v8_crdtp::json::ConvertCBORToJSON(
v8_crdtp::span<uint8_t>(out.data(), out.size()), &remote_object_str);
CHECK(status.ok()) << status.Message();
return remote_object_str;
}
const script::ValueHandleHolder* V8cScriptDebugger::LookupRemoteObjectId(
const std::string& object_id) {
DCHECK(inspector_session_);
v8::Isolate* isolate = global_environment_->isolate();
EntryScope entry_scope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
V8cExceptionState exception_state(isolate);
std::unique_ptr<v8_inspector::StringBuffer> error;
v8::Local<v8::Value> v8_value;
if (!inspector_session_->unwrapObject(&error, ToStringView(object_id),
&v8_value, &context,
nullptr /*objectGroup*/)) {
std::string err_string = FromStringView(error->string());
exception_state.SetSimpleException(kRangeError, "%s", err_string.c_str());
return nullptr;
}
std::unique_ptr<V8cValueHandleHolder> holder(new V8cValueHandleHolder());
FromJSValue(isolate, v8_value, 0 /*conversion_flags*/, &exception_state,
holder.get());
V8cValueHandleHolder* retval = holder.get();
// Keep the scoped_ptr alive in a no-op task so the holder stays valid until
// the bindings code gets the v8::Value out of it through the raw pointer.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind([](std::unique_ptr<V8cValueHandleHolder>) {},
base::Passed(&holder)));
return retval;
}
void V8cScriptDebugger::StartTracing(const std::vector<std::string>& categories,
TraceDelegate* trace_delegate) {
V8cTracingController* tracing_controller = GetTracingController();
CHECK(tracing_controller);
tracing_controller->StartTracing(categories, trace_delegate);
}
void V8cScriptDebugger::StopTracing() {
V8cTracingController* tracing_controller = GetTracingController();
CHECK(tracing_controller);
tracing_controller->StopTracing();
}
void V8cScriptDebugger::AsyncTaskScheduled(const void* task,
const std::string& name,
bool recurring) {
inspector_->asyncTaskScheduled(ToStringView(name), const_cast<void*>(task),
recurring);
}
void V8cScriptDebugger::AsyncTaskStarted(const void* task) {
inspector_->asyncTaskStarted(const_cast<void*>(task));
}
void V8cScriptDebugger::AsyncTaskFinished(const void* task) {
inspector_->asyncTaskFinished(const_cast<void*>(task));
}
void V8cScriptDebugger::AsyncTaskCanceled(const void* task) {
inspector_->asyncTaskCanceled(const_cast<void*>(task));
}
void V8cScriptDebugger::AllAsyncTasksCanceled() {
inspector_->allAsyncTasksCanceled();
}
// v8_inspector::V8InspectorClient implementation.
void V8cScriptDebugger::runMessageLoopOnPause(int contextGroupId) {
DCHECK(contextGroupId == kContextGroupId);
delegate_->OnScriptDebuggerPause();
}
// v8_inspector::V8InspectorClient implementation.
void V8cScriptDebugger::quitMessageLoopOnPause() {
delegate_->OnScriptDebuggerResume();
}
// v8_inspector::V8InspectorClient implementation.
void V8cScriptDebugger::runIfWaitingForDebugger(int contextGroupId) {
delegate_->OnScriptDebuggerResume();
}
// v8_inspector::V8InspectorClient implementation.
std::unique_ptr<v8_inspector::StringBuffer> V8cScriptDebugger::valueSubtype(
v8::Local<v8::Value> value) {
if (value->IsNullOrUndefined() || !value->IsObject()) {
return nullptr;
}
v8::Local<v8::Object> object = value.As<v8::Object>();
if (!WrapperPrivate::HasWrapperPrivate(object)) {
return nullptr;
}
WrapperPrivate* wrapper_private =
WrapperPrivate::GetFromWrapperObject(object);
DCHECK(wrapper_private);
Wrappable::JSObjectType type =
wrapper_private->raw_wrappable()->GetJSObjectType();
if (type == Wrappable::JSObjectType::kNode) {
return v8_inspector::StringBuffer::create(ToStringView("node"));
} else if (type == Wrappable::JSObjectType::kArray) {
return v8_inspector::StringBuffer::create(ToStringView("array"));
} else if (type == Wrappable::JSObjectType::kError) {
return v8_inspector::StringBuffer::create(ToStringView("error"));
} else if (type == Wrappable::JSObjectType::kBlob) {
return v8_inspector::StringBuffer::create(ToStringView("blob"));
}
return nullptr;
}
// v8_inspector::V8InspectorClient implementation.
void V8cScriptDebugger::consoleAPIMessage(
int contextGroupId, v8::Isolate::MessageErrorLevel level,
const v8_inspector::StringView& message,
const v8_inspector::StringView& url, unsigned lineNumber,
unsigned columnNumber, v8_inspector::V8StackTrace* trace) {
std::string source;
if (url.length()) {
std::ostringstream oss;
oss << ": " << FromStringView(url) << ", Line " << lineNumber << ", Col "
<< columnNumber;
source = oss.str();
}
std::string msg(FromStringView(message));
switch (level) {
case v8::Isolate::kMessageLog:
LOG(INFO) << "[console.log()" << source << "] " << msg;
break;
case v8::Isolate::kMessageDebug:
LOG(INFO) << "[console.debug()" << source << "] " << msg;
break;
case v8::Isolate::kMessageInfo:
LOG(INFO) << "[console.info()" << source << "] " << msg;
break;
case v8::Isolate::kMessageError:
LOG(ERROR) << "[console.error()" << source << "] " << msg;
break;
case v8::Isolate::kMessageWarning:
LOG(WARNING) << "[console.warn()" << source << "] " << msg;
break;
case v8::Isolate::kMessageAll:
NOTIMPLEMENTED() << "Invalid MessageErrorLevel";
break;
}
}
// v8_inspector::V8InspectorClient implementation.
v8::Local<v8::Context> V8cScriptDebugger::ensureDefaultContextInGroup(
int contextGroupId) {
v8::Isolate* isolate = global_environment_->isolate();
EntryScope entry_scope(isolate);
if (contextGroupId == kContextGroupId) {
return isolate->GetCurrentContext();
}
DLOG(WARNING) << "No default context for group " << contextGroupId;
return v8::Local<v8::Context>();
}
// v8_inspector::V8Inspector::Channel implementation.
void V8cScriptDebugger::sendResponse(
int callId, std::unique_ptr<v8_inspector::StringBuffer> message) {
std::string response = FromStringView(message->string());
delegate_->OnScriptDebuggerResponse(response);
}
// v8_inspector::V8Inspector::Channel implementation.
void V8cScriptDebugger::sendNotification(
std::unique_ptr<v8_inspector::StringBuffer> message) {
std::string event = FromStringView(message->string());
delegate_->OnScriptDebuggerEvent(event);
}
} // namespace v8c
// Static factory method declared in public interface.
std::unique_ptr<ScriptDebugger> ScriptDebugger::CreateDebugger(
GlobalEnvironment* global_environment, Delegate* delegate) {
auto* v8c_global_environment =
base::polymorphic_downcast<v8c::V8cGlobalEnvironment*>(
global_environment);
return std::unique_ptr<ScriptDebugger>(
new v8c::V8cScriptDebugger(v8c_global_environment, delegate));
}
} // namespace script
} // namespace cobalt