node/deps/v8_inspector/src/inspector/injected-script.cc

/*
 * Copyright (C) 2012 Google Inc. All rights reserved.
 *
 * 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 "src/inspector/injected-script.h"

#include "src/inspector/injected-script-native.h"
#include "src/inspector/injected-script-source.h"
#include "src/inspector/inspected-context.h"
#include "src/inspector/protocol/Protocol.h"
#include "src/inspector/remote-object-id.h"
#include "src/inspector/string-util.h"
#include "src/inspector/v8-console.h"
#include "src/inspector/v8-function-call.h"
#include "src/inspector/v8-injected-script-host.h"
#include "src/inspector/v8-inspector-impl.h"
#include "src/inspector/v8-inspector-session-impl.h"
#include "src/inspector/v8-stack-trace-impl.h"
#include "src/inspector/v8-value-copier.h"

#include "include/v8-inspector.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, arraysize(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());
  v8::Local<v8::Context> context = m_context->context();
  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;
  }
  if (hasInternalError(errorString, resultValue.IsEmpty())) return;
  std::unique_ptr<protocol::Value> protocolValue =
      toProtocolValue(errorString, context, resultValue);
  if (!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;
  v8::Local<v8::Context> context = m_context->context();
  if (!wrapValue(errorString, value, groupName, forceValueType, generatePreview)
           .ToLocal(&wrappedObject))
    return nullptr;
  protocol::ErrorSupport errors;
  std::unique_ptr<protocol::Value> protocolValue =
      toProtocolValue(errorString, context, wrappedObject);
  if (!protocolValue) return nullptr;
  std::unique_ptr<protocol::Runtime::RemoteObject> remoteObject =
      protocol::Runtime::RemoteObject::parse(protocolValue.get(), &errors);
  if (!remoteObject) *errorString = errors.errors();
  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;
  v8::Local<v8::Context> context = m_context->context();
  if (hasInternalError(errorString,
                       !object->Get(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(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());
  v8::Local<v8::Context> context = m_context->context();
  V8FunctionCall function(m_context->inspector(), 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 || r.IsEmpty()) return nullptr;
  protocol::ErrorString errorString;
  std::unique_ptr<protocol::Value> protocolValue =
      toProtocolValue(&errorString, context, r);
  if (!protocolValue) return nullptr;
  protocol::ErrorSupport errors;
  return protocol::Runtime::RemoteObject::parse(protocolValue.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(
        static_cast<int>(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