| // Copyright 2015 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 "src/inspector/v8-injected-script-host.h" |
| |
| #include "src/base/macros.h" |
| #include "src/debug/debug-interface.h" |
| #include "src/inspector/injected-script.h" |
| #include "src/inspector/string-util.h" |
| #include "src/inspector/v8-debugger.h" |
| #include "src/inspector/v8-inspector-impl.h" |
| #include "src/inspector/v8-internal-value-type.h" |
| #include "src/inspector/v8-value-utils.h" |
| |
| #include "include/v8-inspector.h" |
| |
| namespace v8_inspector { |
| |
| namespace { |
| |
| void setFunctionProperty(v8::Local<v8::Context> context, |
| v8::Local<v8::Object> obj, const char* name, |
| v8::FunctionCallback callback, |
| v8::Local<v8::External> external) { |
| v8::Local<v8::String> funcName = |
| toV8StringInternalized(context->GetIsolate(), name); |
| v8::Local<v8::Function> func; |
| if (!v8::Function::New(context, callback, external, 0, |
| v8::ConstructorBehavior::kThrow) |
| .ToLocal(&func)) |
| return; |
| func->SetName(funcName); |
| createDataProperty(context, obj, funcName, func); |
| } |
| |
| V8InspectorImpl* unwrapInspector( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| DCHECK(!info.Data().IsEmpty()); |
| DCHECK(info.Data()->IsExternal()); |
| V8InspectorImpl* inspector = |
| static_cast<V8InspectorImpl*>(info.Data().As<v8::External>()->Value()); |
| DCHECK(inspector); |
| return inspector; |
| } |
| |
| template <typename TypedArray> |
| void addTypedArrayProperty(std::vector<v8::Local<v8::Value>>* props, |
| v8::Isolate* isolate, |
| v8::Local<v8::ArrayBuffer> arraybuffer, |
| String16 name, size_t length) { |
| props->push_back(toV8String(isolate, name)); |
| props->push_back(TypedArray::New(arraybuffer, 0, length)); |
| } |
| |
| } // namespace |
| |
| v8::Local<v8::Object> V8InjectedScriptHost::create( |
| v8::Local<v8::Context> context, V8InspectorImpl* inspector) { |
| v8::Isolate* isolate = inspector->isolate(); |
| v8::Local<v8::Object> injectedScriptHost = v8::Object::New(isolate); |
| bool success = injectedScriptHost->SetPrototype(context, v8::Null(isolate)) |
| .FromMaybe(false); |
| DCHECK(success); |
| USE(success); |
| v8::Local<v8::External> debuggerExternal = |
| v8::External::New(isolate, inspector); |
| setFunctionProperty(context, injectedScriptHost, "nullifyPrototype", |
| V8InjectedScriptHost::nullifyPrototypeCallback, |
| debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "getProperty", |
| V8InjectedScriptHost::getPropertyCallback, |
| debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "internalConstructorName", |
| V8InjectedScriptHost::internalConstructorNameCallback, |
| debuggerExternal); |
| setFunctionProperty( |
| context, injectedScriptHost, "formatAccessorsAsProperties", |
| V8InjectedScriptHost::formatAccessorsAsProperties, debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "subtype", |
| V8InjectedScriptHost::subtypeCallback, debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "getInternalProperties", |
| V8InjectedScriptHost::getInternalPropertiesCallback, |
| debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "objectHasOwnProperty", |
| V8InjectedScriptHost::objectHasOwnPropertyCallback, |
| debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "bind", |
| V8InjectedScriptHost::bindCallback, debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "proxyTargetValue", |
| V8InjectedScriptHost::proxyTargetValueCallback, |
| debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "nativeAccessorDescriptor", |
| V8InjectedScriptHost::nativeAccessorDescriptorCallback, |
| debuggerExternal); |
| setFunctionProperty(context, injectedScriptHost, "typedArrayProperties", |
| V8InjectedScriptHost::typedArrayPropertiesCallback, |
| debuggerExternal); |
| createDataProperty(context, injectedScriptHost, |
| toV8StringInternalized(isolate, "keys"), |
| v8::debug::GetBuiltin(isolate, v8::debug::kObjectKeys)); |
| createDataProperty( |
| context, injectedScriptHost, |
| toV8StringInternalized(isolate, "getPrototypeOf"), |
| v8::debug::GetBuiltin(isolate, v8::debug::kObjectGetPrototypeOf)); |
| createDataProperty( |
| context, injectedScriptHost, |
| toV8StringInternalized(isolate, "getOwnPropertyDescriptor"), |
| v8::debug::GetBuiltin(isolate, |
| v8::debug::kObjectGetOwnPropertyDescriptor)); |
| createDataProperty( |
| context, injectedScriptHost, |
| toV8StringInternalized(isolate, "getOwnPropertyNames"), |
| v8::debug::GetBuiltin(isolate, v8::debug::kObjectGetOwnPropertyNames)); |
| createDataProperty( |
| context, injectedScriptHost, |
| toV8StringInternalized(isolate, "getOwnPropertySymbols"), |
| v8::debug::GetBuiltin(isolate, v8::debug::kObjectGetOwnPropertySymbols)); |
| return injectedScriptHost; |
| } |
| |
| void V8InjectedScriptHost::nullifyPrototypeCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| CHECK_EQ(1, info.Length()); |
| DCHECK(info[0]->IsObject()); |
| if (!info[0]->IsObject()) return; |
| v8::Isolate* isolate = info.GetIsolate(); |
| info[0] |
| .As<v8::Object>() |
| ->SetPrototype(isolate->GetCurrentContext(), v8::Null(isolate)) |
| .ToChecked(); |
| } |
| |
| void V8InjectedScriptHost::getPropertyCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| CHECK(info.Length() == 2 && info[1]->IsString()); |
| if (!info[0]->IsObject()) return; |
| v8::Isolate* isolate = info.GetIsolate(); |
| v8::Local<v8::Context> context = isolate->GetCurrentContext(); |
| v8::TryCatch tryCatch(isolate); |
| v8::Isolate::DisallowJavascriptExecutionScope throwJs( |
| isolate, v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE); |
| v8::Local<v8::Value> property; |
| if (info[0] |
| .As<v8::Object>() |
| ->Get(context, v8::Local<v8::String>::Cast(info[1])) |
| .ToLocal(&property)) { |
| info.GetReturnValue().Set(property); |
| } |
| } |
| |
| void V8InjectedScriptHost::internalConstructorNameCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| if (info.Length() < 1 || !info[0]->IsObject()) return; |
| |
| v8::Local<v8::Object> object = info[0].As<v8::Object>(); |
| info.GetReturnValue().Set(object->GetConstructorName()); |
| } |
| |
| void V8InjectedScriptHost::formatAccessorsAsProperties( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| DCHECK_EQ(info.Length(), 2); |
| info.GetReturnValue().Set(false); |
| if (!info[1]->IsFunction()) return; |
| // Check that function is user-defined. |
| if (info[1].As<v8::Function>()->ScriptId() != v8::UnboundScript::kNoScriptId) |
| return; |
| info.GetReturnValue().Set( |
| unwrapInspector(info)->client()->formatAccessorsAsProperties(info[0])); |
| } |
| |
| void V8InjectedScriptHost::subtypeCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| if (info.Length() < 1) return; |
| |
| v8::Isolate* isolate = info.GetIsolate(); |
| v8::Local<v8::Value> value = info[0]; |
| if (value->IsObject()) { |
| v8::Local<v8::Value> internalType = v8InternalValueTypeFrom( |
| isolate->GetCurrentContext(), v8::Local<v8::Object>::Cast(value)); |
| if (internalType->IsString()) { |
| info.GetReturnValue().Set(internalType); |
| return; |
| } |
| } |
| if (value->IsArray() || value->IsArgumentsObject()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "array")); |
| return; |
| } |
| if (value->IsTypedArray()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "typedarray")); |
| return; |
| } |
| if (value->IsDate()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "date")); |
| return; |
| } |
| if (value->IsRegExp()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "regexp")); |
| return; |
| } |
| if (value->IsMap()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "map")); |
| return; |
| } |
| if (value->IsWeakMap()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "weakmap")); |
| return; |
| } |
| if (value->IsSet()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "set")); |
| return; |
| } |
| if (value->IsWeakSet()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "weakset")); |
| return; |
| } |
| if (value->IsMapIterator() || value->IsSetIterator()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "iterator")); |
| return; |
| } |
| if (value->IsGeneratorObject()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "generator")); |
| return; |
| } |
| if (value->IsNativeError()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "error")); |
| return; |
| } |
| if (value->IsProxy()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "proxy")); |
| return; |
| } |
| if (value->IsPromise()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "promise")); |
| return; |
| } |
| if (value->IsArrayBuffer() || value->IsSharedArrayBuffer()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "arraybuffer")); |
| return; |
| } |
| if (value->IsDataView()) { |
| info.GetReturnValue().Set(toV8StringInternalized(isolate, "dataview")); |
| return; |
| } |
| std::unique_ptr<StringBuffer> subtype = |
| unwrapInspector(info)->client()->valueSubtype(value); |
| if (subtype) { |
| info.GetReturnValue().Set(toV8String(isolate, subtype->string())); |
| return; |
| } |
| } |
| |
| void V8InjectedScriptHost::getInternalPropertiesCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| if (info.Length() < 1) return; |
| |
| std::unordered_set<String16> allowedProperties; |
| if (info[0]->IsBooleanObject() || info[0]->IsNumberObject() || |
| info[0]->IsStringObject() || info[0]->IsSymbolObject()) { |
| allowedProperties.insert(String16("[[PrimitiveValue]]")); |
| } else if (info[0]->IsPromise()) { |
| allowedProperties.insert(String16("[[PromiseStatus]]")); |
| allowedProperties.insert(String16("[[PromiseValue]]")); |
| } else if (info[0]->IsGeneratorObject()) { |
| allowedProperties.insert(String16("[[GeneratorStatus]]")); |
| } else if (info[0]->IsMap() || info[0]->IsWeakMap() || info[0]->IsSet() || |
| info[0]->IsWeakSet() || info[0]->IsMapIterator() || |
| info[0]->IsSetIterator()) { |
| allowedProperties.insert(String16("[[Entries]]")); |
| } |
| if (!allowedProperties.size()) return; |
| |
| v8::Isolate* isolate = info.GetIsolate(); |
| v8::Local<v8::Array> allProperties; |
| if (!unwrapInspector(info) |
| ->debugger() |
| ->internalProperties(isolate->GetCurrentContext(), info[0]) |
| .ToLocal(&allProperties) || |
| !allProperties->IsArray() || allProperties->Length() % 2 != 0) |
| return; |
| |
| { |
| v8::Local<v8::Context> context = isolate->GetCurrentContext(); |
| v8::TryCatch tryCatch(isolate); |
| v8::Isolate::DisallowJavascriptExecutionScope throwJs( |
| isolate, |
| v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE); |
| |
| v8::Local<v8::Array> properties = v8::Array::New(isolate); |
| if (tryCatch.HasCaught()) return; |
| |
| uint32_t outputIndex = 0; |
| for (uint32_t i = 0; i < allProperties->Length(); i += 2) { |
| v8::Local<v8::Value> key; |
| if (!allProperties->Get(context, i).ToLocal(&key)) continue; |
| if (tryCatch.HasCaught()) { |
| tryCatch.Reset(); |
| continue; |
| } |
| String16 keyString = toProtocolStringWithTypeCheck(key); |
| if (keyString.isEmpty() || |
| allowedProperties.find(keyString) == allowedProperties.end()) |
| continue; |
| v8::Local<v8::Value> value; |
| if (!allProperties->Get(context, i + 1).ToLocal(&value)) continue; |
| if (tryCatch.HasCaught()) { |
| tryCatch.Reset(); |
| continue; |
| } |
| createDataProperty(context, properties, outputIndex++, key); |
| createDataProperty(context, properties, outputIndex++, value); |
| } |
| info.GetReturnValue().Set(properties); |
| } |
| } |
| |
| void V8InjectedScriptHost::objectHasOwnPropertyCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| if (info.Length() < 2 || !info[0]->IsObject() || !info[1]->IsString()) return; |
| bool result = info[0] |
| .As<v8::Object>() |
| ->HasOwnProperty(info.GetIsolate()->GetCurrentContext(), |
| v8::Local<v8::String>::Cast(info[1])) |
| .FromMaybe(false); |
| info.GetReturnValue().Set(v8::Boolean::New(info.GetIsolate(), result)); |
| } |
| |
| void V8InjectedScriptHost::bindCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| if (info.Length() < 2 || !info[1]->IsString()) return; |
| InjectedScript* injectedScript = |
| InjectedScript::fromInjectedScriptHost(info.GetIsolate(), info.Holder()); |
| if (!injectedScript) return; |
| |
| v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext(); |
| v8::Local<v8::String> v8groupName = |
| info[1]->ToString(context).ToLocalChecked(); |
| String16 groupName = toProtocolStringWithTypeCheck(v8groupName); |
| int id = injectedScript->bindObject(info[0], groupName); |
| info.GetReturnValue().Set(id); |
| } |
| |
| void V8InjectedScriptHost::proxyTargetValueCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| if (info.Length() != 1 || !info[0]->IsProxy()) { |
| UNREACHABLE(); |
| return; |
| } |
| v8::Local<v8::Value> target = info[0].As<v8::Proxy>(); |
| while (target->IsProxy()) |
| target = v8::Local<v8::Proxy>::Cast(target)->GetTarget(); |
| info.GetReturnValue().Set(target); |
| } |
| |
| void V8InjectedScriptHost::nativeAccessorDescriptorCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| v8::Isolate* isolate = info.GetIsolate(); |
| if (info.Length() != 2 || !info[0]->IsObject() || !info[1]->IsName()) { |
| info.GetReturnValue().Set(v8::Undefined(isolate)); |
| return; |
| } |
| v8::Local<v8::Context> context = isolate->GetCurrentContext(); |
| int flags = v8::debug::GetNativeAccessorDescriptor( |
| context, v8::Local<v8::Object>::Cast(info[0]), |
| v8::Local<v8::Name>::Cast(info[1])); |
| if (flags == static_cast<int>(v8::debug::NativeAccessorType::None)) { |
| info.GetReturnValue().Set(v8::Undefined(isolate)); |
| return; |
| } |
| |
| bool isBuiltin = |
| flags & static_cast<int>(v8::debug::NativeAccessorType::IsBuiltin); |
| bool hasGetter = |
| flags & static_cast<int>(v8::debug::NativeAccessorType::HasGetter); |
| bool hasSetter = |
| flags & static_cast<int>(v8::debug::NativeAccessorType::HasSetter); |
| v8::Local<v8::Object> result = v8::Object::New(isolate); |
| result->SetPrototype(context, v8::Null(isolate)).ToChecked(); |
| createDataProperty(context, result, toV8String(isolate, "isBuiltin"), |
| v8::Boolean::New(isolate, isBuiltin)); |
| createDataProperty(context, result, toV8String(isolate, "hasGetter"), |
| v8::Boolean::New(isolate, hasGetter)); |
| createDataProperty(context, result, toV8String(isolate, "hasSetter"), |
| v8::Boolean::New(isolate, hasSetter)); |
| info.GetReturnValue().Set(result); |
| } |
| |
| void V8InjectedScriptHost::typedArrayPropertiesCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| v8::Isolate* isolate = info.GetIsolate(); |
| if (info.Length() != 1 || !info[0]->IsArrayBuffer()) return; |
| |
| v8::TryCatch tryCatch(isolate); |
| v8::Isolate::DisallowJavascriptExecutionScope throwJs( |
| isolate, v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE); |
| v8::Local<v8::ArrayBuffer> arrayBuffer = info[0].As<v8::ArrayBuffer>(); |
| size_t length = arrayBuffer->ByteLength(); |
| if (length == 0) return; |
| std::vector<v8::Local<v8::Value>> arrays_vector; |
| addTypedArrayProperty<v8::Int8Array>(&arrays_vector, isolate, arrayBuffer, |
| "[[Int8Array]]", length); |
| addTypedArrayProperty<v8::Uint8Array>(&arrays_vector, isolate, arrayBuffer, |
| "[[Uint8Array]]", length); |
| |
| if (length % 2 == 0) { |
| addTypedArrayProperty<v8::Int16Array>(&arrays_vector, isolate, arrayBuffer, |
| "[[Int16Array]]", length / 2); |
| } |
| if (length % 4 == 0) { |
| addTypedArrayProperty<v8::Int32Array>(&arrays_vector, isolate, arrayBuffer, |
| "[[Int32Array]]", length / 4); |
| } |
| |
| if (tryCatch.HasCaught()) return; |
| v8::Local<v8::Context> context = isolate->GetCurrentContext(); |
| v8::Local<v8::Array> arrays = |
| v8::Array::New(isolate, static_cast<uint32_t>(arrays_vector.size())); |
| for (uint32_t i = 0; i < static_cast<uint32_t>(arrays_vector.size()); i++) |
| createDataProperty(context, arrays, i, arrays_vector[i]); |
| if (tryCatch.HasCaught()) return; |
| info.GetReturnValue().Set(arrays); |
| } |
| |
| } // namespace v8_inspector |
