third_party/WebKit/Source/platform/v8_inspector/InjectedScript.cpp - Issue 2295913003: [DevTools] Switch from platform/v8_inspector to v8/v8-inspector.h.

Unified Diff: third_party/WebKit/Source/platform/v8_inspector/InjectedScript.cpp

Issue 2295913003: [DevTools] Switch from platform/v8_inspector to v8/v8-inspector.h. (Closed)

Patch Set: rebase Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« no previous file with comments | « third_party/WebKit/Source/platform/v8_inspector/InjectedScript.h ('k') | third_party/WebKit/Source/platform/v8_inspector/InjectedScriptNative.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: third_party/WebKit/Source/platform/v8_inspector/InjectedScript.cpp

diff --git a/third_party/WebKit/Source/platform/v8_inspector/InjectedScript.cpp b/third_party/WebKit/Source/platform/v8_inspector/InjectedScript.cpp

deleted file mode 100644

index 1a106c8af2d152f2d8242e59e91748d96c7367ef..0000000000000000000000000000000000000000

--- a/third_party/WebKit/Source/platform/v8_inspector/InjectedScript.cpp

+++ /dev/null

@@ -1,504 +0,0 @@

-/*

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions are

- * met:

- *

- * * Redistributions of source code must retain the above copyright

- * notice, this list of conditions and the following disclaimer.

- * * Redistributions in binary form must reproduce the above

- * copyright notice, this list of conditions and the following disclaimer

- * in the documentation and/or other materials provided with the

- * distribution.

- * * Neither the name of Google Inc. nor the names of its

- * contributors may be used to endorse or promote products derived from

- * this software without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- */

-#include "platform/v8_inspector/InjectedScript.h"

-#include "platform/v8_inspector/InjectedScriptNative.h"

-#include "platform/v8_inspector/InjectedScriptSource.h"

-#include "platform/v8_inspector/InspectedContext.h"

-#include "platform/v8_inspector/RemoteObjectId.h"

-#include "platform/v8_inspector/StringUtil.h"

-#include "platform/v8_inspector/V8Compat.h"

-#include "platform/v8_inspector/V8Console.h"

-#include "platform/v8_inspector/V8FunctionCall.h"

-#include "platform/v8_inspector/V8InjectedScriptHost.h"

-#include "platform/v8_inspector/V8InspectorImpl.h"

-#include "platform/v8_inspector/V8InspectorSessionImpl.h"

-#include "platform/v8_inspector/V8StackTraceImpl.h"

-#include "platform/v8_inspector/V8ValueCopier.h"

-#include "platform/v8_inspector/protocol/Protocol.h"

-#include "platform/v8_inspector/public/V8InspectorClient.h"

-namespace v8_inspector {

-using protocol::Array;

-using protocol::Runtime::PropertyDescriptor;

-using protocol::Runtime::InternalPropertyDescriptor;

-using protocol::Runtime::RemoteObject;

-using protocol::Maybe;

-static bool hasInternalError(ErrorString* errorString, bool hasError)

- if (hasError)

- *errorString = "Internal error";

- return hasError;

-std::unique_ptr<InjectedScript> InjectedScript::create(InspectedContext* inspectedContext)

- v8::Isolate* isolate = inspectedContext->isolate();

- v8::HandleScope handles(isolate);

- v8::Local<v8::Context> context = inspectedContext->context();

- v8::Context::Scope scope(context);

- std::unique_ptr<InjectedScriptNative> injectedScriptNative(new InjectedScriptNative(isolate));

- v8::Local<v8::Object> scriptHostWrapper = V8InjectedScriptHost::create(context, inspectedContext->inspector());

- injectedScriptNative->setOnInjectedScriptHost(scriptHostWrapper);

- // Inject javascript into the context. The compiled script is supposed to evaluate into

- // a single anonymous function(it's anonymous to avoid cluttering the global object with

- // inspector's stuff) the function is called a few lines below with InjectedScriptHost wrapper,

- // injected script id and explicit reference to the inspected global object. The function is expected

- // to create and configure InjectedScript instance that is going to be used by the inspector.

- String16 injectedScriptSource(reinterpret_cast<const char*>(InjectedScriptSource_js), sizeof(InjectedScriptSource_js));

- v8::Local<v8::Value> value;

- if (!inspectedContext->inspector()->compileAndRunInternalScript(context, toV8String(isolate, injectedScriptSource)).ToLocal(&value))

- return nullptr;

- DCHECK(value->IsFunction());

- v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(value);

- v8::Local<v8::Object> windowGlobal = context->Global();

- v8::Local<v8::Value> info[] = { scriptHostWrapper, windowGlobal, v8::Number::New(isolate, inspectedContext->contextId()) };

- v8::MicrotasksScope microtasksScope(isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);

- v8::Local<v8::Value> injectedScriptValue;

- if (!function->Call(context, windowGlobal, V8_INSPECTOR_ARRAY_LENGTH(info), info).ToLocal(&injectedScriptValue))

- return nullptr;

- if (!injectedScriptValue->IsObject())

- return nullptr;

- return wrapUnique(new InjectedScript(inspectedContext, injectedScriptValue.As<v8::Object>(), std::move(injectedScriptNative)));

-InjectedScript::InjectedScript(InspectedContext* context, v8::Local<v8::Object> object, std::unique_ptr<InjectedScriptNative> injectedScriptNative)

- : m_context(context)

- , m_value(context->isolate(), object)

- , m_native(std::move(injectedScriptNative))

-InjectedScript::~InjectedScript()

-void InjectedScript::getProperties(ErrorString* errorString, v8::Local<v8::Object> object, const String16& groupName, bool ownProperties, bool accessorPropertiesOnly, bool generatePreview, std::unique_ptr<Array<PropertyDescriptor>>* properties, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)

- v8::HandleScope handles(m_context->isolate());

- V8FunctionCall function(m_context->inspector(), m_context->context(), v8Value(), "getProperties");

- function.appendArgument(object);

- function.appendArgument(groupName);

- function.appendArgument(ownProperties);

- function.appendArgument(accessorPropertiesOnly);

- function.appendArgument(generatePreview);

- v8::TryCatch tryCatch(m_context->isolate());

- v8::Local<v8::Value> resultValue = function.callWithoutExceptionHandling();

- if (tryCatch.HasCaught()) {

- *exceptionDetails = createExceptionDetails(errorString, tryCatch, groupName, generatePreview);

- // FIXME: make properties optional

- *properties = Array<PropertyDescriptor>::create();

- return;

- }

- std::unique_ptr<protocol::Value> protocolValue = toProtocolValue(m_context->context(), resultValue);

- if (hasInternalError(errorString, !protocolValue))

- return;

- protocol::ErrorSupport errors(errorString);

- std::unique_ptr<Array<PropertyDescriptor>> result = Array<PropertyDescriptor>::parse(protocolValue.get(), &errors);

- if (!hasInternalError(errorString, errors.hasErrors()))

- *properties = std::move(result);

-void InjectedScript::releaseObject(const String16& objectId)

- std::unique_ptr<protocol::Value> parsedObjectId = protocol::parseJSON(objectId);

- if (!parsedObjectId)

- return;

- protocol::DictionaryValue* object = protocol::DictionaryValue::cast(parsedObjectId.get());

- if (!object)

- return;

- int boundId = 0;

- if (!object->getInteger("id", &boundId))

- return;

- m_native->unbind(boundId);

-std::unique_ptr<protocol::Runtime::RemoteObject> InjectedScript::wrapObject(ErrorString* errorString, v8::Local<v8::Value> value, const String16& groupName, bool forceValueType, bool generatePreview) const

- v8::HandleScope handles(m_context->isolate());

- v8::Local<v8::Value> wrappedObject;

- if (!wrapValue(errorString, value, groupName, forceValueType, generatePreview).ToLocal(&wrappedObject))

- return nullptr;

- protocol::ErrorSupport errors;

- std::unique_ptr<protocol::Runtime::RemoteObject> remoteObject = protocol::Runtime::RemoteObject::parse(toProtocolValue(m_context->context(), wrappedObject).get(), &errors);

- if (!remoteObject)

- *errorString = "Object has too long reference chain";

- return remoteObject;

-bool InjectedScript::wrapObjectProperty(ErrorString* errorString, v8::Local<v8::Object> object, v8::Local<v8::Name> key, const String16& groupName, bool forceValueType, bool generatePreview) const

- v8::Local<v8::Value> property;

- if (hasInternalError(errorString, !object->Get(m_context->context(), key).ToLocal(&property)))

- return false;

- v8::Local<v8::Value> wrappedProperty;

- if (!wrapValue(errorString, property, groupName, forceValueType, generatePreview).ToLocal(&wrappedProperty))

- return false;

- v8::Maybe<bool> success = createDataProperty(m_context->context(), object, key, wrappedProperty);

- if (hasInternalError(errorString, success.IsNothing() || !success.FromJust()))

- return false;

- return true;

-bool InjectedScript::wrapPropertyInArray(ErrorString* errorString, v8::Local<v8::Array> array, v8::Local<v8::String> property, const String16& groupName, bool forceValueType, bool generatePreview) const

- V8FunctionCall function(m_context->inspector(), m_context->context(), v8Value(), "wrapPropertyInArray");

- function.appendArgument(array);

- function.appendArgument(property);

- function.appendArgument(groupName);

- function.appendArgument(forceValueType);

- function.appendArgument(generatePreview);

- bool hadException = false;

- function.call(hadException);

- return !hasInternalError(errorString, hadException);

-bool InjectedScript::wrapObjectsInArray(ErrorString* errorString, v8::Local<v8::Array> array, const String16& groupName, bool forceValueType, bool generatePreview) const

- V8FunctionCall function(m_context->inspector(), m_context->context(), v8Value(), "wrapObjectsInArray");

- function.appendArgument(array);

- function.appendArgument(groupName);

- function.appendArgument(forceValueType);

- function.appendArgument(generatePreview);

- bool hadException = false;

- function.call(hadException);

- return !hasInternalError(errorString, hadException);

-v8::MaybeLocal<v8::Value> InjectedScript::wrapValue(ErrorString* errorString, v8::Local<v8::Value> value, const String16& groupName, bool forceValueType, bool generatePreview) const

- V8FunctionCall function(m_context->inspector(), m_context->context(), v8Value(), "wrapObject");

- function.appendArgument(value);

- function.appendArgument(groupName);

- function.appendArgument(forceValueType);

- function.appendArgument(generatePreview);

- bool hadException = false;

- v8::Local<v8::Value> r = function.call(hadException);

- if (hasInternalError(errorString, hadException || r.IsEmpty()))

- return v8::MaybeLocal<v8::Value>();

- return r;

-std::unique_ptr<protocol::Runtime::RemoteObject> InjectedScript::wrapTable(v8::Local<v8::Value> table, v8::Local<v8::Value> columns) const

- v8::HandleScope handles(m_context->isolate());

- V8FunctionCall function(m_context->inspector(), m_context->context(), v8Value(), "wrapTable");

- function.appendArgument(table);

- if (columns.IsEmpty())

- function.appendArgument(false);

- else

- function.appendArgument(columns);

- bool hadException = false;

- v8::Local<v8::Value> r = function.call(hadException);

- if (hadException)

- return nullptr;

- protocol::ErrorSupport errors;

- return protocol::Runtime::RemoteObject::parse(toProtocolValue(m_context->context(), r).get(), &errors);

-bool InjectedScript::findObject(ErrorString* errorString, const RemoteObjectId& objectId, v8::Local<v8::Value>* outObject) const

- *outObject = m_native->objectForId(objectId.id());

- if (outObject->IsEmpty())

- *errorString = "Could not find object with given id";

- return !outObject->IsEmpty();

-String16 InjectedScript::objectGroupName(const RemoteObjectId& objectId) const

- return m_native->groupName(objectId.id());

-void InjectedScript::releaseObjectGroup(const String16& objectGroup)

- m_native->releaseObjectGroup(objectGroup);

- if (objectGroup == "console")

- m_lastEvaluationResult.Reset();

-void InjectedScript::setCustomObjectFormatterEnabled(bool enabled)

- v8::HandleScope handles(m_context->isolate());

- V8FunctionCall function(m_context->inspector(), m_context->context(), v8Value(), "setCustomObjectFormatterEnabled");

- function.appendArgument(enabled);

- bool hadException = false;

- function.call(hadException);

- DCHECK(!hadException);

-v8::Local<v8::Value> InjectedScript::v8Value() const

- return m_value.Get(m_context->isolate());

-v8::Local<v8::Value> InjectedScript::lastEvaluationResult() const

- if (m_lastEvaluationResult.IsEmpty())

- return v8::Undefined(m_context->isolate());

- return m_lastEvaluationResult.Get(m_context->isolate());

-v8::MaybeLocal<v8::Value> InjectedScript::resolveCallArgument(ErrorString* errorString, protocol::Runtime::CallArgument* callArgument)

- if (callArgument->hasObjectId()) {

- std::unique_ptr<RemoteObjectId> remoteObjectId = RemoteObjectId::parse(errorString, callArgument->getObjectId(""));

- if (!remoteObjectId)

- return v8::MaybeLocal<v8::Value>();

- if (remoteObjectId->contextId() != m_context->contextId()) {

- *errorString = "Argument should belong to the same JavaScript world as target object";

- return v8::MaybeLocal<v8::Value>();

- }

- v8::Local<v8::Value> object;

- if (!findObject(errorString, *remoteObjectId, &object))

- return v8::MaybeLocal<v8::Value>();

- return object;

- }

- if (callArgument->hasValue() || callArgument->hasUnserializableValue()) {

- String16 value = callArgument->hasValue() ?

- callArgument->getValue(nullptr)->toJSONString() :

- "Number(\"" + callArgument->getUnserializableValue("") + "\")";

- v8::Local<v8::Value> object;

- if (!m_context->inspector()->compileAndRunInternalScript(m_context->context(), toV8String(m_context->isolate(), value)).ToLocal(&object)) {

- *errorString = "Couldn't parse value object in call argument";

- return v8::MaybeLocal<v8::Value>();

- }

- return object;

- }

- return v8::Undefined(m_context->isolate());

-std::unique_ptr<protocol::Runtime::ExceptionDetails> InjectedScript::createExceptionDetails(ErrorString* errorString, const v8::TryCatch& tryCatch, const String16& objectGroup, bool generatePreview)

- if (!tryCatch.HasCaught())

- return nullptr;

- v8::Local<v8::Message> message = tryCatch.Message();

- v8::Local<v8::Value> exception = tryCatch.Exception();

- String16 messageText = message.IsEmpty() ? String16() : toProtocolString(message->Get());

- std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails = protocol::Runtime::ExceptionDetails::create()

- .setExceptionId(m_context->inspector()->nextExceptionId())

- .setText(exception.IsEmpty() ? messageText : String16("Uncaught"))

- .setLineNumber(message.IsEmpty() ? 0 : message->GetLineNumber(m_context->context()).FromMaybe(1) - 1)

- .setColumnNumber(message.IsEmpty() ? 0 : message->GetStartColumn(m_context->context()).FromMaybe(0))

- .build();

- if (!message.IsEmpty()) {

- exceptionDetails->setScriptId(String16::fromInteger(message->GetScriptOrigin().ScriptID()->Value()));

- v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();

- if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)

- exceptionDetails->setStackTrace(m_context->inspector()->debugger()->createStackTrace(stackTrace)->buildInspectorObjectImpl());

- }

- if (!exception.IsEmpty()) {

- std::unique_ptr<protocol::Runtime::RemoteObject> wrapped = wrapObject(errorString, exception, objectGroup, false /* forceValueType */, generatePreview && !exception->IsNativeError());

- if (!wrapped)

- return nullptr;

- exceptionDetails->setException(std::move(wrapped));

- }

- return exceptionDetails;

-void InjectedScript::wrapEvaluateResult(ErrorString* errorString, v8::MaybeLocal<v8::Value> maybeResultValue, const v8::TryCatch& tryCatch, const String16& objectGroup, bool returnByValue, bool generatePreview, std::unique_ptr<protocol::Runtime::RemoteObject>* result, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)

- v8::Local<v8::Value> resultValue;

- if (!tryCatch.HasCaught()) {

- if (hasInternalError(errorString, !maybeResultValue.ToLocal(&resultValue)))

- return;

- std::unique_ptr<RemoteObject> remoteObject = wrapObject(errorString, resultValue, objectGroup, returnByValue, generatePreview);

- if (!remoteObject)

- return;

- if (objectGroup == "console")

- m_lastEvaluationResult.Reset(m_context->isolate(), resultValue);

- *result = std::move(remoteObject);

- } else {

- v8::Local<v8::Value> exception = tryCatch.Exception();

- std::unique_ptr<RemoteObject> remoteObject = wrapObject(errorString, exception, objectGroup, false, generatePreview && !exception->IsNativeError());

- if (!remoteObject)

- return;

- // We send exception in result for compatibility reasons, even though it's accessible through exceptionDetails.exception.

- *result = std::move(remoteObject);

- *exceptionDetails = createExceptionDetails(errorString, tryCatch, objectGroup, generatePreview);

- }

-v8::Local<v8::Object> InjectedScript::commandLineAPI()

- if (m_commandLineAPI.IsEmpty())

- m_commandLineAPI.Reset(m_context->isolate(), V8Console::createCommandLineAPI(m_context));

- return m_commandLineAPI.Get(m_context->isolate());

-InjectedScript::Scope::Scope(ErrorString* errorString, V8InspectorImpl* inspector, int contextGroupId)

- : m_errorString(errorString)

- , m_inspector(inspector)

- , m_contextGroupId(contextGroupId)

- , m_injectedScript(nullptr)

- , m_handleScope(inspector->isolate())

- , m_tryCatch(inspector->isolate())

- , m_ignoreExceptionsAndMuteConsole(false)

- , m_previousPauseOnExceptionsState(V8Debugger::DontPauseOnExceptions)

- , m_userGesture(false)

-bool InjectedScript::Scope::initialize()

- cleanup();

- // TODO(dgozman): what if we reattach to the same context group during evaluate? Introduce a session id?

- V8InspectorSessionImpl* session = m_inspector->sessionForContextGroup(m_contextGroupId);

- if (!session) {

- *m_errorString = "Internal error";

- return false;

- }

- findInjectedScript(session);

- if (!m_injectedScript)

- return false;

- m_context = m_injectedScript->context()->context();

- m_context->Enter();

- return true;

-bool InjectedScript::Scope::installCommandLineAPI()

- DCHECK(m_injectedScript && !m_context.IsEmpty() && !m_commandLineAPIScope.get());

- m_commandLineAPIScope.reset(new V8Console::CommandLineAPIScope(m_context, m_injectedScript->commandLineAPI(), m_context->Global()));

- return true;

-void InjectedScript::Scope::ignoreExceptionsAndMuteConsole()

- DCHECK(!m_ignoreExceptionsAndMuteConsole);

- m_ignoreExceptionsAndMuteConsole = true;

- m_inspector->client()->muteMetrics(m_contextGroupId);

- m_inspector->muteExceptions(m_contextGroupId);

- m_previousPauseOnExceptionsState = setPauseOnExceptionsState(V8Debugger::DontPauseOnExceptions);

-V8Debugger::PauseOnExceptionsState InjectedScript::Scope::setPauseOnExceptionsState(V8Debugger::PauseOnExceptionsState newState)

- if (!m_inspector->debugger()->enabled())

- return newState;

- V8Debugger::PauseOnExceptionsState presentState = m_inspector->debugger()->getPauseOnExceptionsState();

- if (presentState != newState)

- m_inspector->debugger()->setPauseOnExceptionsState(newState);

- return presentState;

-void InjectedScript::Scope::pretendUserGesture()

- DCHECK(!m_userGesture);

- m_userGesture = true;

- m_inspector->client()->beginUserGesture();

-void InjectedScript::Scope::cleanup()

- m_commandLineAPIScope.reset();

- if (!m_context.IsEmpty()) {

- m_context->Exit();

- m_context.Clear();

- }

-InjectedScript::Scope::~Scope()

- if (m_ignoreExceptionsAndMuteConsole) {

- setPauseOnExceptionsState(m_previousPauseOnExceptionsState);

- m_inspector->client()->unmuteMetrics(m_contextGroupId);

- m_inspector->unmuteExceptions(m_contextGroupId);

- }

- if (m_userGesture)

- m_inspector->client()->endUserGesture();

- cleanup();

-InjectedScript::ContextScope::ContextScope(ErrorString* errorString, V8InspectorImpl* inspector, int contextGroupId, int executionContextId)

- : InjectedScript::Scope(errorString, inspector, contextGroupId)

- , m_executionContextId(executionContextId)

-InjectedScript::ContextScope::~ContextScope()

-void InjectedScript::ContextScope::findInjectedScript(V8InspectorSessionImpl* session)

- m_injectedScript = session->findInjectedScript(m_errorString, m_executionContextId);

-InjectedScript::ObjectScope::ObjectScope(ErrorString* errorString, V8InspectorImpl* inspector, int contextGroupId, const String16& remoteObjectId)

- : InjectedScript::Scope(errorString, inspector, contextGroupId)

- , m_remoteObjectId(remoteObjectId)

-InjectedScript::ObjectScope::~ObjectScope()

-void InjectedScript::ObjectScope::findInjectedScript(V8InspectorSessionImpl* session)

- std::unique_ptr<RemoteObjectId> remoteId = RemoteObjectId::parse(m_errorString, m_remoteObjectId);

- if (!remoteId)

- return;

- InjectedScript* injectedScript = session->findInjectedScript(m_errorString, remoteId.get());

- if (!injectedScript)

- return;

- m_objectGroupName = injectedScript->objectGroupName(*remoteId);

- if (!injectedScript->findObject(m_errorString, *remoteId, &m_object))

- return;

- m_injectedScript = injectedScript;

-InjectedScript::CallFrameScope::CallFrameScope(ErrorString* errorString, V8InspectorImpl* inspector, int contextGroupId, const String16& remoteObjectId)

- : InjectedScript::Scope(errorString, inspector, contextGroupId)

- , m_remoteCallFrameId(remoteObjectId)

-InjectedScript::CallFrameScope::~CallFrameScope()

-void InjectedScript::CallFrameScope::findInjectedScript(V8InspectorSessionImpl* session)

- std::unique_ptr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(m_errorString, m_remoteCallFrameId);

- if (!remoteId)

- return;

- m_frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());

- m_injectedScript = session->findInjectedScript(m_errorString, remoteId.get());

-} // namespace v8_inspector