[inspector] introduce debug-interface.h

src/inspector/v8-debugger.cc

 // Copyright 2016 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-debugger.h"
 
 #include "src/inspector/debugger-script.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/script-breakpoint.h"
 #include "src/inspector/string-util.h"
@@ skipping 45 matching lines @@
       m_runningNestedMessageLoop(false),
       m_ignoreScriptParsedEventsCounter(0),
       m_maxAsyncCallStackDepth(0) {}
 
 V8Debugger::~V8Debugger() {}
 
 void V8Debugger::enable() {
   if (m_enableCount++) return;
   DCHECK(!enabled());
   v8::HandleScope scope(m_isolate);
-  v8::Debug::SetDebugEventListener(m_isolate, &V8Debugger::v8DebugEventCallback,
-                                   v8::External::New(m_isolate, this));
-  m_debuggerContext.Reset(m_isolate, v8::Debug::GetDebugContext(m_isolate));
+  v8::DebugInterface::SetDebugEventListener(m_isolate,
+                                            &V8Debugger::v8DebugEventCallback,
+                                            v8::External::New(m_isolate, this));
+  m_debuggerContext.Reset(m_isolate,
+                          v8::DebugInterface::GetDebugContext(m_isolate));
   compileDebuggerScript();
 }
 
 void V8Debugger::disable() {
   if (--m_enableCount) return;
   DCHECK(enabled());
   clearBreakpoints();
   m_debuggerScript.Reset();
   m_debuggerContext.Reset();
   allAsyncTasksCanceled();
-  v8::Debug::SetDebugEventListener(m_isolate, nullptr);
+  v8::DebugInterface::SetDebugEventListener(m_isolate, nullptr);
 }
 
 bool V8Debugger::enabled() const { return !m_debuggerScript.IsEmpty(); }
 
 // static
 int V8Debugger::contextId(v8::Local<v8::Context> context) {
   v8::Local<v8::Value> data =
       context->GetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex));
   if (data.IsEmpty() || !data->IsString()) return 0;
   String16 dataString = toProtocolString(data.As<v8::String>());
@@ skipping 74 matching lines @@
   success = info->Set(context, toV8StringInternalized(m_isolate, "condition"),
                       toV8String(m_isolate, scriptBreakpoint.condition))
                 .FromMaybe(false);
   DCHECK(success);
 
   v8::Local<v8::Function> setBreakpointFunction = v8::Local<v8::Function>::Cast(
       m_debuggerScript.Get(m_isolate)
           ->Get(context, toV8StringInternalized(m_isolate, "setBreakpoint"))
           .ToLocalChecked());
   v8::Local<v8::Value> breakpointId =
-      v8::Debug::Call(debuggerContext(), setBreakpointFunction, info)
+      v8::DebugInterface::Call(debuggerContext(), setBreakpointFunction, info)
           .ToLocalChecked();
   if (!breakpointId->IsString()) return "";
   *actualLineNumber =
       info->Get(context, toV8StringInternalized(m_isolate, "lineNumber"))
           .ToLocalChecked()
           ->Int32Value(context)
           .FromJust();
   *actualColumnNumber =
       info->Get(context, toV8StringInternalized(m_isolate, "columnNumber"))
           .ToLocalChecked()
@@ skipping 14 matching lines @@
                 toV8String(m_isolate, breakpointId))
           .FromMaybe(false);
   DCHECK(success);
 
   v8::Local<v8::Function> removeBreakpointFunction =
       v8::Local<v8::Function>::Cast(
           m_debuggerScript.Get(m_isolate)
               ->Get(context,
                     toV8StringInternalized(m_isolate, "removeBreakpoint"))
               .ToLocalChecked());
-  v8::Debug::Call(debuggerContext(), removeBreakpointFunction, info)
+  v8::DebugInterface::Call(debuggerContext(), removeBreakpointFunction, info)
       .ToLocalChecked();
 }
 
 void V8Debugger::clearBreakpoints() {
   v8::HandleScope scope(m_isolate);
   v8::Local<v8::Context> context = debuggerContext();
   v8::Context::Scope contextScope(context);
 
   v8::Local<v8::Function> clearBreakpoints = v8::Local<v8::Function>::Cast(
       m_debuggerScript.Get(m_isolate)
           ->Get(context, toV8StringInternalized(m_isolate, "clearBreakpoints"))
           .ToLocalChecked());
-  v8::Debug::Call(debuggerContext(), clearBreakpoints).ToLocalChecked();
+  v8::DebugInterface::Call(debuggerContext(), clearBreakpoints)
+      .ToLocalChecked();
 }
 
 void V8Debugger::setBreakpointsActivated(bool activated) {
   if (!enabled()) {
     UNREACHABLE();
     return;
   }
   v8::HandleScope scope(m_isolate);
   v8::Local<v8::Context> context = debuggerContext();
   v8::Context::Scope contextScope(context);
 
   v8::Local<v8::Object> info = v8::Object::New(m_isolate);
   bool success = false;
   success = info->Set(context, toV8StringInternalized(m_isolate, "enabled"),
                       v8::Boolean::New(m_isolate, activated))
                 .FromMaybe(false);
   DCHECK(success);
   v8::Local<v8::Function> setBreakpointsActivated =
       v8::Local<v8::Function>::Cast(
           m_debuggerScript.Get(m_isolate)
               ->Get(context, toV8StringInternalized(m_isolate,
                                                     "setBreakpointsActivated"))
               .ToLocalChecked());
-  v8::Debug::Call(debuggerContext(), setBreakpointsActivated, info)
+  v8::DebugInterface::Call(debuggerContext(), setBreakpointsActivated, info)
       .ToLocalChecked();
 
   m_breakpointsActivated = activated;
 }
 
 V8Debugger::PauseOnExceptionsState V8Debugger::getPauseOnExceptionsState() {
   DCHECK(enabled());
   v8::HandleScope scope(m_isolate);
   v8::Local<v8::Context> context = debuggerContext();
   v8::Context::Scope contextScope(context);
@@ skipping 12 matching lines @@
   v8::Context::Scope contextScope(debuggerContext());
 
   v8::Local<v8::Value> argv[] = {
       v8::Int32::New(m_isolate, pauseOnExceptionsState)};
   callDebuggerMethod("setPauseOnExceptionsState", 1, argv);
 }
 
 void V8Debugger::setPauseOnNextStatement(bool pause) {
   if (m_runningNestedMessageLoop) return;
   if (pause)
-    v8::Debug::DebugBreak(m_isolate);
+    v8::DebugInterface::DebugBreak(m_isolate);
   else
-    v8::Debug::CancelDebugBreak(m_isolate);
+    v8::DebugInterface::CancelDebugBreak(m_isolate);
 }
 
 bool V8Debugger::canBreakProgram() {
   if (!m_breakpointsActivated) return false;
   return m_isolate->InContext();
 }
 
 void V8Debugger::breakProgram() {
   if (isPaused()) {
     DCHECK(!m_runningNestedMessageLoop);
     v8::Local<v8::Value> exception;
     v8::Local<v8::Array> hitBreakpoints;
     handleProgramBreak(m_pausedContext, m_executionState, exception,
                        hitBreakpoints);
     return;
   }
 
   if (!canBreakProgram()) return;
 
   v8::HandleScope scope(m_isolate);
   v8::Local<v8::Function> breakFunction;
   if (!v8::Function::New(m_isolate->GetCurrentContext(),
                          &V8Debugger::breakProgramCallback,
                          v8::External::New(m_isolate, this), 0,
                          v8::ConstructorBehavior::kThrow)
            .ToLocal(&breakFunction))
     return;
-  v8::Debug::Call(debuggerContext(), breakFunction).ToLocalChecked();
+  v8::DebugInterface::Call(debuggerContext(), breakFunction).ToLocalChecked();
 }
 
 void V8Debugger::continueProgram() {
   if (isPaused()) m_inspector->client()->quitMessageLoopOnPause();
   m_pausedContext.Clear();
   m_executionState.Clear();
 }
 
 void V8Debugger::stepIntoStatement() {
   DCHECK(isPaused());
@@ skipping 32 matching lines @@
 }
 
 bool V8Debugger::setScriptSource(
     const String16& sourceID, v8::Local<v8::String> newSource, bool dryRun,
     ErrorString* error,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails,
     JavaScriptCallFrames* newCallFrames, Maybe<bool>* stackChanged) {
   class EnableLiveEditScope {
    public:
     explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate) {
-      v8::Debug::SetLiveEditEnabled(m_isolate, true);
+      v8::DebugInterface::SetLiveEditEnabled(m_isolate, true);
       inLiveEditScope = true;
     }
     ~EnableLiveEditScope() {
-      v8::Debug::SetLiveEditEnabled(m_isolate, false);
+      v8::DebugInterface::SetLiveEditEnabled(m_isolate, false);
       inLiveEditScope = false;
     }
 
    private:
     v8::Isolate* m_isolate;
   };
 
   DCHECK(enabled());
   v8::HandleScope scope(m_isolate);
 
@@ skipping 75 matching lines @@
   if (!m_isolate->InContext()) return JavaScriptCallFrames();
   v8::Local<v8::Value> currentCallFramesV8;
   if (m_executionState.IsEmpty()) {
     v8::Local<v8::Function> currentCallFramesFunction =
         v8::Local<v8::Function>::Cast(
             m_debuggerScript.Get(m_isolate)
                 ->Get(debuggerContext(),
                       toV8StringInternalized(m_isolate, "currentCallFrames"))
                 .ToLocalChecked());
     currentCallFramesV8 =
-        v8::Debug::Call(debuggerContext(), currentCallFramesFunction,
-                        v8::Integer::New(m_isolate, limit))
+        v8::DebugInterface::Call(debuggerContext(), currentCallFramesFunction,
+                                 v8::Integer::New(m_isolate, limit))
             .ToLocalChecked();
   } else {
     v8::Local<v8::Value> argv[] = {m_executionState,
                                    v8::Integer::New(m_isolate, limit)};
     currentCallFramesV8 =
         callDebuggerMethod("currentCallFrames", arraysize(argv), argv)
             .ToLocalChecked();
   }
   DCHECK(!currentCallFramesV8.IsEmpty());
   if (!currentCallFramesV8->IsArray()) return JavaScriptCallFrames();
@@ skipping 78 matching lines @@
   } else if (result == V8DebuggerAgentImpl::RequestStepInto) {
     v8::Local<v8::Value> argv[] = {executionState};
     callDebuggerMethod(stepIntoV8MethodName, 1, argv);
   } else if (result == V8DebuggerAgentImpl::RequestStepOut) {
     v8::Local<v8::Value> argv[] = {executionState};
     callDebuggerMethod(stepOutV8MethodName, 1, argv);
   }
 }
 
 void V8Debugger::v8DebugEventCallback(
-    const v8::Debug::EventDetails& eventDetails) {
+    const v8::DebugInterface::EventDetails& eventDetails) {
   V8Debugger* thisPtr = toV8Debugger(eventDetails.GetCallbackData());
   thisPtr->handleV8DebugEvent(eventDetails);
 }
 
 v8::Local<v8::Value> V8Debugger::callInternalGetterFunction(
     v8::Local<v8::Object> object, const char* functionName) {
   v8::MicrotasksScope microtasks(m_isolate,
                                  v8::MicrotasksScope::kDoNotRunMicrotasks);
   v8::Local<v8::Value> getterValue =
       object
           ->Get(m_isolate->GetCurrentContext(),
                 toV8StringInternalized(m_isolate, functionName))
           .ToLocalChecked();
   DCHECK(!getterValue.IsEmpty() && getterValue->IsFunction());
   return v8::Local<v8::Function>::Cast(getterValue)
       ->Call(m_isolate->GetCurrentContext(), object, 0, 0)
       .ToLocalChecked();
 }
 
 void V8Debugger::handleV8DebugEvent(
-    const v8::Debug::EventDetails& eventDetails) {
+    const v8::DebugInterface::EventDetails& eventDetails) {
   if (!enabled()) return;
   v8::DebugEvent event = eventDetails.GetEvent();
   if (event != v8::AsyncTaskEvent && event != v8::Break &&
       event != v8::Exception && event != v8::AfterCompile &&
       event != v8::BeforeCompile && event != v8::CompileError)
     return;
 
   v8::Local<v8::Context> eventContext = eventDetails.GetEventContext();
   DCHECK(!eventContext.IsEmpty());
 
@@ skipping 128 matching lines @@
     return v8::MaybeLocal<v8::Value>();
   if (!markArrayEntriesAsInternal(context, v8::Local<v8::Array>::Cast(copied),
                                   V8InternalValueType::kScope))
     return v8::MaybeLocal<v8::Value>();
   return copied;
 }
 
 v8::MaybeLocal<v8::Array> V8Debugger::internalProperties(
     v8::Local<v8::Context> context, v8::Local<v8::Value> value) {
   v8::Local<v8::Array> properties;
-  if (!v8::Debug::GetInternalProperties(m_isolate, value).ToLocal(&properties))
+  if (!v8::DebugInterface::GetInternalProperties(m_isolate, value)
+           .ToLocal(&properties))
     return v8::MaybeLocal<v8::Array>();
   if (value->IsFunction()) {
     v8::Local<v8::Function> function = value.As<v8::Function>();
     v8::Local<v8::Value> location = functionLocation(context, function);
     if (location->IsObject()) {
       createDataProperty(
           context, properties, properties->Length(),
           toV8StringInternalized(m_isolate, "[[FunctionLocation]]"));
       createDataProperty(context, properties, properties->Length(), location);
     }
@@ skipping 250 matching lines @@
 
   size_t stackSize =
       fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
   if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
     stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
   return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 }  // namespace v8_inspector