Apply CZipArchiveWriter refactoring.

Source/FrameDump.cpp

@@ -136,29 +136,29 @@ void CFrameDump::Write(Framework::CStream& output) const
 {
 	Framework::CZipArchiveWriter archive;
 
-	archive.InsertFile(new CMemoryStateFile(STATE_INITIAL_GSRAM, m_initialGsRam, CGSHandler::RAMSIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_INITIAL_GSRAM, m_initialGsRam, CGSHandler::RAMSIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_INITIAL_GSREGS, m_initialGsRegisters, sizeof(uint64) * CGSHandler::REGISTER_MAX));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_INITIAL_GSREGS, m_initialGsRegisters, sizeof(uint64) * CGSHandler::REGISTER_MAX));
 
 	{
-		auto privRegsStateFile = new CRegisterStateFile(STATE_INITIAL_GSPRIVREGS);
+		auto privRegsStateFile = std::make_unique<CRegisterStateFile>(STATE_INITIAL_GSPRIVREGS);
 		privRegsStateFile->SetRegister64(STATE_PRIVREG_SMODE2, m_initialSMODE2);
-		archive.InsertFile(privRegsStateFile);
+		archive.InsertFile(std::move(privRegsStateFile));
 	}
 
 	unsigned int currentPacket = 0;
 	for(const auto& packet : m_packets)
 	{
 		auto packetMetadataFileName = STATE_PACKET_METADATA_PREFIX + std::to_string(currentPacket);
-		archive.InsertFile(new CMemoryStateFile(packetMetadataFileName.c_str(), &packet.metadata, sizeof(CGsPacketMetadata)));
+		archive.InsertFile(std::make_unique<CMemoryStateFile>(packetMetadataFileName.c_str(), &packet.metadata, sizeof(CGsPacketMetadata)));
 		if(!packet.registerWrites.empty())
 		{
 			auto packetRegisterWritesFileName = STATE_PACKET_REGISTERWRITES_PREFIX + std::to_string(currentPacket);
-			archive.InsertFile(new CMemoryStateFile(packetRegisterWritesFileName.c_str(), packet.registerWrites.data(), packet.registerWrites.size() * sizeof(CGSHandler::RegisterWrite)));
+			archive.InsertFile(std::make_unique<CMemoryStateFile>(packetRegisterWritesFileName.c_str(), packet.registerWrites.data(), packet.registerWrites.size() * sizeof(CGSHandler::RegisterWrite)));
 		}
 		if(!packet.imageData.empty())
 		{
 			auto packetImageDataName = STATE_PACKET_IMAGEDATA_PREFIX + std::to_string(currentPacket);
-			archive.InsertFile(new CMemoryStateFile(packetImageDataName.c_str(), packet.imageData.data(), packet.imageData.size()));
+			archive.InsertFile(std::make_unique<CMemoryStateFile>(packetImageDataName.c_str(), packet.imageData.data(), packet.imageData.size()));
 		}
 		currentPacket++;
 	}

Source/PS2VM.cpp

@@ -563,12 +563,12 @@ bool CPS2VM::LoadVMState(const fs::path& statePath)
 
 void CPS2VM::SaveVmTimingState(Framework::CZipArchiveWriter& archive)
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_VM_TIMING_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_VM_TIMING_XML);
 	registerFile->SetRegister32(STATE_VM_TIMING_VBLANK_TICKS, m_vblankTicks);
 	registerFile->SetRegister32(STATE_VM_TIMING_IN_VBLANK, m_inVblank);
 	registerFile->SetRegister32(STATE_VM_TIMING_EE_EXECUTION_TICKS, m_eeExecutionTicks);
 	registerFile->SetRegister32(STATE_VM_TIMING_IOP_EXECUTION_TICKS, m_iopExecutionTicks);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CPS2VM::LoadVmTimingState(Framework::CZipArchiveReader& archive)

Source/ee/DMAC.cpp

@@ -1025,7 +1025,7 @@ void CDMAC::LoadState(Framework::CZipArchiveReader& archive)
 
 void CDMAC::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 	registerFile->SetRegister32(STATE_REGS_CTRL, m_D_CTRL);
 	registerFile->SetRegister32(STATE_REGS_STAT, m_D_STAT);
 	registerFile->SetRegister32(STATE_REGS_ENABLE, m_D_ENABLE);
@@ -1046,7 +1046,7 @@ void CDMAC::SaveState(Framework::CZipArchiveWriter& archive)
 	registerFile->SetRegister32(STATE_REGS_D6_TADR, m_D6_TADR);
 	registerFile->SetRegister32(STATE_REGS_D8_SADR, m_D8_SADR);
 	registerFile->SetRegister32(STATE_REGS_D9_SADR, m_D9_SADR);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 
 	m_D0.SaveState(archive);
 	m_D1.SaveState(archive);

Source/ee/Dmac_Channel.cpp

@@ -43,7 +43,7 @@ void CChannel::Reset()
 void CChannel::SaveState(Framework::CZipArchiveWriter& archive)
 {
 	auto path = string_format(STATE_REGS_XML_FORMAT, m_number);
-	CRegisterStateFile* registerFile = new CRegisterStateFile(path.c_str());
+	auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
 	registerFile->SetRegister32(STATE_REGS_CHCR, m_CHCR);
 	registerFile->SetRegister32(STATE_REGS_MADR, m_nMADR);
 	registerFile->SetRegister32(STATE_REGS_QWC, m_nQWC);
@@ -51,7 +51,7 @@ void CChannel::SaveState(Framework::CZipArchiveWriter& archive)
 	registerFile->SetRegister32(STATE_REGS_SCCTRL, m_nSCCTRL);
 	registerFile->SetRegister32(STATE_REGS_ASR0, m_nASR[0]);
 	registerFile->SetRegister32(STATE_REGS_ASR1, m_nASR[1]);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CChannel::LoadState(Framework::CZipArchiveReader& archive)

Source/ee/Ee_LibMc2.cpp

@@ -49,12 +49,12 @@ void CLibMc2::Reset()
 
 void CLibMc2::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	auto registerFile = new CRegisterStateFile(STATE_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_XML);
 	registerFile->SetRegister32(STATE_LAST_CMD, m_lastCmd);
 	registerFile->SetRegister32(STATE_LAST_RESULT, m_lastResult);
 	registerFile->SetRegister32(STATE_WAIT_THREADID, m_waitThreadId);
 	registerFile->SetRegister32(STATE_WAIT_VBLANK_COUNT, m_waitVBlankCount);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CLibMc2::LoadState(Framework::CZipArchiveReader& archive)

Source/ee/Ee_SubSystem.cpp

@@ -362,15 +362,15 @@ void CSubSystem::NotifyVBlankEnd()
 
 void CSubSystem::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	archive.InsertFile(new CMemoryStateFile(STATE_EE, &m_EE.m_State, sizeof(MIPSSTATE)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_EE, &m_EE.m_State, sizeof(MIPSSTATE)));
-	archive.InsertFile(new CMemoryStateFile(STATE_VU0, &m_VU0.m_State, sizeof(MIPSSTATE)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_VU0, &m_VU0.m_State, sizeof(MIPSSTATE)));
-	archive.InsertFile(new CMemoryStateFile(STATE_VU1, &m_VU1.m_State, sizeof(MIPSSTATE)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_VU1, &m_VU1.m_State, sizeof(MIPSSTATE)));
-	archive.InsertFile(new CMemoryStateFile(STATE_RAM, m_ram, PS2::EE_RAM_SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_RAM, m_ram, PS2::EE_RAM_SIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_SPR, m_spr, PS2::EE_SPR_SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_SPR, m_spr, PS2::EE_SPR_SIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_VUMEM0, m_vuMem0, PS2::VUMEM0SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_VUMEM0, m_vuMem0, PS2::VUMEM0SIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_MICROMEM0, m_microMem0, PS2::MICROMEM0SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_MICROMEM0, m_microMem0, PS2::MICROMEM0SIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_VUMEM1, m_vuMem1, PS2::VUMEM1SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_VUMEM1, m_vuMem1, PS2::VUMEM1SIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_MICROMEM1, m_microMem1, PS2::MICROMEM1SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_MICROMEM1, m_microMem1, PS2::MICROMEM1SIZE));
 
 	m_dmac.SaveState(archive);
 	m_intc.SaveState(archive);

Source/ee/GIF.cpp

@@ -77,7 +77,7 @@ void CGIF::LoadState(Framework::CZipArchiveReader& archive)
 
 void CGIF::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 	registerFile->SetRegister32(STATE_REGS_M3P, m_path3Masked ? 1 : 0);
 	registerFile->SetRegister32(STATE_REGS_ACTIVEPATH, m_activePath);
 	registerFile->SetRegister32(STATE_REGS_MODE, m_MODE);
@@ -91,7 +91,7 @@ void CGIF::SaveState(Framework::CZipArchiveWriter& archive)
 	registerFile->SetRegister32(STATE_REGS_PATH3_XFER_ACTIVE_TICKS, m_path3XferActiveTicks);
 	registerFile->SetRegister128(STATE_REGS_FIFO_BUFFER, *reinterpret_cast<uint128*>(&m_fifoBuffer));
 	registerFile->SetRegister32(STATE_REGS_FIFO_INDEX, m_fifoIndex);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 uint32 CGIF::ProcessPacked(const uint8* memory, uint32 address, uint32 end)

Source/ee/INTC.cpp

@@ -71,8 +71,8 @@ void CINTC::LoadState(Framework::CZipArchiveReader& archive)
 
 void CINTC::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 	registerFile->SetRegister32("INTC_STAT", m_INTC_STAT);
 	registerFile->SetRegister32("INTC_MASK", m_INTC_MASK);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }

Source/ee/SIF.cpp

@@ -313,7 +313,7 @@ void CSIF::LoadState(Framework::CZipArchiveReader& archive)
 void CSIF::SaveState(Framework::CZipArchiveWriter& archive)
 {
 	{
-		auto registerFile = new CRegisterStateFile(STATE_REGS_XML);
+		auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 		registerFile->SetRegister32(STATE_REG_MAINADDR, m_nMAINADDR);
 		registerFile->SetRegister32(STATE_REG_SUBADDR, m_nSUBADDR);
 		registerFile->SetRegister32(STATE_REG_MSFLAG, m_nMSFLAG);
@@ -321,10 +321,10 @@ void CSIF::SaveState(Framework::CZipArchiveWriter& archive)
 		registerFile->SetRegister32(STATE_REG_EERECVADDR, m_nEERecvAddr);
 		registerFile->SetRegister32(STATE_REG_DATAADDR, m_nDataAddr);
 		registerFile->SetRegister32(STATE_REG_PACKETPROCESSED, m_packetProcessed);
-		archive.InsertFile(registerFile);
+		archive.InsertFile(std::move(registerFile));
 	}
 
-	archive.InsertFile(new CMemoryStateFile(STATE_PACKETQUEUE, m_packetQueue.data(), m_packetQueue.size()));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_PACKETQUEUE, m_packetQueue.data(), m_packetQueue.size()));
 
 	SaveCallReplies(archive);
 	SaveBindReplies(archive);
@@ -332,7 +332,7 @@ void CSIF::SaveState(Framework::CZipArchiveWriter& archive)
 
 void CSIF::SaveCallReplies(Framework::CZipArchiveWriter& archive)
 {
-	auto callRepliesFile = new CStructCollectionStateFile(STATE_CALL_REPLIES_XML);
+	auto callRepliesFile = std::make_unique<CStructCollectionStateFile>(STATE_CALL_REPLIES_XML);
 	for(const auto& callReplyIterator : m_callReplies)
 	{
 		const auto& callReply(callReplyIterator.second);
@@ -344,12 +344,12 @@ void CSIF::SaveCallReplies(Framework::CZipArchiveWriter& archive)
 		}
 		callRepliesFile->InsertStruct(replyId.c_str(), replyStruct);
 	}
-	archive.InsertFile(callRepliesFile);
+	archive.InsertFile(std::move(callRepliesFile));
 }
 
 void CSIF::SaveBindReplies(Framework::CZipArchiveWriter& archive)
 {
-	auto bindRepliesFile = new CStructCollectionStateFile(STATE_BIND_REPLIES_XML);
+	auto bindRepliesFile = std::make_unique<CStructCollectionStateFile>(STATE_BIND_REPLIES_XML);
 	for(const auto& bindReplyIterator : m_bindReplies)
 	{
 		const auto& bindReply(bindReplyIterator.second);
@@ -361,7 +361,7 @@ void CSIF::SaveBindReplies(Framework::CZipArchiveWriter& archive)
 		replyStruct.SetRegister32(STATE_BIND_REPLY_TIMEOUT, bindReply.timeout);
 		bindRepliesFile->InsertStruct(replyId.c_str(), replyStruct);
 	}
-	archive.InsertFile(bindRepliesFile);
+	archive.InsertFile(std::move(bindRepliesFile));
 }
 
 CSIF::PacketQueue CSIF::LoadPacketQueue(Framework::CZipArchiveReader& archive)

Source/ee/Timer.cpp

@@ -259,7 +259,7 @@ void CTimer::LoadState(Framework::CZipArchiveReader& archive)
 
 void CTimer::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 	for(unsigned int i = 0; i < MAX_TIMER; i++)
 	{
 		const auto& timer = m_timer[i];
@@ -270,7 +270,7 @@ void CTimer::SaveState(Framework::CZipArchiveWriter& archive)
 		registerFile->SetRegister32((timerPrefix + "HOLD").c_str(), timer.nHOLD);
 		registerFile->SetRegister32((timerPrefix + "REM").c_str(), timer.clockRemain);
 	}
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CTimer::NotifyVBlankStart()

Source/ee/Vif.cpp

@@ -268,7 +268,7 @@ void CVif::SaveState(Framework::CZipArchiveWriter& archive)
 {
 	{
 		auto path = string_format(STATE_PATH_REGS_FORMAT, m_number);
-		auto registerFile = new CRegisterStateFile(path.c_str());
+		auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
 		registerFile->SetRegister32(STATE_REGS_STAT, m_STAT);
 		registerFile->SetRegister32(STATE_REGS_ERR, m_ERR);
 		registerFile->SetRegister32(STATE_REGS_CODE, m_CODE);
@@ -295,11 +295,11 @@ void CVif::SaveState(Framework::CZipArchiveWriter& archive)
 		registerFile->SetRegister32(STATE_REGS_INTERRUPTDELAYTICKS, m_interruptDelayTicks);
 		registerFile->SetRegister128(STATE_REGS_STREAM_BUFFER, m_stream.GetBuffer());
 		registerFile->SetRegister32(STATE_REGS_STREAM_BUFFERPOSITION, m_stream.GetBufferPosition());
-		archive.InsertFile(registerFile);
+		archive.InsertFile(std::move(registerFile));
 	}
 	{
 		auto path = string_format(STATE_PATH_FIFO_FORMAT, m_number);
-		archive.InsertFile(new CMemoryStateFile(path.c_str(), &m_fifoBuffer, sizeof(m_fifoBuffer)));
+		archive.InsertFile(std::make_unique<CMemoryStateFile>(path.c_str(), &m_fifoBuffer, sizeof(m_fifoBuffer)));
 	}
 }
 

Source/ee/Vif1.cpp

@@ -38,14 +38,14 @@ void CVif1::SaveState(Framework::CZipArchiveWriter& archive)
 	CVif::SaveState(archive);
 
 	auto path = string_format(STATE_PATH_FORMAT, m_number);
-	CRegisterStateFile* registerFile = new CRegisterStateFile(path.c_str());
+	auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
 	registerFile->SetRegister32(STATE_REGS_BASE, m_BASE);
 	registerFile->SetRegister32(STATE_REGS_TOP, m_TOP);
 	registerFile->SetRegister32(STATE_REGS_TOPS, m_TOPS);
 	registerFile->SetRegister32(STATE_REGS_OFST, m_OFST);
 	registerFile->SetRegister128(STATE_REGS_DIRECTQWORDBUFFER, *reinterpret_cast<uint128*>(&m_directQwordBuffer));
 	registerFile->SetRegister32(STATE_REGS_DIRECTQWORDBUFFER_INDEX, m_directQwordBufferIndex);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CVif1::LoadState(Framework::CZipArchiveReader& archive)

Source/ee/Vpu.cpp

@@ -113,9 +113,9 @@ void CVpu::SaveState(Framework::CZipArchiveWriter& archive)
 {
 	{
 		auto path = string_format(STATE_PATH_REGS_FORMAT, m_number);
-		auto registerFile = new CRegisterStateFile(path.c_str());
+		auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
 		registerFile->SetRegister32(STATE_REGS_RUNNING, m_running);
-		archive.InsertFile(registerFile);
+		archive.InsertFile(std::move(registerFile));
 	}
 
 	m_vif->SaveState(archive);

Source/gs/GSHandler.cpp

@@ -245,12 +245,12 @@ void CGSHandler::SaveState(Framework::CZipArchiveWriter& archive)
 {
 	SendGSCall([&]() { SyncMemoryCache(); }, true);
 
-	archive.InsertFile(new CMemoryStateFile(STATE_RAM, GetRam(), RAMSIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_RAM, GetRam(), RAMSIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_REGS, m_nReg, sizeof(uint64) * CGSHandler::REGISTER_MAX));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_REGS, m_nReg, sizeof(uint64) * CGSHandler::REGISTER_MAX));
-	archive.InsertFile(new CMemoryStateFile(STATE_TRXCTX, &m_trxCtx, sizeof(TRXCONTEXT)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_TRXCTX, &m_trxCtx, sizeof(TRXCONTEXT)));
 
 	{
-		CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_PRIVREGS);
+		auto registerFile = std::make_unique<CRegisterStateFile>(STATE_PRIVREGS);
 
 		registerFile->SetRegister64(STATE_PRIVREGS_PMODE, m_nPMODE);
 		registerFile->SetRegister64(STATE_PRIVREGS_SMODE2, m_nSMODE2);
@@ -266,7 +266,7 @@ void CGSHandler::SaveState(Framework::CZipArchiveWriter& archive)
 		registerFile->SetRegister32(STATE_REG_CBP0, m_nCBP0);
 		registerFile->SetRegister32(STATE_REG_CBP1, m_nCBP1);
 
-		archive.InsertFile(registerFile);
+		archive.InsertFile(std::move(registerFile));
 	}
 }
 

Source/iop/IopBios.cpp

@@ -326,7 +326,7 @@ uint32& CIopBios::ModuleStartRequestFree() const
 
 void CIopBios::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	CStructCollectionStateFile* modulesFile = new CStructCollectionStateFile(STATE_MODULES);
+	auto modulesFile = std::make_unique<CStructCollectionStateFile>(STATE_MODULES);
 	{
 		for(const auto& modulePair : m_modules)
 		{
@@ -341,7 +341,7 @@ void CIopBios::SaveState(Framework::CZipArchiveWriter& archive)
 			}
 		}
 	}
-	archive.InsertFile(modulesFile);
+	archive.InsertFile(std::move(modulesFile));
 
 	auto builtInModules = GetBuiltInModules();
 	for(const auto& module : builtInModules)
@@ -349,7 +349,7 @@ void CIopBios::SaveState(Framework::CZipArchiveWriter& archive)
 		module->SaveState(archive);
 	}
 
-	archive.InsertFile(new CMemoryStateFile(STATE_MODULESTARTREQUESTS, m_moduleStartRequests, sizeof(m_moduleStartRequests)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_MODULESTARTREQUESTS, m_moduleStartRequests, sizeof(m_moduleStartRequests)));
 }
 
 void CIopBios::LoadState(Framework::CZipArchiveReader& archive)

Source/iop/Iop_Cdvdfsv.cpp

@@ -139,7 +139,7 @@ void CCdvdfsv::LoadState(Framework::CZipArchiveReader& archive)
 
 void CCdvdfsv::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto registerFile = new CRegisterStateFile(STATE_FILENAME);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_FILENAME);
 
 	registerFile->SetRegister32(STATE_PENDINGCOMMAND, m_pendingCommand);
 	registerFile->SetRegister32(STATE_PENDINGREADSECTOR, m_pendingReadSector);
@@ -150,7 +150,7 @@ void CCdvdfsv::SaveState(Framework::CZipArchiveWriter& archive) const
 	registerFile->SetRegister32(STATE_STREAMPOS, m_streamPos);
 	registerFile->SetRegister32(STATE_STREAMBUFFERSIZE, m_streamBufferSize);
 
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CCdvdfsv::Invoke(CMIPS& context, unsigned int functionId)

Source/iop/Iop_Cdvdman.cpp

@@ -66,13 +66,13 @@ void CCdvdman::LoadState(Framework::CZipArchiveReader& archive)
 
 void CCdvdman::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto registerFile = new CRegisterStateFile(STATE_FILENAME);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_FILENAME);
 	registerFile->SetRegister32(STATE_CALLBACK_ADDRESS, m_callbackPtr);
 	registerFile->SetRegister32(STATE_STATUS, m_status);
 	registerFile->SetRegister32(STATE_DISCCHANGED, m_discChanged);
 	registerFile->SetRegister32(STATE_PENDING_COMMAND, m_pendingCommand);
 	registerFile->SetRegister32(STATE_PENDING_COMMAND_DELAY, m_pendingCommandDelay);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 static uint8 Uint8ToBcd(uint8 input)

Source/iop/Iop_Dmac.cpp

@@ -209,12 +209,12 @@ void CDmac::LoadState(Framework::CZipArchiveReader& archive)
 void CDmac::SaveState(Framework::CZipArchiveWriter& archive)
 {
 	{
-		auto registerFile = new CRegisterStateFile(STATE_REGS_XML);
+		auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 		registerFile->SetRegister32(STATE_REGS_DPCR, m_DPCR);
 		registerFile->SetRegister32(STATE_REGS_DPCR2, m_DPCR2);
 		registerFile->SetRegister32(STATE_REGS_DPCR3, m_DPCR3);
 		registerFile->SetRegister32(STATE_REGS_DICR, m_DICR);
-		archive.InsertFile(registerFile);
+		archive.InsertFile(std::move(registerFile));
 	}
 
 	for(unsigned int i = 0; i < MAX_CHANNEL; i++)

Source/iop/Iop_DmacChannel.cpp

@@ -41,11 +41,11 @@ void CChannel::LoadState(Framework::CZipArchiveReader& archive)
 void CChannel::SaveState(Framework::CZipArchiveWriter& archive)
 {
 	auto path = string_format(STATE_REGS_XML_FORMAT, m_number);
-	auto registerFile = new CRegisterStateFile(path.c_str());
+	auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
 	registerFile->SetRegister32(STATE_REGS_CHCR, m_CHCR);
 	registerFile->SetRegister32(STATE_REGS_BCR, m_BCR);
 	registerFile->SetRegister32(STATE_REGS_MADR, m_MADR);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CChannel::SetReceiveFunction(const ReceiveFunctionType& receiveFunction)

Source/iop/Iop_FileIo.cpp

@@ -111,9 +111,9 @@ void CFileIo::LoadState(Framework::CZipArchiveReader& archive)
 
 void CFileIo::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto registerFile = new CRegisterStateFile(STATE_VERSION_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_VERSION_XML);
 	registerFile->SetRegister32(STATE_VERSION_MODULEVERSION, m_moduleVersion);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 	m_handler->SaveState(archive);
 }
 

Source/iop/Iop_FileIoHandler1000.cpp

@@ -43,10 +43,10 @@ void CFileIoHandler1000::LoadState(Framework::CZipArchiveReader& archive)
 
 void CFileIoHandler1000::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto registerFile = new CRegisterStateFile(STATE_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_XML);
 	registerFile->SetRegister32(STATE_MODULEDATAADDR, m_moduleDataAddr);
 	registerFile->SetRegister32(STATE_TRAMPOLINEADDR, m_trampolineAddr);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CFileIoHandler1000::AllocateMemory()

Source/iop/Iop_FileIoHandler2200.cpp

@@ -120,15 +120,15 @@ void CFileIoHandler2200::LoadState(Framework::CZipArchiveReader& archive)
 void CFileIoHandler2200::SaveState(Framework::CZipArchiveWriter& archive) const
 {
 	{
-		auto registerFile = new CRegisterStateFile(STATE_XML);
+		auto registerFile = std::make_unique<CRegisterStateFile>(STATE_XML);
 		registerFile->SetRegister32(STATE_RESULTPTR0, m_resultPtr[0]);
 		registerFile->SetRegister32(STATE_RESULTPTR1, m_resultPtr[1]);
-		archive.InsertFile(registerFile);
+		archive.InsertFile(std::move(registerFile));
 	}
 
 	{
-		auto memoryFile = new CMemoryStateFile(STATE_PENDINGREPLY, &m_pendingReply, sizeof(m_pendingReply));
+		auto memoryFile = std::make_unique<CMemoryStateFile>(STATE_PENDINGREPLY, &m_pendingReply, sizeof(m_pendingReply));
-		archive.InsertFile(memoryFile);
+		archive.InsertFile(std::move(memoryFile));
 	}
 }
 

Source/iop/Iop_Ilink.cpp

@@ -50,7 +50,7 @@ void CIlink::LoadState(Framework::CZipArchiveReader& archive)
 
 void CIlink::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 	registerFile->SetRegister32(STATE_REGS_CTRL2, m_ctrl2);
 	registerFile->SetRegister32(STATE_REGS_PHYRESULT, m_phyResult);
 	registerFile->SetRegister32(STATE_REGS_INTR0, m_intr0);
@@ -59,7 +59,7 @@ void CIlink::SaveState(Framework::CZipArchiveWriter& archive)
 	registerFile->SetRegister32(STATE_REGS_INTR1MASK, m_intr1Mask);
 	registerFile->SetRegister32(STATE_REGS_INTR2, m_intr2);
 	registerFile->SetRegister32(STATE_REGS_INTR2MASK, m_intr2Mask);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 uint32 CIlink::ReadRegister(uint32 address)

Source/iop/Iop_Intc.cpp

@@ -22,10 +22,10 @@ void CIntc::LoadState(Framework::CZipArchiveReader& archive)
 
 void CIntc::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 	registerFile->SetRegister64(STATE_REGS_STATUS, m_status.f);
 	registerFile->SetRegister64(STATE_REGS_MASK, m_mask.f);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 uint32 CIntc::ReadRegister(uint32 address)

Source/iop/Iop_Ioman.cpp

@@ -1050,7 +1050,7 @@ void CIoman::LoadState(Framework::CZipArchiveReader& archive)
 
 void CIoman::SaveFilesState(Framework::CZipArchiveWriter& archive) const
 {
-	auto fileStateFile = new CXmlStateFile(STATE_FILES_FILENAME, STATE_FILES_FILESNODE);
+	auto fileStateFile = std::make_unique<CXmlStateFile>(STATE_FILES_FILENAME, STATE_FILES_FILESNODE);
 	auto filesStateNode = fileStateFile->GetRoot();
 
 	for(const auto& filePair : m_files)
@@ -1068,12 +1068,12 @@ void CIoman::SaveFilesState(Framework::CZipArchiveWriter& archive) const
 		filesStateNode->InsertNode(fileStateNode);
 	}
 
-	archive.InsertFile(fileStateFile);
+	archive.InsertFile(std::move(fileStateFile));
 }
 
 void CIoman::SaveUserDevicesState(Framework::CZipArchiveWriter& archive) const
 {
-	auto deviceStateFile = new CXmlStateFile(STATE_USERDEVICES_FILENAME, STATE_USERDEVICES_DEVICESNODE);
+	auto deviceStateFile = std::make_unique<CXmlStateFile>(STATE_USERDEVICES_FILENAME, STATE_USERDEVICES_DEVICESNODE);
 	auto devicesStateNode = deviceStateFile->GetRoot();
 
 	for(const auto& devicePair : m_userDevices)
@@ -1084,12 +1084,12 @@ void CIoman::SaveUserDevicesState(Framework::CZipArchiveWriter& archive) const
 		devicesStateNode->InsertNode(deviceStateNode);
 	}
 
-	archive.InsertFile(deviceStateFile);
+	archive.InsertFile(std::move(deviceStateFile));
 }
 
 void CIoman::SaveMountedDevicesState(Framework::CZipArchiveWriter& archive) const
 {
-	auto deviceStateFile = new CXmlStateFile(STATE_MOUNTEDDEVICES_FILENAME, STATE_MOUNTEDDEVICES_DEVICESNODE);
+	auto deviceStateFile = std::make_unique<CXmlStateFile>(STATE_MOUNTEDDEVICES_FILENAME, STATE_MOUNTEDDEVICES_DEVICESNODE);
 	auto devicesStateNode = deviceStateFile->GetRoot();
 
 	for(const auto& devicePair : m_mountedDevices)
@@ -1100,7 +1100,7 @@ void CIoman::SaveMountedDevicesState(Framework::CZipArchiveWriter& archive) cons
 		devicesStateNode->InsertNode(deviceStateNode);
 	}
 
-	archive.InsertFile(deviceStateFile);
+	archive.InsertFile(std::move(deviceStateFile));
 }
 
 void CIoman::LoadFilesState(Framework::CZipArchiveReader& archive)

Source/iop/Iop_Loadcore.cpp

@@ -142,9 +142,9 @@ void CLoadcore::LoadState(Framework::CZipArchiveReader& archive)
 
 void CLoadcore::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto registerFile = new CRegisterStateFile(STATE_VERSION_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_VERSION_XML);
 	registerFile->SetRegister32(STATE_VERSION_MODULEVERSION, m_moduleVersion);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CLoadcore::SetLoadExecutableHandler(const LoadExecutableHandler& loadExecutableHandler)

Source/iop/Iop_McServ.cpp

@@ -1141,7 +1141,7 @@ void CMcServ::LoadState(Framework::CZipArchiveReader& archive)
 
 void CMcServ::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto stateFile = new CXmlStateFile(STATE_MEMCARDS_FILE, STATE_MEMCARDS_NODE);
+	auto stateFile = std::make_unique<CXmlStateFile>(STATE_MEMCARDS_FILE, STATE_MEMCARDS_NODE);
 	auto stateNode = stateFile->GetRoot();
 
 	for(unsigned int i = 0; i < MAX_PORTS; i++)
@@ -1152,7 +1152,7 @@ void CMcServ::SaveState(Framework::CZipArchiveWriter& archive) const
 		stateNode->InsertNode(cardNode);
 	}
 
-	archive.InsertFile(stateFile);
+	archive.InsertFile(std::move(stateFile));
 }
 
 /////////////////////////////////////////////

Source/iop/Iop_NamcoArcade.cpp

@@ -453,10 +453,10 @@ void CNamcoArcade::ProcessJvsPacket(const uint8* input, uint8* output)
 
 void CNamcoArcade::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto registerFile = new CRegisterStateFile(STATE_FILE);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_FILE);
 	registerFile->SetRegister32(STATE_RECV_ADDR, m_recvAddr);
 	registerFile->SetRegister32(STATE_SEND_ADDR, m_sendAddr);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CNamcoArcade::LoadState(Framework::CZipArchiveReader& archive)

Source/iop/Iop_PadMan.cpp

@@ -77,13 +77,13 @@ bool CPadMan::Invoke(uint32 method, uint32* args, uint32 argsSize, uint32* ret,
 
 void CPadMan::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_PADDATA);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_PADDATA);
 
 	registerFile->SetRegister32(STATE_PADDATA_PAD0_ADDRESS, m_padDataAddress[0]);
 	registerFile->SetRegister32(STATE_PADDATA_PAD1_ADDRESS, m_padDataAddress[1]);
 	registerFile->SetRegister32(STATE_PADDATA_TYPE, m_padDataType);
 
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CPadMan::LoadState(Framework::CZipArchiveReader& archive)

Source/iop/Iop_RootCounters.cpp

@@ -99,7 +99,7 @@ void CRootCounters::LoadState(Framework::CZipArchiveReader& archive)
 
 void CRootCounters::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 	for(unsigned int i = 0; i < MAX_COUNTERS; i++)
 	{
 		const auto& counter = m_counter[i];
@@ -109,7 +109,7 @@ void CRootCounters::SaveState(Framework::CZipArchiveWriter& archive)
 		registerFile->SetRegister32((counterPrefix + "TGT").c_str(), counter.target);
 		registerFile->SetRegister32((counterPrefix + "REM").c_str(), counter.clockRemain);
 	}
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CRootCounters::Update(unsigned int ticks)

Source/iop/Iop_SifCmd.cpp

@@ -93,7 +93,7 @@ void CSifCmd::LoadState(Framework::CZipArchiveReader& archive)
 
 void CSifCmd::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto modulesFile = new CStructCollectionStateFile(STATE_MODULES);
+	auto modulesFile = std::make_unique<CStructCollectionStateFile>(STATE_MODULES);
 	{
 		int moduleIndex = 0;
 		for(const auto& module : m_servers)
@@ -107,7 +107,7 @@ void CSifCmd::SaveState(Framework::CZipArchiveWriter& archive) const
 			modulesFile->InsertStruct(moduleName.c_str(), moduleStruct);
 		}
 	}
-	archive.InsertFile(modulesFile);
+	archive.InsertFile(std::move(modulesFile));
 }
 
 std::string CSifCmd::GetId() const

Source/iop/Iop_Sio2.cpp

@@ -105,18 +105,18 @@ void CSio2::SaveState(Framework::CZipArchiveWriter& archive)
 	auto outputBuffer = std::vector<uint8>(m_outputBuffer.begin(), m_outputBuffer.end());
 
 	{
-		auto registerFile = new CRegisterStateFile(STATE_REGS_XML);
+		auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
 		registerFile->SetRegister32(STATE_REGS_CURRENTREGINDEX, m_currentRegIndex);
 		registerFile->SetRegister32(STATE_REGS_STAT6C, m_stat6C);
-		archive.InsertFile(registerFile);
+		archive.InsertFile(std::move(registerFile));
 	}
 
-	archive.InsertFile(new CMemoryStateFile(STATE_REGS, &m_regs, sizeof(m_regs)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_REGS, &m_regs, sizeof(m_regs)));
-	archive.InsertFile(new CMemoryStateFile(STATE_CTRL1, &m_ctrl1, sizeof(m_ctrl1)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_CTRL1, &m_ctrl1, sizeof(m_ctrl1)));
-	archive.InsertFile(new CMemoryStateFile(STATE_CTRL2, &m_ctrl2, sizeof(m_ctrl2)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_CTRL2, &m_ctrl2, sizeof(m_ctrl2)));
-	archive.InsertFile(new CMemoryStateFile(STATE_PAD, &m_padState, sizeof(m_padState)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_PAD, &m_padState, sizeof(m_padState)));
-	archive.InsertFile(new CMemoryStateFile(STATE_INPUT, inputBuffer.data(), inputBuffer.size()));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_INPUT, inputBuffer.data(), inputBuffer.size()));
-	archive.InsertFile(new CMemoryStateFile(STATE_OUTPUT, outputBuffer.data(), outputBuffer.size()));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_OUTPUT, outputBuffer.data(), outputBuffer.size()));
 }
 
 void CSio2::SetButtonState(unsigned int padNumber, PS2::CControllerInfo::BUTTON button, bool pressed, uint8* ram)

Source/iop/Iop_SpuBase.cpp

@@ -258,7 +258,7 @@ void CSpuBase::SaveState(Framework::CZipArchiveWriter& archive)
 {
 	auto path = string_format(STATE_PATH_FORMAT, m_spuNumber);
 
-	auto registerFile = new CRegisterStateFile(path.c_str());
+	auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
 	registerFile->SetRegister32(STATE_REGS_CTRL, m_ctrl);
 	registerFile->SetRegister32(STATE_REGS_IRQADDR, m_irqAddr);
 	registerFile->SetRegister32(STATE_REGS_TRANSFERMODE, m_transferMode);
@@ -294,10 +294,10 @@ void CSpuBase::SaveState(Framework::CZipArchiveWriter& archive)
 		registerFile->SetRegister32((channelPrefix + STATE_CHANNEL_REGS_ADDRESS).c_str(), channel.address);
 		registerFile->SetRegister32((channelPrefix + STATE_CHANNEL_REGS_REPEAT).c_str(), channel.repeat);
 		registerFile->SetRegister32((channelPrefix + STATE_CHANNEL_REGS_CURRENT).c_str(), channel.current);
-		reader.SaveState(registerFile, channelPrefix);
+		reader.SaveState(registerFile.get(), channelPrefix);
 	}
 
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 bool CSpuBase::IsEnabled() const

Source/iop/Iop_SubSystem.cpp

@@ -106,10 +106,10 @@ void CSubSystem::NotifyVBlankEnd()
 
 void CSubSystem::SaveState(Framework::CZipArchiveWriter& archive)
 {
-	archive.InsertFile(new CMemoryStateFile(STATE_CPU, &m_cpu.m_State, sizeof(MIPSSTATE)));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_CPU, &m_cpu.m_State, sizeof(MIPSSTATE)));
-	archive.InsertFile(new CMemoryStateFile(STATE_RAM, m_ram, IOP_RAM_SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_RAM, m_ram, IOP_RAM_SIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_SCRATCH, m_scratchPad, IOP_SCRATCH_SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_SCRATCH, m_scratchPad, IOP_SCRATCH_SIZE));
-	archive.InsertFile(new CMemoryStateFile(STATE_SPURAM, m_spuRam, SPU_RAM_SIZE));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_SPURAM, m_spuRam, SPU_RAM_SIZE));
 	m_intc.SaveState(archive);
 	m_dmac.SaveState(archive);
 	m_counters.SaveState(archive);

Source/iop/Iop_Timrman.cpp

@@ -180,9 +180,9 @@ void CTimrman::Invoke(CMIPS& context, unsigned int functionId)
 
 void CTimrman::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	auto registerFile = new CRegisterStateFile(STATE_FILENAME);
+	auto registerFile = std::make_unique<CRegisterStateFile>(STATE_FILENAME);
 	registerFile->SetRegister32(STATE_HARDTIMERALLOC, m_hardTimerAlloc);
-	archive.InsertFile(registerFile);
+	archive.InsertFile(std::move(registerFile));
 }
 
 void CTimrman::LoadState(Framework::CZipArchiveReader& archive)

Source/iop/namco_arcade/Iop_NamcoAcRam.cpp

@@ -96,7 +96,7 @@ void CAcRam::Invoke(CMIPS& context, unsigned int functionId)
 
 void CAcRam::SaveState(Framework::CZipArchiveWriter& archive) const
 {
-	archive.InsertFile(new CMemoryStateFile(STATE_EXTRAM_FILE, m_extRam, g_extRamSize));
+	archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_EXTRAM_FILE, m_extRam, g_extRamSize));
 }
 
 void CAcRam::LoadState(Framework::CZipArchiveReader& archive)

deps/Framework

@@ -1 +1 @@
-Subproject commit 64bddd377a74292965ab7cad99966efd72cdd892
+Subproject commit cbeb7e234eb37d87b1ab7cbfad4fb4b46af949ce