[debug] Remove DebugInterface class

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 38 matching lines @@
 
 V8Debugger::V8Debugger(v8::Isolate* isolate, V8InspectorImpl* inspector)
     : m_isolate(isolate),
       m_inspector(inspector),
       m_lastContextId(0),
       m_enableCount(0),
       m_breakpointsActivated(true),
       m_runningNestedMessageLoop(false),
       m_ignoreScriptParsedEventsCounter(0),
       m_maxAsyncCallStackDepth(0),
-      m_pauseOnExceptionsState(v8::DebugInterface::NoBreakOnException),
+      m_pauseOnExceptionsState(v8::debug::NoBreakOnException),
       m_wasmTranslation(isolate, this) {}
 
 V8Debugger::~V8Debugger() {}
 
 void V8Debugger::enable() {
   if (m_enableCount++) return;
   DCHECK(!enabled());
   v8::HandleScope scope(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));
-  v8::DebugInterface::ChangeBreakOnException(
-      m_isolate, v8::DebugInterface::NoBreakOnException);
-  m_pauseOnExceptionsState = v8::DebugInterface::NoBreakOnException;
+  v8::debug::DebugInterface::SetDebugEventListener(
+      m_isolate, &V8Debugger::v8DebugEventCallback,
+      v8::External::New(m_isolate, this));
+  m_debuggerContext.Reset(
+      m_isolate, v8::debug::DebugInterface::GetDebugContext(m_isolate));
+  v8::debug::DebugInterface::ChangeBreakOnException(
+      m_isolate, v8::debug::NoBreakOnException);
+  m_pauseOnExceptionsState = v8::debug::NoBreakOnException;
   compileDebuggerScript();
 }
 
 void V8Debugger::disable() {
   if (--m_enableCount) return;
   DCHECK(enabled());
   clearBreakpoints();
   m_debuggerScript.Reset();
   m_debuggerContext.Reset();
   allAsyncTasksCanceled();
   m_wasmTranslation.Clear();
-  v8::DebugInterface::SetDebugEventListener(m_isolate, nullptr);
+  v8::debug::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 15 matching lines @@
   if (dataString.isEmpty()) return 0;
   size_t commaPos = dataString.find(",");
   if (commaPos == String16::kNotFound) return 0;
   return dataString.substring(0, commaPos).toInteger();
 }
 
 void V8Debugger::getCompiledScripts(
     int contextGroupId,
     std::vector<std::unique_ptr<V8DebuggerScript>>& result) {
   v8::HandleScope scope(m_isolate);
-  v8::PersistentValueVector<v8::DebugInterface::Script> scripts(m_isolate);
-  v8::DebugInterface::GetLoadedScripts(m_isolate, scripts);
+  v8::PersistentValueVector<v8::debug::Script> scripts(m_isolate);
+  v8::debug::DebugInterface::GetLoadedScripts(m_isolate, scripts);
   String16 contextPrefix = String16::fromInteger(contextGroupId) + ",";
   for (size_t i = 0; i < scripts.Size(); ++i) {
-    v8::Local<v8::DebugInterface::Script> script = scripts.Get(i);
+    v8::Local<v8::debug::Script> script = scripts.Get(i);
     if (!script->WasCompiled()) continue;
     v8::Local<v8::String> v8ContextData;
     if (!script->ContextData().ToLocal(&v8ContextData)) continue;
     String16 contextData = toProtocolString(v8ContextData);
     if (contextData.find(contextPrefix) != 0) continue;
     result.push_back(std::unique_ptr<V8DebuggerScript>(
         new V8DebuggerScript(m_isolate, script, false)));
   }
 }
 
@@ skipping 22 matching lines @@
   success = info->Set(context, toV8StringInternalized(m_isolate, "condition"),
                       toV8String(m_isolate, breakpoint.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::DebugInterface::Call(debuggerContext(), setBreakpointFunction, info)
+      v8::debug::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::DebugInterface::Call(debuggerContext(), removeBreakpointFunction, info)
+  v8::debug::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::DebugInterface::Call(debuggerContext(), clearBreakpoints)
+  v8::debug::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::DebugInterface::Call(debuggerContext(), setBreakpointsActivated, info)
+  v8::debug::DebugInterface::Call(debuggerContext(), setBreakpointsActivated,
+                                  info)
       .ToLocalChecked();
 
   m_breakpointsActivated = activated;
 }
 
-v8::DebugInterface::ExceptionBreakState
-V8Debugger::getPauseOnExceptionsState() {
+v8::debug::ExceptionBreakState V8Debugger::getPauseOnExceptionsState() {
   DCHECK(enabled());
   return m_pauseOnExceptionsState;
 }
 
 void V8Debugger::setPauseOnExceptionsState(
-    v8::DebugInterface::ExceptionBreakState pauseOnExceptionsState) {
+    v8::debug::ExceptionBreakState pauseOnExceptionsState) {
   DCHECK(enabled());
   if (m_pauseOnExceptionsState == pauseOnExceptionsState) return;
-  v8::DebugInterface::ChangeBreakOnException(m_isolate, pauseOnExceptionsState);
+  v8::debug::DebugInterface::ChangeBreakOnException(m_isolate,
+                                                    pauseOnExceptionsState);
   m_pauseOnExceptionsState = pauseOnExceptionsState;
 }
 
 void V8Debugger::setPauseOnNextStatement(bool pause) {
   if (m_runningNestedMessageLoop) return;
   if (pause)
-    v8::DebugInterface::DebugBreak(m_isolate);
+    v8::debug::DebugInterface::DebugBreak(m_isolate);
   else
-    v8::DebugInterface::CancelDebugBreak(m_isolate);
+    v8::debug::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::DebugInterface::Call(debuggerContext(), breakFunction).ToLocalChecked();
+  v8::debug::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());
   DCHECK(!m_executionState.IsEmpty());
-  v8::DebugInterface::PrepareStep(m_isolate, v8::DebugInterface::StepIn);
+  v8::debug::DebugInterface::PrepareStep(m_isolate, v8::debug::StepIn);
   continueProgram();
 }
 
 void V8Debugger::stepOverStatement() {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
-  v8::DebugInterface::PrepareStep(m_isolate, v8::DebugInterface::StepNext);
+  v8::debug::DebugInterface::PrepareStep(m_isolate, v8::debug::StepNext);
   continueProgram();
 }
 
 void V8Debugger::stepOutOfFunction() {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
-  v8::DebugInterface::PrepareStep(m_isolate, v8::DebugInterface::StepOut);
+  v8::debug::DebugInterface::PrepareStep(m_isolate, v8::debug::StepOut);
   continueProgram();
 }
 
 void V8Debugger::clearStepping() {
   DCHECK(enabled());
-  v8::DebugInterface::ClearStepping(m_isolate);
+  v8::debug::DebugInterface::ClearStepping(m_isolate);
 }
 
 Response V8Debugger::setScriptSource(
     const String16& sourceID, v8::Local<v8::String> newSource, bool dryRun,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails,
     JavaScriptCallFrames* newCallFrames, Maybe<bool>* stackChanged,
     bool* compileError) {
   class EnableLiveEditScope {
    public:
     explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate) {
-      v8::DebugInterface::SetLiveEditEnabled(m_isolate, true);
+      v8::debug::DebugInterface::SetLiveEditEnabled(m_isolate, true);
       inLiveEditScope = true;
     }
     ~EnableLiveEditScope() {
-      v8::DebugInterface::SetLiveEditEnabled(m_isolate, false);
+      v8::debug::DebugInterface::SetLiveEditEnabled(m_isolate, false);
       inLiveEditScope = false;
     }
 
    private:
     v8::Isolate* m_isolate;
   };
 
   *compileError = false;
   DCHECK(enabled());
   v8::HandleScope scope(m_isolate);
@@ skipping 74 matching lines @@
 JavaScriptCallFrames V8Debugger::currentCallFrames(int limit) {
   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::DebugInterface::Call(debuggerContext(), currentCallFramesFunction,
-                                 v8::Integer::New(m_isolate, limit))
-            .ToLocalChecked();
+    currentCallFramesV8 = v8::debug::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();
   v8::Local<v8::Array> callFramesArray = currentCallFramesV8.As<v8::Array>();
@@ skipping 65 matching lines @@
     // The agent may have been removed in the nested loop.
     agent =
         m_inspector->enabledDebuggerAgentForGroup(getGroupId(pausedContext));
     if (agent) agent->didContinue();
     m_runningNestedMessageLoop = false;
   }
   m_pausedContext.Clear();
   m_executionState.Clear();
 
   if (result == V8DebuggerAgentImpl::RequestStepFrame) {
-    v8::DebugInterface::PrepareStep(m_isolate, v8::DebugInterface::StepFrame);
+    v8::debug::DebugInterface::PrepareStep(m_isolate, v8::debug::StepFrame);
   } else if (result == V8DebuggerAgentImpl::RequestStepInto) {
-    v8::DebugInterface::PrepareStep(m_isolate, v8::DebugInterface::StepIn);
+    v8::debug::DebugInterface::PrepareStep(m_isolate, v8::debug::StepIn);
   } else if (result == V8DebuggerAgentImpl::RequestStepOut) {
-    v8::DebugInterface::PrepareStep(m_isolate, v8::DebugInterface::StepOut);
+    v8::debug::DebugInterface::PrepareStep(m_isolate, v8::debug::StepOut);
   }
 }
 
 void V8Debugger::v8DebugEventCallback(
-    const v8::DebugInterface::EventDetails& eventDetails) {
+    const v8::debug::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, nullptr)
       .ToLocalChecked();
 }
 
 void V8Debugger::handleV8DebugEvent(
-    const v8::DebugInterface::EventDetails& eventDetails) {
+    const v8::debug::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::CompileError)
     return;
 
   v8::Local<v8::Context> eventContext = eventDetails.GetEventContext();
   DCHECK(!eventContext.IsEmpty());
 
@@ skipping 11 matching lines @@
   v8::HandleScope scope(m_isolate);
   if (event == v8::AfterCompile || event == v8::CompileError) {
     v8::Context::Scope contextScope(debuggerContext());
     // Determine if the script is a wasm script.
     v8::Local<v8::Value> scriptMirror =
         callInternalGetterFunction(eventDetails.GetEventData(), "script");
     DCHECK(scriptMirror->IsObject());
     v8::Local<v8::Value> scriptWrapper =
         callInternalGetterFunction(scriptMirror.As<v8::Object>(), "value");
     DCHECK(scriptWrapper->IsObject());
-    v8::Local<v8::DebugInterface::Script> script;
-    if (!v8::DebugInterface::Script::Wrap(m_isolate,
-                                          scriptWrapper.As<v8::Object>())
+    v8::Local<v8::debug::Script> script;
+    if (!v8::debug::Script::Wrap(m_isolate, scriptWrapper.As<v8::Object>())
              .ToLocal(&script)) {
       return;
     }
     if (script->IsWasm()) {
       m_wasmTranslation.AddScript(scriptWrapper.As<v8::Object>());
     } else if (m_ignoreScriptParsedEventsCounter == 0) {
       agent->didParseSource(
           std::unique_ptr<V8DebuggerScript>(
               new V8DebuggerScript(m_isolate, script, inLiveEditScope)),
           event == v8::AfterCompile);
@@ skipping 130 matching lines @@
 }
 
 v8::MaybeLocal<v8::Value> V8Debugger::generatorScopes(
     v8::Local<v8::Context> context, v8::Local<v8::Value> generator) {
   return getTargetScopes(context, generator, GENERATOR);
 }
 
 v8::MaybeLocal<v8::Array> V8Debugger::internalProperties(
     v8::Local<v8::Context> context, v8::Local<v8::Value> value) {
   v8::Local<v8::Array> properties;
-  if (!v8::DebugInterface::GetInternalProperties(m_isolate, value)
+  if (!v8::debug::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 257 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