[inspector] migrate Debugger to new style

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 311 matching lines @@
   DCHECK(!m_executionState.IsEmpty());
   v8::DebugInterface::PrepareStep(m_isolate, v8::DebugInterface::StepOut);
   continueProgram();
 }
 
 void V8Debugger::clearStepping() {
   DCHECK(enabled());
   v8::DebugInterface::ClearStepping(m_isolate);
 }
 
-bool V8Debugger::setScriptSource(
+Response V8Debugger::setScriptSource(
     const String16& sourceID, v8::Local<v8::String> newSource, bool dryRun,
-    ErrorString* error,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails,
-    JavaScriptCallFrames* newCallFrames, Maybe<bool>* stackChanged) {
+    JavaScriptCallFrames* newCallFrames, Maybe<bool>* stackChanged,
+    bool* compileError) {
   class EnableLiveEditScope {
    public:
     explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate) {
       v8::DebugInterface::SetLiveEditEnabled(m_isolate, true);
       inLiveEditScope = true;
     }
     ~EnableLiveEditScope() {
       v8::DebugInterface::SetLiveEditEnabled(m_isolate, false);
       inLiveEditScope = false;
     }
 
    private:
     v8::Isolate* m_isolate;
   };
 
+  *compileError = false;
   DCHECK(enabled());
   v8::HandleScope scope(m_isolate);
 
   std::unique_ptr<v8::Context::Scope> contextScope;
   if (!isPaused())
     contextScope = wrapUnique(new v8::Context::Scope(debuggerContext()));
 
   v8::Local<v8::Value> argv[] = {toV8String(m_isolate, sourceID), newSource,
                                  v8Boolean(dryRun, m_isolate)};
 
   v8::Local<v8::Value> v8result;
   {
     EnableLiveEditScope enableLiveEditScope(m_isolate);
     v8::TryCatch tryCatch(m_isolate);
     tryCatch.SetVerbose(false);
     v8::MaybeLocal<v8::Value> maybeResult =
         callDebuggerMethod("liveEditScriptSource", 3, argv);
     if (tryCatch.HasCaught()) {
       v8::Local<v8::Message> message = tryCatch.Message();
       if (!message.IsEmpty())
-        *error = toProtocolStringWithTypeCheck(message->Get());
+        return Response::Error(toProtocolStringWithTypeCheck(message->Get()));
       else
-        *error = "Unknown error.";
-      return false;
+        return Response::InternalError();
     }
     v8result = maybeResult.ToLocalChecked();
   }
   DCHECK(!v8result.IsEmpty());
   v8::Local<v8::Context> context = m_isolate->GetCurrentContext();
   v8::Local<v8::Object> resultTuple =
       v8result->ToObject(context).ToLocalChecked();
   int code = static_cast<int>(resultTuple->Get(context, 0)
                                   .ToLocalChecked()
                                   ->ToInteger(context)
                                   .ToLocalChecked()
                                   ->Value());
   switch (code) {
     case 0: {
       *stackChanged = resultTuple->Get(context, 1)
                           .ToLocalChecked()
                           ->BooleanValue(context)
                           .FromJust();
       // Call stack may have changed after if the edited function was on the
       // stack.
       if (!dryRun && isPaused()) {
         JavaScriptCallFrames frames = currentCallFrames();
         newCallFrames->swap(frames);
       }
-      return true;
+      return Response::OK();
     }
     // Compile error.
     case 1: {
       *exceptionDetails =
           protocol::Runtime::ExceptionDetails::create()
               .setExceptionId(m_inspector->nextExceptionId())
               .setText(toProtocolStringWithTypeCheck(
                   resultTuple->Get(context, 2).ToLocalChecked()))
               .setLineNumber(static_cast<int>(resultTuple->Get(context, 3)
                                                   .ToLocalChecked()
                                                   ->ToInteger(context)
                                                   .ToLocalChecked()
                                                   ->Value()) -
                              1)
               .setColumnNumber(static_cast<int>(resultTuple->Get(context, 4)
                                                     .ToLocalChecked()
                                                     ->ToInteger(context)
                                                     .ToLocalChecked()
                                                     ->Value()) -
                                1)
               .build();
-      return false;
+      *compileError = true;
+      return Response::OK();
     }
   }
-  *error = "Unknown error.";
-  return false;
+  return Response::InternalError();
 }
 
 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(),
@@ skipping 536 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