[DevTools] Rename V8Debugger to V8Inspector.

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

 /*
  * 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
@@ skipping 21 matching lines @@
 
 #include "platform/inspector_protocol/Parser.h"
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.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/V8Compat.h"
 #include "platform/v8_inspector/V8Console.h"
-#include "platform/v8_inspector/V8DebuggerImpl.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/V8StringUtil.h"
-#include "platform/v8_inspector/public/V8Debugger.h"
-#include "platform/v8_inspector/public/V8DebuggerClient.h"
+#include "platform/v8_inspector/public/V8InspectorClient.h"
 
 using blink::protocol::Array;
 using blink::protocol::Debugger::CallFrame;
 using blink::protocol::Runtime::PropertyDescriptor;
 using blink::protocol::Runtime::InternalPropertyDescriptor;
 using blink::protocol::Runtime::RemoteObject;
 using blink::protocol::Maybe;
 
 namespace blink {
 
 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->debugger());
+    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->debugger()->compileAndRunInternalScript(context, toV8String(isolate, injectedScriptSource)).ToLocal(&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, PROTOCOL_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->debugger(), m_context->context(), v8Value(), "getProperties");
+    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(tryCatch.Message());
@@ skipping 47 matching lines @@
     if (!wrapValue(errorString, property, groupName, forceValueType, generatePreview).ToLocal(&wrappedProperty))
         return false;
     v8::Maybe<bool> success = object->Set(m_context->context(), 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->debugger(), m_context->context(), v8Value(), "wrapPropertyInArray");
+    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->debugger(), m_context->context(), v8Value(), "wrapObjectsInArray");
+    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->debugger(), m_context->context(), v8Value(), "wrapObject");
+    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->debugger(), m_context->context(), v8Value(), "wrapTable");
+    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;
@@ skipping 16 matching lines @@
 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->debugger(), m_context->context(), v8Value(), "setCustomObjectFormatterEnabled");
+    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());
 }
@@ skipping 18 matching lines @@
         v8::Local<v8::Value> object;
         if (!findObject(errorString, *remoteObjectId, &object))
             return v8::MaybeLocal<v8::Value>();
         return object;
     }
     if (callArgument->hasValue()) {
         String16 value = callArgument->getValue(nullptr)->toJSONString();
         if (callArgument->getType(String16()) == "number")
             value = "Number(" + value + ")";
         v8::Local<v8::Value> object;
-        if (!m_context->debugger()->compileAndRunInternalScript(m_context->context(), toV8String(m_context->isolate(), value)).ToLocal(&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(v8::Local<v8::Message> message)
 {
     std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetailsObject = protocol::Runtime::ExceptionDetails::create()
         .setText(toProtocolString(message->Get()))
         .setScriptId(String16::fromInteger(message->GetScriptOrigin().ScriptID()->Value()))
         .setLineNumber(message->GetLineNumber(m_context->context()).FromMaybe(1) - 1)
         .setColumnNumber(message->GetStartColumn(m_context->context()).FromMaybe(0))
         .build();
 
     v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
     if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)
-        exceptionDetailsObject->setStackTrace(m_context->debugger()->createStackTraceImpl(stackTrace)->buildInspectorObjectImpl());
+        exceptionDetailsObject->setStackTrace(m_context->inspector()->createStackTraceImpl(stackTrace)->buildInspectorObjectImpl());
     return exceptionDetailsObject;
 }
 
 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<bool>* wasThrown, 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);
@@ skipping 17 matching lines @@
     }
 }
 
 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, V8DebuggerImpl* debugger, int contextGroupId)
+InjectedScript::Scope::Scope(ErrorString* errorString, V8InspectorImpl* inspector, int contextGroupId)
     : m_errorString(errorString)
-    , m_debugger(debugger)
+    , m_inspector(inspector)
     , m_contextGroupId(contextGroupId)
     , m_injectedScript(nullptr)
-    , m_handleScope(debugger->isolate())
-    , m_tryCatch(debugger->isolate())
+    , m_handleScope(inspector->isolate())
+    , m_tryCatch(inspector->isolate())
     , m_ignoreExceptionsAndMuteConsole(false)
-    , m_previousPauseOnExceptionsState(V8DebuggerImpl::DontPauseOnExceptions)
+    , m_previousPauseOnExceptionsState(V8InspectorImpl::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_debugger->sessionForContextGroup(m_contextGroupId);
+    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_debugger->client()->muteWarningsAndDeprecations(m_contextGroupId);
-    m_previousPauseOnExceptionsState = setPauseOnExceptionsState(V8DebuggerImpl::DontPauseOnExceptions);
+    m_inspector->client()->muteWarningsAndDeprecations(m_contextGroupId);
+    m_previousPauseOnExceptionsState = setPauseOnExceptionsState(V8InspectorImpl::DontPauseOnExceptions);
 }
 
-V8DebuggerImpl::PauseOnExceptionsState InjectedScript::Scope::setPauseOnExceptionsState(V8DebuggerImpl::PauseOnExceptionsState newState)
+V8InspectorImpl::PauseOnExceptionsState InjectedScript::Scope::setPauseOnExceptionsState(V8InspectorImpl::PauseOnExceptionsState newState)
 {
-    if (!m_debugger->enabled())
+    if (!m_inspector->enabled())
         return newState;
-    V8DebuggerImpl::PauseOnExceptionsState presentState = m_debugger->getPauseOnExceptionsState();
+    V8InspectorImpl::PauseOnExceptionsState presentState = m_inspector->getPauseOnExceptionsState();
     if (presentState != newState)
-        m_debugger->setPauseOnExceptionsState(newState);
+        m_inspector->setPauseOnExceptionsState(newState);
     return presentState;
 }
 
 void InjectedScript::Scope::pretendUserGesture()
 {
     DCHECK(!m_userGesture);
     m_userGesture = true;
-    m_debugger->client()->beginUserGesture();
+    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_debugger->client()->unmuteWarningsAndDeprecations(m_contextGroupId);
+        m_inspector->client()->unmuteWarningsAndDeprecations(m_contextGroupId);
     }
     if (m_userGesture)
-        m_debugger->client()->endUserGesture();
+        m_inspector->client()->endUserGesture();
     cleanup();
 }
 
-InjectedScript::ContextScope::ContextScope(ErrorString* errorString, V8DebuggerImpl* debugger, int contextGroupId, int executionContextId)
-    : InjectedScript::Scope(errorString, debugger, contextGroupId)
+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, V8DebuggerImpl* debugger, int contextGroupId, const String16& remoteObjectId)
-    : InjectedScript::Scope(errorString, debugger, contextGroupId)
+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, V8DebuggerImpl* debugger, int contextGroupId, const String16& remoteObjectId)
-    : InjectedScript::Scope(errorString, debugger, contextGroupId)
+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 blink