From 8c514b5e3b36a0ccb7a29e56612df6da4945f478 Mon Sep 17 00:00:00 2001 From: yp9522 Date: Fri, 29 Aug 2025 15:07:13 +0800 Subject: [PATCH] adjust the SendResponse Issue: https://gitee.com/openharmony/arkcompiler_toolchain/issues/ICVDT0 Signed-off-by: yp9522 Change-Id: Id8442c74451341adcce1fb37c10e7a70f8854893 --- tooling/dynamic/agent/debugger_impl.cpp | 308 ++++++++++---------- tooling/dynamic/agent/debugger_impl.h | 66 +++-- tooling/dynamic/agent/runtime_impl.cpp | 51 ++-- tooling/dynamic/agent/runtime_impl.h | 10 +- tooling/dynamic/test/debugger_impl_test.cpp | 7 +- tooling/dynamic/test/runtime_impl_test.cpp | 21 +- 6 files changed, 238 insertions(+), 225 deletions(-) diff --git a/tooling/dynamic/agent/debugger_impl.cpp b/tooling/dynamic/agent/debugger_impl.cpp index 15dbc0d9..424f2d30 100755 --- a/tooling/dynamic/agent/debugger_impl.cpp +++ b/tooling/dynamic/agent/debugger_impl.cpp @@ -86,7 +86,7 @@ bool DebuggerImpl::NotifyScriptParsed(const std::string &fileName, std::string_v LOG_DEBUGGER(DEBUG) << "NotifyScriptParsed: Unmerge file: " << fileName; return false; } - + const char *recordName = entryPoint.data(); auto mainMethodIndex = panda_file::File::EntityId(jsPandaFile->GetMainMethodIndex(recordName)); const std::string &source = extractor->GetSourceCode(mainMethodIndex); @@ -505,104 +505,112 @@ void DebuggerImpl::DispatcherImpl::Dispatch(const DispatchRequest &request) { Method method = GetMethodEnum(request.GetMethod()); LOG_DEBUGGER(DEBUG) << "dispatch [" << request.GetMethod() << "] to DebuggerImpl"; + if (method == Method::CLIENT_DISCONNECT) { + ClientDisconnect(request); + return; + } + DispatchResponse response = DispatchResponse::Fail("unknown method: " + request.GetMethod()); + std::unique_ptr result = nullptr; switch (method) { case Method::CONTINUE_TO_LOCATION: - ContinueToLocation(request); + response = ContinueToLocation(request); break; case Method::ENABLE: - Enable(request); + response = Enable(request, result); break; case Method::DISABLE: - Disable(request); + response = Disable(request); break; case Method::EVALUATE_ON_CALL_FRAME: - EvaluateOnCallFrame(request); + response = EvaluateOnCallFrame(request, result); break; case Method::GET_POSSIBLE_BREAKPOINTS: - GetPossibleBreakpoints(request); + response = GetPossibleBreakpoints(request, result); break; case Method::GET_SCRIPT_SOURCE: - GetScriptSource(request); + response = GetScriptSource(request, result); break; case Method::PAUSE: - Pause(request); + response = Pause(request); break; case Method::REMOVE_BREAKPOINT: - RemoveBreakpoint(request); + response = RemoveBreakpoint(request); break; case Method::REMOVE_BREAKPOINTS_BY_URL: - RemoveBreakpointsByUrl(request); + response = RemoveBreakpointsByUrl(request); break; case Method::RESUME: - Resume(request); + response = Resume(request); break; case Method::SET_ASYNC_CALL_STACK_DEPTH: - SetAsyncCallStackDepth(request); + response = SetAsyncCallStackDepth(request); break; case Method::SET_BREAKPOINT_BY_URL: - SetBreakpointByUrl(request); + response = SetBreakpointByUrl(request, result); break; case Method::SET_BREAKPOINTS_ACTIVE: - SetBreakpointsActive(request); + response = SetBreakpointsActive(request); break; case Method::SET_PAUSE_ON_EXCEPTIONS: - SetPauseOnExceptions(request); + response = SetPauseOnExceptions(request); break; case Method::SET_SKIP_ALL_PAUSES: - SetSkipAllPauses(request); + response = SetSkipAllPauses(request); break; case Method::STEP_INTO: - StepInto(request); + response = StepInto(request); break; case Method::SMART_STEP_INTO: - SmartStepInto(request); + response = SmartStepInto(request); break; case Method::STEP_OUT: - StepOut(request); + response = StepOut(request); break; case Method::STEP_OVER: - StepOver(request); + response = StepOver(request); break; case Method::SET_MIXED_DEBUG_ENABLED: - SetMixedDebugEnabled(request); + response = SetMixedDebugEnabled(request); break; case Method::SET_BLACKBOX_PATTERNS: - SetBlackboxPatterns(request); + response = SetBlackboxPatterns(request); break; case Method::REPLY_NATIVE_CALLING: - ReplyNativeCalling(request); + response = ReplyNativeCalling(request); break; case Method::GET_POSSIBLE_AND_SET_BREAKPOINT_BY_URL: - GetPossibleAndSetBreakpointByUrl(request); + response = GetPossibleAndSetBreakpointByUrl(request, result); break; case Method::DROP_FRAME: - DropFrame(request); + response = DropFrame(request); break; case Method::SET_NATIVE_RANGE: - SetNativeRange(request); + response = SetNativeRange(request); break; case Method::RESET_SINGLE_STEPPER: - ResetSingleStepper(request); - break; - case Method::CLIENT_DISCONNECT: - ClientDisconnect(request); + response = ResetSingleStepper(request); break; case Method::CALL_FUNCTION_ON: - CallFunctionOn(request); + response = CallFunctionOn(request, result); break; case Method::SAVE_ALL_POSSIBLE_BREAKPOINTS: - SaveAllPossibleBreakpoints(request); + response = SaveAllPossibleBreakpoints(request); break; case Method::SET_SYMBOLIC_BREAKPOINTS: - SetSymbolicBreakpoints(request); + response = SetSymbolicBreakpoints(request); break; case Method::REMOVE_SYMBOLIC_BREAKPOINTS: - RemoveSymbolicBreakpoints(request); + response = RemoveSymbolicBreakpoints(request); break; default: - SendResponse(request, DispatchResponse::Fail("Unknown method: " + request.GetMethod())); + response = DispatchResponse::Fail("Unknown method: " + request.GetMethod()); break; } + if (result) { + SendResponse(request, response, *result); + } else { + SendResponse(request, response); + } } DebuggerImpl::DispatcherImpl::Method DebuggerImpl::DispatcherImpl::GetMethodEnum(const std::string& method) @@ -674,110 +682,105 @@ DebuggerImpl::DispatcherImpl::Method DebuggerImpl::DispatcherImpl::GetMethodEnum } } -void DebuggerImpl::DispatcherImpl::ContinueToLocation(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::ContinueToLocation(const DispatchRequest &request) { std::unique_ptr params = ContinueToLocationParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } - DispatchResponse response = debugger_->ContinueToLocation(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::Enable(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::Enable(const DispatchRequest &request, + std::unique_ptr &result) { std::unique_ptr params = EnableParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } UniqueDebuggerId id; DispatchResponse response = debugger_->Enable(*params, &id); debugger_->InitializeExtendedProtocolsList(); - DebuggerEnableReturns result(id, debugger_->debuggerExtendedProtocols_); - SendResponse(request, response, result); + result = std::make_unique(id, debugger_->debuggerExtendedProtocols_); + return response; } -void DebuggerImpl::DispatcherImpl::Disable(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::Disable(const DispatchRequest &request) { DispatchResponse response = debugger_->Disable(); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::EvaluateOnCallFrame(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::EvaluateOnCallFrame(const DispatchRequest &request, + std::unique_ptr &result) { std::unique_ptr params = EvaluateOnCallFrameParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } std::unique_ptr result1; DispatchResponse response = debugger_->EvaluateOnCallFrame(*params, &result1); if (result1 == nullptr) { - SendResponse(request, response); - return; + return response; } - EvaluateOnCallFrameReturns result(std::move(result1)); - SendResponse(request, response, result); + result = std::make_unique(std::move(result1)); + return response; } -void DebuggerImpl::DispatcherImpl::GetPossibleBreakpoints(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::GetPossibleBreakpoints(const DispatchRequest &request, + std::unique_ptr &result) { std::unique_ptr params = GetPossibleBreakpointsParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } std::vector> locations; DispatchResponse response = debugger_->GetPossibleBreakpoints(*params, &locations); - GetPossibleBreakpointsReturns result(std::move(locations)); - SendResponse(request, response, result); + result = std::make_unique(std::move(locations)); + return response; } -void DebuggerImpl::DispatcherImpl::GetScriptSource(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::GetScriptSource(const DispatchRequest &request, + std::unique_ptr &result) { std::unique_ptr params = GetScriptSourceParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } std::string source; DispatchResponse response = debugger_->GetScriptSource(*params, &source); - GetScriptSourceReturns result(source); - SendResponse(request, response, result); + result = std::make_unique(source); + return response; } -void DebuggerImpl::DispatcherImpl::Pause(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::Pause(const DispatchRequest &request) { DispatchResponse response = debugger_->Pause(); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::RemoveBreakpoint(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::RemoveBreakpoint(const DispatchRequest &request) { std::unique_ptr params = RemoveBreakpointParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->RemoveBreakpoint(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::RemoveBreakpointsByUrl(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::RemoveBreakpointsByUrl(const DispatchRequest &request) { std::unique_ptr params = RemoveBreakpointsByUrlParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->RemoveBreakpointsByUrl(*params); - SendResponse(request, response); + return response; } std::string DebuggerImpl::DispatcherImpl::RemoveBreakpointsByUrl( @@ -792,57 +795,55 @@ std::string DebuggerImpl::DispatcherImpl::RemoveBreakpointsByUrl( return ReturnsValueToString(callId, DispatchResponseToJson(response)); } -void DebuggerImpl::DispatcherImpl::Resume(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::Resume(const DispatchRequest &request) { std::unique_ptr params = ResumeParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->Resume(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::SetBreakpointByUrl(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetBreakpointByUrl(const DispatchRequest &request, + std::unique_ptr &result) { std::unique_ptr params = SetBreakpointByUrlParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } std::string outId; std::vector> outLocations; DispatchResponse response = debugger_->SetBreakpointByUrl(*params, &outId, &outLocations); - SetBreakpointByUrlReturns result(outId, std::move(outLocations)); - SendResponse(request, response, result); + result = std::make_unique(outId, std::move(outLocations)); + return response; } -void DebuggerImpl::DispatcherImpl::SetBreakpointsActive(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetBreakpointsActive(const DispatchRequest &request) { std::unique_ptr params = SetBreakpointsActiveParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SetBreakpointsActive(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::GetPossibleAndSetBreakpointByUrl(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::GetPossibleAndSetBreakpointByUrl(const DispatchRequest &request, + std::unique_ptr &result) { std::unique_ptr params = GetPossibleAndSetBreakpointParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } std::vector> outLocation; DispatchResponse response = debugger_->GetPossibleAndSetBreakpointByUrl(*params, outLocation); - GetPossibleAndSetBreakpointByUrlReturns result(std::move(outLocation)); - SendResponse(request, response, result); + result = std::make_unique(std::move(outLocation)); + return response; } std::string DebuggerImpl::DispatcherImpl::GetPossibleAndSetBreakpointByUrl( @@ -863,16 +864,15 @@ std::string DebuggerImpl::DispatcherImpl::GetPossibleAndSetBreakpointByUrl( return ReturnsValueToString(callId, result.ToJson()); } -void DebuggerImpl::DispatcherImpl::SaveAllPossibleBreakpoints(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SaveAllPossibleBreakpoints(const DispatchRequest &request) { std::unique_ptr params = SaveAllPossibleBreakpointsParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SaveAllPossibleBreakpoints(*params); - SendResponse(request, response); + return response; } std::string DebuggerImpl::DispatcherImpl::SaveAllPossibleBreakpoints( @@ -886,164 +886,151 @@ std::string DebuggerImpl::DispatcherImpl::SaveAllPossibleBreakpoints( return ReturnsValueToString(callId, DispatchResponseToJson(response)); } -void DebuggerImpl::DispatcherImpl::SetSymbolicBreakpoints(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetSymbolicBreakpoints(const DispatchRequest &request) { std::unique_ptr params = SetSymbolicBreakpointsParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SetSymbolicBreakpoints(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::RemoveSymbolicBreakpoints(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::RemoveSymbolicBreakpoints(const DispatchRequest &request) { std::unique_ptr params = RemoveSymbolicBreakpointsParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->RemoveSymbolicBreakpoints(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::SetAsyncCallStackDepth(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetAsyncCallStackDepth(const DispatchRequest &request) { std::unique_ptr params = SetAsyncCallStackDepthParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SetAsyncCallStackDepth(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::SetPauseOnExceptions(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetPauseOnExceptions(const DispatchRequest &request) { std::unique_ptr params = SetPauseOnExceptionsParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SetPauseOnExceptions(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::SetSkipAllPauses(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetSkipAllPauses(const DispatchRequest &request) { std::unique_ptr params = SetSkipAllPausesParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SetSkipAllPauses(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::SetNativeRange(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetNativeRange(const DispatchRequest &request) { std::unique_ptr params = SetNativeRangeParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SetNativeRange(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::ResetSingleStepper(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::ResetSingleStepper(const DispatchRequest &request) { std::unique_ptr params = ResetSingleStepperParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->ResetSingleStepper(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::StepInto(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::StepInto(const DispatchRequest &request) { std::unique_ptr params = StepIntoParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->StepInto(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::SmartStepInto(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SmartStepInto(const DispatchRequest &request) { std::unique_ptr params = SmartStepIntoParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SmartStepInto(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::StepOut(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::StepOut(const DispatchRequest &request) { DispatchResponse response = debugger_->StepOut(); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::StepOver(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::StepOver(const DispatchRequest &request) { std::unique_ptr params = StepOverParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->StepOver(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::SetMixedDebugEnabled(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetMixedDebugEnabled(const DispatchRequest &request) { std::unique_ptr params = SetMixedDebugParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->SetMixedDebugEnabled(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::ReplyNativeCalling(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::ReplyNativeCalling(const DispatchRequest &request) { std::unique_ptr params = ReplyNativeCallingParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->ReplyNativeCalling(*params); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::SetBlackboxPatterns(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::SetBlackboxPatterns(const DispatchRequest &request) { DispatchResponse response = debugger_->SetBlackboxPatterns(); - SendResponse(request, response); + return response; } -void DebuggerImpl::DispatcherImpl::DropFrame(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::DropFrame(const DispatchRequest &request) { std::unique_ptr params = DropFrameParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } DispatchResponse response = debugger_->DropFrame(*params); - SendResponse(request, response); + return response; } // inner message, not SendResponse to outer @@ -1052,12 +1039,12 @@ void DebuggerImpl::DispatcherImpl::ClientDisconnect([[maybe_unused]] const Dispa debugger_->ClientDisconnect(); } -void DebuggerImpl::DispatcherImpl::CallFunctionOn(const DispatchRequest &request) +DispatchResponse DebuggerImpl::DispatcherImpl::CallFunctionOn(const DispatchRequest &request, + std::unique_ptr &result) { std::unique_ptr params = CallFunctionOnParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } std::unique_ptr outRemoteObject; @@ -1068,12 +1055,11 @@ void DebuggerImpl::DispatcherImpl::CallFunctionOn(const DispatchRequest &request LOG_DEBUGGER(WARN) << "CallFunctionOn thrown an exception"; } if (outRemoteObject == nullptr) { - SendResponse(request, response); - return; + return response; } - CallFunctionOnReturns result(std::move(outRemoteObject), std::move(outExceptionDetails)); - SendResponse(request, response, result); + result = std::make_unique(std::move(outRemoteObject), std::move(outExceptionDetails)); + return response; } bool DebuggerImpl::Frontend::AllowNotify(const EcmaVM *vm) const @@ -1273,7 +1259,7 @@ DispatchResponse DebuggerImpl::EvaluateOnCallFrame(const EvaluateOnCallFramePara JSPandaFile::ENTRY_FUNCTION_NAME); auto res = DebuggerApi::EvaluateViaFuncCall(const_cast(vm_), funcRef, callFrameHandlers_[callFrameId]); - + JSNApi::SwitchContext(vm_, originContext); if (vm_->GetJSThread()->HasPendingException()) { @@ -1559,7 +1545,7 @@ DispatchResponse DebuggerImpl::SetSymbolicBreakpoints(const SetSymbolicBreakpoin } // Symbolic breakpoints support only function names DebuggerApi::SetSymbolicBreakpoint(jsDebugger_, *(params.GetFunctionNamesSet())); - + return DispatchResponse::Ok(); } diff --git a/tooling/dynamic/agent/debugger_impl.h b/tooling/dynamic/agent/debugger_impl.h index 7eab7c3f..208670b6 100644 --- a/tooling/dynamic/agent/debugger_impl.h +++ b/tooling/dynamic/agent/debugger_impl.h @@ -157,41 +157,47 @@ public: : DispatcherBase(channel), debugger_(std::move(debugger)) {} ~DispatcherImpl() override = default; - void ContinueToLocation(const DispatchRequest &request); + DispatchResponse ContinueToLocation(const DispatchRequest &request); std::string GetJsFrames(); std::string EvaluateOnCallFrame(const int32_t callId, std::unique_ptr params); std::string CallFunctionOn(const int32_t callId, std::unique_ptr params); void Dispatch(const DispatchRequest &request) override; - void Enable(const DispatchRequest &request); - void Disable(const DispatchRequest &request); - void EvaluateOnCallFrame(const DispatchRequest &request); - void GetPossibleBreakpoints(const DispatchRequest &request); - void GetScriptSource(const DispatchRequest &request); - void Pause(const DispatchRequest &request); - void RemoveBreakpoint(const DispatchRequest &request); - void RemoveBreakpointsByUrl(const DispatchRequest &request); - void Resume(const DispatchRequest &request); - void SetAsyncCallStackDepth(const DispatchRequest &request); - void SetBreakpointByUrl(const DispatchRequest &request); - void SetBreakpointsActive(const DispatchRequest &request); - void SetPauseOnExceptions(const DispatchRequest &request); - void SetSkipAllPauses(const DispatchRequest &request); - void SetNativeRange(const DispatchRequest &request); - void ResetSingleStepper(const DispatchRequest &request); - void StepInto(const DispatchRequest &request); - void SmartStepInto(const DispatchRequest &request); - void StepOut(const DispatchRequest &request); - void StepOver(const DispatchRequest &request); - void SetMixedDebugEnabled(const DispatchRequest &request); - void SetBlackboxPatterns(const DispatchRequest &request); - void ReplyNativeCalling(const DispatchRequest &request); - void GetPossibleAndSetBreakpointByUrl(const DispatchRequest &request); - void DropFrame(const DispatchRequest &request); + DispatchResponse Enable(const DispatchRequest &request, std::unique_ptr &result); + DispatchResponse Disable(const DispatchRequest &request); + DispatchResponse EvaluateOnCallFrame(const DispatchRequest &request, + std::unique_ptr &result); + DispatchResponse GetPossibleBreakpoints(const DispatchRequest &request, + std::unique_ptr &result); + DispatchResponse GetScriptSource(const DispatchRequest &request, + std::unique_ptr &result); + DispatchResponse Pause(const DispatchRequest &request); + DispatchResponse RemoveBreakpoint(const DispatchRequest &request); + DispatchResponse RemoveBreakpointsByUrl(const DispatchRequest &request); + DispatchResponse Resume(const DispatchRequest &request); + DispatchResponse SetAsyncCallStackDepth(const DispatchRequest &request); + DispatchResponse SetBreakpointByUrl(const DispatchRequest &request, + std::unique_ptr &result); + DispatchResponse SetBreakpointsActive(const DispatchRequest &request); + DispatchResponse SetPauseOnExceptions(const DispatchRequest &request); + DispatchResponse SetSkipAllPauses(const DispatchRequest &request); + DispatchResponse SetNativeRange(const DispatchRequest &request); + DispatchResponse ResetSingleStepper(const DispatchRequest &request); + DispatchResponse StepInto(const DispatchRequest &request); + DispatchResponse SmartStepInto(const DispatchRequest &request); + DispatchResponse StepOut(const DispatchRequest &request); + DispatchResponse StepOver(const DispatchRequest &request); + DispatchResponse SetMixedDebugEnabled(const DispatchRequest &request); + DispatchResponse SetBlackboxPatterns(const DispatchRequest &request); + DispatchResponse ReplyNativeCalling(const DispatchRequest &request); + DispatchResponse GetPossibleAndSetBreakpointByUrl(const DispatchRequest &request, + std::unique_ptr &result); + DispatchResponse DropFrame(const DispatchRequest &request); void ClientDisconnect(const DispatchRequest &request); - void CallFunctionOn(const DispatchRequest &request); - void SaveAllPossibleBreakpoints(const DispatchRequest &request); - void SetSymbolicBreakpoints(const DispatchRequest &request); - void RemoveSymbolicBreakpoints(const DispatchRequest &request); + DispatchResponse CallFunctionOn(const DispatchRequest &request, + std::unique_ptr &result); + DispatchResponse SaveAllPossibleBreakpoints(const DispatchRequest &request); + DispatchResponse SetSymbolicBreakpoints(const DispatchRequest &request); + DispatchResponse RemoveSymbolicBreakpoints(const DispatchRequest &request); std::string SaveAllPossibleBreakpoints(const int32_t callId, std::unique_ptr params); std::string RemoveBreakpointsByUrl(const int32_t callId, diff --git a/tooling/dynamic/agent/runtime_impl.cpp b/tooling/dynamic/agent/runtime_impl.cpp index 663623b7..262a3478 100644 --- a/tooling/dynamic/agent/runtime_impl.cpp +++ b/tooling/dynamic/agent/runtime_impl.cpp @@ -30,26 +30,33 @@ void RuntimeImpl::DispatcherImpl::Dispatch(const DispatchRequest &request) { Method method = GetMethodEnum(request.GetMethod()); LOG_DEBUGGER(DEBUG) << "dispatch [" << request.GetMethod() << "] to RuntimeImpl"; + DispatchResponse response = DispatchResponse::Fail("unknown method: " + request.GetMethod()); + std::unique_ptr result = nullptr; switch (method) { case Method::ENABLE: - Enable(request); + response = Enable(request, result); break; case Method::DISABLE: - Disable(request); + response = Disable(request); break; case Method::GET_PROPERTIES: - GetProperties(request); + response = GetProperties(request, result); break; case Method::RUN_IF_WAITING_FOR_DEBUGGER: - RunIfWaitingForDebugger(request); + response = RunIfWaitingForDebugger(request); break; case Method::GET_HEAP_USAGE: - GetHeapUsage(request); + response = GetHeapUsage(request, result); break; default: - SendResponse(request, DispatchResponse::Fail("unknown method: " + request.GetMethod())); + response = DispatchResponse::Fail("unknown method: " + request.GetMethod()); break; } + if (result) { + SendResponse(request, response, *result); + } else { + SendResponse(request, response); + } } RuntimeImpl::DispatcherImpl::Method RuntimeImpl::DispatcherImpl::GetMethodEnum(const std::string& method) @@ -69,32 +76,33 @@ RuntimeImpl::DispatcherImpl::Method RuntimeImpl::DispatcherImpl::GetMethodEnum(c } } -void RuntimeImpl::DispatcherImpl::Enable(const DispatchRequest &request) +DispatchResponse RuntimeImpl::DispatcherImpl::Enable(const DispatchRequest &request, + std::unique_ptr &result) { DispatchResponse response = runtime_->Enable(); runtime_->InitializeExtendedProtocolsList(); - EnableReturns result(runtime_->runtimeExtendedProtocols_); - SendResponse(request, response, result); + result = std::make_unique(runtime_->runtimeExtendedProtocols_); + return response; } -void RuntimeImpl::DispatcherImpl::Disable(const DispatchRequest &request) +DispatchResponse RuntimeImpl::DispatcherImpl::Disable(const DispatchRequest &request) { DispatchResponse response = runtime_->Disable(); - SendResponse(request, response); + return response; } -void RuntimeImpl::DispatcherImpl::RunIfWaitingForDebugger(const DispatchRequest &request) +DispatchResponse RuntimeImpl::DispatcherImpl::RunIfWaitingForDebugger(const DispatchRequest &request) { DispatchResponse response = runtime_->RunIfWaitingForDebugger(); - SendResponse(request, response); + return response; } -void RuntimeImpl::DispatcherImpl::GetProperties(const DispatchRequest &request) +DispatchResponse RuntimeImpl::DispatcherImpl::GetProperties(const DispatchRequest &request, + std::unique_ptr &result) { std::unique_ptr params = GetPropertiesParams::Create(request.GetParams()); if (params == nullptr) { - SendResponse(request, DispatchResponse::Fail("wrong params")); - return; + return DispatchResponse::Fail("wrong params"); } std::vector> outPropertyDesc; @@ -107,11 +115,11 @@ void RuntimeImpl::DispatcherImpl::GetProperties(const DispatchRequest &request) ASSERT(outExceptionDetails.value() != nullptr); LOG_DEBUGGER(WARN) << "GetProperties thrown an exception"; } - GetPropertiesReturns result(std::move(outPropertyDesc), + result = std::make_unique(std::move(outPropertyDesc), std::move(outInternalDescs), std::move(outPrivateProperties), std::move(outExceptionDetails)); - SendResponse(request, response, result); + return response; } std::string RuntimeImpl::DispatcherImpl::GetProperties( @@ -142,13 +150,14 @@ std::string RuntimeImpl::DispatcherImpl::GetProperties( return ReturnsValueToString(callId, result.ToJson()); } -void RuntimeImpl::DispatcherImpl::GetHeapUsage(const DispatchRequest &request) +DispatchResponse RuntimeImpl::DispatcherImpl::GetHeapUsage(const DispatchRequest &request, + std::unique_ptr &result) { double usedSize = 0; double totalSize = 0; DispatchResponse response = runtime_->GetHeapUsage(&usedSize, &totalSize); - GetHeapUsageReturns result(usedSize, totalSize); - SendResponse(request, response, result); + result = std::make_unique(usedSize, totalSize); + return response; } bool RuntimeImpl::Frontend::AllowNotify() const diff --git a/tooling/dynamic/agent/runtime_impl.h b/tooling/dynamic/agent/runtime_impl.h index 28040df3..30ef72de 100644 --- a/tooling/dynamic/agent/runtime_impl.h +++ b/tooling/dynamic/agent/runtime_impl.h @@ -47,12 +47,12 @@ public: ~DispatcherImpl() override = default; void Dispatch(const DispatchRequest &request) override; - void Disable(const DispatchRequest &request); - void Enable(const DispatchRequest &request); - void RunIfWaitingForDebugger(const DispatchRequest &request); - void GetProperties(const DispatchRequest &request); + DispatchResponse Disable(const DispatchRequest &request); + DispatchResponse Enable(const DispatchRequest &request, std::unique_ptr &result); + DispatchResponse RunIfWaitingForDebugger(const DispatchRequest &request); + DispatchResponse GetProperties(const DispatchRequest &request, std::unique_ptr &result); std::string GetProperties(const int32_t callId, std::unique_ptr params); - void GetHeapUsage(const DispatchRequest &request); + DispatchResponse GetHeapUsage(const DispatchRequest &request, std::unique_ptr &result); enum class Method { ENABLE, diff --git a/tooling/dynamic/test/debugger_impl_test.cpp b/tooling/dynamic/test/debugger_impl_test.cpp index 7d2b752a..734fa175 100644 --- a/tooling/dynamic/test/debugger_impl_test.cpp +++ b/tooling/dynamic/test/debugger_impl_test.cpp @@ -1493,13 +1493,16 @@ HWTEST_F_L0(DebuggerImplTest, DispatcherImplCallFunctionOn__001) std::string msg = std::string() + R"({"id":0,"method":"Debugger.callFunctionOn","params":{ "callFrameId":"0", "functionDeclaration":0}})"; DispatchRequest request(msg); - dispatcherImpl->CallFunctionOn(request); + std::unique_ptr result = nullptr; + DispatchResponse response = dispatcherImpl->CallFunctionOn(request, result); + protocolChannel->SendResponse(request, response, *result); ASSERT_TRUE(outStrForCallbackCheck.find("wrong params") != std::string::npos); msg = std::string() + R"({"id":0,"method":"Debugger.callFunctionOn","params":{ "callFrameId":"0", "functionDeclaration":"test"}})"; DispatchRequest request1(msg); - dispatcherImpl->CallFunctionOn(request1); + response = dispatcherImpl->CallFunctionOn(request1, result); + protocolChannel->SendResponse(request1, response, *result); ASSERT_TRUE(outStrForCallbackCheck.find("Unsupport eval now") == std::string::npos); if (protocolChannel != nullptr) { delete protocolChannel; diff --git a/tooling/dynamic/test/runtime_impl_test.cpp b/tooling/dynamic/test/runtime_impl_test.cpp index f7d9d908..3f3e1759 100644 --- a/tooling/dynamic/test/runtime_impl_test.cpp +++ b/tooling/dynamic/test/runtime_impl_test.cpp @@ -83,8 +83,10 @@ HWTEST_F_L0(RuntimeImplTest, DispatcherImplEnable) auto dispatcherImpl = std::make_unique(channel, std::move(runtimeImpl)); std::string msg = std::string() + R"({"id":0,"method":"Rumtime.enable","params":{}})"; + std::unique_ptr res = nullptr; DispatchRequest request1(msg); - dispatcherImpl->Enable(request1); + DispatchResponse response = dispatcherImpl->Enable(request1, res); + channel->SendResponse(request1, response, *res); ASSERT_TRUE(result.find("protocols") != std::string::npos); if (channel != nullptr) { delete channel; @@ -103,7 +105,8 @@ HWTEST_F_L0(RuntimeImplTest, DispatcherImplDisable) std::string msg = std::string() + R"({"id":0,"method":"Rumtime.disable","params":{}})"; DispatchRequest request1(msg); - dispatcherImpl->Disable(request1); + DispatchResponse response = dispatcherImpl->Disable(request1); + channel->SendResponse(request1, response, PtBaseReturns()); ASSERT_TRUE(result == "{\"id\":0,\"result\":{}}"); if (channel != nullptr) { delete channel; @@ -122,7 +125,8 @@ HWTEST_F_L0(RuntimeImplTest, DispatcherImplRunIfWaitingForDebugger) std::string msg = std::string() + R"({"id":0,"method":"Rumtime.runIfWaitingForDebugger","params":{}})"; DispatchRequest request1(msg); - dispatcherImpl->RunIfWaitingForDebugger(request1); + DispatchResponse response = dispatcherImpl->RunIfWaitingForDebugger(request1); + channel->SendResponse(request1, response, PtBaseReturns()); ASSERT_TRUE(result == "{\"id\":0,\"result\":{}}"); if (channel != nullptr) { delete channel; @@ -141,12 +145,15 @@ HWTEST_F_L0(RuntimeImplTest, DispatcherImplGetProperties__001) std::string msg = std::string() + R"({"id":0,"method":"Rumtime.getProperties","params":{"objectId":0}})"; DispatchRequest request(msg); - dispatcherImpl->GetProperties(request); + std::unique_ptr res = nullptr; + DispatchResponse response = dispatcherImpl->GetProperties(request, res); + channel->SendResponse(request, response, *res); ASSERT_TRUE(result.find("wrong params") != std::string::npos); msg = std::string() + R"({"id":0,"method":"Rumtime.getProperties","params":{"objectId":"0"}})"; DispatchRequest request1(msg); - dispatcherImpl->GetProperties(request1); + response = dispatcherImpl->GetProperties(request1, res); + channel->SendResponse(request1, response, *res); ASSERT_TRUE(result.find("Unknown object id") != std::string::npos); if (channel != nullptr) { delete channel; @@ -182,7 +189,9 @@ HWTEST_F_L0(RuntimeImplTest, DispatcherImplGetHeapUsage) std::string msg = std::string() + R"({"id":0,"method":"Rumtime.getHeapUsage ","params":{}})"; DispatchRequest request(msg); - dispatcherImpl->GetHeapUsage(request); + std::unique_ptr res = nullptr; + DispatchResponse response = dispatcherImpl->GetHeapUsage(request, res); + channel->SendResponse(request, response, *res); ASSERT_TRUE(result.find("usedSize") != std::string::npos); ASSERT_TRUE(result.find("totalSize") != std::string::npos); if (channel != nullptr) { -- Gitee