| // Copyright 2018 The Fuchsia 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/developer/debug/zxdb/client/mock_remote_api.h" | |
| #include <cstdint> | |
| #include <utility> | |
| #include <vector> | |
| #include "src/developer/debug/ipc/protocol.h" | |
| #include "src/developer/debug/shared/message_loop.h" | |
| #include "src/developer/debug/zxdb/common/err.h" | |
| namespace zxdb { | |
| MockRemoteAPI::MockRemoteAPI() = default; | |
| MockRemoteAPI::~MockRemoteAPI() = default; | |
| int MockRemoteAPI::GetAndResetResumeCount() { | |
| int result = resume_count_; | |
| resume_count_ = 0; | |
| return result; | |
| } | |
| void MockRemoteAPI::AddMemory(uint64_t address, std::vector<uint8_t> data) { | |
| memory_.AddMemory(address, std::move(data)); | |
| } | |
| void MockRemoteAPI::SetRegisterCategory(debug::RegisterCategory cat, | |
| std::vector<debug::RegisterValue> regs) { | |
| register_replies_[cat] = std::move(regs); | |
| } | |
| void MockRemoteAPI::Attach(const debug_ipc::AttachRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::AttachReply)> cb) { | |
| last_attach_ = request; | |
| debug_ipc::AttachReply reply; | |
| reply.koid = request.koid; | |
| reply.name = "<mock>"; | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, [cb = std::move(cb), reply] mutable { cb(Err(), reply); }); | |
| } | |
| void MockRemoteAPI::AddOrChangeBreakpoint( | |
| const debug_ipc::AddOrChangeBreakpointRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::AddOrChangeBreakpointReply)> cb) { | |
| breakpoint_add_count_++; | |
| last_breakpoint_add_ = request; | |
| debug::MessageLoop::Current()->PostTask(FROM_HERE, [cb = std::move(cb)] mutable { | |
| cb(Err(), debug_ipc::AddOrChangeBreakpointReply()); | |
| }); | |
| } | |
| void MockRemoteAPI::AddressSpace(const debug_ipc::AddressSpaceRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::AddressSpaceReply)> cb) { | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, | |
| [reply = address_space_reply_, cb = std::move(cb)] mutable { cb(Err(), std::move(reply)); }); | |
| } | |
| void MockRemoteAPI::RemoveBreakpoint( | |
| const debug_ipc::RemoveBreakpointRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::RemoveBreakpointReply)> cb) { | |
| breakpoint_remove_count_++; | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, [cb = std::move(cb)] mutable { cb(Err(), debug_ipc::RemoveBreakpointReply()); }); | |
| } | |
| void MockRemoteAPI::ThreadStatus(const debug_ipc::ThreadStatusRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::ThreadStatusReply)> cb) { | |
| debug_ipc::ThreadStatusReply reply; | |
| if (auto maybe_reply = thread_status_reply_) { | |
| reply = *maybe_reply; | |
| } else { | |
| // We can't really fill anything in, but make sure we at least have the same process and thread | |
| // ids as the request. | |
| reply.record.id = request.id; | |
| } | |
| // Returns the canned response. | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, [cb = std::move(cb), reply] mutable { cb(Err(), std::move(reply)); }); | |
| } | |
| void MockRemoteAPI::Pause(const debug_ipc::PauseRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::PauseReply)> cb) { | |
| // Returns the canned response. | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, | |
| [cb = std::move(cb), response = pause_reply_] mutable { cb(Err(), std::move(response)); }); | |
| } | |
| void MockRemoteAPI::Resume(const debug_ipc::ResumeRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::ResumeReply)> cb) { | |
| // Always returns success. | |
| resume_count_++; | |
| last_resume_ = request; | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, [cb = std::move(cb), resume_quits_loop = resume_quits_loop_] mutable { | |
| cb(Err(), debug_ipc::ResumeReply()); | |
| if (resume_quits_loop) { | |
| debug::MessageLoop::Current()->QuitNow(); | |
| } | |
| }); | |
| } | |
| void MockRemoteAPI::ReadMemory(const debug_ipc::ReadMemoryRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::ReadMemoryReply)> cb) { | |
| read_memory_requests_.push_back(request); | |
| read_memory_total_bytes_ += request.size; | |
| std::vector<uint8_t> result = memory_.ReadMemory(request.address, request.size); | |
| debug::MessageLoop::Current()->PostTask(FROM_HERE, [request, result, cb = std::move(cb)] mutable { | |
| debug_ipc::ReadMemoryReply reply; | |
| // For now this is very simple and returns the result as one block. A more complete | |
| // implementation would convert short reads into multiple blocks. | |
| reply.blocks.resize(1); | |
| auto& block = reply.blocks[0]; | |
| block.address = request.address; | |
| block.valid = request.size > 0 && !result.empty(); | |
| block.size = block.valid ? static_cast<uint32_t>(result.size()) : request.size; | |
| if (block.valid) { | |
| block.data = std::move(result); | |
| } | |
| cb(Err(), std::move(reply)); | |
| }); | |
| } | |
| void MockRemoteAPI::ReadRegisters( | |
| const debug_ipc::ReadRegistersRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::ReadRegistersReply)> cb) { | |
| debug_ipc::ReadRegistersReply reply; | |
| for (const auto& cat : request.categories) { | |
| const auto& regs = register_replies_[cat]; | |
| reply.registers.insert(reply.registers.end(), regs.begin(), regs.end()); | |
| } | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, [reply, cb = std::move(cb)] mutable { cb(Err(), reply); }); | |
| } | |
| void MockRemoteAPI::WriteRegisters( | |
| const debug_ipc::WriteRegistersRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::WriteRegistersReply)> cb) { | |
| last_write_registers_ = request; | |
| debug::MessageLoop::Current()->PostTask(FROM_HERE, [cb = std::move(cb)] mutable { | |
| debug_ipc::WriteRegistersReply reply; | |
| cb(Err(), reply); | |
| }); | |
| } | |
| void MockRemoteAPI::Detach(const debug_ipc::DetachRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::DetachReply)> cb) { | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, [cb = std::move(cb)] mutable { cb(Err(), debug_ipc::DetachReply()); }); | |
| } | |
| void MockRemoteAPI::Kill(const debug_ipc::KillRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::KillReply)> cb) { | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, [cb = std::move(cb)] mutable { cb(Err(), debug_ipc::KillReply()); }); | |
| } | |
| void MockRemoteAPI::Modules(const debug_ipc::ModulesRequest& request, | |
| fit::callback<void(const Err&, debug_ipc::ModulesReply)> cb) { | |
| debug::MessageLoop::Current()->PostTask( | |
| FROM_HERE, [cb = std::move(cb)] mutable { cb(Err(), debug_ipc::ModulesReply()); }); | |
| } | |
| } // namespace zxdb |