GTASource/game/SaveLoad/savegame_queued_operations.cpp

#include "savegame_queued_operations.h"

// Rage headers
//	#include "file/savegame.h"
#include "rline/rlhttptask.h"
#include "system/param.h"

// Game headers
#include "audio/northaudioengine.h"
#include "camera/CamInterface.h"
#include "control/replay/File/ReplayFileManager.h"
#include "control/gamelogic.h"
#include "core/game.h"
#include "frontend/loadingscreens.h"
#include "frontend/ProfileSettings.h"

#include "Network/Cloud/UserContentManager.h"

#include "network/NetworkInterface.h"
#include "renderer/rendertargets.h"				//	for VideoResManager::GetNativeWidth() and GetNativeHeight()
#include "renderer/ScreenshotManager.h"
#include "SaveLoad/GenericGameStorage.h"
#include "SaveLoad/savegame_channel.h"
#include "SaveLoad/savegame_check_file_exists.h"
#include "SaveLoad/savegame_damaged_check.h"
#include "SaveLoad/savegame_delete.h"
#include "SaveLoad/savegame_frontend.h"
#include "SaveLoad/savegame_get_file_size.h"
#include "SaveLoad/savegame_initial_checks.h"
#include "SaveLoad/savegame_list.h"
#include "SaveLoad/savegame_load.h"
#include "SaveLoad/savegame_load_block.h"
#include "SaveLoad/savegame_messages.h"
#include "SaveLoad/savegame_new_game_checks.h"
#include "SaveLoad/savegame_photo_buffer.h"
#include "SaveLoad/savegame_photo_cloud_deleter.h"
#include "SaveLoad/savegame_photo_cloud_list.h"
#include "SaveLoad/savegame_photo_load_local.h"
#include "SaveLoad/savegame_photo_local_list.h"
#include "SaveLoad/savegame_photo_local_metadata.h"
#include "SaveLoad/savegame_photo_manager.h"
#include "SaveLoad/savegame_photo_save_local.h"
#include "SaveLoad/savegame_save.h"
#include "SaveLoad/savegame_save_block.h"
#include "SaveLoad/savegame_slow_ps3_scan.h"
#include "SaveLoad/savegame_users_and_devices.h"
#include "SaveLoad/SavegameMigration/savegame_export.h"
#include "SaveLoad/SavegameMigration/savegame_import.h"
#include "SaveMigration/SaveMigration.h"
#include "script/script.h"
#include "streaming/streaming.h"
#include "streaming/streamingvisualize.h"
#include "system/controlMgr.h"
#include "Stats/StatsInterface.h"

SAVEGAME_OPTIMISATIONS()

RAGE_DEFINE_SUBCHANNEL(savegame, queueop, DIAG_SEVERITY_DEBUG3)
#undef __savegame_channel 
#define __savegame_channel savegame_queueop

#if __ALLOW_LOCAL_MP_STATS_SAVES
XPARAM(enableLocalMPSaveCache);
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

XPARAM(outputCloudFiles);

PARAM(useNewStagingUrl, "[savegame_queued_operations] ignore the staging url returned by the UGC upload");

#if RSG_ORBIS


void CSavegameQueuedOperation_SpaceCheck::Init()
{
	// Results
	m_MemoryRequiredForBasicSaveGame = 0;
	m_SpaceChecksProgress = SPACE_CHECKS_BEGIN;
}

//	Return true to Pop() from queue

bool CSavegameQueuedOperation_SpaceCheck::Update()
{
	switch (m_SpaceChecksProgress)
	{
		case SPACE_CHECKS_BEGIN :
			CSavegameNewGameChecks::BeginNewGameChecks();
			m_SpaceChecksProgress = SPACE_CHECKS_PROCESS;
			break;

		case SPACE_CHECKS_PROCESS :
			switch(CSavegameNewGameChecks::ChecksAtStartOfNewGame())
			{
				case MEM_CARD_COMPLETE :
					m_MemoryRequiredForBasicSaveGame = CSavegameNewGameChecks::GetFreeSpaceRequiredForSaveGames();
					m_Status = MEM_CARD_COMPLETE;
					return true;
					break;
				case MEM_CARD_BUSY :
					break;
				case MEM_CARD_ERROR :
					m_Status = MEM_CARD_ERROR;
					return true;
					break;
			}
			break;
	}
	return false;
}

#endif // RSG_ORBIS

#if USE_PROFILE_SAVEGAME

#if USE_DOWNLOAD0_FOR_PROFILE_BACKUP

void CSavegameQueuedOperation_ProfileLoad::Init(s32 localIndex, void *pProfileBuffer, s32 BufferSize)
{
	m_localIndex = localIndex;
	m_pProfileBuffer = pProfileBuffer;
	m_SizeOfProfileBuffer = BufferSize;

	m_MainProfileSlot = INDEX_OF_PS3_PROFILE_SLOT;
	m_BackupProfileSlot = INDEX_OF_BACKUP_PROFILE_SLOT;

	m_MainProfileModTime = 0;
	m_BackupProfileModTime = 0;

	// Results
	m_SizeOfLoadedProfile = 0;

	m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_BEGIN_GET_MAIN_PROFILE_MOD_TIME;
}

//	Return true to Pop() from queue
bool CSavegameQueuedOperation_ProfileLoad::Update()
{
	switch (m_ProfileLoadProgress)
	{
		case PROFILE_LOAD_PROGRESS_BEGIN_GET_MAIN_PROFILE_MOD_TIME :
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");

			if (BeginGetModifiedTime(m_MainProfileSlot, "Main Profile"))
			{
				m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_CHECK_GET_MAIN_PROFILE_MOD_TIME;
			}
			else
			{
				m_Status = MEM_CARD_ERROR;
			}
			break;

		case PROFILE_LOAD_PROGRESS_CHECK_GET_MAIN_PROFILE_MOD_TIME :
			{
				u32 mainModTimeHigh = 0;
				u32 mainModTimeLow = 0;
				switch (CheckGetModifiedTime(mainModTimeHigh, mainModTimeLow, "Main Profile"))
				{
				case MEM_CARD_COMPLETE :
					m_MainProfileModTime = ((u64) mainModTimeHigh) << 32;
					m_MainProfileModTime |= mainModTimeLow;

					if (m_MainProfileModTime == 0)
					{
						savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::Update - mod time for main profile is 0. Maybe the file doesn't exist. Don't attempt to load the backup profile either");
						m_Status = MEM_CARD_ERROR;
					}
					else
					{
						m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_BEGIN_GET_BACKUP_PROFILE_MOD_TIME;
					}
					break;

				case MEM_CARD_BUSY :
					break;

				case MEM_CARD_ERROR :
					savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::Update - CheckGetModifiedTime returned MEM_CARD_ERROR for the main profile. Maybe the file doesn't exist. Don't attempt to load the backup profile either");
					m_Status = MEM_CARD_ERROR;
					break;
				}
			}
			break;

		case PROFILE_LOAD_PROGRESS_BEGIN_GET_BACKUP_PROFILE_MOD_TIME :
			if (BeginGetModifiedTime(m_BackupProfileSlot, "Backup Profile"))
			{
				m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_CHECK_GET_BACKUP_PROFILE_MOD_TIME;
			}
			else
			{
				savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::Update - BeginGetModifiedTime failed for the backup profile. Skip straight to BEGIN_LOAD_MOST_RECENT_PROFILE to attempt to load the main profile");
				m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_BEGIN_LOAD_MOST_RECENT_PROFILE;
			}
			break;

		case PROFILE_LOAD_PROGRESS_CHECK_GET_BACKUP_PROFILE_MOD_TIME :
			{
				u32 backupModTimeHigh = 0;
				u32 backupModTimeLow = 0;
				switch (CheckGetModifiedTime(backupModTimeHigh, backupModTimeLow, "Backup Profile"))
				{
				case MEM_CARD_COMPLETE :
					m_BackupProfileModTime = ((u64) backupModTimeHigh) << 32;
					m_BackupProfileModTime |= backupModTimeLow;

					m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_BEGIN_LOAD_MOST_RECENT_PROFILE;
					break;

				case MEM_CARD_BUSY :
					break;

				case MEM_CARD_ERROR :
					savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::Update - CheckGetModifiedTime failed for the backup profile. Skip straight to BEGIN_LOAD_MOST_RECENT_PROFILE to attempt to load the main profile");
					m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_BEGIN_LOAD_MOST_RECENT_PROFILE;
					break;
				}
			}
			break;

		case PROFILE_LOAD_PROGRESS_BEGIN_LOAD_MOST_RECENT_PROFILE :
			{
				s32 slotToLoad = m_MainProfileSlot;

				if (m_BackupProfileModTime > m_MainProfileModTime)
				{
					savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::Update - backup profile is more recent than the main profile so load the backup");
					slotToLoad = m_BackupProfileSlot;
				}

				CSavegameFilenames::MakeValidSaveNameForLocalFile(slotToLoad);
				if(SAVEGAME.BeginLoad(m_localIndex, 0, 0, CSavegameFilenames::GetFilenameOfLocalFile(), m_pProfileBuffer, m_SizeOfProfileBuffer))
				{
					m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_CHECK_LOAD;
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::Update - BeginLoad failed");
					SAVEGAME.EndLoad(m_localIndex);
					m_Status = MEM_CARD_ERROR;
				}
			}
			break;

		case PROFILE_LOAD_PROGRESS_CHECK_LOAD :
			{
				bool valid;
				if (SAVEGAME.CheckLoad(m_localIndex, valid, m_SizeOfLoadedProfile))
				{
					SAVEGAME.EndLoad(m_localIndex);

					if(valid)
					{
						m_Status = MEM_CARD_COMPLETE;
					}
					else
					{
						savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::Update - SAVEGAME.CheckLoad failed");
						m_Status = MEM_CARD_ERROR;
					}
				}
			}
			break;
	}

	if ( (m_Status == MEM_CARD_COMPLETE) || (m_Status == MEM_CARD_ERROR) )
	{
		return true;
	}

	return false;
}


bool CSavegameQueuedOperation_ProfileLoad::BeginGetModifiedTime(s32 slotIndex, const char* OUTPUT_ONLY(pDebugString))
{
	CSavegameFilenames::MakeValidSaveNameForLocalFile(slotIndex);
	if (SAVEGAME.BeginGetFileModifiedTime(m_localIndex, CSavegameFilenames::GetFilenameOfLocalFile()))
	{
		return true;
	}
	else
	{
		savegameAssertf(0, "CSavegameQueuedOperation_ProfileLoad::BeginGetModifiedTime - BeginGetFileModifiedTime failed for %s", pDebugString);
		savegameDebugf1("CSavegameQueuedOperation_ProfileLoad::BeginGetModifiedTime - BeginGetFileModifiedTime failed for %s\n", pDebugString);
		return false;
	}
}


MemoryCardError CSavegameQueuedOperation_ProfileLoad::CheckGetModifiedTime(u32 &modTimeHigh, u32 &modTimeLow, const char* OUTPUT_ONLY(pDebugString))
{
	if (SAVEGAME.CheckGetFileModifiedTime(m_localIndex, modTimeHigh, modTimeLow))
	{	//	returns true for error or success, false for busy
		SAVEGAME.EndGetFileModifiedTime(m_localIndex);

		if (CSavegameUsers::HasPlayerJustSignedOut())
		{
//			CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_PLAYER_HAS_SIGNED_OUT);
			return MEM_CARD_ERROR;
		}

		if (CSavegameDevices::HasSelectedDeviceJustBeenRemoved())
		{
//			CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_SELECTED_DEVICE_HAS_BEEN_REMOVED);
			return MEM_CARD_ERROR;
		}

		if (SAVEGAME.GetState(m_localIndex) == fiSaveGameState::HAD_ERROR)
		{
			savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::CheckGetModifiedTime - SAVEGAME.GetState returned an error for %s", pDebugString);
//			CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_GET_FILE_MODIFIED_TIME_FAILED1);
			return MEM_CARD_ERROR;
		}

		if (SAVEGAME.GetError(m_localIndex) != fiSaveGame::SAVE_GAME_SUCCESS)
		{
			savegameDisplayf("CSavegameQueuedOperation_ProfileLoad::CheckGetModifiedTime - SAVEGAME.GetError returned an error for %s", pDebugString);
//			CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_GET_FILE_MODIFIED_TIME_FAILED2);
			return MEM_CARD_ERROR;
		}

		return MEM_CARD_COMPLETE;
	}

	return MEM_CARD_BUSY;
}


bool CSavegameQueuedOperation_ProfileLoad::Shutdown()
{
	//	This Profile Load has been interrupted so request another attempt
	CProfileSettings::GetInstance().Read();
	return true;
}



void CSavegameQueuedOperation_ProfileSave::Init(s32 localIndex, void *pProfileBuffer, s32 BufferSize, eProfileSaveDestination saveProfileDestination)
{
	m_localIndex = localIndex;
	m_pProfileBuffer = pProfileBuffer;
	m_SizeOfProfileBuffer = BufferSize;

	m_SaveProfileDestination = saveProfileDestination;

	if (m_SaveProfileDestination == SAVE_BACKUP_PROFILE_ONLY)
	{
		m_SlotToSaveTo = INDEX_OF_BACKUP_PROFILE_SLOT;
	}
	else
	{
		m_SlotToSaveTo = INDEX_OF_PS3_PROFILE_SLOT;
	}

	m_ProfileSaveProgress = PROFILE_SAVE_PROGRESS_BEGIN_SAVE;
}


bool CSavegameQueuedOperation_ProfileSave::Update()
{
	switch (m_ProfileSaveProgress)
	{
	case PROFILE_SAVE_PROGRESS_BEGIN_SAVE :
		CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_PROF_SV	//	Not sure if this will ever be displayed

		CSavingMessage::BeginDisplaying(CSavingMessage::STORAGE_DEVICE_MESSAGE_SAVING);

		CSavegameFilenames::MakeValidSaveNameForLocalFile(m_SlotToSaveTo);
		if (!SAVEGAME.BeginSave(m_localIndex, 0, CSavegameFilenames::GetNameToDisplay(), CSavegameFilenames::GetFilenameOfLocalFile(), m_pProfileBuffer, m_SizeOfProfileBuffer, true) )	//	bool overwrite)
		{
			savegameDisplayf("CSavegameQueuedOperation_ProfileSave::Update - BeginSave failed");
			SAVEGAME.EndSave(m_localIndex);

			CSavingMessage::Clear();

			m_Status = MEM_CARD_ERROR;
			return true;
		}

		m_ProfileSaveProgress = PROFILE_SAVE_PROGRESS_CHECK_SAVE;
		break;

	case PROFILE_SAVE_PROGRESS_CHECK_SAVE :
		{
			bool bOutIsValid;
			bool bFileExists;

			if (SAVEGAME.CheckSave(m_localIndex, bOutIsValid, bFileExists))
			{
				SAVEGAME.EndSave(m_localIndex);

				savegameDisplayf("CSavegameQueuedOperation_ProfileSave::Update - about to call CSavingMessage::Clear()");
				CSavingMessage::Clear();

				if (m_SaveProfileDestination == SAVE_BOTH_PROFILES)
				{
					if (m_SlotToSaveTo == INDEX_OF_PS3_PROFILE_SLOT)
					{
						savegameDisplayf("CSavegameQueuedOperation_ProfileSave::Update - finished saving the main profile. The flag is set to save both the main and the backup profile now so move on to saving the backup profile");
						m_SlotToSaveTo = INDEX_OF_BACKUP_PROFILE_SLOT;
						m_ProfileSaveProgress = PROFILE_SAVE_PROGRESS_BEGIN_SAVE;
					}
					else
					{
						savegameDisplayf("CSavegameQueuedOperation_ProfileSave::Update - finished saving the backup profile");
						m_Status = MEM_CARD_COMPLETE;
						return true;
					}
				}
				else
				{
					if (m_SaveProfileDestination == SAVE_BACKUP_PROFILE_ONLY)
					{
						savegameDisplayf("CSavegameQueuedOperation_ProfileSave::Update - finished saving the backup profile so request a save of the main profile when the streaming isn't busy");

						CProfileSettings::GetInstance().RequestMainProfileSave();
					}
					else if (savegameVerifyf(m_SaveProfileDestination == SAVE_MAIN_PROFILE_ONLY, "CSavegameQueuedOperation_ProfileSave::Update - expected m_SaveProfileDestination to be SAVE_MAIN_PROFILE_ONLY"))
					{
						savegameDisplayf("CSavegameQueuedOperation_ProfileSave::Update - finished saving the main profile so set status to MEM_CARD_COMPLETE");
					}

					m_Status = MEM_CARD_COMPLETE;
					return true;
				}
			}
		}
		break;
	}

	return false;
}

bool CSavegameQueuedOperation_ProfileSave::Shutdown()
{
	//	I don't think I need to do anything here. I'll just rely on CGenericGameStorage::FinishAllUnfinishedSaveGameOperations()
	return false;
}


#else	//	USE_DOWNLOAD0_FOR_PROFILE_BACKUP

void CSavegameQueuedOperation_ProfileLoad::Init(s32 localIndex, char *pFilenameOfPS3Profile, void *pProfileBuffer, s32 BufferSize)
{
	m_localIndex = localIndex;
	m_FilenameOfPS3Profile = pFilenameOfPS3Profile;
	m_pProfileBuffer = pProfileBuffer;
	m_SizeOfProfileBuffer = BufferSize;

	// Results
	m_SizeOfLoadedProfile = 0;

	m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_BEGIN_CREATOR_CHECK;
}

bool CSavegameQueuedOperation_ProfileLoad::Update()
{
	switch (m_ProfileLoadProgress)
	{
		case PROFILE_LOAD_PROGRESS_BEGIN_CREATOR_CHECK :

			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_PROF_LD	//	Not sure if this will ever be displayed

			if (CGenericGameStorage::DoCreatorCheck())
			{
				if (!SAVEGAME.BeginGetCreator(m_localIndex, 0, 0, m_FilenameOfPS3Profile) )
				{
					Assertf(0, "CSavegameQueuedOperation_ProfileLoad::Update - BeginGetCreator failed");
					savegameWarningf("CSavegameQueuedOperation_ProfileLoad::Update - BeginGetCreator failed\n");
					m_Status = MEM_CARD_ERROR;
					return true;
				}
				else
				{
					m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_CHECK_CREATOR_CHECK;
				}
			}
			else
			{
				m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_BEGIN_LOAD;
			}
			break;

		case PROFILE_LOAD_PROGRESS_CHECK_CREATOR_CHECK :
			{
				bool bIsCreator = false;
#if __PPU
				bool bHasCreator = false;
				if (SAVEGAME.CheckGetCreator(m_localIndex, bIsCreator, bHasCreator))
#else
				if (SAVEGAME.CheckGetCreator(m_localIndex, bIsCreator))
#endif	//	__PPU
				{	//	returns true for error or success, false for busy
					SAVEGAME.EndGetCreator(m_localIndex);

					m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_BEGIN_LOAD;

					if (SAVEGAME.GetState(m_localIndex) == fiSaveGameState::HAD_ERROR)
					{
						savegameWarningf("CSavegameQueuedOperation_ProfileLoad::Update - SAVE_GAME_DIALOG_CHECK_GET_CREATOR_FAILED1\n");
						m_Status = MEM_CARD_ERROR;
						return true;
					}
					else
					{
						if (SAVEGAME.GetError(m_localIndex) != fiSaveGame::SAVE_GAME_SUCCESS)
						{
							savegameWarningf("CSavegameQueuedOperation_ProfileLoad::Update - SAVE_GAME_DIALOG_CHECK_GET_CREATOR_FAILED2\n");
							m_Status = MEM_CARD_ERROR;
							return true;
						}
						else
						{
#if __PPU
							if (!bHasCreator || !bIsCreator)
#else
							if (!bIsCreator)
#endif	//	__PPU
							{
								savegameWarningf("CSavegameQueuedOperation_ProfileLoad::Update - SAVE_GAME_DIALOG_PLAYER_IS_NOT_CREATOR\n");
								m_Status = MEM_CARD_ERROR;
								return true;
							}
						}
					}
				}
			}
			break;

		case PROFILE_LOAD_PROGRESS_BEGIN_LOAD :

			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_PROF_LD	//	Not sure if this will ever be displayed

			if(!SAVEGAME.BeginLoad(m_localIndex, 0, 0, m_FilenameOfPS3Profile, m_pProfileBuffer, m_SizeOfProfileBuffer))
			{
				Warningf("CSavegameQueuedOperation_ProfileLoad::Update - BeginLoad failed\n");
				SAVEGAME.EndLoad(m_localIndex);
				m_Status = MEM_CARD_ERROR;
				return true;
			}
			m_ProfileLoadProgress = PROFILE_LOAD_PROGRESS_CHECK_LOAD;
			break;

		case PROFILE_LOAD_PROGRESS_CHECK_LOAD :
		{
			bool valid;
			if (SAVEGAME.CheckLoad(m_localIndex, valid, m_SizeOfLoadedProfile))
			{
				SAVEGAME.EndLoad(m_localIndex);

				if(!valid)
				{
					savegameWarningf("CSavegameQueuedOperation_ProfileLoad::Update - SAVE_GAME_DIALOG_CHECK_LOAD_FAILED2\n");
					m_Status = MEM_CARD_ERROR;
					return true;
				}

				m_Status = MEM_CARD_COMPLETE;

				return true;
			}
			break;
		}
	}

	return false;
}

bool CSavegameQueuedOperation_ProfileLoad::Shutdown()
{
	//	This Profile Load has been interrupted so request another attempt
	CProfileSettings::GetInstance().Read();
	return true;
}


void CSavegameQueuedOperation_ProfileSave::Init(s32 localIndex, char16 ProfileName[LengthOfProfileName], char *pFilenameOfPS3Profile, void *pProfileBuffer, s32 BufferSize)
{
	m_localIndex = localIndex;
	wcsncpy(m_ProfileName, ProfileName, LengthOfProfileName);
	m_FilenameOfPS3Profile = pFilenameOfPS3Profile;
	m_pProfileBuffer = pProfileBuffer;
	m_SizeOfProfileBuffer = BufferSize;

	m_ProfileSaveProgress = PROFILE_SAVE_PROGRESS_BEGIN_SAVE;
}

bool CSavegameQueuedOperation_ProfileSave::Update()
{
	switch (m_ProfileSaveProgress)
	{
		case PROFILE_SAVE_PROGRESS_BEGIN_SAVE :
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_PROF_SV	//	Not sure if this will ever be displayed

			CSavingMessage::BeginDisplaying(CSavingMessage::STORAGE_DEVICE_MESSAGE_SAVING);

			if (!SAVEGAME.BeginSave(m_localIndex, 0, m_ProfileName, m_FilenameOfPS3Profile, m_pProfileBuffer, m_SizeOfProfileBuffer, true) )	//	bool overwrite)
			{
				Warningf("CProfileSettings::StartWrite - BeginSave failed\n");
				SAVEGAME.EndSave(m_localIndex);

				CSavingMessage::Clear();

				m_Status = MEM_CARD_ERROR;
				return true;
			}

			m_ProfileSaveProgress = PROFILE_SAVE_PROGRESS_CHECK_SAVE;
			break;

		case PROFILE_SAVE_PROGRESS_CHECK_SAVE :
		{
			bool bOutIsValid;
			bool bFileExists;

			if (SAVEGAME.CheckSave(m_localIndex, bOutIsValid, bFileExists))
			{
				SAVEGAME.EndSave(m_localIndex);

				savegameDisplayf("CSavegameQueuedOperation_ProfileSave::Update - about to call CSavingMessage::Clear()");
				CSavingMessage::Clear();

				m_Status = MEM_CARD_COMPLETE;
				return true;
			}
		}
		break;
	}

	return false;
}

bool CSavegameQueuedOperation_ProfileSave::Shutdown()
{
//	I don't think I need to do anything here. I'll just rely on CGenericGameStorage::FinishAllUnfinishedSaveGameOperations()
	return false;
}

#endif	//	USE_DOWNLOAD0_FOR_PROFILE_BACKUP

#endif // USE_PROFILE_SAVEGAME

#if RSG_ORBIS

// *********************** PS3DamagedCheck *****************************

void CSavegameQueuedOperation_PS4DamagedCheck::Init(s32 slotIndex)
{
	//	Set m_slotIndex even if it's out of range
	//	CSavegameQueuedOperation_PS3DamagedCheck::Update() will handle the slot being out of range and will return MEM_CARD_ERROR
	savegameAssertf((slotIndex >= 0) && (slotIndex < MAX_NUM_EXPECTED_SAVE_FILES), "CSavegameQueuedOperation_PS3DamagedCheck::Init - slot index %d is out of range 0 to %d", slotIndex, MAX_NUM_EXPECTED_SAVE_FILES);
	m_slotIndex = slotIndex;
	savegameDebugf1("CSavegameQueuedOperation_PS3DamagedCheck::Init called for slot %d. Time = %d\n", slotIndex, sysTimer::GetSystemMsTime());
}

bool CSavegameQueuedOperation_PS4DamagedCheck::Shutdown()
{
	CSavegameDamagedCheck::ResetProgressState();

	return true;
}

//	Return true to Pop() from queue
bool CSavegameQueuedOperation_PS4DamagedCheck::Update()
{
	//	I could call CSavegameDialogScreens::SetDialogBoxHeading() to set a heading here but I don't think it would ever be displayed

	if ( (m_slotIndex < 0) || (m_slotIndex >= MAX_NUM_EXPECTED_SAVE_FILES) )
	{
		savegameAssertf(0, "CSavegameQueuedOperation_PS3DamagedCheck::Update - slot index %d is out of range 0 to %d", m_slotIndex, MAX_NUM_EXPECTED_SAVE_FILES);
		m_Status = MEM_CARD_ERROR;
		return true;
	}

	if (CSavegameList::IsSaveGameSlotEmpty(m_slotIndex))
	{
		savegameDebugf1("CSavegameQueuedOperation_PS3DamagedCheck::Update - slot %d is empty. Time = %d\n", m_slotIndex, sysTimer::GetSystemMsTime());
		m_Status = MEM_CARD_COMPLETE;
		return true;
	}

	switch (CSavegameList::CheckIfSlotIsDamaged(m_slotIndex))
	{
		case MEM_CARD_COMPLETE :
			savegameDebugf1("CSavegameQueuedOperation_PS3DamagedCheck::Update - completed for slot %d. Time = %d. Slot is %sdamaged\n", m_slotIndex, sysTimer::GetSystemMsTime(), CSavegameList::GetIsDamaged(m_slotIndex)?"":"not ");
			m_Status = MEM_CARD_COMPLETE;
			return true;
//			break;

		case MEM_CARD_BUSY :
			break;

		case MEM_CARD_ERROR :
			m_Status = MEM_CARD_ERROR;
			return true;
//			break;
	}

	return false;
}

#endif	//	__PPU



// Photos *********************************************************************************************************
#if __LOAD_LOCAL_PHOTOS
void CSavegameQueuedOperation_LoadLocalPhoto::Init(const CSavegamePhotoUniqueId &uniquePhotoId, CPhotoBuffer *pPhotoBuffer)
{
	savegameDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Init called for unique photo Id %d", uniquePhotoId.GetValue());

	m_UniquePhotoId = uniquePhotoId;

	// check that pPhotoBuffer isn't NULL
	m_pBufferToStoreLoadedPhoto = pPhotoBuffer;

	m_SizeOfJpegBuffer = CPhotoBuffer::GetDefaultSizeOfJpegBuffer();

	m_TextureDownloadRequestHandle = CTextureDownloadRequest::INVALID_HANDLE;

	m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_BEGIN_LOAD;
}

void CSavegameQueuedOperation_LoadLocalPhoto::EndLoadLocalPhoto()
{
//	I think the save operation will have already been set back to OPERATION_NONE after LOCAL_PHOTO_LOAD_PROGRESS_CHECK_LOAD 
//	photoAssertf(CGenericGameStorage::GetSaveOperation() == OPERATION_LOADING_LOCAL_PHOTO, "CSavegameQueuedOperation_LoadLocalPhoto::EndLoadLocalPhoto - SaveOperation should be OPERATION_LOADING_LOCAL_PHOTO");
	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_LoadLocalPhoto::Update()
{
	switch (m_LocalPhotoLoadProgress)
	{
	case LOCAL_PHOTO_LOAD_PROGRESS_BEGIN_LOAD :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");

//			CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_PHOTO_FROM_CLOUD);
//			CSavegameInitialChecks::BeginInitialChecks(false);

			// check that uniquePhotoId is valid
			// check that m_pBufferToStoreLoadedPhoto isn't NULL

			switch (CSavegamePhotoLoadLocal::BeginLocalPhotoLoad(m_UniquePhotoId, m_pBufferToStoreLoadedPhoto))
			{
				case MEM_CARD_COMPLETE :
					m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_CHECK_LOAD;
					break;
				case MEM_CARD_BUSY :
					photoAssertf(0, "CSavegameQueuedOperation_LoadLocalPhoto::Update - didn't expect CSavegamePhotoLoadLocal::BeginLocalPhotoLoad to ever return MEM_CARD_BUSY");
					break;
				case MEM_CARD_ERROR :
					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_LOCAL_LOAD_JPEG_FAILED);
					m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
					break;
			}
		}
		break;

	case LOCAL_PHOTO_LOAD_PROGRESS_CHECK_LOAD :
		{
			CSavingMessage::BeginDisplaying(CSavingMessage::STORAGE_DEVICE_MESSAGE_CLOUD_LOADING);

			MemoryCardError LoadState = CSavegamePhotoLoadLocal::DoLocalPhotoLoad();
			if (LoadState == MEM_CARD_ERROR)
			{
				if (SAVE_GAME_DIALOG_PLAYER_HAS_SIGNED_OUT == CSavegameDialogScreens::GetMostRecentErrorCode())
				{
					photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - player has signed out");
					m_Status = MEM_CARD_ERROR;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - CSavegamePhotoLoadLocal::DoLocalPhotoLoad() returned an error");
					m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
			else if (LoadState == MEM_CARD_COMPLETE)
			{
				photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - CSavegamePhotoLoadLocal::DoLocalPhotoLoad() succeeded");

				m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_REQUEST_TEXTURE_DECODE;
			}
		}
		break;

	case LOCAL_PHOTO_LOAD_PROGRESS_REQUEST_TEXTURE_DECODE :
		{
//			if (!CSavegameUsers::HasPlayerJustSignedOut() && NetworkInterface::IsCloudAvailable())
			{
//				if (photoVerifyf(CPhotoManager::GetHasValidMetadata(m_IndexWithinMergedPhotoList), "CSavegameQueuedOperation_LoadUGCPhoto::Update - invalid metadata!"))
				{
					char textureName[CTextureDictionariesForGalleryPhotos::ms_MaxLengthOfTextureName];
					CTextureDictionariesForGalleryPhotos::GetNameOfPhotoTextureDictionary(m_UniquePhotoId, textureName, CTextureDictionariesForGalleryPhotos::ms_MaxLengthOfTextureName);

					CTextureDecodeRequestDesc requestDesc;

					requestDesc.m_TxtAndTextureHash	= textureName;
					requestDesc.m_Type				= CTextureDecodeRequestDesc::JPEG_BUFFER;	//	CTextureDownloadRequestDesc::UGC_FILE;

					requestDesc.m_BufferPtr			= m_pBufferToStoreLoadedPhoto->GetJpegBuffer();			// Buffer with the data blob (memory is owned by the user and must guarantee it will be valid until the request completes).

// Is the size in bytes or KBytes?
//	Should I be using GetSizeOfAllocatedJpegBuffer()?
//	Do I not need m_SizeOfJpegBuffer?
					requestDesc.m_BufferSize		= m_pBufferToStoreLoadedPhoto->GetExactSizeOfJpegData();			// Size for the buffer

					if (m_UniquePhotoId.GetIsMaximised())
					{
						requestDesc.m_JPEGScalingFactor = VideoResManager::DOWNSCALE_ONE;
					}
					else
					{
						requestDesc.m_JPEGScalingFactor = CHighQualityScreenshot::GetDownscaleForNoneMaximizedView();
					}

//					bool								m_JPEGEncodeAsDXT;		// JPEG-only: allows specifying whether the JPEG should be encoded as a DXT1 texture, rather than uncompressed RGBA8.

					// Issue the request
					TextureDownloadRequestHandle handle;
					CTextureDownloadRequest::Status retVal;
					retVal = DOWNLOADABLETEXTUREMGR.RequestTextureDecode(handle, requestDesc);

					// Check the return value
					if ( (retVal == CTextureDownloadRequest::IN_PROGRESS) || (retVal == CTextureDownloadRequest::READY_FOR_USER) )
					{
						photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - RequestTextureDecode succeeded. Return value was %d", retVal);

						// Cache the handle for querying the state of the request
						m_TextureDownloadRequestHandle = handle;
						m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_WAIT_FOR_TEXTURE_DECODE;
					}
					else
					{
						photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - RequestTextureDecode failed. Return value was %d", retVal);

						CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_LOCAL_LOAD_JPEG_FAILED);
						m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
					}
				}
// 				else
// 				{
// 					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_LOCAL_LOAD_JPEG_FAILED);
// 					m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
// 				}
			}
// 			else
// 			{
// 				photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - REQUEST_TEXTURE_DOWNLOAD - player signed out or cloud not available");
// 
// 				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_LOCAL_LOAD_JPEG_FAILED);
// 				m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
// 			}
		}
		break;


	case LOCAL_PHOTO_LOAD_PROGRESS_WAIT_FOR_TEXTURE_DECODE :
		if (m_TextureDownloadRequestHandle == CTextureDownloadRequest::INVALID_HANDLE)
		{
			photoAssertf(0, "CSavegameQueuedOperation_LoadLocalPhoto::Update - didn't expect TextureDownloadRequestHandle to be invalid inside LOCAL_PHOTO_LOAD_PROGRESS_WAIT_FOR_TEXTURE_DECODE");
			//			m_Status = MEM_CARD_ERROR;
			CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_LOCAL_LOAD_JPEG_FAILED);
			m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
		}
		else
		{
			// Reset our handle if the request has failed
			if (DOWNLOADABLETEXTUREMGR.HasRequestFailed(m_TextureDownloadRequestHandle))
			{
				photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - WAIT_FOR_TEXTURE_DECODE - request failed");

				DOWNLOADABLETEXTUREMGR.ReleaseTextureDownloadRequest(m_TextureDownloadRequestHandle);
				m_TextureDownloadRequestHandle = CTextureDownloadRequest::INVALID_HANDLE;
				//				m_Status = MEM_CARD_ERROR;
				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_LOCAL_LOAD_JPEG_FAILED);
				m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
			}
			// Check if our request is ready
			else if (DOWNLOADABLETEXTUREMGR.IsRequestReady(m_TextureDownloadRequestHandle))
			{
				photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - WAIT_FOR_TEXTURE_DECODE - request is ready");

				strLocalIndex txdSlotForRequest = DOWNLOADABLETEXTUREMGR.GetRequestTxdSlot(m_TextureDownloadRequestHandle);

				// Add a reference for us before releasing the request
				g_TxdStore.AddRef(txdSlotForRequest, REF_OTHER);

				m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_READ_METADATA;
			}
		}
		break;

	case LOCAL_PHOTO_LOAD_PROGRESS_READ_METADATA :
		{
			CSavegamePhotoMetadata metadataForLoadedPhoto;

			if (photoVerifyf(metadataForLoadedPhoto.ReadMetadataFromString(m_pBufferToStoreLoadedPhoto->GetJsonBuffer()), "CSavegameQueuedOperation_LoadLocalPhoto::Update - failed to read metadata from json string"))
			{
				atString titleString(m_pBufferToStoreLoadedPhoto->GetTitleString());
				atString descriptionString(m_pBufferToStoreLoadedPhoto->GetDescriptionString());
				CSavegamePhotoLocalMetadata::Add(m_UniquePhotoId, metadataForLoadedPhoto, titleString, descriptionString);

				eImageSignatureResult validateResult = CPhotoManager::ValidateCRCForImage(metadataForLoadedPhoto.GetImageSignature(), m_pBufferToStoreLoadedPhoto->GetJpegBuffer(), m_pBufferToStoreLoadedPhoto->GetExactSizeOfJpegData());
				if (photoVerifyf(IMAGE_SIGNATURE_MISMATCH != validateResult, "CSavegameQueuedOperation_LoadLocalPhoto::Update - image signature validation failed. Can't use this image."))
				{
					CMetadataForOnePhoto *pMetadata = CSavegamePhotoLocalMetadata::GetMetadataForUniquePhotoId(m_UniquePhotoId);
					if (photoVerifyf(pMetadata, "CSavegameQueuedOperation_LoadLocalPhoto::Update - failed to find metadata for unique photo Id %d", m_UniquePhotoId.GetValue()))
					{
						if (validateResult == IMAGE_SIGNATURE_VALID)
						{
							pMetadata->SetHasValidSignature(true);
						}
						else
						{
							pMetadata->SetHasValidSignature(false);
						}
					}

					m_LocalPhotoLoadProgress = LOCAL_PHOTO_LOAD_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH;
				}
				else
				{
					strLocalIndex txdSlotForRequest = DOWNLOADABLETEXTUREMGR.GetRequestTxdSlot(m_TextureDownloadRequestHandle);
					g_TxdStore.RemoveRef(txdSlotForRequest, REF_OTHER);

					//	Should I display an error message, continue without a warning or set m_Status to MEM_CARD_ERROR?
					m_Status = MEM_CARD_ERROR;
				}
			}
			else
			{
				//	Should I display an error message, continue without a warning or set m_Status to MEM_CARD_ERROR?
				m_Status = MEM_CARD_ERROR;
			}
		}
		break;

	case LOCAL_PHOTO_LOAD_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH :
		if (CSavingMessage::HasLoadingMessageDisplayedForLongEnough())
		{
			// The following is called for savegames. I'm not sure if it's needed for photos / MP stats.
			CSavegameDialogScreens::SetMessageAsProcessing(false);	//	GSWTODO - not sure if this should be in here or in DeSerialize()

			EndLoadLocalPhoto();

			m_Status = MEM_CARD_COMPLETE;
		}
		break;


	case LOCAL_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS :
		{
			CSavingMessage::Clear();

			bool bDisplayingMessageAboutFailingToLoadAThumbnail = false;
			if (!m_UniquePhotoId.GetIsMaximised())
			{	//	if loading a thumbnail photo
				switch (CSavegameDialogScreens::GetMostRecentErrorCode())
				{
				case SAVE_GAME_DIALOG_BEGIN_LOCAL_LOAD_JPEG_FAILED :
				case SAVE_GAME_DIALOG_CHECK_LOCAL_LOAD_JPEG_FAILED :
//				case SAVE_GAME_DIALOG_BEGIN_LOCAL_LOAD_JSON_FAILED :
//				case SAVE_GAME_DIALOG_CHECK_LOCAL_LOAD_JSON_FAILED :
					bDisplayingMessageAboutFailingToLoadAThumbnail = true;
					break;
				default :
					break;
				}
			}

			if (bDisplayingMessageAboutFailingToLoadAThumbnail && CPhotoManager::GetWarningMessageForGalleryPhotoLoadFailureHasAlreadyBeenSeen())
			{
				CSavegameDialogScreens::ClearSaveGameError();
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				if (CSavegameDialogScreens::HandleSaveGameErrorCode())
				{
					if (bDisplayingMessageAboutFailingToLoadAThumbnail)
					{
						CPhotoManager::SetWarningMessageForGalleryPhotoLoadFailureHasAlreadyBeenSeen(true);
					}
					m_Status = MEM_CARD_ERROR;
				}
			}
		}
		break;
	}


	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		if (m_Status == MEM_CARD_ERROR)
		{
			//		savegameWarningf("Error in CalculateSizeOfRequiredBuffer: code=%d", CSavegameDialogScreens::GetMostRecentErrorCode());
			photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - failed");

			CSavingMessage::Clear();

			EndLoadLocalPhoto();

			// The following is called for savegames. I'm not sure if it's needed for photos / MP stats.
			CSavegameDialogScreens::SetMessageAsProcessing(false);

			CPhotoManager::SetTextureDownloadFailed(m_UniquePhotoId);
		}
		else if (m_Status == MEM_CARD_COMPLETE)
		{
			photoDisplayf("CSavegameQueuedOperation_LoadLocalPhoto::Update - succeeded");

			CPhotoManager::SetTextureDownloadSucceeded(m_UniquePhotoId);
		}

		if (m_TextureDownloadRequestHandle != CTextureDownloadRequest::INVALID_HANDLE)
		{
			// We have the txd slot, we can now release our request
			DOWNLOADABLETEXTUREMGR.ReleaseTextureDownloadRequest(m_TextureDownloadRequestHandle);
			m_TextureDownloadRequestHandle = CTextureDownloadRequest::INVALID_HANDLE;
		}

		m_pBufferToStoreLoadedPhoto->FreeBuffer();

		return true;
	}

	return false;
}
#endif	//	__LOAD_LOCAL_PHOTOS

#if !__LOAD_LOCAL_PHOTOS
void CSavegameQueuedOperation_LoadUGCPhoto::Init(const CIndexWithinMergedPhotoList &indexWithinMergedPhotoList, CIndexOfPhotoOnCloud indexOfPhotoFile)
{
// 	if (m_pMetadataString)
// 	{
// 		photoAssertf(0, "CSavegameQueuedOperation_LoadUGCPhoto::Init - expected metadata string to be NULL here");
// 		delete [] m_pMetadataString;
// 		m_pMetadataString = NULL;
// 	}

	m_IndexWithinMergedPhotoList = indexWithinMergedPhotoList;
	m_IndexOfPhotoFile = indexOfPhotoFile;

	m_SizeOfJpegBuffer = CPhotoBuffer::GetDefaultSizeOfJpegBuffer();
//	m_SizeOfJsonBuffer = CPhotoBuffer::GetDefaultSizeOfJsonBuffer();

//	m_TxdSlotForRequest = -1;
	m_TextureDownloadRequestHandle = CTextureDownloadRequest::INVALID_HANDLE;

	m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_BEGIN_PLAYER_IS_SIGNED_IN;
}

void CSavegameQueuedOperation_LoadUGCPhoto::EndLoadBlockCloud()
{
	photoAssertf(CGenericGameStorage::GetSaveOperation() == OPERATION_LOADING_PHOTO_FROM_CLOUD, "CSavegameQueuedOperation_LoadUGCPhoto::EndLoadBlock - SaveOperation should be OPERATION_LOADING_PHOTO_FROM_CLOUD");
	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
}


//    Return true to Pop() from queue
bool CSavegameQueuedOperation_LoadUGCPhoto::Update()
{
	switch (m_UGCPhotoLoadProgress)
	{
	case UGC_PHOTO_LOAD_PROGRESS_BEGIN_PLAYER_IS_SIGNED_IN :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_L_PH_CL

			CSavegameFilenames::SetFilenameOfCloudFile("");	//	Hopefully the InitialChecks don't rely on a valid savegame filename

			CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_PHOTO_FROM_CLOUD);
			CSavegameInitialChecks::BeginInitialChecks(false);

			m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_CHECK_PLAYER_IS_SIGNED_IN;
		}
		break;
	case UGC_PHOTO_LOAD_PROGRESS_CHECK_PLAYER_IS_SIGNED_IN :
		{
			CSavingMessage::BeginDisplaying(CSavingMessage::STORAGE_DEVICE_MESSAGE_CLOUD_LOADING);

			MemoryCardError SelectionState = CSavegameInitialChecks::InitialChecks();
			if (SelectionState == MEM_CARD_ERROR)
			{
				if (SAVE_GAME_DIALOG_PLAYER_HAS_SIGNED_OUT == CSavegameDialogScreens::GetMostRecentErrorCode())
				{
					photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - player has signed out");
					m_Status = MEM_CARD_ERROR;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - InitialChecks() returned an error");
					m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
			else if (SelectionState == MEM_CARD_COMPLETE)
			{
				photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - InitialChecks() succeeded");

				if (CPhotoManager::GetHasValidMetadata(m_IndexWithinMergedPhotoList))
				{
					m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_REQUEST_TEXTURE_DOWNLOAD;
				}
				else
				{
//					m_Status = MEM_CARD_ERROR;
					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_CLOUD_LOAD_JPEG_FAILED);
					m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
		}
		break;

	case UGC_PHOTO_LOAD_PROGRESS_REQUEST_TEXTURE_DOWNLOAD :
		{
			if (!CSavegameUsers::HasPlayerJustSignedOut() && NetworkInterface::IsCloudAvailable())
			{
				if (photoVerifyf(CPhotoManager::GetHasValidMetadata(m_IndexWithinMergedPhotoList), "CSavegameQueuedOperation_LoadUGCPhoto::Update - invalid metadata!"))
				{
					char textureName[CTextureDictionariesForGalleryPhotos::ms_MaxLengthOfTextureName];
					CTextureDictionariesForGalleryPhotos::GetNameOfPhotoTextureDictionary(m_IndexWithinMergedPhotoList, textureName, CTextureDictionariesForGalleryPhotos::ms_MaxLengthOfTextureName);

					CTextureDownloadRequestDesc requestDesc;
					requestDesc.m_TxdName			= textureName;
					requestDesc.m_TextureName		= textureName;
					requestDesc.m_Type				= CTextureDownloadRequestDesc::UGC_FILE;

                    requestDesc.m_CloudFilePath		= CPhotoManager::GetContentIdOfPhotoOnCloud(m_IndexWithinMergedPhotoList);
					requestDesc.m_BufferPresize		= m_SizeOfJpegBuffer;
					requestDesc.m_GamerIndex		= NetworkInterface::GetLocalGamerIndex();
					requestDesc.m_CloudMemberId		= rlCloudMemberId();
					requestDesc.m_UseCacheFile		= true;

                    requestDesc.m_nFileID		    = CPhotoManager::GetFileID(m_IndexWithinMergedPhotoList);
                    requestDesc.m_nFileVersion		= CPhotoManager::GetFileVersion(m_IndexWithinMergedPhotoList);
                    requestDesc.m_nLanguage		    = CPhotoManager::GetLanguage(m_IndexWithinMergedPhotoList);

                    if (m_IndexWithinMergedPhotoList.GetIsMaximised())
					{
						requestDesc.m_JPEGScalingFactor = VideoResManager::DOWNSCALE_ONE;
					}
					else
					{
						requestDesc.m_JPEGScalingFactor = CHighQualityScreenshot::GetDownscaleForNoneMaximizedView();
					}


					// Issue the request
					TextureDownloadRequestHandle handle;
					CTextureDownloadRequest::Status retVal;
					retVal = DOWNLOADABLETEXTUREMGR.RequestTextureDownload(handle, requestDesc);

					// Check the return value
					if ( (retVal == CTextureDownloadRequest::IN_PROGRESS) || (retVal == CTextureDownloadRequest::READY_FOR_USER) )
					{
						photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - RequestTextureDownload succeeded. Return value was %d", retVal);

	//					m_bWaitingForTextureDownload = true;
	//					m_bTextureDownloadSucceeded = false;

						// Cache the handle for querying the state of the request
						m_TextureDownloadRequestHandle = handle;
						m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_WAIT_FOR_TEXTURE_DOWNLOAD;
					}
					else
					{
						photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - RequestTextureDownload failed. Return value was %d", retVal);

						//	dlcWarningf("CDownloadableTextureManagerDebug::OnLoadTexture: request failed before being issued");
//						m_Status = MEM_CARD_ERROR;
						CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_CLOUD_LOAD_JPEG_FAILED);
						m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
					}
				}
				else
				{
//					m_Status = MEM_CARD_ERROR;
					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_CLOUD_LOAD_JPEG_FAILED);
					m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
			else
			{
				photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - REQUEST_TEXTURE_DOWNLOAD - player signed out or cloud not available");

//				m_Status = MEM_CARD_ERROR;
				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_CLOUD_LOAD_JPEG_FAILED);
				m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
			}
		}
		break;


	case UGC_PHOTO_LOAD_PROGRESS_WAIT_FOR_TEXTURE_DOWNLOAD :
		if (m_TextureDownloadRequestHandle == CTextureDownloadRequest::INVALID_HANDLE)
		{
			photoAssertf(0, "CSavegameQueuedOperation_LoadUGCPhoto::Update - didn't expect TextureDownloadRequestHandle to be invalid inside UGC_PHOTO_LOAD_PROGRESS_WAIT_FOR_TEXTURE_DOWNLOAD");
//			m_Status = MEM_CARD_ERROR;
			CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_CLOUD_LOAD_JPEG_FAILED);
			m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
		}
		else
		{
			// Reset our handle if the request has failed
			if (DOWNLOADABLETEXTUREMGR.HasRequestFailed(m_TextureDownloadRequestHandle))
			{
				photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - WAIT_FOR_TEXTURE_DOWNLOAD - request failed");

				DOWNLOADABLETEXTUREMGR.ReleaseTextureDownloadRequest(m_TextureDownloadRequestHandle);
				m_TextureDownloadRequestHandle = CTextureDownloadRequest::INVALID_HANDLE;
//				m_Status = MEM_CARD_ERROR;
				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_CLOUD_LOAD_JPEG_FAILED);
				m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS;
			}
			// Check if our request is ready
			else if (DOWNLOADABLETEXTUREMGR.IsRequestReady(m_TextureDownloadRequestHandle))
			{
				photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - WAIT_FOR_TEXTURE_DOWNLOAD - request is ready");

					strLocalIndex txdSlotForRequest = DOWNLOADABLETEXTUREMGR.GetRequestTxdSlot(m_TextureDownloadRequestHandle);

					// Add a reference for us before releasing the request
					g_TxdStore.AddRef(txdSlotForRequest, REF_OTHER);

					m_UGCPhotoLoadProgress = UGC_PHOTO_LOAD_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH;
			}
		}
		break;

	case UGC_PHOTO_LOAD_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH :
		if (CSavingMessage::HasLoadingMessageDisplayedForLongEnough())
		{
			// The following is called for savegames. I'm not sure if it's needed for photos / MP stats.
			CSavegameDialogScreens::SetMessageAsProcessing(false);	//	GSWTODO - not sure if this should be in here or in DeSerialize()

			EndLoadBlockCloud();

			m_Status = MEM_CARD_COMPLETE;
		}
		break;


	case UGC_PHOTO_LOAD_PROGRESS_HANDLE_ERRORS :
		{
			CSavingMessage::Clear();

			bool bDisplayingMessageAboutFailingToLoadAThumbnail = false;
			if (!m_IndexWithinMergedPhotoList.GetIsMaximised())
			{	//	if loading a thumbnail photo
				switch (CSavegameDialogScreens::GetMostRecentErrorCode())
				{
				case SAVE_GAME_DIALOG_BEGIN_CLOUD_LOAD_JPEG_FAILED :
				case SAVE_GAME_DIALOG_CHECK_CLOUD_LOAD_JPEG_FAILED :
				case SAVE_GAME_DIALOG_BEGIN_CLOUD_LOAD_JSON_FAILED :
				case SAVE_GAME_DIALOG_CHECK_CLOUD_LOAD_JSON_FAILED :
					bDisplayingMessageAboutFailingToLoadAThumbnail = true;
					break;
				default :
					break;
				}
			}

			if (bDisplayingMessageAboutFailingToLoadAThumbnail && CPhotoManager::GetWarningMessageForGalleryPhotoLoadFailureHasAlreadyBeenSeen())
			{
				CSavegameDialogScreens::ClearSaveGameError();
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				if (CSavegameDialogScreens::HandleSaveGameErrorCode())
				{
					if (bDisplayingMessageAboutFailingToLoadAThumbnail)
					{
						CPhotoManager::SetWarningMessageForGalleryPhotoLoadFailureHasAlreadyBeenSeen(true);
					}
					m_Status = MEM_CARD_ERROR;
				}
			}
		}
		break;
	}


	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		if (m_Status == MEM_CARD_ERROR)
		{
			//		savegameWarningf("Error in CalculateSizeOfRequiredBuffer: code=%d", CSavegameDialogScreens::GetMostRecentErrorCode());
			photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - failed");

			CSavingMessage::Clear();

			EndLoadBlockCloud();

			// The following is called for savegames. I'm not sure if it's needed for photos / MP stats.
			CSavegameDialogScreens::SetMessageAsProcessing(false);

			CPhotoManager::SetTextureDownloadFailed(m_IndexWithinMergedPhotoList);
		}
		else if (m_Status == MEM_CARD_COMPLETE)
		{
			photoDisplayf("CSavegameQueuedOperation_LoadUGCPhoto::Update - succeeded");

			CPhotoManager::SetTextureDownloadSucceeded(m_IndexWithinMergedPhotoList);
		}

		if (m_TextureDownloadRequestHandle != CTextureDownloadRequest::INVALID_HANDLE)
		{
			// We have the txd slot, we can now release our request
			DOWNLOADABLETEXTUREMGR.ReleaseTextureDownloadRequest(m_TextureDownloadRequestHandle);
			m_TextureDownloadRequestHandle = CTextureDownloadRequest::INVALID_HANDLE;
		}

// 		if (m_pMetadataString)
// 		{
// 			delete [] m_pMetadataString;
// 			m_pMetadataString = NULL;
// 		}

		//	Temporary function until the proper code to create a photo buffer is ready to use
		//		FreePhotoBuffer();
		return true;
	}

	return false;
}
#endif	//	!__LOAD_LOCAL_PHOTOS


void CSavegameQueuedOperation_PhotoSave::Init(u8 *pJpegBuffer, u32 exactSizeOfJpegBuffer, CSavegamePhotoMetadata const &metadataToSave, const char* pTitle, const char* pDescription)
{
	m_pJpegBuffer = pJpegBuffer;
	m_ExactSizeOfJpegBuffer = exactSizeOfJpegBuffer;

//	safecpy(m_DisplayName, pTitle, NELEM(m_DisplayName));
//	safecpy(m_Description, pDescription, NELEM(m_Description));
	m_DisplayName = pTitle;
	m_Description = pDescription;
	m_MetadataToSave = metadataToSave;

	m_pMetadataStringForUploadingToUGC = NULL;
	
	m_PhotoSaveProgress = PHOTO_SAVE_PROGRESS_CREATE_METADATA_STRING;
}


//    Return true to Pop() from queue
bool CSavegameQueuedOperation_PhotoSave::Update()
{
	switch (m_PhotoSaveProgress)
	{
		case PHOTO_SAVE_PROGRESS_CREATE_METADATA_STRING :
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_S_PH_CL

				m_Status = MEM_CARD_ERROR;

				m_pMetadataStringForUploadingToUGC = rage_new char[CPhotoBuffer::GetDefaultSizeOfJsonBuffer()];
				if (photoVerifyf(m_pMetadataStringForUploadingToUGC, "CSavegameQueuedOperation_PhotoSave::Update - PHOTO_SAVE_PROGRESS_CREATE_METADATA_STRING - failed to allocate memory for metadata string"))
				{
					if (photoVerifyf(m_MetadataToSave.WriteMetadataToString(m_pMetadataStringForUploadingToUGC, CPhotoBuffer::GetDefaultSizeOfJsonBuffer(), true), "CSavegameQueuedOperation_PhotoSave::Update - PHOTO_SAVE_PROGRESS_CREATE_METADATA_STRING - WriteMetadataToString() failed"))
					{
						photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - PHOTO_SAVE_PROGRESS_CREATE_METADATA_STRING - WriteMetadataToString() succeeded");

						m_Status = MEM_CARD_BUSY;
						m_PhotoSaveProgress = PHOTO_SAVE_PROGRESS_BEGIN_CREATE_UGC;
					}
				}
			}
			break;

//	Photos are no longer saved to member space first. They now go straight to UGC
/*
		case PHOTO_SAVE_PROGRESS_BEGIN_CLOUD_SAVE :
			{
				MemoryCardError resultOfBeginCall = CSavegameSaveBlock::BeginCloudPhotoSave(m_pJpegBuffer, m_ExactSizeOfJpegBuffer);
			
				switch (resultOfBeginCall)
				{
				case MEM_CARD_COMPLETE :
					photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - BEGIN_CLOUD_SAVE - BeginSaveBlock succeeded");
					m_PhotoSaveProgress = PHOTO_SAVE_PROGRESS_CHECK_CLOUD_SAVE;
					break;

				case MEM_CARD_BUSY :
					photoAssertf(0, "CSavegameQueuedOperation_PhotoSave::Update - BEGIN_CLOUD_SAVE - didn't expect CSavegameSaveBlock::BeginSaveBlock() to ever return MEM_CARD_BUSY");
					m_Status = MEM_CARD_ERROR;
					break;
				case MEM_CARD_ERROR :
					photoAssertf(0, "CSavegameQueuedOperation_PhotoSave::Update - BEGIN_CLOUD_SAVE - CSavegameSaveBlock::BeginSaveBlock() returned MEM_CARD_ERROR for cloud save");
					m_Status = MEM_CARD_ERROR;
					break;
				}
			}
			break;

		case PHOTO_SAVE_PROGRESS_CHECK_CLOUD_SAVE :
			switch (CSavegameSaveBlock::SaveBlock(true))
			{
			case MEM_CARD_COMPLETE :
				photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - CHECK_CLOUD_SAVE - CSavegameSaveBlock succeeded");
				m_PhotoSaveProgress = PHOTO_SAVE_PROGRESS_BEGIN_CREATE_UGC;
				break;

			case MEM_CARD_BUSY :    // the save is still in progress
				break;

			case MEM_CARD_ERROR :
				photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - CHECK_CLOUD_SAVE - CSavegameSaveBlock failed");
				m_Status = MEM_CARD_ERROR;
				break;
			}
			break;
*/

		case PHOTO_SAVE_PROGRESS_BEGIN_CREATE_UGC :
			{
				if (photoVerifyf(!UserContentManager::GetInstance().IsCreatePending(), "CSavegameQueuedOperation_PhotoSave::Update - BEGIN_CREATE_UGC - a Create is already pending"))
				{
//					to get the title and description, I could declare an instance of the metadata class and call
//						bool CSavegamePhotoMetadata::ReadMetadataFromString(const char *pString)

                    rlUgc::SourceFile srcFile(0, m_pJpegBuffer, m_ExactSizeOfJpegBuffer);
                    
					const bool bPublish = true;	//	John Hynd says that this means "share so that others can see your photos"
					photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - BEGIN_CREATE_UGC - Title is %s, sizeOfJpegBuffer=%u, metadata string is %s", m_DisplayName.c_str(), m_ExactSizeOfJpegBuffer, m_pMetadataStringForUploadingToUGC);
					
                    if (UserContentManager::GetInstance().Create(m_DisplayName, 
                                                                 m_Description, 
                                                                 &srcFile,
                                                                 1,
                                                                 NULL, //tags
                                                                 m_pMetadataStringForUploadingToUGC, 
                                                                 RLUGC_CONTENT_TYPE_GTA5PHOTO, 
                                                                 bPublish))
					{
						photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - BEGIN_CREATE_UGC - UGC creation was successfully started");
						m_PhotoSaveProgress = PHOTO_SAVE_PROGRESS_CHECK_CREATE_UGC;
					}
					else
					{
						photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - BEGIN_CREATE_UGC - UGC creation failed to start");
						CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_UGC_PHONE_PHOTO_SAVE_FAILED);
						m_PhotoSaveProgress = PHOTO_SAVE_PROGRESS_DISPLAY_UGC_ERROR;
					}
				}
			}
			break;

		case PHOTO_SAVE_PROGRESS_CHECK_CREATE_UGC :
			if (UserContentManager::GetInstance().HasCreateFinished())
			{
				if (UserContentManager::GetInstance().DidCreateSucceed())
				{
					photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - CHECK_CREATE_UGC - UGC creation has completed successfully");
					m_Status = MEM_CARD_COMPLETE;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_PhotoSave::Update - CHECK_CREATE_UGC - UGC creation has failed");
					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_UGC_PHONE_PHOTO_SAVE_FAILED);
					m_PhotoSaveProgress = PHOTO_SAVE_PROGRESS_DISPLAY_UGC_ERROR;
				}
			}
			break;

		case PHOTO_SAVE_PROGRESS_DISPLAY_UGC_ERROR :
			if (CSavegameDialogScreens::HandleSaveGameErrorCode())
			{
				m_Status = MEM_CARD_ERROR;
			}
			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		if (m_pMetadataStringForUploadingToUGC)
		{
			delete [] m_pMetadataStringForUploadingToUGC;
			m_pMetadataStringForUploadingToUGC = NULL;
		}

//		CHighQualityScreenshot::ResetState();
//		FreePhotoBuffer();
		return true;
	}

	return false;
}

bool CSavegameQueuedOperation_PhotoSave::Shutdown()
{
//	I'm not sure what to do here. If I've started uploading a photo, do I just let it finish by itself?
	return false;
}

// End of CSavegameQueuedOperation_PhotoSave *********************************************************************************************


// CSavegameQueuedOperation_SavePhotoForMissionCreator *********************************************************************************************


void CSavegameQueuedOperation_SavePhotoForMissionCreator::Init(const char *pFilename, CPhotoBuffer *pPhotoBuffer)
{
	m_pPhotoBuffer = pPhotoBuffer;

	savegameAssertf(strlen(pFilename) < MAX_LENGTH_OF_PATH_TO_MISSION_CREATOR_PHOTO, "CSavegameQueuedOperation_SavePhotoForMissionCreator::Init - filename %s is too long. MAX_LENGTH_OF_PATH_TO_MISSION_CREATOR_PHOTO is %d. Increase it", pFilename, MAX_LENGTH_OF_PATH_TO_MISSION_CREATOR_PHOTO);
	safecpy(m_Filename, pFilename, MAX_LENGTH_OF_PATH_TO_MISSION_CREATOR_PHOTO);

	m_PhotoSaveProgress = MISSION_CREATOR_PHOTO_SAVE_PROGRESS_BEGIN_CLOUD_SAVE;

}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_SavePhotoForMissionCreator::Update()
{
	switch (m_PhotoSaveProgress)
	{
	case MISSION_CREATOR_PHOTO_SAVE_PROGRESS_BEGIN_CLOUD_SAVE :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_S_PH_CL	//	I could have a different message here to differentiate it from the gallery photos

			MemoryCardError resultOfBeginCall = MEM_CARD_ERROR;

			resultOfBeginCall = CSavegameSaveBlock::BeginSaveOfMissionCreatorPhoto(m_Filename, m_pPhotoBuffer->GetJpegBuffer(), m_pPhotoBuffer->GetExactSizeOfJpegData());

			switch (resultOfBeginCall)
			{
			case MEM_CARD_COMPLETE :
				photoDisplayf("CSavegameQueuedOperation_SavePhotoForMissionCreator::Update - BEGIN_CLOUD_SAVE - BeginSaveOfMissionCreatorPhoto succeeded");
				m_PhotoSaveProgress = MISSION_CREATOR_PHOTO_SAVE_PROGRESS_CHECK_CLOUD_SAVE;
				break;

			case MEM_CARD_BUSY :
				photoAssertf(0, "CSavegameQueuedOperation_SavePhotoForMissionCreator::Update - BEGIN_CLOUD_SAVE - didn't expect CSavegameSaveBlock::BeginSaveOfMissionCreatorPhoto() to ever return MEM_CARD_BUSY");
				m_Status = MEM_CARD_ERROR;
				break;
			case MEM_CARD_ERROR :
				photoAssertf(0, "CSavegameQueuedOperation_SavePhotoForMissionCreator::Update - BEGIN_CLOUD_SAVE - CSavegameSaveBlock::BeginSaveOfMissionCreatorPhoto() returned MEM_CARD_ERROR");
				m_Status = MEM_CARD_ERROR;
				break;
			}
		}
		break;

	case MISSION_CREATOR_PHOTO_SAVE_PROGRESS_CHECK_CLOUD_SAVE :
		switch (CSavegameSaveBlock::SaveBlock(true))
		{
		case MEM_CARD_COMPLETE :
			photoDisplayf("CSavegameQueuedOperation_SavePhotoForMissionCreator::Update - CHECK_CLOUD_SAVE - CSavegameSaveBlock succeeded");
			m_Status = MEM_CARD_COMPLETE;
			break;

		case MEM_CARD_BUSY :    // the save is still in progress
			break;

		case MEM_CARD_ERROR :
			photoDisplayf("CSavegameQueuedOperation_SavePhotoForMissionCreator::Update - CHECK_CLOUD_SAVE - CSavegameSaveBlock failed");
			m_Status = MEM_CARD_ERROR;
			break;
		}
		break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		//		CHighQualityScreenshot::ResetState();
		//		FreePhotoBuffer();
		return true;
	}

	return false;
}

// End of CSavegameQueuedOperation_SavePhotoForMissionCreator *********************************************************************************************

// CSavegameQueuedOperation_LoadPhotoForMissionCreator *********************************************************************************************

void CSavegameQueuedOperation_LoadPhotoForMissionCreator::Init(const sRequestData &requestData, CPhotoBuffer *pPhotoBuffer, u32 maxSizeOfBuffer)
{
	m_pPhotoBuffer = pPhotoBuffer;
	m_MaxSizeOfBuffer = maxSizeOfBuffer;
    m_RequestData = requestData;

	m_PhotoLoadProgress = MISSION_CREATOR_PHOTO_LOAD_PROGRESS_BEGIN_CLOUD_LOAD;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_LoadPhotoForMissionCreator::Update()
{
	switch (m_PhotoLoadProgress)
	{
	case MISSION_CREATOR_PHOTO_LOAD_PROGRESS_BEGIN_CLOUD_LOAD :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_L_PH_CL	//	I could have a different message here to differentiate it from the gallery photos

			MemoryCardError resultOfBeginCall = MEM_CARD_ERROR;

			resultOfBeginCall = CSavegameLoadJpegFromCloud::BeginLoadJpegFromCloud(m_RequestData, m_pPhotoBuffer, m_MaxSizeOfBuffer, RL_CLOUD_NAMESPACE_UGC, false);

			switch (resultOfBeginCall)
			{
			case MEM_CARD_COMPLETE :
				photoDisplayf("CSavegameQueuedOperation_LoadPhotoForMissionCreator::Update - BEGIN_CLOUD_LOAD - CSavegameLoadJpegFromCloud::BeginLoadJpegFromCloud() succeeded");
				m_PhotoLoadProgress = MISSION_CREATOR_PHOTO_LOAD_PROGRESS_CHECK_CLOUD_LOAD;
				break;

			case MEM_CARD_BUSY :
				photoAssertf(0, "CSavegameQueuedOperation_LoadPhotoForMissionCreator::Update - BEGIN_CLOUD_LOAD - didn't expect CSavegameLoadJpegFromCloud::BeginLoadJpegFromCloud() to ever return MEM_CARD_BUSY");
				m_Status = MEM_CARD_ERROR;
				break;
			case MEM_CARD_ERROR :
				photoAssertf(0, "CSavegameQueuedOperation_LoadPhotoForMissionCreator::Update - BEGIN_CLOUD_LOAD - CSavegameLoadJpegFromCloud::BeginLoadJpegFromCloud() returned MEM_CARD_ERROR");
				m_Status = MEM_CARD_ERROR;
				break;
			}
		}
		break;

	case MISSION_CREATOR_PHOTO_LOAD_PROGRESS_CHECK_CLOUD_LOAD :
		switch (CSavegameLoadJpegFromCloud::LoadJpegFromCloud())
		{
		case MEM_CARD_COMPLETE :
			photoDisplayf("CSavegameQueuedOperation_LoadPhotoForMissionCreator::Update - CHECK_CLOUD_LOAD - CSavegameLoadJpegFromCloud::LoadJpegFromCloud() succeeded");
			m_Status = MEM_CARD_COMPLETE;
			break;

		case MEM_CARD_BUSY :    // the save is still in progress
			break;

		case MEM_CARD_ERROR :
			photoDisplayf("CSavegameQueuedOperation_LoadPhotoForMissionCreator::Update - CHECK_CLOUD_LOAD - CSavegameLoadJpegFromCloud::LoadJpegFromCloud() failed");
			m_Status = MEM_CARD_ERROR;
			break;
		}
		break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		//		CHighQualityScreenshot::ResetState();
		//		FreePhotoBuffer();
		return true;
	}

	return false;
}


// End of Photos *********************************************************************************************

// MP Stats *******************************************************************************************

void CSavegameQueuedOperation_MPStats_Load::Init(const u32 saveCategory)
{
	m_IndexOfMpSave = saveCategory;
#if __ALLOW_LOCAL_MP_STATS_SAVES
	m_IndexOfSavegameFile = saveCategory + CSavegameList::GetBaseIndexForSavegameFileType(SG_FILE_TYPE_MULTIPLAYER_STATS);
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

	if (saveCategory == 0)
	{
		m_SavegameType = SAVEGAME_MULTIPLAYER_COMMON;
	}
	else
	{
		m_SavegameType = SAVEGAME_MULTIPLAYER_CHARACTER;
	}

	m_OpProgress = MP_STATS_LOAD_PROGRESS_BEGIN_CLOUD_LOAD;
}

bool CSavegameQueuedOperation_MPStats_Load::Shutdown()
{
	m_OpProgress = MP_STATS_LOAD_PROGRESS_CLOUD_FINISH;

//	CGenericGameStorage::SetCloudSaveResultcode( HTTP_CODE_CLIENTCLOSEDREQUEST );
	CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FAILED_TO_LOAD);

	m_Status = MEM_CARD_ERROR;

	CSavingMessage::Clear();

	m_Cloud.Shutdown();

	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);

	return true;
}

void CSavegameQueuedOperation_MPStats_Load::Cancel()
{
	savegameAssertf(MEM_CARD_BUSY == m_Status, "We are not currently loading the mp savegame.");
	if (MEM_CARD_BUSY == m_Status)
	{
		m_OpProgress = MP_STATS_LOAD_PROGRESS_CLOUD_FINISH;

		//	CGenericGameStorage::SetCloudSaveResultcode( HTTP_CODE_CLIENTCLOSEDREQUEST );
		CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FAILED_TO_LOAD);

		m_Status = MEM_CARD_ERROR;

		CSavingMessage::Clear();

		m_Cloud.Shutdown();

		CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
	}
}


#if __BANK
void OutputContentsOfCloudFile(void *pBuffer, u32 BufferLength)
{
	if(PARAM_outputCloudFiles.Get())
	{
		const fiDevice* device = fiDevice::GetDevice("cloudsave0.bak", false);

		int newFileIndex = 0;
		if (device)
		{
			u64 oldestTime = (u64)-1;

			const int numberOfBackups = 6;
			for(int i = 0; i < numberOfBackups; i++)
			{
				char newFileName[RAGE_MAX_PATH];
				formatf(newFileName, "cloudsave%d.bak", i);

				if (!ASSET.Exists(newFileName, ""))
				{
					newFileIndex = i;
					break;
				}
				else 
				{
					char fullNewFileName[RAGE_MAX_PATH];
					ASSET.FullWritePath(fullNewFileName, RAGE_MAX_PATH, newFileName, "");
					u64 fileTime = device->GetFileTime(fullNewFileName);

					if (fileTime < oldestTime)
					{
						oldestTime = fileTime;
						newFileIndex = i;
					}
				}

			}
		}

		char newFileName[RAGE_MAX_PATH];
		formatf(newFileName, "cloudsave%d", newFileIndex);

		fiStream* pStream(ASSET.Create(newFileName, "bak"));
		if (pStream)
		{
			pStream->Write(pBuffer, BufferLength);
			pStream->Close();
		}
	}
}
#endif	//	__BANK

#if __ALLOW_LOCAL_MP_STATS_SAVES
bool CSavegameQueuedOperation_MPStats_Load::ReadPosixTimeFromCloudFile(u64 &timeStamp)
{
	CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_MPSTATS_FROM_CLOUD);
	//Setup Pointers to buffers and size
	CGenericGameStorage::SetBuffer((u8*)m_Cloud.GetBuffer(), m_Cloud.GetBufferLength(), m_SavegameType);
	CGenericGameStorage::SetOnlyReadTimestampFromMPSave(true);

	bool returnValue = CGenericGameStorage::LoadBlockData(m_SavegameType, StatsInterface::CanUseEncrytionInMpSave());

	CGenericGameStorage::SetOnlyReadTimestampFromMPSave(false);
	//Clear Pointers to buffers and size
	CGenericGameStorage::SetBuffer(NULL, 0, m_SavegameType);
	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);

	if (returnValue)
	{
		CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_NONE);
		timeStamp = CGenericGameStorage::GetTimestampReadFromMpSave();
		savegameDisplayf("CSavegameQueuedOperation_MPStats_Load::ReadPosixTimeFromCloudFile - timestamp of cloud file is %lu", timeStamp);
	}
	else
	{
		CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FAILED_TO_LOAD);
		timeStamp = 0;
		savegameDisplayf("CSavegameQueuedOperation_MPStats_Load::ReadPosixTimeFromCloudFile - LoadBlockData failed when reading time stamp from cloud file");		
	}

	return returnValue;
}

void CSavegameQueuedOperation_MPStats_Load::ReadPosixTimeFromLocalFile(u64 &timeStamp)
{
	timeStamp = 0;
	if (m_bLocalFileHasLoaded)
	{
		CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_MPSTATS_SAVEGAME_FROM_CONSOLE);
		CGenericGameStorage::SetOnlyReadTimestampFromMPSave(true);
		CGenericGameStorage::AllowReasonForFailureToBeSet(false);

		if (CGenericGameStorage::LoadBlockData(m_SavegameType))
		{
			timeStamp = CGenericGameStorage::GetTimestampReadFromMpSave();
			savegameDisplayf("CSavegameQueuedOperation_MPStats_Load::ReadPosixTimeFromLocalFile - timestamp of local file is %lu", timeStamp);
		}
		else
		{
			savegameDisplayf("CSavegameQueuedOperation_MPStats_Load::ReadPosixTimeFromLocalFile - LoadBlockData failed when reading time stamp from local file");
		}

		CGenericGameStorage::AllowReasonForFailureToBeSet(true);
		CGenericGameStorage::SetOnlyReadTimestampFromMPSave(false);
		CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
	}
}

void CSavegameQueuedOperation_MPStats_Load::ReadFullDataFromLocalFile()
{
	CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_MPSTATS_SAVEGAME_FROM_CONSOLE);
	CGenericGameStorage::AllowReasonForFailureToBeSet(false);

	//	Pass false for useEncryption. If the buffer needed to be decrypted then it would have been done when reading the timestamp above.
	if (CGenericGameStorage::LoadBlockData(m_SavegameType, false))
	{
		savegameDisplayf("CSavegameQueuedOperation_MPStats_Load::ReadFullDataFromLocalFile - LoadBlockData succeeded when reading data from local file");
	}
	else
	{
		m_bFailedToReadFromLocalFile = true;
		savegameDisplayf("CSavegameQueuedOperation_MPStats_Load::ReadFullDataFromLocalFile - LoadBlockData failed when reading data from local file");
	}

	CGenericGameStorage::AllowReasonForFailureToBeSet(true);
	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
}
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES


void CSavegameQueuedOperation_MPStats_Load::ReadFullDataFromCloudFile()
{
	m_bFailedToReadFromCloudFile = false;
	CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_MPSTATS_FROM_CLOUD);
	//Setup Pointers to buffers and size
	CGenericGameStorage::SetBuffer((u8*)m_Cloud.GetBuffer(), m_Cloud.GetBufferLength(), m_SavegameType);

	bool bDecryptBuffer = StatsInterface::CanUseEncrytionInMpSave();
#if __ALLOW_LOCAL_MP_STATS_SAVES
	bDecryptBuffer = false;	//	Pass false for useEncryption. If the buffer needed to be decrypted then it would have been done when reading the timestamp above.
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

	//Default error is Failure to load
	CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FAILED_TO_LOAD);

	if (CGenericGameStorage::LoadBlockData(m_SavegameType, bDecryptBuffer))
	{
		CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_NONE);
		savegameDisplayf("CSavegameQueuedOperation_MPStats_Load::ReadFullDataFromCloudFile - LoadBlockData succeeded when reading data from cloud file");
	}
	else
	{
		m_bFailedToReadFromCloudFile = true;
		savegameAssertf(0, "LoadBlockData failed when reading data from cloud file '%s'", CSavegameFilenames::GetFilenameOfCloudFile());
		savegameErrorf("CSavegameQueuedOperation_MPStats_Load::ReadFullDataFromCloudFile - LoadBlockData failed when reading data from cloud file");
	}

	//Clear Pointers to buffers and size
	CGenericGameStorage::SetBuffer(NULL, 0, m_SavegameType);
	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
}


// If an error occurs when loading or reading the cloud file then return an error (even if the local file is read successfully)
//    Return true to Pop() from queue
bool CSavegameQueuedOperation_MPStats_Load::Update()
{
	switch (m_OpProgress)
	{
		case MP_STATS_LOAD_PROGRESS_BEGIN_CLOUD_LOAD :
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_LOAD_MP

				CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FAILED_TO_LOAD);
				m_OpProgress = MP_STATS_LOAD_PROGRESS_FREE_BOTH_BUFFERS;

#if __ALLOW_LOCAL_MP_STATS_SAVES
				m_bLocalFileExists = false;
				m_bLocalFileIsDamaged = false;

				m_bLocalFileHasLoaded = false;
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

				m_bCloudFileHasLoaded = false;

				if (savegameVerifyf(CGenericGameStorage::GetSaveOperation() == OPERATION_NONE, "CSavegameQueuedOperation_MPStats_Load::Update - MP_STATS_LOAD_PROGRESS_BEGIN_LOAD - operation is not OPERATION_NONE"))
				{
					// this was getting called when the player had signed in, then signed out without closing the sign-in UI in between.
					if(NetworkInterface::GetActiveGamerInfo() && NetworkInterface::IsCloudAvailable())
					{
						CSavegameUsers::SetUniqueIDOfGamerWhoStartedTheLoad(NetworkInterface::GetActiveGamerInfo()->GetGamerId());
						CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_MPSTATS_FROM_CLOUD);

						CSavegameFilenames::MakeValidSaveNameForMpStatsCloudFile(m_IndexOfMpSave);

						CSavingMessage::BeginDisplaying(CSavingMessage::STORAGE_DEVICE_MESSAGE_CLOUD_LOADING);

						if (m_Cloud.RequestFile(CSavegameFilenames::GetFilenameOfCloudFile(), NetworkInterface::GetLocalGamerIndex(), rlCloudMemberId(), StatsInterface::GetCloudSavegameService()))
						{
							CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_NONE);
							m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD;

#if __ALLOW_LOCAL_MP_STATS_SAVES
#if !__FINAL
							if (PARAM_enableLocalMPSaveCache.Get())
#endif
							{
								m_OpProgress = MP_STATS_LOAD_PROGRESS_BEGIN_CHECK_LOCAL_FILE_EXISTS;
							}
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

							m_Status = MEM_CARD_BUSY;	//	Graeme - I think m_Status will already be MEM_CARD_BUSY at this stage
						}
					}
				}
			}
			break;

#if __ALLOW_LOCAL_MP_STATS_SAVES
		case MP_STATS_LOAD_PROGRESS_BEGIN_CHECK_LOCAL_FILE_EXISTS :
			CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
			switch (CSavegameCheckFileExists::BeginCheckFileExists(m_IndexOfSavegameFile))
			{
			case MEM_CARD_COMPLETE :
				m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_LOCAL_FILE_EXISTS;
				break;
			case MEM_CARD_BUSY :
				savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Load::Update - didn't expect CSavegameCheckFileExists::BeginCheckFileExists() to ever return MEM_CARD_BUSY");
				m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD;
				break;
			case MEM_CARD_ERROR :
				savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Load::Update - CSavegameCheckFileExists::BeginCheckFileExists() returned MEM_CARD_ERROR");
				m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD;
				break;
			}
			break;

		case MP_STATS_LOAD_PROGRESS_CHECK_LOCAL_FILE_EXISTS :
			switch (CSavegameCheckFileExists::CheckFileExists())
			{
				case MEM_CARD_COMPLETE :
					CSavegameCheckFileExists::GetFileStatus(m_bLocalFileExists, m_bLocalFileIsDamaged);
					savegameDebugf1("CSavegameQueuedOperation_MPStats_Load::Update - completed for local slot %d. Time = %d. Slot %s. Slot is %sdamaged\n", m_IndexOfSavegameFile, sysTimer::GetSystemMsTime(), m_bLocalFileExists?"exists":"doesn't exist", m_bLocalFileIsDamaged?"":"not ");
					
					if (m_bLocalFileExists && !m_bLocalFileIsDamaged)
					{
						m_OpProgress = MP_STATS_LOAD_PROGRESS_BEGIN_LOCAL_LOAD;
					}
					else
					{
						m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD;
					}
					break;

				case MEM_CARD_BUSY :    // the load is still in progress
					break;

				case MEM_CARD_ERROR :
					m_bLocalFileExists = false;
					m_bLocalFileIsDamaged = false;
					savegameDebugf1("CSavegameQueuedOperation_MPStats_Load::Update - failed for slot %d. Time = %d. Slot %s. Slot is %sdamaged\n", m_IndexOfSavegameFile, sysTimer::GetSystemMsTime(), m_bLocalFileExists?"exists":"doesn't exist", m_bLocalFileIsDamaged?"":"not ");
					m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD;
					break;
			}
			break;

		case MP_STATS_LOAD_PROGRESS_BEGIN_LOCAL_LOAD :
			if (savegameVerifyf(CSavegameLoad::GetLoadStatus() == GENERIC_LOAD_DO_NOTHING, "CSavegameQueuedOperation_MPStats_Load::Update - expected LoadStatus to be GENERIC_LOAD_DO_NOTHING"))
			{
				CSavegameFilenames::MakeValidSaveNameForLocalFile(m_IndexOfSavegameFile);
				CSavegameLoad::BeginLoad(m_SavegameType);

				m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_LOCAL_LOAD;
			}
			else
			{
				m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD;
			}
			break;

		case MP_STATS_LOAD_PROGRESS_CHECK_LOCAL_LOAD :
			{
				switch (CSavegameLoad::GenericLoad())
				{
					case MEM_CARD_COMPLETE:
						m_bLocalFileHasLoaded = true;
						m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD;
						break;
					case MEM_CARD_BUSY: // the load is still in progress
						break;
					case MEM_CARD_ERROR:
						m_bLocalFileHasLoaded = false;
						m_OpProgress = MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD;
						break;
				}
			}
			break;
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

		case MP_STATS_LOAD_PROGRESS_CHECK_CLOUD_LOAD :
			{
				CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
				CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_MPSTATS_FROM_CLOUD);
				if (!m_Cloud.Pending())
				{
					m_bCloudFileHasLoaded = false;
					m_OpProgress = MP_STATS_LOAD_PROGRESS_FREE_BOTH_BUFFERS;

					m_Cloud.CheckBufferSize();

					if (m_Cloud.Succeeded())
					{
#if __BANK
						OutputContentsOfCloudFile(m_Cloud.GetBuffer(), m_Cloud.GetBufferLength());
#endif // __BANK

						savegameAssertf(m_Cloud.GetBuffer(), "CSavegameQueuedOperation_MPStats_Load::Update - Buffer from cloud load is empty.");
						if (m_Cloud.GetBuffer())
						{
							m_bCloudFileHasLoaded = true;
							m_OpProgress = MP_STATS_LOAD_PROGRESS_DESERIALIZE_FROM_MOST_RECENT_FILE;
						}
					}
					else
					{
						savegameWarningf("CSavegameQueuedOperation_MPStats_Load::Update - Cloud load failed");

						const int resultCode = m_Cloud.GetResultCode(); //See http result codes

						CGenericGameStorage::SetCloudSaveResultcode( resultCode );
						CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FAILED_TO_LOAD);

						if (resultCode == HTTP_CODE_FILENOTFOUND) // File Not Found
						{
							CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FILE_NOT_FOUND);
						}
						else if (resultCode == HTTP_CODE_REQUESTTIMEOUT) // Request has timed out
						{
							CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_SERVER_TIMEOUT);
						}
						else
						{
							if (resultCode >= HTTP_CODE_ANYSERVERERROR)
							{
								CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_SERVER_ERROR);
							}

							savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Load::Update - Cloud LOAD failed - http result code = %d", resultCode);
						}
					}

					CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
				}
			}
			break;

		case MP_STATS_LOAD_PROGRESS_DESERIALIZE_FROM_MOST_RECENT_FILE :
			{
				if (savegameVerifyf(m_bCloudFileHasLoaded, "CSavegameQueuedOperation_MPStats_Load::Update - didn't expect to reach MP_STATS_LOAD_PROGRESS_DESERIALIZE_FROM_MOST_RECENT_FILE if the cloud load failed"))
				{
#if __ALLOW_LOCAL_MP_STATS_SAVES
					u64 timeStampOfCloudSave = 0;
					u64 timeStampOfLocalSave = 0;
			
					m_bFailedToReadFromCloudFile = false;
					m_bFailedToReadFromLocalFile = false;

					if (!ReadPosixTimeFromCloudFile(timeStampOfCloudSave))
					{
						m_bFailedToReadFromCloudFile = true;
						m_OpProgress = MP_STATS_LOAD_PROGRESS_FREE_BOTH_BUFFERS;
						break;
					}

					ReadPosixTimeFromLocalFile(timeStampOfLocalSave);

// Deserialize from most recent file
					if (timeStampOfCloudSave >= timeStampOfLocalSave)
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES
					{
						ReadFullDataFromCloudFile();
					}
#if __ALLOW_LOCAL_MP_STATS_SAVES
					else
					{
						ReadFullDataFromLocalFile();
					}
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES
				}

				m_OpProgress = MP_STATS_LOAD_PROGRESS_FREE_BOTH_BUFFERS;
			}
			break;

		case MP_STATS_LOAD_PROGRESS_FREE_BOTH_BUFFERS :
			{
				CSavingMessage::Clear();

				m_Cloud.Shutdown();
				CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_MPSTATS_FROM_CLOUD);
				CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(m_SavegameType);	//	Graeme - Does this only need to be called for local MP Stats files?

				CGenericGameStorage::SetSaveOperation(OPERATION_NONE);

#if __ALLOW_LOCAL_MP_STATS_SAVES
				CGenericGameStorage::SetSaveOperation(OPERATION_LOADING_MPSTATS_SAVEGAME_FROM_CONSOLE);
				CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(m_SavegameType);
//				CGenericGameStorage::FreeAllDataToBeSaved(m_SavegameType);
				CSavegameLoad::EndGenericLoad();
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

				if (!m_bCloudFileHasLoaded || m_bFailedToReadFromCloudFile
#if __ALLOW_LOCAL_MP_STATS_SAVES
					|| m_bFailedToReadFromLocalFile
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES
					)
				{
					m_Status = MEM_CARD_ERROR;
				}
				else
				{
					m_Status = MEM_CARD_COMPLETE;
				}
			}
			break;

		case MP_STATS_LOAD_PROGRESS_CLOUD_FINISH :
			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		return true;
	}

	return false;
}

void CSavegameQueuedOperation_MPStats_Save::Init(const u32 saveCategory
#if __ALLOW_LOCAL_MP_STATS_SAVES
	, eMPStatsSaveDestination saveDestination
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES
	)
{
	m_SlotIndex = saveCategory;

	if (saveCategory == 0)
	{
		m_SavegameType = SAVEGAME_MULTIPLAYER_COMMON;
	}
	else
	{
		m_SavegameType = SAVEGAME_MULTIPLAYER_CHARACTER;
	}

#if __ALLOW_LOCAL_MP_STATS_SAVES
	m_bSaveToCloud = false;
	m_bSaveToConsole = false;

	switch (saveDestination)
	{
		case MP_STATS_SAVE_TO_CLOUD :
			m_bSaveToCloud = true;
			break;
		case MP_STATS_SAVE_TO_CONSOLE :
			m_bSaveToConsole = true;
			break;
		case MP_STATS_SAVE_TO_CLOUD_AND_CONSOLE :
			m_bSaveToCloud = true;
			m_bSaveToConsole = true;
			break;
	}

	if (m_bSaveToConsole)
	{
		m_OpProgress = MP_STATS_SAVE_PROGRESS_CREATE_LOCAL_DATA_TO_BE_SAVED;
	}
	else
	{
		savegameAssertf(m_bSaveToCloud, "CSavegameQueuedOperation_MPStats_Save::Init - both bSaveToCloud and bSaveToConsole have been specified as false");
		m_OpProgress = MP_STATS_SAVE_PROGRESS_CREATE_CLOUD_DATA_TO_BE_SAVED;
	}

	m_bLocalSaveSucceeded = false;
#else	//	__ALLOW_LOCAL_MP_STATS_SAVES
	m_OpProgress = MP_STATS_SAVE_PROGRESS_CREATE_CLOUD_DATA_TO_BE_SAVED;
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

	m_bCloudSaveSucceeded = false;
}

bool CSavegameQueuedOperation_MPStats_Save::Shutdown()
{
	m_OpProgress = MP_STATS_SAVE_PROGRESS_FINISH;

	CGenericGameStorage::SetCloudSaveResultcode( HTTP_CODE_CLIENTCLOSEDREQUEST );
//	CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FAILED_TO_LOAD);

	m_Status = MEM_CARD_ERROR;

	CSavingMessage::Clear();

	m_Cloud.Shutdown();

	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);

	return true;
}

void CSavegameQueuedOperation_MPStats_Save::Cancel()
{
	savegameAssertf(m_Status == MEM_CARD_BUSY, "We are NOT currently saving the game to the cloud.");
	if (m_Status == MEM_CARD_BUSY)
	{
		CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(m_SavegameType);
		CGenericGameStorage::FreeAllDataToBeSaved(m_SavegameType);

		m_OpProgress = MP_STATS_SAVE_PROGRESS_FINISH;

		CGenericGameStorage::SetCloudSaveResultcode( HTTP_CODE_CLIENTCLOSEDREQUEST );
		//	CGenericGameStorage::SetReasonForFailureToLoadSavegame(LOAD_FAILED_REASON_FAILED_TO_LOAD);

		m_Status = MEM_CARD_ERROR;

		CSavingMessage::Clear();

		m_Cloud.Shutdown();

		CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
	}
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_MPStats_Save::Update()
{
	switch (m_OpProgress)
	{
#if __ALLOW_LOCAL_MP_STATS_SAVES
// ****************** Local Save ******************
		case MP_STATS_SAVE_PROGRESS_CREATE_LOCAL_DATA_TO_BE_SAVED :
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_SAVE_MP

				CGenericGameStorage::SetSaveOperation(OPERATION_SAVING_MPSTATS_SAVEGAME_TO_CONSOLE);

				MemoryCardError CalculateSizeStatus = CGenericGameStorage::CreateSaveDataAndCalculateSize(m_SavegameType, false);
				switch (CalculateSizeStatus)
				{
				case MEM_CARD_COMPLETE :
					savegameAssertf(CGenericGameStorage::GetBufferSize(m_SavegameType) > 0, "CSavegameQueuedOperation_MPStats_Save::Update - size of local MP save game buffer has not been calculated");
					CSavegameInitialChecks::SetSizeOfBufferToBeSaved(CGenericGameStorage::GetBufferSize(m_SavegameType));
					m_OpProgress = MP_STATS_SAVE_PROGRESS_BEGIN_LOCAL_SAVE;
					break;

				case MEM_CARD_BUSY :
					// Don't do anything - still calculating size - it might be that we're waiting for memory to be available to create the save data
					break;

				case MEM_CARD_ERROR :
					savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Save::Update - CGenericGameStorage::CreateSaveDataAndCalculateSize failed for local buffer");
					m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_LOCAL_SAVE_BUFFER;
					break;
				}
			}
			break;

		case MP_STATS_SAVE_PROGRESS_BEGIN_LOCAL_SAVE :
			{
				CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
				switch (CSavegameSave::BeginGameSave(CSavegameList::GetBaseIndexForSavegameFileType(SG_FILE_TYPE_MULTIPLAYER_STATS) + m_SlotIndex, m_SavegameType))
				{
					case MEM_CARD_COMPLETE :
						m_OpProgress = MP_STATS_SAVE_PROGRESS_LOCAL_SAVE_UPDATE;
						break;
					case MEM_CARD_BUSY :
						savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Save::Update - didn't expect CSavegameSave::BeginGameSave to ever return MEM_CARD_BUSY");
						m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_LOCAL_SAVE_BUFFER;
						break;
					case MEM_CARD_ERROR :
						savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Save::Update - CSavegameSave::BeginGameSave failed");
						m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_LOCAL_SAVE_BUFFER;
						break;
				}
			}
			break;

		case MP_STATS_SAVE_PROGRESS_LOCAL_SAVE_UPDATE :
			{
				switch (CSavegameSave::GenericSave())
				{
					case MEM_CARD_COMPLETE :
						m_bLocalSaveSucceeded = true;
						m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_LOCAL_SAVE_BUFFER;
						break;

					case MEM_CARD_BUSY :	 // the save is still in progress
						break;

					case MEM_CARD_ERROR :
						m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_LOCAL_SAVE_BUFFER;
						break;
				}
			}
			break;

		case MP_STATS_SAVE_PROGRESS_FREE_LOCAL_SAVE_BUFFER :
			
			CGenericGameStorage::SetSaveOperation(OPERATION_SAVING_MPSTATS_SAVEGAME_TO_CONSOLE);

			CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(m_SavegameType);
			CGenericGameStorage::FreeAllDataToBeSaved(m_SavegameType);

			CGenericGameStorage::SetSaveOperation(OPERATION_NONE);

			if (m_bSaveToCloud)
			{
				CGenericGameStorage::SetSaveOperation(OPERATION_SAVING_MPSTATS_TO_CLOUD);

				m_OpProgress = MP_STATS_SAVE_PROGRESS_CREATE_CLOUD_DATA_TO_BE_SAVED;
			}
			else
			{
				m_OpProgress = MP_STATS_SAVE_PROGRESS_FINISH;
			}
			break;
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES

// ****************** Cloud Save ******************

		case MP_STATS_SAVE_PROGRESS_CREATE_CLOUD_DATA_TO_BE_SAVED :
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_SAVE_MP

				CGenericGameStorage::SetSaveOperation(OPERATION_SAVING_MPSTATS_TO_CLOUD);

				MemoryCardError CalculateSizeStatus = CGenericGameStorage::CreateSaveDataAndCalculateSize(m_SavegameType, false);
				switch (CalculateSizeStatus)
				{
					case MEM_CARD_COMPLETE :
						savegameAssertf(CGenericGameStorage::GetBufferSize(m_SavegameType) > 0, "CSavegameQueuedOperation_MPStats_Save::Update - size of cloud MP save game buffer has not been calculated");
						CSavegameInitialChecks::SetSizeOfBufferToBeSaved(CGenericGameStorage::GetBufferSize(m_SavegameType));
						m_OpProgress = MP_STATS_SAVE_PROGRESS_ALLOCATE_CLOUD_SAVE_BUFFER;
						break;

					case MEM_CARD_BUSY :
						// Don't do anything - still calculating size - it might be that we're waiting for memory to be available to create the save data
						break;

					case MEM_CARD_ERROR :
						savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Save::Update - CGenericGameStorage::CreateSaveDataAndCalculateSize failed for cloud");
						m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_CLOUD_SAVE_BUFFER;
						break;
				}
			}
			break;

		case MP_STATS_SAVE_PROGRESS_ALLOCATE_CLOUD_SAVE_BUFFER :
			{
				MemoryCardError AllocateBufferStatus = CGenericGameStorage::AllocateBuffer(m_SavegameType, true);
				switch (AllocateBufferStatus)
				{
					case MEM_CARD_COMPLETE :
						m_OpProgress = MP_STATS_SAVE_PROGRESS_BEGIN_FILL_CLOUD_SAVE_BUFFER;
 						break;
 					case MEM_CARD_BUSY :
 						//	Don't do anything - still waiting for memory to be allocated
 						break;
 					case MEM_CARD_ERROR :
						savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Save::Update - CGenericGameStorage::AllocateBuffer failed");
						m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_CLOUD_SAVE_BUFFER;
 						break;
				}
			}
			break;

		case MP_STATS_SAVE_PROGRESS_BEGIN_FILL_CLOUD_SAVE_BUFFER:
			{
				if (CGenericGameStorage::BeginSaveBlockData(m_SavegameType, StatsInterface::CanUseEncrytionInMpSave()))
				{
					m_OpProgress = MP_STATS_SAVE_PROGRESS_FILL_CLOUD_SAVE_BUFFER;
				}
				else
				{
	//				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_SAVE_BLOCK_DATA_FAILED);
					savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Save::Update - CGenericGameStorage::BeginSaveBlockData failed for cloud buffer");
					CGenericGameStorage::EndSaveBlockData(m_SavegameType);
					m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_CLOUD_SAVE_BUFFER;
				}
			}
			break;

		case MP_STATS_SAVE_PROGRESS_FILL_CLOUD_SAVE_BUFFER :
			{
				switch (CGenericGameStorage::GetSaveBlockDataStatus(m_SavegameType))
				{
				case SAVEBLOCKDATA_PENDING:
					// Don't do anything - still waiting for data to be saved
					break;
				case SAVEBLOCKDATA_ERROR:
					{
		//				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_SAVE_BLOCK_DATA_FAILED);
						savegameAssertf(0, "CSavegameQueuedOperation_MPStats_Save::Update - CGenericGameStorage::SaveBlockData failed for cloud buffer");
						CGenericGameStorage::EndSaveBlockData(m_SavegameType);
						m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_CLOUD_SAVE_BUFFER;
					}
					break;
				case SAVEBLOCKDATA_SUCCESS:
					{
						CGenericGameStorage::EndSaveBlockData(m_SavegameType);
						m_OpProgress = MP_STATS_SAVE_PROGRESS_BEGIN_CLOUD_SAVE;
					}
					break;
				default:
					FatalAssertf(0, "CSavegameQueuedOperation_MPStats_Save::Update - Unexpected return value from CGenericGameStorage::SaveBlockData");
					break;
				}

			}
			break;

		case MP_STATS_SAVE_PROGRESS_BEGIN_CLOUD_SAVE:
			{
				// this was getting called when the player had signed in, then signed out without closing the sign-in UI in between.
				if(NetworkInterface::GetActiveGamerInfo() && NetworkInterface::IsCloudAvailable())
				{
					CSavegameFilenames::MakeValidSaveNameForMpStatsCloudFile(m_SlotIndex);

					CSavingMessage::BeginDisplaying(CSavingMessage::STORAGE_DEVICE_MESSAGE_CLOUD_SAVING);

					m_Cloud.PostFile(CGenericGameStorage::GetBuffer(m_SavegameType)
						,CGenericGameStorage::GetBufferSize(m_SavegameType)
						,CSavegameFilenames::GetFilenameOfCloudFile()
						,NetworkInterface::GetLocalGamerIndex()
						,StatsInterface::GetCloudSavegameService());

					m_OpProgress = MP_STATS_SAVE_PROGRESS_CLOUD_SAVE_UPDATE;

					m_Status = MEM_CARD_BUSY;	//	Graeme - I think m_Status will already be MEM_CARD_BUSY at this stage
				}
				else
				{
					CGenericGameStorage::SetCloudSaveResultcode( HTTP_CODE_CLIENTCLOSEDREQUEST );
					m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_CLOUD_SAVE_BUFFER;
				}
			}
			break;

		case MP_STATS_SAVE_PROGRESS_CLOUD_SAVE_UPDATE:
			{
				if (!m_Cloud.Pending())
				{
					CGenericGameStorage::SetCloudSaveResultcode( m_Cloud.GetResultCode() );

					if (m_Cloud.Succeeded())
					{
						m_bCloudSaveSucceeded = true;
					}
					else
					{
						savegameWarningf("CSavegameQueuedOperationCloud::Update - Cloud save failed");

						const int resultCode = m_Cloud.GetResultCode(); //See http result codes

						if (resultCode == HTTP_CODE_REQUESTTIMEOUT 
							|| resultCode == HTTP_CODE_TOOMANYREQUESTS 
							|| resultCode == HTTP_CODE_GATEWAYTIMEOUT 
							NOTFINAL_ONLY( || resultCode==HTTP_CODE_ANYSERVERERROR )
							)
						{
							savegameWarningf("CSavegameQueuedOperationCloud::Update - Cloud SAVE failed - http result code = %d", resultCode);
						}
						else
						{
							savegameAssertf(0, "CSavegameQueuedOperationCloud::Update - Cloud SAVE failed - http result code = %d", resultCode);
						}
					}

					m_OpProgress = MP_STATS_SAVE_PROGRESS_FREE_CLOUD_SAVE_BUFFER;
				}
			}
			break;

		case MP_STATS_SAVE_PROGRESS_FREE_CLOUD_SAVE_BUFFER :
			CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(m_SavegameType);
			CGenericGameStorage::FreeAllDataToBeSaved(m_SavegameType);

			CGenericGameStorage::SetSaveOperation(OPERATION_NONE);

			m_OpProgress = MP_STATS_SAVE_PROGRESS_FINISH;
			break;

		case MP_STATS_SAVE_PROGRESS_FINISH :
			break;
	}

	if (m_OpProgress == MP_STATS_SAVE_PROGRESS_FINISH)
	{
		if (m_bCloudSaveSucceeded
#if __ALLOW_LOCAL_MP_STATS_SAVES
			|| m_bLocalSaveSucceeded
#endif	//	__ALLOW_LOCAL_MP_STATS_SAVES
			)
		{	//	Set status to complete if either save succeeded
			m_Status = MEM_CARD_COMPLETE;
		}
		else
		{
			m_Status = MEM_CARD_ERROR;
		}

		CSavingMessage::Clear();
		m_Cloud.Shutdown();

		return true;
	}

	return false;
}

// End of MP Stats *******************************************************************************************


void CSavegameQueuedOperation_ManualLoad::Init()
{
	m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_SAVEGAME_LIST;

	m_bQuitAsSoonAsNoSavegameOperationsAreRunning = false;
#if RSG_ORBIS
	deleteBackupSave = false;
#endif
}

bool CSavegameQueuedOperation_ManualLoad::Update()
{
#if __ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME
	bool bReturnSelection = false;
#endif	//	__ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME

	switch (m_ManualLoadProgress)
	{
		case MANUAL_LOAD_PROGRESS_BEGIN_SAVEGAME_LIST :
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_LOAD

			if (!CSavegameFrontEnd::BeginSaveGameList())
			{
				Assertf(0, "CSavegameQueuedOperation_ManualLoad::Update - CSavegameFrontEnd::BeginSaveGameList failed");
				CPauseMenu::Close();
				savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (1)");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				if (!CPauseMenu::GetNoValidSaveGameFiles())	//	sm_bNoValidSaveGameFiles will be true if the PS3 hard disk has been 
															//	scanned previously and there are no valid save games on it
				{
					//CPauseMenu::LockMenuControl();n

				}
				m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_CHECK_SAVEGAME_LIST;
			}
			break;

		case MANUAL_LOAD_PROGRESS_CHECK_SAVEGAME_LIST :
			{
				switch (CSavegameFrontEnd::SaveGameMenuCheck(m_bQuitAsSoonAsNoSavegameOperationsAreRunning))
				{
					case MEM_CARD_COMPLETE :

						if (CSavegameFrontEnd::ShouldDeleteSavegame())
						{
							m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_DELETE;
						}
						else
						{
#if __ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME
							if (CSavegameFrontEnd::ShouldUploadFileToCloud())
							{
								savegameAssertf(!CSavegameList::IsSaveGameSlotEmpty(CSavegameFrontEnd::GetSaveGameSlotToUpload()), "CSavegameQueuedOperation_ManualLoad::Update - didn't expect slot %d to be empty", CSavegameFrontEnd::GetSaveGameSlotToUpload());
								savegameAssertf(!CSavegameList::GetIsDamaged(CSavegameFrontEnd::GetSaveGameSlotToUpload()), "CSavegameQueuedOperation_ManualLoad::Update - didn't expect slot %d to be damaged", CSavegameFrontEnd::GetSaveGameSlotToUpload());
								m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_LOAD_FOR_CLOUD_UPLOAD;
							}
							else
#endif	//	__ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME
							{
								savegameAssertf(!CSavegameList::IsSaveGameSlotEmpty(CSavegameFrontEnd::GetSaveGameSlotToLoad()), "CSavegameQueuedOperation_ManualLoad::Update - didn't expect slot %d to be empty", CSavegameFrontEnd::GetSaveGameSlotToLoad());
								savegameAssertf(!CSavegameList::GetIsDamaged(CSavegameFrontEnd::GetSaveGameSlotToLoad()), "CSavegameQueuedOperation_ManualLoad::Update - didn't expect slot %d to be damaged", CSavegameFrontEnd::GetSaveGameSlotToLoad());
								m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_LOAD;

								STRVIS_SET_MARKER_TEXT("LOAD_PROGRESS_CHECK_SAVEGAME_LIST - Complete");

								// We just pressed the "Yes, we want to load a saved game"
								camInterface::FadeOut(0);	// Fade out now (B*939357)
								CLoadingScreens::Init(LOADINGSCREEN_CONTEXT_LOADLEVEL, 0);

								// pause streaming any other misc processing
								CStreaming::SetIsPlayerPositioned(false);
							}
						}
						break;

					case MEM_CARD_BUSY :	//	still processing, do nothing
						break;

					case MEM_CARD_ERROR :
						CPauseMenu::BackOutOfLoadGamePanes();
						savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (2)");
						m_Status = MEM_CARD_ERROR;
						break;
				}
			}
			break;

		case MANUAL_LOAD_PROGRESS_BEGIN_LOAD :
			if (MEM_CARD_ERROR == CSavegameList::BeginGameLoad(CSavegameFrontEnd::GetSaveGameSlotToLoad()))
			{
				camInterface::FadeIn(0);	//	CPauseMenu::CheckWhatToDoWhenClosed() will be calling FadeOut() at about the same time as this because bCloseAndStartSavedGame will be set
				CPauseMenu::AbandonLoadingOfSavedGame();	//	so clear bCloseAndStartSavedGame
				CGame::SetStateToIdle();
				CLoadingScreens::Shutdown(SHUTDOWN_CORE);
				savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (3)");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_CHECK_LOAD;
			}
			break;

		case MANUAL_LOAD_PROGRESS_CHECK_LOAD :
			{
				switch (CSavegameLoad::GenericLoad())
				{
				case MEM_CARD_COMPLETE:
					{
						STRVIS_SET_MARKER_TEXT("LOAD_PROGRESS_CHECK_LOAD - complete");
						camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading

						CGame::HandleLoadedSaveGame();
						savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_COMPLETE (1)");
						m_Status = MEM_CARD_COMPLETE;
					}
					break;
				case MEM_CARD_BUSY: // the load is still in progress
					break;
				case MEM_CARD_ERROR:
					{
						camInterface::FadeIn(0);	//	CPauseMenu::CheckWhatToDoWhenClosed() will be calling FadeOut() at about the same time as this because bCloseAndStartSavedGame will be set
						CPauseMenu::AbandonLoadingOfSavedGame();	//	so clear bCloseAndStartSavedGame
						CGame::SetStateToIdle();
						CLoadingScreens::Shutdown(SHUTDOWN_CORE);
						savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (4)");
						m_Status = MEM_CARD_ERROR;
					}
					break;
				}
			}
			break;

		case MANUAL_LOAD_PROGRESS_BEGIN_DELETE :
			{
				s32 correctSlot = CSavegameFrontEnd::GetSaveGameSlotToDelete();
#if RSG_ORBIS
				if(deleteBackupSave)
				{
					//make sure we get the correct slot numbers for the main save and the backup save
					if(CSavegameFrontEnd::GetSaveGameSlotToDelete() < TOTAL_NUMBER_OF_SLOTS_FOR_SAVEGAMES)
						correctSlot = CSavegameFrontEnd::GetSaveGameSlotToDelete() + INDEX_OF_BACKUPSAVE_SLOT;
				}
#endif
				CSavegameFilenames::CreateNameOfLocalFile(m_FilenameOfFileToDelete, SAVE_GAME_MAX_FILENAME_LENGTH_OF_LOCAL_FILE, correctSlot);

#if RSG_ORBIS
				CSavegameList::SetSlotToUpdateOnceDeleteHasCompleted(correctSlot);
#endif	//	RSG_ORBIS

				if (CSavegameDelete::Begin(m_FilenameOfFileToDelete, false, false))	//	m_bCloudFile))
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - CSavegameDelete::Begin succeeded for %s", m_FilenameOfFileToDelete);
					m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_CHECK_DELETE;
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - CSavegameDelete::Begin failed for %s", m_FilenameOfFileToDelete);
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (5)");
					m_Status = MEM_CARD_ERROR;
//					return true;
				}
			}
			break;

		case MANUAL_LOAD_PROGRESS_CHECK_DELETE :
			{
				switch (CSavegameDelete::Update())
				{
				case MEM_CARD_COMPLETE :
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - CSavegameDelete::Update succeeded for %s", m_FilenameOfFileToDelete);
					
#if ENABLE_SINGLE_PLAYER_CLOUD_SAVES
					CLiveManager::UnregisterSinglePlayerCloudSaveFile(m_FilenameOfFileToDelete);
#endif	//	RSG_PC

#if RSG_ORBIS
					//set progress back to start of delete to delete appropriate backup save
					if(!deleteBackupSave && CSavegameFrontEnd::GetSaveGameSlotToDelete() < TOTAL_NUMBER_OF_SLOTS_FOR_SAVEGAMES)
					{
						deleteBackupSave = true;
						m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_DELETE;
					}
					else
#endif
					{
#if RSG_ORBIS
						deleteBackupSave = false;

#if USE_DOWNLOAD0_FOR_AUTOSAVE_BACKUP && GTA_REPLAY
						if (CSavegameFilenames::IsThisTheNameOfAnAutosaveBackupFile(m_FilenameOfFileToDelete))
						{
							savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - CSavegameDelete::Update succeeded for an autosave backup in download0 so call ReplayFileManager::RefreshNonClipDirectorySizes()");
							ReplayFileManager::RefreshNonClipDirectorySizes();
						}
#endif	//	USE_DOWNLOAD0_FOR_AUTOSAVE_BACKUP && GTA_REPLAY
#endif	//	RSG_ORBIS

						m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_DISPLAY_DELETE_SUCCESS_MESSAGE;
					}

#if RSG_ORBIS
					CSavegameList::UpdateSlotDataAfterDelete();
#endif	//	RSG_ORBIS
//					m_Status = MEM_CARD_COMPLETE;
//					return true;
					break;

				case MEM_CARD_BUSY :
					break;

				case MEM_CARD_ERROR :
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - CSavegameDelete::Update failed for %s", m_FilenameOfFileToDelete);
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (6)");
					m_Status = MEM_CARD_ERROR;
//					return true;
					break;
				}
			}
			break;

		case MANUAL_LOAD_PROGRESS_DISPLAY_DELETE_SUCCESS_MESSAGE :
			{
//				CSavingMessage::Clear();

				bool ReturnSelection = false;
				if (CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_DELETION_OF_SAVEGAME_SUCCEEDED, 0, &ReturnSelection))
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_COMPLETE (2)");
					m_Status = MEM_CARD_COMPLETE;
					CPauseMenu::SetSavegameListIsBeingRedrawnAfterDeletingASavegame(true);
				}
			}
			break;


#if __ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME
		case MANUAL_LOAD_PROGRESS_BEGIN_LOAD_FOR_CLOUD_UPLOAD :
			{
				FillJsonString(CSavegameFrontEnd::GetSaveGameSlotToUpload());

				if (MEM_CARD_ERROR == CSavegameList::BeginGameLoad(CSavegameFrontEnd::GetSaveGameSlotToUpload()))
				{
//					camInterface::FadeIn(0);	//	CPauseMenu::CheckWhatToDoWhenClosed() will be calling FadeOut() at about the same time as this because bCloseAndStartSavedGame will be set
//					CPauseMenu::AbandonLoadingOfSavedGame();	//	so clear bCloseAndStartSavedGame
//					CGame::SetStateToIdle();
//					CLoadingScreens::Shutdown(SHUTDOWN_CORE);
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (7)");
					m_Status = MEM_CARD_ERROR;
				}
				else
				{
					m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_CHECK_LOAD_FOR_CLOUD_UPLOAD;
				}
			}
			break;
	
		case MANUAL_LOAD_PROGRESS_CHECK_LOAD_FOR_CLOUD_UPLOAD :
			{
				switch (CSavegameLoad::GenericLoad())
				{
				case MEM_CARD_COMPLETE:
					{
//						STRVIS_SET_MARKER_TEXT("LOAD_PROGRESS_CHECK_LOAD - complete");
//						camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading

//						CGame::HandleLoadedSaveGame();
//						m_Status = MEM_CARD_COMPLETE;
						CSavegameLoad::EndGenericLoad();
						m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_CLOUD_UPLOAD;
					}
					break;
				case MEM_CARD_BUSY: // the load is still in progress
					if (SAVE_GAME_DIALOG_NONE == CSavegameDialogScreens::GetMostRecentErrorCode())
					{
						CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_LOADING_LOCAL_SAVEGAME_BEFORE_UPLOADING_TO_CLOUD, 0, &bReturnSelection);
					}
					break;
				case MEM_CARD_ERROR:
					{
//						camInterface::FadeIn(0);	//	CPauseMenu::CheckWhatToDoWhenClosed() will be calling FadeOut() at about the same time as this because bCloseAndStartSavedGame will be set
//						CPauseMenu::AbandonLoadingOfSavedGame();	//	so clear bCloseAndStartSavedGame
//						CGame::SetStateToIdle();
//						CLoadingScreens::Shutdown(SHUTDOWN_CORE);
						CSavegameLoad::EndGenericLoad();
						savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (8)");
						m_Status = MEM_CARD_ERROR;
					}
					break;
				}
			}
			break;

		case MANUAL_LOAD_PROGRESS_BEGIN_CLOUD_UPLOAD :
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_S_PH_CL	//	I could have a different message here to differentiate it from the gallery photos

				MemoryCardError resultOfBeginCall = MEM_CARD_ERROR;

				resultOfBeginCall = CSavegameSaveBlock::BeginUploadOfSavegameToCloud("GTA5/saves/PreviousGenSave.save", CGenericGameStorage::GetBuffer(SAVEGAME_SINGLE_PLAYER), CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER), m_JsonString);

				switch (resultOfBeginCall)
				{
				case MEM_CARD_COMPLETE :
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - BEGIN_CLOUD_UPLOAD - BeginUploadOfSavegameToCloud succeeded");
					m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_CHECK_CLOUD_UPLOAD;
					break;

				case MEM_CARD_BUSY :
					savegameAssertf(0, "CSavegameQueuedOperation_ManualLoad::Update - BEGIN_CLOUD_UPLOAD - didn't expect CSavegameSaveBlock::BeginUploadOfSavegameToCloud() to ever return MEM_CARD_BUSY");
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (9)");
					m_Status = MEM_CARD_ERROR;
					break;
				case MEM_CARD_ERROR :
					savegameAssertf(0, "CSavegameQueuedOperation_ManualLoad::Update - BEGIN_CLOUD_UPLOAD - CSavegameSaveBlock::BeginUploadOfSavegameToCloud() returned MEM_CARD_ERROR");
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (10)");
					m_Status = MEM_CARD_ERROR;
					break;
				}

			}
			break;

		case MANUAL_LOAD_PROGRESS_CHECK_CLOUD_UPLOAD :
			{
				switch (CSavegameSaveBlock::SaveBlock(true))
				{
				case MEM_CARD_COMPLETE :
					photoDisplayf("CSavegameQueuedOperation_ManualLoad::Update - CHECK_CLOUD_UPLOAD - CSavegameSaveBlock succeeded");
					m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_DISPLAY_UPLOAD_SUCCESS_MESSAGE;
					break;

				case MEM_CARD_BUSY :    // the save is still in progress
					if (SAVE_GAME_DIALOG_NONE == CSavegameDialogScreens::GetMostRecentErrorCode())
					{
						CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_UPLOADING_SAVEGAME_TO_CLOUD, 0, &bReturnSelection);
					}
					break;

				case MEM_CARD_ERROR :
					photoDisplayf("CSavegameQueuedOperation_ManualLoad::Update - CHECK_CLOUD_UPLOAD - CSavegameSaveBlock failed");
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_ERROR (11)");
					m_Status = MEM_CARD_ERROR;
					break;
				}
			}
			break;

		case MANUAL_LOAD_PROGRESS_DISPLAY_UPLOAD_SUCCESS_MESSAGE :
			{
//				CSavingMessage::Clear();

				bool ReturnSelection = false;
				if (CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_UPLOAD_OF_SAVEGAME_SUCCEEDED, 0, &ReturnSelection))
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_COMPLETE (3)");
					m_Status = MEM_CARD_COMPLETE;
				}
			}
			break;
#endif	//	__ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME
	}


	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		switch (m_ManualLoadProgress)
		{
			case MANUAL_LOAD_PROGRESS_BEGIN_DELETE :
			case MANUAL_LOAD_PROGRESS_CHECK_DELETE :
			case MANUAL_LOAD_PROGRESS_DISPLAY_DELETE_SUCCESS_MESSAGE :
				{
					if (m_bQuitAsSoonAsNoSavegameOperationsAreRunning)
					{
						return true;
					}
					else
					{
						m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_SAVEGAME_LIST;
						savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_BUSY (1)");
						m_Status = MEM_CARD_BUSY;
					}
				}
				break;

#if __ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME
			case MANUAL_LOAD_PROGRESS_BEGIN_LOAD_FOR_CLOUD_UPLOAD :
			case MANUAL_LOAD_PROGRESS_CHECK_LOAD_FOR_CLOUD_UPLOAD :
			case MANUAL_LOAD_PROGRESS_BEGIN_CLOUD_UPLOAD :
			case MANUAL_LOAD_PROGRESS_CHECK_CLOUD_UPLOAD :
			case MANUAL_LOAD_PROGRESS_DISPLAY_UPLOAD_SUCCESS_MESSAGE :
				{
					CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(SAVEGAME_SINGLE_PLAYER);
					//			CSavegameLoad::EndGenericLoad();	//	this line should maybe be moved so that it only gets called in UPLOAD_PROGRESS_CHECK_LOAD for pass or fail

					//			CPauseMenu::BackOutOfLoadGamePanes();

					if (m_bQuitAsSoonAsNoSavegameOperationsAreRunning)
					{
						return true;
					}
					else
					{
						m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_SAVEGAME_LIST;
						savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - setting status to MEM_CARD_BUSY (2)");
						m_Status = MEM_CARD_BUSY;
					}
				}
				break;
#endif	//	__ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME

			default :
				{
					if (m_Status == MEM_CARD_COMPLETE)
					{
						savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - m_Status is MEM_CARD_COMPLETE so returning TRUE");

						return true;
					}
					else if (m_Status == MEM_CARD_ERROR)
					{
						// We won't be starting a new session so unpause the streaming
						CStreaming::SetIsPlayerPositioned(true);

						// Un-mute the audio
						audNorthAudioEngine::CancelStartNewGame();

						savegameDisplayf("CSavegameQueuedOperation_ManualLoad::Update - m_Status is MEM_CARD_ERROR so returning TRUE");

						return true;
					}
				}
				break;
		}
	}

	return false;
}

#if __ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME
bool CSavegameQueuedOperation_ManualLoad::FillJsonString(s32 savegameSlotNumber)
{
	memset(m_JsonString, 0, LENGTH_OF_JSON_STRING);
	RsonWriter rsonWriter(m_JsonString, LENGTH_OF_JSON_STRING, RSON_FORMAT_JSON);
	rsonWriter.Reset();

	bool bSuccess = rsonWriter.Begin(NULL, NULL);	//	Top-level structure to contain all the rest of the data

	if (bSuccess)
	{
		bool SlotIsEmpty = false;
		bool SlotIsDamaged = false;

		char cSaveGameName[SAVE_GAME_MAX_DISPLAY_NAME_LENGTH];
		char cSaveGameDate[MAX_MENU_ITEM_CHAR_LENGTH];

		CSavegameList::GetDisplayNameAndDateForThisSaveGameItem(savegameSlotNumber, cSaveGameName, cSaveGameDate, &SlotIsEmpty, &SlotIsDamaged);
		bSuccess = rsonWriter.WriteString("disp", cSaveGameName);
	}

	if (bSuccess)
	{
		bSuccess = rsonWriter.End();	//	Close the top-level structure
	}

	return bSuccess;
}
#endif	//	__ALLOW_CLOUD_UPLOAD_OF_LOCAL_SAVEGAME



void CSavegameQueuedOperation_ManualSave::Init()
{
	m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_CREATE_SAVE_BUFFER;

	m_bQuitAsSoonAsNoSavegameOperationsAreRunning = false;
#if RSG_ORBIS
	deleteBackupSave = false;
#endif
}

bool CSavegameQueuedOperation_ManualSave::Update()
{
	switch (m_ManualSaveProgress)
	{
		case MANUAL_SAVE_PROGRESS_CREATE_SAVE_BUFFER :
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_SAVE

				MemoryCardError CalculateSizeStatus = CGenericGameStorage::CreateSaveDataAndCalculateSize(SAVEGAME_SINGLE_PLAYER, false);
				switch (CalculateSizeStatus)
				{
				case MEM_CARD_COMPLETE :
					Assertf(CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER) > 0, "CSavegameQueuedOperation_ManualSave::Update - size of save game buffer has not been calculated");
					CSavegameInitialChecks::SetSizeOfBufferToBeSaved(CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER));
					m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_BEGIN_SAVEGAME_LIST;
					break;

				case MEM_CARD_BUSY :
					// Don't do anything - still calculating size - it might be that we're waiting for memory to be available to create the save data
					break;

				case MEM_CARD_ERROR :
//					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_ALLOCATE_MEMORY_FAILED);
//					return MEM_CARD_ERROR;
					Assertf(0, "CSavegameQueuedOperation_ManualSave::Update - CGenericGameStorage::CreateSaveDataAndCalculateSize failed");
					CPauseMenu::Close();
					m_Status = MEM_CARD_ERROR;
					break;
				}
			}
			break;
		case MANUAL_SAVE_PROGRESS_BEGIN_SAVEGAME_LIST :
			if (!CSavegameFrontEnd::BeginSaveGameList())
			{
				Assertf(0, "CSavegameQueuedOperation_ManualSave::Update - CSavegameFrontEnd::BeginSaveGameList failed");
				CPauseMenu::Close();
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				if (!CPauseMenu::GetNoValidSaveGameFiles())	//	sm_bNoValidSaveGameFiles will be true if the PS3 hard disk has been 
															//	scanned previously and there are no valid save games on it
				{
					CPauseMenu::LockMenuControl(true);
				}
				m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_CHECK_SAVEGAME_LIST;
			}
			break;
		case MANUAL_SAVE_PROGRESS_CHECK_SAVEGAME_LIST :
			switch (CSavegameFrontEnd::SaveGameMenuCheck(m_bQuitAsSoonAsNoSavegameOperationsAreRunning))
			{
			case MEM_CARD_COMPLETE :
				if (CSavegameFrontEnd::ShouldDeleteSavegame())
				{
					m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_BEGIN_DELETE;
				}
				else
				{
#if __MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE
					CPauseMenu::Close();
					m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_WAIT_UNTIL_PAUSE_MENU_IS_CLOSED;
					m_SafetyTimeOut.Reset();
#else	//	__MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE
					m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_CHECK_SAVE;
#endif	//	__MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE
				}
				break;

			case MEM_CARD_BUSY :	//	still processing, do nothing
				break;

			case MEM_CARD_ERROR :
				CPauseMenu::UnlockMenuControl();	//	or should this be CPauseMenu::BackOutOfSaveGameList()?
				CPauseMenu::Close();
				m_Status = MEM_CARD_ERROR;
				break;
			}
			break;

#if __MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE
		case MANUAL_SAVE_PROGRESS_WAIT_UNTIL_PAUSE_MENU_IS_CLOSED :
			{
				bool bMoveOnToNextStage = false;

				if (!CPauseMenu::IsActive())
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - MANUAL_SAVE_PROGRESS_WAIT_UNTIL_PAUSE_MENU_IS_CLOSED - CPauseMenu::IsActive() has returned false so move on to MANUAL_SAVE_PROGRESS_WAIT_UNTIL_SPINNER_CAN_BE_DISPLAYED. m_SafetyTimeOut=%f", m_SafetyTimeOut.GetMsTime());
					bMoveOnToNextStage = true;
				}
				else if (m_SafetyTimeOut.GetMsTime() > 3000.0f)
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - MANUAL_SAVE_PROGRESS_WAIT_UNTIL_PAUSE_MENU_IS_CLOSED - CPauseMenu::IsActive() has returned true but timing out and moving on to MANUAL_SAVE_PROGRESS_WAIT_UNTIL_SPINNER_CAN_BE_DISPLAYED anyway");
					bMoveOnToNextStage = true;
				}

				if (bMoveOnToNextStage)
				{
					m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_WAIT_UNTIL_SPINNER_CAN_BE_DISPLAYED;
					m_SafetyTimeOut.Reset();
				}
			}
			break;

		case MANUAL_SAVE_PROGRESS_WAIT_UNTIL_SPINNER_CAN_BE_DISPLAYED :
			if (camInterface::IsFadedOut())
			{
				if (CGtaOldLoadingScreen::IsUsingLoadingRenderFunction())
				{
					m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_CHECK_SAVE;
					savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - MANUAL_SAVE_PROGRESS_WAIT_UNTIL_SPINNER_CAN_BE_DISPLAYED - CGtaOldLoadingScreen::IsUsingLoadingRenderFunction() is true. m_SafetyTimeOut=%f", m_SafetyTimeOut.GetMsTime());
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - MANUAL_SAVE_PROGRESS_WAIT_UNTIL_SPINNER_CAN_BE_DISPLAYED - camInterface::IsFadedOut() but CGtaOldLoadingScreen::IsUsingLoadingRenderFunction() is false. m_SafetyTimeOut=%f", m_SafetyTimeOut.GetMsTime());
					if (m_SafetyTimeOut.GetMsTime() > 3000.0f)
					{
						savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - safety time out");
						m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_CHECK_SAVE;
					}
				}
			}
			else
			{
				m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_CHECK_SAVE;
			}
			break;
#endif	//	__MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE

		case MANUAL_SAVE_PROGRESS_CHECK_SAVE :
			
			switch (CSavegameSave::GenericSave())
			{
				case MEM_CARD_COMPLETE :
#if !__MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE
					CPauseMenu::Close();
#endif	//	!__MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE
					m_Status = MEM_CARD_COMPLETE;
					break;

				case MEM_CARD_BUSY :	 // the save is still in progress
					break;

				case MEM_CARD_ERROR :
#if !__MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE
					CPauseMenu::Close();
#endif	//	!__MANUAL_SAVE_CLOSE_PAUSE_MENU_AS_SOON_AS_POSSIBLE
					m_Status = MEM_CARD_ERROR;
					break;
			}
			break;

//	DELETING A SAVEGAME

		case MANUAL_SAVE_PROGRESS_BEGIN_DELETE :
			{
				s32 correctSlot = CSavegameFrontEnd::GetSaveGameSlotToDelete();
#if RSG_ORBIS
				if(deleteBackupSave)
				{
					//make sure we get the correct slot numbers for the main save and the backup save
					if(CSavegameFrontEnd::GetSaveGameSlotToDelete() < TOTAL_NUMBER_OF_SLOTS_FOR_SAVEGAMES)
						correctSlot = CSavegameFrontEnd::GetSaveGameSlotToDelete() + INDEX_OF_BACKUPSAVE_SLOT;
				}
#endif
				CSavegameFilenames::CreateNameOfLocalFile(m_FilenameOfFileToDelete, SAVE_GAME_MAX_FILENAME_LENGTH_OF_LOCAL_FILE, correctSlot);
			
#if RSG_ORBIS
				CSavegameList::SetSlotToUpdateOnceDeleteHasCompleted(correctSlot);
#endif	//	RSG_ORBIS

				if (CSavegameDelete::Begin(m_FilenameOfFileToDelete, false, false))	//	m_bCloudFile))
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - CSavegameDelete::Begin succeeded for %s", m_FilenameOfFileToDelete);
					m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_CHECK_DELETE;
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - CSavegameDelete::Begin failed for %s", m_FilenameOfFileToDelete);
					m_Status = MEM_CARD_ERROR;
//					return true;
				}
			}
			break;

		case MANUAL_SAVE_PROGRESS_CHECK_DELETE :
			{
				switch (CSavegameDelete::Update())
				{
				case MEM_CARD_COMPLETE :
					savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - CSavegameDelete::Update succeeded for %s", m_FilenameOfFileToDelete);
					
#if ENABLE_SINGLE_PLAYER_CLOUD_SAVES
					CLiveManager::UnregisterSinglePlayerCloudSaveFile(m_FilenameOfFileToDelete);
#endif	//	RSG_PC

#if RSG_ORBIS
					//set progress back to start of delete to delete appropriate backup save
					if(!deleteBackupSave)
					{
						deleteBackupSave = true;
						m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_BEGIN_DELETE;
					}
					else
#endif
					{
#if RSG_ORBIS
						deleteBackupSave = false;

#if USE_DOWNLOAD0_FOR_AUTOSAVE_BACKUP && GTA_REPLAY
						if (CSavegameFilenames::IsThisTheNameOfAnAutosaveBackupFile(m_FilenameOfFileToDelete))
						{	// We probably can't actually reach here since the autosave isn't displayed in the Save menu
							savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - CSavegameDelete::Update succeeded for an autosave backup in download0 so call ReplayFileManager::RefreshNonClipDirectorySizes()");
							ReplayFileManager::RefreshNonClipDirectorySizes();
						}
#endif	//	USE_DOWNLOAD0_FOR_AUTOSAVE_BACKUP && GTA_REPLAY
#endif	//	RSG_ORBIS
						m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_DISPLAY_DELETE_SUCCESS_MESSAGE;
					}

#if RSG_ORBIS
					CSavegameList::UpdateSlotDataAfterDelete();
#endif	//	RSG_ORBIS

//					m_Status = MEM_CARD_COMPLETE;
//					return true;
					break;

				case MEM_CARD_BUSY :
					break;

				case MEM_CARD_ERROR :
					savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update - CSavegameDelete::Update failed for %s", m_FilenameOfFileToDelete);
					m_Status = MEM_CARD_ERROR;
//					return true;
					break;
				}
			}
			break;

		case MANUAL_SAVE_PROGRESS_DISPLAY_DELETE_SUCCESS_MESSAGE :
			{
//				CSavingMessage::Clear();

				bool ReturnSelection = false;
				if (CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_DELETION_OF_SAVEGAME_SUCCEEDED, 0, &ReturnSelection))
				{
					m_Status = MEM_CARD_COMPLETE;
				}
			}
			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		bool bRedisplayListAfterDeletingASavegame = false;
		switch (m_ManualSaveProgress)
		{
			case MANUAL_SAVE_PROGRESS_BEGIN_DELETE :
			case MANUAL_SAVE_PROGRESS_CHECK_DELETE :
			case MANUAL_SAVE_PROGRESS_DISPLAY_DELETE_SUCCESS_MESSAGE :
				if (!m_bQuitAsSoonAsNoSavegameOperationsAreRunning)
				{
					CPauseMenu::SetSavegameListIsBeingRedrawnAfterDeletingASavegame(true);

					m_ManualSaveProgress = MANUAL_SAVE_PROGRESS_BEGIN_SAVEGAME_LIST;
					m_Status = MEM_CARD_BUSY;

					bRedisplayListAfterDeletingASavegame = true;
				}
				break;

			default :
				break;
		}

		if (!bRedisplayListAfterDeletingASavegame)
		{
			CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(SAVEGAME_SINGLE_PLAYER);
			CGenericGameStorage::FreeAllDataToBeSaved(SAVEGAME_SINGLE_PLAYER);

			//	Do this for all successful saves
			if (m_Status == MEM_CARD_COMPLETE)
			{
				CTheScripts::GetMissionReplayStats().ClearReplayStatsStructure();
				savegameDisplayf("CSavegameQueuedOperation_ManualSave::Update has cleared the replay stats structure after a successful save");
			}

			return true;
		}
	}

	return false;
}


bool CSavegameQueuedOperation_ManualSave::Shutdown()
{
//	I don't think I need to do anything here. I'll just rely on CGenericGameStorage::FinishAllUnfinishedSaveGameOperations()
	return false;
}


void CSavegameQueuedOperation_Autosave::Init()
{
	m_AutosaveProgress = AUTOSAVE_PROGRESS_CREATE_SAVE_BUFFER;
}

	//	Return true to Pop() from queue
bool CSavegameQueuedOperation_Autosave::Update()
{
	switch (m_AutosaveProgress)
	{
		case AUTOSAVE_PROGRESS_CREATE_SAVE_BUFFER :
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_AUTO

				MemoryCardError CalculateSizeStatus = CGenericGameStorage::CreateSaveDataAndCalculateSize(SAVEGAME_SINGLE_PLAYER, true);
				switch (CalculateSizeStatus)
				{
				case MEM_CARD_COMPLETE :
					Assertf(CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER) > 0, "CSavegameQueuedOperation_Autosave::Update - size of save game buffer has not been calculated");
					CSavegameInitialChecks::SetSizeOfBufferToBeSaved(CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER));
					CSavegameSave::BeginGameSave(-1, SAVEGAME_SINGLE_PLAYER);
					m_AutosaveProgress = AUTOSAVE_PROGRESS_CHECK_SAVE;
					break;

				case MEM_CARD_BUSY :
					// Don't do anything - still calculating size - it might be that we're waiting for memory to be available to create the save data
					break;

				case MEM_CARD_ERROR :
//					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_ALLOCATE_MEMORY_FAILED);
//					return MEM_CARD_ERROR;
					Assertf(0, "CSavegameQueuedOperation_Autosave::Update - CGenericGameStorage::CreateSaveDataAndCalculateSize failed");
//					CPauseMenu::Close();
					m_Status = MEM_CARD_ERROR;
					break;
				}
			}
			break;

		case AUTOSAVE_PROGRESS_CHECK_SAVE :
			switch (CSavegameSave::GenericSave())
			{
			case MEM_CARD_COMPLETE :
				m_Status = MEM_CARD_COMPLETE;
				break;

			case MEM_CARD_BUSY :	 // the save is still in progress
				break;

			case MEM_CARD_ERROR :
				m_Status = MEM_CARD_ERROR;
				break;
			}
			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(SAVEGAME_SINGLE_PLAYER);
		CGenericGameStorage::FreeAllDataToBeSaved(SAVEGAME_SINGLE_PLAYER);

		//	Do this for all successful saves
		if (m_Status == MEM_CARD_COMPLETE)
		{
#if USE_SAVE_DATA_MEMORY && !USE_DOWNLOAD0_FOR_AUTOSAVE_BACKUP
			CGenericGameStorage::RequestBackupOfAutosave();
#endif	//	USE_SAVE_DATA_MEMORY && !USE_DOWNLOAD0_FOR_AUTOSAVE_BACKUP

			CTheScripts::GetMissionReplayStats().ClearReplayStatsStructure();
			savegameDisplayf("CSavegameQueuedOperation_Autosave::Update has cleared the replay stats structure after a successful save");
		}

		return true;
	}

	return false;
}

bool CSavegameQueuedOperation_Autosave::Shutdown()
{
//	I don't think I need to do anything here. I'll just rely on CGenericGameStorage::FinishAllUnfinishedSaveGameOperations()
	return false;
}


#if GTA_REPLAY

#if USE_SAVE_SYSTEM
void CSavegameQueuedOperation_ReplayLoad::Init()
{
	m_ManualLoadProgress = REPLAY_LOAD_PROGRESS_BEGIN_LOAD;
}

bool CSavegameQueuedOperation_ReplayLoad::Update()
{
	switch (m_ManualLoadProgress)
	{
	case REPLAY_LOAD_PROGRESS_BEGIN_LOAD :

		CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_LD_RPL

		if (MEM_CARD_ERROR == CSavegameList::BeginGameLoad(INDEX_OF_REPLAYSAVE_SLOT))
		{
			//	should I call CPauseMenu::Close(); here?

			CGame::SetStateToIdle();

			camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading
			CGame::StartNewGame(CGameLogic::GetCurrentLevelIndex());

			m_Status = MEM_CARD_ERROR;
			return true;
		}

		camInterface::FadeOut(0);  // fade out the screen
		CGame::LoadSaveGame();

		m_ManualLoadProgress = REPLAY_LOAD_PROGRESS_CHECK_LOAD;
		break;

	case REPLAY_LOAD_PROGRESS_CHECK_LOAD :
		{
			switch (CSavegameLoad::GenericLoad())
			{
			case MEM_CARD_COMPLETE:
				{
					camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading

					CGame::HandleLoadedSaveGame();
					m_Status = MEM_CARD_COMPLETE;
					return true;
				}
//				break;
			case MEM_CARD_BUSY: // the load is still in progress
				break;
			case MEM_CARD_ERROR:
				{
					// allow the player to choose a different slot
					//	Try the following rather than calling BeginSaveGameList() here
					//m_ManualLoadProgress = MANUAL_LOAD_PROGRESS_BEGIN_SAVEGAME_LIST;

					CGame::SetStateToIdle();

					camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading
					CGame::StartNewGame(CGameLogic::GetCurrentLevelIndex());

					m_Status = MEM_CARD_ERROR;
					return true;
				}
//				break;
			}
		}
		break;
	}

	return false;
}



void CSavegameQueuedOperation_ReplaySave::Init()
{
	gnetAssertf( !NetworkInterface::IsGameInProgress(), "PLEASE YOU CAN NOT MAKE A SINGLE PLAYER SAVE WHILE IN MULTIPLAYER - THIS WILL BREAK THE SINGLE PLAYER SAVE" );
	m_AutosaveProgress = REPLAY_SAVE_PROGRESS_CREATE_SAVE_BUFFER;
}

//	Return true to Pop() from queue
bool CSavegameQueuedOperation_ReplaySave::Update()
{
	switch (m_AutosaveProgress)
	{
	case REPLAY_SAVE_PROGRESS_CREATE_SAVE_BUFFER :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_SV_RPL

			MemoryCardError CalculateSizeStatus = CGenericGameStorage::CreateSaveDataAndCalculateSize(SAVEGAME_SINGLE_PLAYER, false);
			switch (CalculateSizeStatus)
			{
			case MEM_CARD_COMPLETE :
				Assertf(CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER) > 0, "CSavegameQueuedOperation_ReplaySave::Update - size of save game buffer has not been calculated");
				CSavegameInitialChecks::SetSizeOfBufferToBeSaved(CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER));
				CSavegameSave::BeginGameSave(INDEX_OF_REPLAYSAVE_SLOT, SAVEGAME_SINGLE_PLAYER);
				m_AutosaveProgress = REPLAY_SAVE_PROGRESS_CHECK_SAVE;
				break;

			case MEM_CARD_BUSY :
				// Don't do anything - still calculating size - it might be that we're waiting for memory to be available to create the save data
				break;

			case MEM_CARD_ERROR :
				//					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_ALLOCATE_MEMORY_FAILED);
				//					return MEM_CARD_ERROR;
				Assertf(0, "CSavegameQueuedOperation_ReplaySave::Update - CGenericGameStorage::CreateSaveDataAndCalculateSize failed");
				//					CPauseMenu::Close();
				m_Status = MEM_CARD_ERROR;
				break;
			}
		}
		break;

	case REPLAY_SAVE_PROGRESS_CHECK_SAVE :
		switch (CSavegameSave::GenericSave())
		{
		case MEM_CARD_COMPLETE :
			m_Status = MEM_CARD_COMPLETE;
			break;

		case MEM_CARD_BUSY :	 // the save is still in progress
			break;

		case MEM_CARD_ERROR :
			m_Status = MEM_CARD_ERROR;
			break;
		}
		break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(SAVEGAME_SINGLE_PLAYER);
		CGenericGameStorage::FreeAllDataToBeSaved(SAVEGAME_SINGLE_PLAYER);
		return true;
	}

	return false;
}
#endif	//	USE_SAVE_SYSTEM

// TransferReplayFile ************************************************************************************************

#if RSG_ORBIS

void CSavegameQueuedOperation_TransferReplayFile::Init(const char* fileName, void* pSrc, u32 bufferSize, bool UNUSED_PARAM(saveIcon), bool overwrite)
{
	safecpy(m_FileName, fileName, REPLAYPATHLENGTH);

	m_localIndex = CSavegameUsers::GetUser();
	
	//ensure any mounts display name uses the 
	//.clip suffix
	atString displayName(fileName);
	displayName.Replace(".jpg", ".clip");
	safecpy(m_DisplayName, displayName.c_str(), REPLAYPATHLENGTH);

	m_Buffer = pSrc;
	m_BufferSize = bufferSize;

	m_OverWrite = overwrite;

	m_Progress = REPLAY_OP_PROGRESS_BEGIN_TRANSFER;
}

bool CSavegameQueuedOperation_TransferReplayFile::Update()
{
	switch(m_Progress)
	{	
	case REPLAY_OP_PROGRESS_BEGIN_TRANSFER:
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_PROF_SV	//	Not sure if this will ever be displayed

			if (!SAVEGAME.BeginSave(m_localIndex, CGenericGameStorage::GetContentType(), m_DisplayName, m_FileName, (void*)m_Buffer, m_BufferSize, m_OverWrite) )	//	bool overwrite)
			{
				Warningf("ReplayClip::StartWrite - BeginSave failed\n");
				SAVEGAME.EndSave(m_localIndex);
				SAVEGAME.SetStateToIdle(m_localIndex);
				m_Status = MEM_CARD_ERROR;
				return true;
			}

			m_Progress = REPLAY_OP_PROGRESS_CHECK_TRANSFER;
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_TRANSFER:
		{
			bool bOutIsValid;
			bool bFileExists;

			if (SAVEGAME.CheckSave(m_localIndex, bOutIsValid, bFileExists))
			{
				SAVEGAME.EndSave(m_localIndex);
				
				if (SAVEGAME.GetState(m_localIndex) == fiSaveGameState::HAD_ERROR || !bOutIsValid)
				{
					SAVEGAME.SetStateToIdle(CSavegameUsers::GetUser());

					m_Status = MEM_CARD_ERROR;
					return true;
				}
				
				m_Status = MEM_CARD_COMPLETE;
				return true;
			}
			break;
		}
	}

	return false;
}

#endif // RSG_ORBIS

// End of TransferReplayFile ****************************************************************************************

// EnumerateReplayFile *********************************************************************************************

void CSavegameQueuedOperation_EnumerateReplayFiles::Init(eReplayEnumerationTypes enumType, FileDataStorage* dataStorage, const char* filter)
{
	m_Enumtype = enumType;
	safecpy(m_Filter, filter, REPLAYPATHLENGTH);
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_ENUMERATE;
	m_FileList = dataStorage;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_EnumerateReplayFiles::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_ENUMERATE:
		{
#if RSG_ORBIS
			// Worth running this before we enumerate files
			// to make sure this local user Id is still the same for the PSN user
			if(ReplayFileManager::UpdateUserIDDirectoriesOnChange())
#endif
			{
				if ( !ReplayFileManager::EnumerateFiles(m_Enumtype, *m_FileList, m_Filter) )
				{
					savegameDisplayf("CSavegameQueuedOperation_EnumerateReplayFiles::Update - BEGIN_ENUMERATE failed - FileOp is already running ...keep trying until it is free");
				}
				else
				{
					m_Progress = REPLAY_OP_PROGRESS_CHECK_ENUMERATE;
				}
			}
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_ENUMERATE:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					savegameDisplayf("CSavegameQueuedOperation_EnumerateReplayFiles::Update - CHECK_ENUMERATE succeeded");
					m_Status = MEM_CARD_COMPLETE;
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_EnumerateReplayFiles::Update - CHECK_ENUMERATE failed");
					m_Status = MEM_CARD_ERROR;
				}
			}
			break;
		}
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		if (m_Status == MEM_CARD_COMPLETE)
		{
			savegameDisplayf("CSavegameQueuedOperation_EnumerateReplayFiles::Update - succeeded");
		}
		else
		{
			savegameDisplayf("CSavegameQueuedOperation_EnumerateReplayFiles::Update - failed");
		}
		return true;
	}

	return false;
}

// End of EnumerateReplayFiles ****************************************************************************************

// ReplayUpdateFavourites *********************************************************************************************

void CSavegameQueuedOperation_ReplayUpdateFavourites::Init()
{
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_UPDATE_FAVOURITES;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_ReplayUpdateFavourites::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_UPDATE_FAVOURITES:
		{
			if ( !ReplayFileManager::UpdateFavourites() )
			{
				savegameDisplayf("CSavegameQueuedOperation_ReplayUpdateFavourites::Update - REPLAY_OP_PROGRESS_BEGIN_UPDATE_FAVOURITES failed");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				m_Progress = REPLAY_OP_PROGRESS_CHECK_UPDATE_FAVOURITES;
			}
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_UPDATE_FAVOURITES:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					savegameDisplayf("CSavegameQueuedOperation_ReplayUpdateFavourites::Update - REPLAY_OP_PROGRESS_CHECK_UPDATE_FAVOURITES succeeded");
					m_Status = MEM_CARD_COMPLETE;
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_ReplayUpdateFavourites::Update - REPLAY_OP_PROGRESS_CHECK_UPDATE_FAVOURITES failed");
					m_Status = MEM_CARD_ERROR;
				}

				return true;
			}
			break;
		}
	}

	return false;
}

// End of ReplayUpdateFavourites **************************************************************************************

// ReplayMultiDelete *********************************************************************************************

void CSavegameQueuedOperation_ReplayMultiDelete::Init(const char* filter)
{
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_REPLAY_MULTI_DELETE;
	safecpy(m_Filter, filter, REPLAYPATHLENGTH);
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_ReplayMultiDelete::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_REPLAY_MULTI_DELETE:
		{
			if ( !ReplayFileManager::ProcessMultiDelete(m_Filter) )
			{
				savegameDisplayf("CSavegameQueuedOperation_ReplayMultiDelete::Update - REPLAY_OP_PROGRESS_BEGIN_REPLAY_MULTI_DELETE failed");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				m_Progress = REPLAY_OP_PROGRESS_CHECK_REPLAY_MULTI_DELETE;
			}
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_REPLAY_MULTI_DELETE:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					savegameDisplayf("CSavegameQueuedOperation_ReplayMultiDelete::Update - REPLAY_OP_PROGRESS_CHECK_REPLAY_MULTI_DELETE succeeded");
					m_Status = MEM_CARD_COMPLETE;
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_ReplayMultiDelete::Update - REPLAY_OP_PROGRESS_CHECK_REPLAY_MULTI_DELETE failed");
					m_Status = MEM_CARD_ERROR;
				}

				return true;
			}
			break;
		}
	}

	return false;
}

// End of ReplayMultiDelete **************************************************************************************


// DeleteReplayClip *********************************************************************************************

void CSavegameQueuedOperation_DeleteReplayClips::Init(const char* filePath)
{
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_DELETE_CLIP;

	safecpy(m_Path, filePath, REPLAYPATHLENGTH);
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_DeleteReplayClips::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_DELETE_CLIP:
		{
			if( !ReplayFileManager::DeleteFile(m_Path) )
			{
				savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - BEGIN_DELETE_CLIP failed");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				m_Progress = REPLAY_OP_PROGRESS_CHECK_DELETE_CLIP;
			}
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_DELETE_CLIP:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - CHECK_DELETE_CLIP succeeded");
					
					//continue to the next file
					m_Progress = REPLAY_OP_PROGRESS_BEGIN_DELETE_JPG;
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - CHECK_DELETE_CLIP failed");
					m_Status = MEM_CARD_ERROR;
				}
			}
			break;
		}
	case REPLAY_OP_PROGRESS_BEGIN_DELETE_JPG:
		{
			atString path(m_Path);
			path.Replace(".clip", ".jpg");

			if( !ReplayFileManager::DeleteFile(path.c_str()) )
			{
				savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - BEGIN_DELETE_JPG failed");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				m_Progress = REPLAY_OP_PROGRESS_CHECK_DELETE_JPG;
			}
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_DELETE_JPG:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - CHECK_DELETE_JPG succeeded");
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - CHECK_DELETE_JPG failed");
				}

#if RSG_PC
				// try to delete any logfile
				m_Progress = REPLAY_OP_PROGRESS_BEGIN_DELETE_LOGFILE;
#else

#if DO_REPLAY_OUTPUT_XML
				//continue to the next file
				m_Progress = REPLAY_OP_PROGRESS_BEGIN_DELETE_XML;
#else
				m_Status = MEM_CARD_COMPLETE;
#endif

#endif	//RSG_PC
				
			}
			break;
		}

	case REPLAY_OP_PROGRESS_BEGIN_DELETE_LOGFILE:
		{
			atString path(m_Path);
			path.Replace(".clip", ".txt");

			if( !ReplayFileManager::DeleteFile(path.c_str()) )
			{

#if DO_REPLAY_OUTPUT_XML
				//continue to the next file
				m_Progress = REPLAY_OP_PROGRESS_BEGIN_DELETE_XML;
#else
				m_Status = MEM_CARD_ERROR;
#endif
			}
			else
			{
				m_Progress = REPLAY_OP_PROGRESS_CHECK_DELETE_LOGFILE;
			}
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_DELETE_LOGFILE:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - CHECK_DELETE_LOGFILE succeeded");
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - CHECK_DELETE_LOGFILE failed");
				}

#if DO_REPLAY_OUTPUT_XML
				//continue to the next file
				m_Progress = REPLAY_OP_PROGRESS_BEGIN_DELETE_XML;
#else
				m_Status = MEM_CARD_COMPLETE;
#endif

			}
			break;
		}


#if DO_REPLAY_OUTPUT_XML
	case REPLAY_OP_PROGRESS_BEGIN_DELETE_XML:
		{
			atString path(m_Path);
			path.Replace(".clip", ".xml");

			if( !ReplayFileManager::DeleteFile(path.c_str()) )
			{
				savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - BEGIN_DELETE_XML failed");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				m_Progress = REPLAY_OP_PROGRESS_CHECK_DELETE_XML;
			}
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_DELETE_XML:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - CHECK_DELETE_XML succeeded");
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - CHECK_DELETE_XML failed- in ReplayDebug on PC, this XML file  may have not existed");
				}

				// always return a success, as debug XML file doesn't always exist
				m_Status = MEM_CARD_COMPLETE;
			}
			break;
		}
#endif
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		// if any of the main stages fails, it quits out with MEM_CARD_ERROR ...which brings up the prompt saying it didn't work
		if (m_Status == MEM_CARD_COMPLETE)
		{
			savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update - success - MEM_CARD_COMPLETE");
		}
		else
		{
			savegameDisplayf("CSavegameQueuedOperation_DeleteReplayClips::Update -  fail - MEM_CARD_ERROR");
		}
		return true;
	}

	return false;
}

// End of DeleteReplayClip **************************************************************************************

// DeleteReplayFile *********************************************************************************************

void CSavegameQueuedOperation_DeleteReplayFile::Init(const char* filePath)
{
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_DELETE_FILE;
	safecpy(m_Path, filePath, REPLAYPATHLENGTH);
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_DeleteReplayFile::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_DELETE_FILE:
		{
			if( !ReplayFileManager::DeleteFile(m_Path) )
			{
				m_Status = MEM_CARD_ERROR;
				return true;
			}

			m_Progress = REPLAY_OP_PROGRESS_CHECK_DELETE_FILE;
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_DELETE_FILE:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayFile::Update - succeeded");
					m_Status = MEM_CARD_COMPLETE;
				}
				else
				{
					savegameDisplayf("CSavegameQueuedOperation_DeleteReplayFile::Update - failed");
					m_Status = MEM_CARD_ERROR;
				}
				return true;
			}
			break;
		}
	}

	return false;
}

// End of DeleteReplayFile ************************************************************************************

// LoadReplayClip *********************************************************************************************

void CSavegameQueuedOperation_LoadReplayClip::Init(const char* filePath, CBufferInfo& bufferInfo, tLoadStartFunc loadStartFunc)
{
	safecpy(m_Path, filePath, REPLAYPATHLENGTH);
	m_BufferInfo = &bufferInfo;
	m_LoadStartFunc = loadStartFunc;
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_LOAD;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_LoadReplayClip::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_LOAD:
		{
			if( !ReplayFileManager::StartLoad(m_Path, m_BufferInfo, m_LoadStartFunc) )
			{
				m_Status = MEM_CARD_ERROR;
				return true;
			}

			m_Progress = REPLAY_OP_PROGRESS_CHECK_LOAD;
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_LOAD:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				m_Status = MEM_CARD_ERROR;

				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					m_Status = MEM_CARD_COMPLETE;
				}

				return true;
			}
		}
	}

	return false;
}

// End of LoadReplayClip ************************************************************************************

// LoadMontage *********************************************************************************************

void CSavegameQueuedOperation_LoadMontage::Init(const char* filePath, CMontage* montage)
{
	safecpy(m_Path, filePath, REPLAYPATHLENGTH);
	m_Montage = montage;
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_LOAD;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_LoadMontage::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_LOAD:
		{
			if( !ReplayFileManager::LoadMontage(m_Path, m_Montage) )
			{
				m_Status = MEM_CARD_ERROR;
				return true;
			}

			m_Progress = REPLAY_OP_PROGRESS_CHECK_LOAD;
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_LOAD:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				m_Status = MEM_CARD_ERROR;

				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					m_Status = MEM_CARD_COMPLETE;
				}

				return true;
			}
		}
	}

	return false;
}

// End of LoadMontage ************************************************************************************

// SaveMontage *********************************************************************************************

void CSavegameQueuedOperation_SaveMontage::Init(const char* filePath, CMontage* montage)
{
	safecpy(m_Path, filePath, REPLAYPATHLENGTH);
	m_Montage = montage;
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_SAVE;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_SaveMontage::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_SAVE:
		{
			if( !ReplayFileManager::SaveMontage(m_Path, m_Montage) )
			{
				m_Status = MEM_CARD_ERROR;
				return true;
			}

			m_Progress = REPLAY_OP_PROGRESS_CHECK_SAVE;
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_SAVE:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				m_Status = MEM_CARD_ERROR;

				if( ReplayFileManager::GetLastErrorCode() == REPLAY_ERROR_SUCCESS )
				{
					m_Status = MEM_CARD_COMPLETE;
				}

				return true;
			}
		}
	}

	return false;
}

// End of LoadMontage ************************************************************************************

// LoadReplayHeader *****************************************************************************************

void CSavegameQueuedOperation_LoadReplayHeader::Init(const char* filepath)
{
	// REPLAY_CLIPS_PATH change
	char path[REPLAYPATHLENGTH];
	ReplayFileManager::getClipDirectory(path);
	formatf(m_Path, REPLAYPATHLENGTH, "%s%s", path, filepath);
	
	m_Progress = REPLAY_OP_PROGRESS_BEGIN_LOAD;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_LoadReplayHeader::Update()
{
	switch(m_Progress)
	{
	case REPLAY_OP_PROGRESS_BEGIN_LOAD:
		{
			if( !ReplayFileManager::StartLoadReplayHeader(m_Path) )
			{
				m_Status = MEM_CARD_ERROR;
				return true;
			}

			m_Progress = REPLAY_OP_PROGRESS_CHECK_LOAD;
			break;
		}
	case REPLAY_OP_PROGRESS_CHECK_LOAD:
		{
			if( !ReplayFileManager::IsPerformingFileOp() )
			{
				m_Header = ReplayFileManager::GetHeader(m_Path);

				m_Status = MEM_CARD_ERROR;

				if( m_Header != NULL )
				{
					m_Status = MEM_CARD_COMPLETE;
				}

				return true;
			}
			break;
		}
	}

	return false;
}

// End of LoadReplayHeader ***************************************************************************************

#endif // GTA_REPLAY

// MissionRepeatLoad *********************************************************************************************

void CSavegameQueuedOperation_MissionRepeatLoad::Init()
{
	m_MissionRepeatLoadProgress = MISSION_REPEAT_LOAD_PROGRESS_PRE_LOAD;
}

//	Return true to Pop() from queue
bool CSavegameQueuedOperation_MissionRepeatLoad::Update()
{
	switch (m_MissionRepeatLoadProgress)
	{
		case MISSION_REPEAT_LOAD_PROGRESS_PRE_LOAD :

#if GTA_REPLAY
			if(CReplayMgr::IsSaving())
			{
				return false;
			}
#endif // GTA_REPLAY

			m_MissionRepeatLoadProgress = MISSION_REPEAT_LOAD_PROGRESS_BEGIN_LOAD;
			break;
		case MISSION_REPEAT_LOAD_PROGRESS_BEGIN_LOAD :
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_LD_RPT

			if (MEM_CARD_ERROR == CSavegameList::BeginGameLoad(INDEX_OF_MISSION_REPEAT_SAVE_SLOT))
			{
				CTheScripts::GetMissionReplayStats().ClearReplayStatsStructure();	//	It doesn't make sense to apply any improved stats for the replayed mission if we've been forced to start a new session

				CGame::SetStateToIdle();

				camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading
				CGame::StartNewGame(CGameLogic::GetCurrentLevelIndex());

				m_Status = MEM_CARD_ERROR;
				return true;
			}

			camInterface::FadeOut(0);  // fade out the screen
			CGame::LoadSaveGame();

			m_MissionRepeatLoadProgress = MISSION_REPEAT_LOAD_PROGRESS_CHECK_LOAD;
			break;

		case MISSION_REPEAT_LOAD_PROGRESS_CHECK_LOAD :
			{
				switch (CSavegameLoad::GenericLoad())
				{
				case MEM_CARD_COMPLETE:
					{
						camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading

						CGame::HandleLoadedSaveGame();
						m_Status = MEM_CARD_COMPLETE;
						return true;
					}
//					break;
				case MEM_CARD_BUSY: // the load is still in progress
					break;
				case MEM_CARD_ERROR:
					{
						CTheScripts::GetMissionReplayStats().ClearReplayStatsStructure();	//	It doesn't make sense to apply any improved stats for the replayed mission if we've been forced to start a new session

						CGame::SetStateToIdle();

						camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading
						CGame::StartNewGame(CGameLogic::GetCurrentLevelIndex());

						m_Status = MEM_CARD_ERROR;
						return true;
					}
//					break;
				}
			}
			break;
	}

	return false;
}


// MissionRepeatSave *********************************************************************************************

void CSavegameQueuedOperation_MissionRepeatSave::Init(bool bBenchmarkTest)
{
	m_MissionRepeatSaveProgress = MISSION_REPEAT_SAVE_PROGRESS_DISPLAY_WARNING_SCREEN;
	m_bBenchmarkTest = bBenchmarkTest;
}

//	Return true to Pop() from queue
bool CSavegameQueuedOperation_MissionRepeatSave::Update()
{
	switch (m_MissionRepeatSaveProgress)
	{
		case MISSION_REPEAT_SAVE_PROGRESS_DISPLAY_WARNING_SCREEN :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_SV_RPT

			//	Only display this warning if the player is signed in and has chosen a device?
			//	That would avoid multiple warning screens

			bool bReturnSelection = false;

			SaveGameDialogCode messageToDisplay = SAVE_GAME_DIALOG_MISSION_REPEAT_MAKES_A_SAVE;
			if (m_bBenchmarkTest)
			{
				messageToDisplay = SAVE_GAME_DIALOG_PC_BENCHMARK_TEST_MAKES_A_SAVE;
			}
			if (CSavegameDialogScreens::HandleSaveGameDialogBox(messageToDisplay, 0, &bReturnSelection))
			{
				if (bReturnSelection)
				{
					m_MissionRepeatSaveProgress = MISSION_REPEAT_SAVE_PROGRESS_CREATE_SAVE_BUFFER;
				}
				else
				{
					m_Status = MEM_CARD_ERROR;
				}
			}
		}
		break;

		case MISSION_REPEAT_SAVE_PROGRESS_CREATE_SAVE_BUFFER :
		{
			MemoryCardError CalculateSizeStatus = CGenericGameStorage::CreateSaveDataAndCalculateSize(SAVEGAME_SINGLE_PLAYER, false);
			switch (CalculateSizeStatus)
			{
			case MEM_CARD_COMPLETE :
				Assertf(CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER) > 0, "CSavegameQueuedOperation_MissionRepeatSave::Update - size of save game buffer has not been calculated");
				CSavegameInitialChecks::SetSizeOfBufferToBeSaved(CGenericGameStorage::GetBufferSize(SAVEGAME_SINGLE_PLAYER));
				CSavegameSave::BeginGameSave(INDEX_OF_MISSION_REPEAT_SAVE_SLOT, SAVEGAME_SINGLE_PLAYER);
				m_MissionRepeatSaveProgress = MISSION_REPEAT_SAVE_PROGRESS_CHECK_SAVE;
				break;

			case MEM_CARD_BUSY :
				// Don't do anything - still calculating size - it might be that we're waiting for memory to be available to create the save data
				break;

			case MEM_CARD_ERROR :
				//					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_ALLOCATE_MEMORY_FAILED);
				//					return MEM_CARD_ERROR;
				Assertf(0, "CSavegameQueuedOperation_MissionRepeatSave::Update - CGenericGameStorage::CreateSaveDataAndCalculateSize failed");
				//					CPauseMenu::Close();
				m_Status = MEM_CARD_ERROR;
				break;
			}
		}
		break;

		case MISSION_REPEAT_SAVE_PROGRESS_CHECK_SAVE :
			switch (CSavegameSave::GenericSave())
			{
			case MEM_CARD_COMPLETE :
				m_Status = MEM_CARD_COMPLETE;
				break;

			case MEM_CARD_BUSY :	 // the save is still in progress
				break;

			case MEM_CARD_ERROR :
				m_Status = MEM_CARD_ERROR;
				break;
			}
			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(SAVEGAME_SINGLE_PLAYER);
		CGenericGameStorage::FreeAllDataToBeSaved(SAVEGAME_SINGLE_PLAYER);
		return true;
	}

	return false;
}


// CheckFileExists *********************************************************************************************

void CSavegameQueuedOperation_CheckFileExists::Init(s32 SlotIndex)
{
	if (savegameVerifyf( (SlotIndex >= 0) && (SlotIndex < MAX_NUM_EXPECTED_SAVE_FILES), 
		"CSavegameQueuedOperation_CheckFileExists::Init - Slot Index %d is out of the range 0 to %d", 
		SlotIndex, MAX_NUM_EXPECTED_SAVE_FILES))
	{
		m_SlotIndex = SlotIndex;
		m_bFileExists = false;
		m_bFileIsDamaged = false;
		m_CheckFileExistsProgress = CHECK_FILE_EXISTS_PROGRESS_BEGIN;
	}
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_CheckFileExists::Update()
{
	switch (m_CheckFileExistsProgress)
	{
		case CHECK_FILE_EXISTS_PROGRESS_BEGIN :
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_EXISTS	//	Graeme - I don't think this is actually used just now. Nothing calls CGenericGameStorage::QueueCheckFileExists()

			switch (CSavegameCheckFileExists::BeginCheckFileExists(m_SlotIndex))
			{
				case MEM_CARD_COMPLETE :
					m_CheckFileExistsProgress = CHECK_FILE_EXISTS_PROGRESS_CHECK;
					break;
				case MEM_CARD_BUSY :
					savegameAssertf(0, "CSavegameQueuedOperation_CheckFileExists::Update - didn't expect CSavegameCheckFileExists::BeginCheckFileExists() to ever return MEM_CARD_BUSY");
					m_Status = MEM_CARD_ERROR;
					break;
				case MEM_CARD_ERROR :
					savegameAssertf(0, "CSavegameQueuedOperation_CheckFileExists::Update - CSavegameCheckFileExists::BeginCheckFileExists() returned MEM_CARD_ERROR");
					m_Status = MEM_CARD_ERROR;
					break;
			}
			break;
		case CHECK_FILE_EXISTS_PROGRESS_CHECK :
			switch (CSavegameCheckFileExists::CheckFileExists())
			{
			case MEM_CARD_COMPLETE :
				CSavegameCheckFileExists::GetFileStatus(m_bFileExists, m_bFileIsDamaged);
				savegameDebugf1("CSavegameQueuedOperation_CheckFileExists::Update - completed for slot %d. Time = %d. Slot %s. Slot is %sdamaged\n", m_SlotIndex, sysTimer::GetSystemMsTime(), m_bFileExists?"exists":"doesn't exist", m_bFileIsDamaged?"":"not ");
				m_Status = MEM_CARD_COMPLETE;
				break;

			case MEM_CARD_BUSY :    // the load is still in progress
				break;

			case MEM_CARD_ERROR :
				m_bFileExists = false;
				m_bFileIsDamaged = false;
				savegameDebugf1("CSavegameQueuedOperation_CheckFileExists::Update - failed for slot %d. Time = %d. Slot %s. Slot is %sdamaged\n", m_SlotIndex, sysTimer::GetSystemMsTime(), m_bFileExists?"exists":"doesn't exist", m_bFileIsDamaged?"":"not ");
				m_Status = MEM_CARD_ERROR;
				break;
			}
			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		return true;
	}

	return false;
}

// End of CheckFileExists *********************************************************************************************


// CreateSortedListOfSavegames *********************************************************************************************

void CSavegameQueuedOperation_CreateSortedListOfSavegames::Init(bool bDisplayWarningScreens)
{
	m_bDisplayWarningScreens = bDisplayWarningScreens;
	m_CreateSortedListOfSavegamesProgress = CREATE_SORTED_LIST_OF_SAVEGAMES_BEGIN;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_CreateSortedListOfSavegames::Update()
{
	switch (m_CreateSortedListOfSavegamesProgress)
	{
		case CREATE_SORTED_LIST_OF_SAVEGAMES_BEGIN :
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");

			CGenericGameStorage::SetSaveOperation(OPERATION_ENUMERATING_SAVEGAMES);
			CSavegameInitialChecks::BeginInitialChecks(false);

			m_CreateSortedListOfSavegamesProgress = CREATE_SORTED_LIST_OF_SAVEGAMES_CHECK;
			break;

		case CREATE_SORTED_LIST_OF_SAVEGAMES_CHECK :
			{
				MemoryCardError EnumerationState = CSavegameInitialChecks::InitialChecks();
				if (EnumerationState == MEM_CARD_ERROR)
				{
					if (SAVE_GAME_DIALOG_PLAYER_HAS_SIGNED_OUT == CSavegameDialogScreens::GetMostRecentErrorCode())
					{
						photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfSavegames::Update - player has signed out");
						m_Status = MEM_CARD_ERROR;
					}
					else
					{
						photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfSavegames::Update - InitialChecks() returned an error");
						m_CreateSortedListOfSavegamesProgress = CREATE_SORTED_LIST_OF_SAVEGAMES_HANDLE_ERRORS;
					}
				}
				else if (EnumerationState == MEM_CARD_COMPLETE)
				{
					photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfSavegames::Update - InitialChecks() succeeded");

					m_Status = MEM_CARD_COMPLETE;
				}
			}
			break;

		case CREATE_SORTED_LIST_OF_SAVEGAMES_HANDLE_ERRORS :
			if (!m_bDisplayWarningScreens || CSavegameDialogScreens::HandleSaveGameErrorCode())
			{
				CSavegameDialogScreens::ClearSaveGameError();
				m_Status = MEM_CARD_ERROR;
			}
			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		EndCreatedSortedList();

		return true;
	}

	return false;
}

void CSavegameQueuedOperation_CreateSortedListOfSavegames::EndCreatedSortedList()
{
	photoAssertf(CGenericGameStorage::GetSaveOperation() == OPERATION_ENUMERATING_SAVEGAMES, "CSavegameQueuedOperation_CreateSortedListOfSavegames::EndCreatedSortedList - SaveOperation should be OPERATION_ENUMERATING_SAVEGAMES");
	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
}


// End of CreateSortedListOfSavegames *********************************************************************************************

#if __LOAD_LOCAL_PHOTOS

void CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Init(bool bDisplayWarningScreens)
{
	m_bDisplayWarningScreens = bDisplayWarningScreens;

	m_bCloudEnumerationHasBeenStarted = false;
	m_bLocalEnumerationHasBeenStarted = false;

	m_bHadCloudError = false;
	m_bHadLocalError = false;

	m_CreateSortedListOfLocalPhotosProgress = CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_BEGIN_CLOUD_ENUMERATION;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update()
{
	switch (m_CreateSortedListOfLocalPhotosProgress)
	{
	case CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_BEGIN_CLOUD_ENUMERATION :

		CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");

		m_CreateSortedListOfLocalPhotosProgress = CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_BEGIN_LOCAL_ENUMERATION;

		m_bCloudEnumerationHasBeenStarted = false;

		if (CPhotoManager::IsListOfPhotosUpToDate(false))
		{
		}
		else
		{
			if (NetworkInterface::IsCloudAvailable())
			{	//	I need to check IsCloudAvailable() here to prevent a "Cloud not available" Verifyf inside CListOfUGCPhotosOnCloud::RequestListOfDirectoryContents()
				if (CPhotoManager::RequestListOfCloudPhotos())
				{
					m_bCloudEnumerationHasBeenStarted = true;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - RequestListOfCloudPhotos() failed");
					
	//	The player should still be allowed to view their local photos even if the cloud photos can't be enumerated here
	//				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_CLOUD_LOAD_PHOTO_LIST_FAILED);
	//				m_CreateSortedListOfLocalPhotosProgress = CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_HANDLE_ERRORS;
				}
			}
			else
			{
				photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - NetworkInterface::IsCloudAvailable() returned false");
			}
		}
		break;
	case CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_BEGIN_LOCAL_ENUMERATION :

		if (CPhotoManager::IsListOfPhotosUpToDate(true))
		{
			m_bLocalEnumerationHasBeenStarted = false;

			if (m_bCloudEnumerationHasBeenStarted)
			{
				m_CreateSortedListOfLocalPhotosProgress = CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_CHECK_CLOUD_ENUMERATION;
			}
			else
			{
				m_Status = MEM_CARD_COMPLETE;
			}
		}
		else
		{
			CGenericGameStorage::SetSaveOperation(OPERATION_ENUMERATING_PHOTOS);
			CSavegameInitialChecks::BeginInitialChecks(false);

			m_bLocalEnumerationHasBeenStarted = true;
			m_CreateSortedListOfLocalPhotosProgress = CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_CHECK_LOCAL_ENUMERATION;
		}
		break;

	case CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_CHECK_LOCAL_ENUMERATION :
		{
			MemoryCardError EnumerationState = CSavegameInitialChecks::InitialChecks();
			if (EnumerationState == MEM_CARD_ERROR)
			{	//	What should I do about the cloud enumeration if the local enumeration fails?
				m_bHadLocalError = true;

				if (SAVE_GAME_DIALOG_PLAYER_HAS_SIGNED_OUT == CSavegameDialogScreens::GetMostRecentErrorCode())
				{
					photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - player has signed out");
					m_Status = MEM_CARD_ERROR;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - InitialChecks() returned an error");
					m_CreateSortedListOfLocalPhotosProgress = CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_HANDLE_ERRORS;
				}
			}
			else if (EnumerationState == MEM_CARD_COMPLETE)
			{
				photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - InitialChecks() succeeded");

#if !__NO_OUTPUT
				CSavegamePhotoLocalList::DisplayContentsOfList();
#endif	//	!__NO_OUTPUT

				if (m_bCloudEnumerationHasBeenStarted)
				{
					m_CreateSortedListOfLocalPhotosProgress = CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_CHECK_CLOUD_ENUMERATION;
				}
				else
				{
					m_Status = MEM_CARD_COMPLETE;
				}
			}
		}
		break;

	case CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_CHECK_CLOUD_ENUMERATION :
		photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - CHECK_CLOUD_ENUMERATION");
		if (CPhotoManager::GetIsCloudPhotoRequestPending() == false)
		{
			if (CPhotoManager::GetHasCloudPhotoRequestSucceeded())
			{
				photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - cloud request has completed");
				CPhotoManager::FillMergedListOfPhotos();
				m_Status = MEM_CARD_COMPLETE;
			}
			else
			{
				if (CPhotoManager::ShouldDisplayCloudPhotoEnumerationError())
				{
					CPhotoManager::SetDisplayCloudPhotoEnumerationError(false);

					photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - cloud request has failed");
//					m_Status = MEM_CARD_ERROR;
					m_bHadCloudError = true;
					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_CLOUD_LOAD_PHOTO_LIST_FAILED);
					m_CreateSortedListOfLocalPhotosProgress = CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_HANDLE_ERRORS;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::Update - cloud request has failed but ShouldDisplayCloudPhotoEnumerationError() returned FALSE so set m_Status to MEM_CARD_COMPLETE");
					m_Status = MEM_CARD_COMPLETE;
				}
			}
		}
		break;

	case CREATE_SORTED_LIST_OF_LOCAL_PHOTOS_HANDLE_ERRORS :
		if (!m_bDisplayWarningScreens || CSavegameDialogScreens::HandleSaveGameErrorCode())
		{
			CSavegameDialogScreens::ClearSaveGameError();
			m_Status = MEM_CARD_ERROR;
		}
		break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		EndCreatedSortedList();

		if (m_Status == MEM_CARD_ERROR)
		{
			if (m_bHadCloudError && !m_bHadLocalError)
			{	//	Allow the player to proceed even if the cloud photos couldn't be read. They should still be able to view their local photos in the gallery.
				//	They shouldn't be allowed to upload them though since we won't be able to tell if they've already been uploaded
				m_Status = MEM_CARD_COMPLETE;
			}
		}

		return true;
	}

	return false;
}

void CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::EndCreatedSortedList()
{
	if (m_bLocalEnumerationHasBeenStarted)
	{
		photoAssertf(CGenericGameStorage::GetSaveOperation() == OPERATION_ENUMERATING_PHOTOS, "CSavegameQueuedOperation_CreateSortedListOfLocalPhotos::EndCreatedSortedList - SaveOperation should be OPERATION_ENUMERATING_PHOTOS");
	}
	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
}




void CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Init(const CSavegamePhotoUniqueId &uniquePhotoId, CPhotoBuffer *pPhotoBuffer)
{
	photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Init called for unique photo Id %d", uniquePhotoId.GetValue());

	if (photoVerifyf(pPhotoBuffer, "CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Init - pPhotoBuffer is NULL"))
	{
		m_UniquePhotoId = uniquePhotoId;
		m_pBufferToStoreLoadedPhoto = pPhotoBuffer;

		m_NewTitle.Reset();

		CMetadataForOnePhoto *pMetadata = CSavegamePhotoLocalMetadata::GetMetadataForUniquePhotoId(m_UniquePhotoId);

		if (photoVerifyf(pMetadata, "CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Init - failed to find metadata for unique photo Id %d", m_UniquePhotoId.GetValue()))
		{
			m_NewTitle = pMetadata->GetTitleOfPhoto();
		}

		m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_BEGIN_LOAD;
	}
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update()
{
	switch (m_UpdateMetadataProgress)
	{
	case UPDATE_METADATA_PROGRESS_BEGIN_LOAD :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");

			switch (CSavegamePhotoLoadLocal::BeginLocalPhotoLoad(m_UniquePhotoId, m_pBufferToStoreLoadedPhoto))
			{
			case MEM_CARD_COMPLETE :
				m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_CHECK_LOAD;
				break;
			case MEM_CARD_BUSY :
				photoAssertf(0, "CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - didn't expect CSavegamePhotoLoadLocal::BeginLocalPhotoLoad to ever return MEM_CARD_BUSY");
				break;
			case MEM_CARD_ERROR :
				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_LOCAL_LOAD_JPEG_FAILED);
				m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_HANDLE_ERRORS;
				break;
			}
		}
		break;

	case UPDATE_METADATA_PROGRESS_CHECK_LOAD :
		{
			CSavingMessage::BeginDisplaying(CSavingMessage::STORAGE_DEVICE_MESSAGE_CLOUD_LOADING);

			MemoryCardError LoadState = CSavegamePhotoLoadLocal::DoLocalPhotoLoad();
			if (LoadState == MEM_CARD_ERROR)
			{
				if (SAVE_GAME_DIALOG_PLAYER_HAS_SIGNED_OUT == CSavegameDialogScreens::GetMostRecentErrorCode())
				{
					photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - player has signed out");
					m_Status = MEM_CARD_ERROR;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - CSavegamePhotoLoadLocal::DoLocalPhotoLoad() returned an error");
					m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_HANDLE_ERRORS;
				}
			}
			else if (LoadState == MEM_CARD_COMPLETE)
			{
				photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - CSavegamePhotoLoadLocal::DoLocalPhotoLoad() succeeded. Updating title to %s", m_NewTitle.c_str());

				if (m_pBufferToStoreLoadedPhoto->ReadAndVerifyLoadedBuffer())
				{
					//	We could also overwrite the metadata and description if we need to in the future
					if (m_pBufferToStoreLoadedPhoto->SetTitleString(m_NewTitle.c_str()))
					{
						m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_BEGIN_SAVE;
					}
					else
					{
						photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - SetTitleString() returned an error");
						photoAssertf(0, "CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - SetTitleString() returned an error");
						m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_HANDLE_ERRORS;
					}
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - ReadAndVerifyLoadedBuffer() returned an error");
					photoAssertf(0, "CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - ReadAndVerifyLoadedBuffer() returned an error");
					m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_HANDLE_ERRORS;
				}
			}
		}
		break;

	case UPDATE_METADATA_PROGRESS_BEGIN_SAVE :
		switch (CSavegamePhotoSaveLocal::BeginSavePhotoLocal(m_UniquePhotoId, m_pBufferToStoreLoadedPhoto))
		{
		case MEM_CARD_COMPLETE :
			m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_CHECK_SAVE;
			break;
		case MEM_CARD_BUSY :
			savegameAssertf(0, "CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - didn't expect CSavegamePhotoSaveLocal::BeginSavePhotoLocal() to ever return MEM_CARD_BUSY");
			m_Status = MEM_CARD_ERROR;
			break;
		case MEM_CARD_ERROR :
			savegameAssertf(0, "CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - CSavegamePhotoSaveLocal::BeginSavePhotoLocal() returned MEM_CARD_ERROR");
			m_Status = MEM_CARD_ERROR;
			break;
		}
		break;

	case UPDATE_METADATA_PROGRESS_CHECK_SAVE :
		switch (CSavegamePhotoSaveLocal::DoSavePhotoLocal())
		{
		case MEM_CARD_COMPLETE :
//	For some reason on PS4 resaving the photo doesn't lead to a new ModTimeLow when enumerating the photos so the resaved photo maintains its position in the sorted list
#if __UPDATING_LOCAL_PHOTO_TITLE_AFFECTS_MOD_TIME
			//	This photo is now the most-recently saved photo so move it to the top of the list of local photos
			CSavegamePhotoLocalList::Delete(m_UniquePhotoId);
			CSavegamePhotoLocalList::InsertAtTopOfList(m_UniquePhotoId);

#if !__NO_OUTPUT
			photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - list of local photos after re-inserting unique photo Id %d is", m_UniquePhotoId.GetValue());
			CSavegamePhotoLocalList::DisplayContentsOfList();
#endif	//	!__NO_OUTPUT

#endif	//	__UPDATING_LOCAL_PHOTO_TITLE_AFFECTS_MOD_TIME

			m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_BEGIN_UPDATE_UGC_TITLE;		//	UPDATE_METADATA_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH;
			break;

		case MEM_CARD_BUSY :	 // the save is still in progress
			break;

		case MEM_CARD_ERROR :
			m_Status = MEM_CARD_ERROR;
			break;
		}
		break;

	case UPDATE_METADATA_PROGRESS_BEGIN_UPDATE_UGC_TITLE :
		{
			//	I won't return MEM_CARD_ERROR if the cloud rename fails. As long as the local rename succeeds, I'll return MEM_CARD_COMPLETE

			m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH;

			if (CSavegamePhotoCloudList::GetListIsUpToDate())
			{
				if (CSavegamePhotoCloudList::DoesCloudPhotoExistWithThisUniqueId(m_UniquePhotoId))
				{
					CSavegamePhotoCloudList::SetTitleOfPhoto(m_UniquePhotoId, m_NewTitle.c_str());

					const char *pContentId = CSavegamePhotoCloudList::GetContentIdOfPhotoOnCloud(m_UniquePhotoId);

					photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - a cloud photo exists with unique photo Id %d (content Id is %s) so I'll call UpdateContent() with the new Title %s", m_UniquePhotoId.GetValue(), pContentId, m_NewTitle.c_str());

					rlUgc::SourceFile aUgcFile[1];

					if (photoVerifyf(UserContentManager::GetInstance().UpdateContent(pContentId, 
						m_NewTitle.c_str(), 
						NULL,			// szDesc
						NULL,			// szDataJson
						aUgcFile,		// pFiles
						0,				// nFiles
						NULL,			// szTags
						RLUGC_CONTENT_TYPE_GTA5PHOTO), 
						"CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - UpdateContent for UGC metadata has failed to start"))
					{
						photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - UpdateContent for UGC metadata has been started");
						m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_CHECK_UPDATE_UGC_TITLE;
					}
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - no photo with unique photo Id %d exists on the cloud that needs its Title updated", m_UniquePhotoId.GetValue());
				}
			}
			else
			{
				photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - list of cloud photos is not up to date so I can't check whether there is a corresponding cloud photo that needs its Title updated");
			}
		}
		break;

	case UPDATE_METADATA_PROGRESS_CHECK_UPDATE_UGC_TITLE :
		if (UserContentManager::GetInstance().HasModifyFinished())
		{
			//	I won't return MEM_CARD_ERROR if the cloud rename fails. As long as the local rename succeeds, I'll return MEM_CARD_COMPLETE

			if (UserContentManager::GetInstance().DidModifySucceed())
			{
				photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - UpdateContent for UGC succeeded");
			}
			else
			{
				photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - UpdateContent for UGC failed");
			}
			m_UpdateMetadataProgress = UPDATE_METADATA_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH;
		}
		break;

	case UPDATE_METADATA_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH :
		if (CSavingMessage::HasLoadingMessageDisplayedForLongEnough())
		{
			// The following is called for savegames. I'm not sure if it's needed for photos / MP stats.
			CSavegameDialogScreens::SetMessageAsProcessing(false);	//	GSWTODO - not sure if this should be in here or in DeSerialize()

			m_Status = MEM_CARD_COMPLETE;
		}
		break;

	case UPDATE_METADATA_PROGRESS_HANDLE_ERRORS :
		{
			CSavingMessage::Clear();

			if (CSavegameDialogScreens::HandleSaveGameErrorCode())
			{
				m_Status = MEM_CARD_ERROR;
			}
		}
		break;
	}


	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		if (m_Status == MEM_CARD_ERROR)
		{
			photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - failed");

			CSavingMessage::Clear();

			// The following is called for savegames. I'm not sure if it's needed for photos / MP stats.
			CSavegameDialogScreens::SetMessageAsProcessing(false);
		}
		else if (m_Status == MEM_CARD_COMPLETE)
		{
			photoDisplayf("CSavegameQueuedOperation_UpdateMetadataOfLocalAndCloudPhoto::Update - succeeded");
		}

		m_pBufferToStoreLoadedPhoto->FreeBuffer();

		return true;
	}

	return false;
}


// UploadLocalPhotoToCloud *********************************************************************************************

void CSavegameQueuedOperation_UploadLocalPhotoToCloud::Init(const CSavegamePhotoUniqueId &uniquePhotoId, CPhotoBuffer *pPhotoBuffer)
{
	if (photoVerifyf(pPhotoBuffer, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::Init - pPhotoBuffer is NULL"))
	{
		m_UniquePhotoId = uniquePhotoId;
		m_pBufferContainingLocalPhoto = pPhotoBuffer;

		safecpy(m_ContentIdOfUGCPhoto, "");

		safecpy(m_LimelightStagingFileName, "");
		safecpy(m_LimelightStagingAuthToken, "");

		m_NetStatusResultCode = 0;

		m_UploadPosixTime = 0;

		m_LimelightUploadStatus.Reset();

		safecpy(m_CdnUploadResponseHeaderValueBuffer, "");

		m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_CHECK_NUMBER_OF_UPLOADED_PHOTOS;
	}
}

void CSavegameQueuedOperation_UploadLocalPhotoToCloud::EndLocalPhotoUpload()
{
//	photoAssertf(CGenericGameStorage::GetSaveOperation() == OPERATION_LOADING_LOCAL_PHOTO, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::EndLoadLocalPhoto - SaveOperation should be OPERATION_LOADING_LOCAL_PHOTO");
	CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update()
{
    // This is the header we want to look for in the CDN upload request response.
    // We forward its value to the UGC Publish request in a header of the same name.
    static const char* cdnUploadHeaderResponsePath = "X-Akamai-RSGShardPath";

	switch (m_UploadLocalPhotoProgress)
	{
	case LOCAL_PHOTO_UPLOAD_PROGRESS_CHECK_NUMBER_OF_UPLOADED_PHOTOS :
		m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_BEGIN_LOAD;
		if (photoVerifyf(CSavegamePhotoCloudList::GetListIsUpToDate(), "CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - the list of cloud photos is not up to date so we can't get the number of uploaded photos"))
		{
			photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - number of uploaded photos is %u", CSavegamePhotoCloudList::GetNumberOfPhotos());
			if (CSavegamePhotoCloudList::GetNumberOfPhotos() >= MAX_PHOTOS_TO_LOAD_FROM_CLOUD)
			{
				m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_DISPLAY_WARNING_OLDEST_DELETE;
			}
		}
		break;

	case LOCAL_PHOTO_UPLOAD_PROGRESS_DISPLAY_WARNING_OLDEST_DELETE :
		{
			bool bReturnSelection = false;
			if (CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_OLDEST_UPLOADED_PHOTO_WILL_BE_DELETED, CSavegamePhotoCloudList::GetNumberOfPhotos(), &bReturnSelection))
			{
				if (bReturnSelection)
				{
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - player has chosen to replace their oldest uploaded photo");

					m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_BEGIN_LOAD;	//	If the deletion of the oldest cloud photo fails for any reason then continue to upload the local photo anyway

					CSavegamePhotoUniqueId uniqueIdOfOldestCloudPhoto = CSavegamePhotoCloudList::GetUniqueIdOfOldestPhoto();
					if (photoVerifyf(!uniqueIdOfOldestCloudPhoto.GetIsFree(), "CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - unique id of oldest cloud photo is %d", uniqueIdOfOldestCloudPhoto.GetValue()))
					{
						const char *pContentId = CSavegamePhotoCloudList::GetContentIdOfPhotoOnCloud(uniqueIdOfOldestCloudPhoto);

						photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - the oldest cloud photo has unique photo Id %d (content Id is %s). I'll add it to the cloud delete queue", uniqueIdOfOldestCloudPhoto.GetValue(), pContentId);

						if (photoVerifyf(CSavegamePhotoCloudDeleter::AddContentIdToQueue(pContentId), "CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - failed to queue the deletion of the oldest cloud photo"))
						{
							CSavegamePhotoCloudList::RemovePhotoFromList(uniqueIdOfOldestCloudPhoto);	//	I'm assuming that the cloud delete will succeed
							photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - setting m_UploadLocalPhotoProgress to LOCAL_PHOTO_UPLOAD_PROGRESS_WAIT_FOR_DELETION_TO_FINISH");
							m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_WAIT_FOR_DELETION_TO_FINISH;
						}
					}
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - player has chosen not to replace their oldest uploaded photo so give up now");
					m_Status = MEM_CARD_ERROR;
				}
			}
		}
		break;

	case LOCAL_PHOTO_UPLOAD_PROGRESS_WAIT_FOR_DELETION_TO_FINISH :
		photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - waiting for queue of cloud photo deletes to be empty");
		if (CSavegamePhotoCloudDeleter::IsQueueEmpty())		//	I'm not actually checking whether the cloud delete succeeded or not. I'd have to expand CSavegamePhotoCloudDeleter to record that.
		{
			photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - queue of cloud photo deletes is now empty");
			m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_BEGIN_LOAD;
		}
		break;

	case LOCAL_PHOTO_UPLOAD_PROGRESS_BEGIN_LOAD :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");

			switch (CSavegamePhotoLoadLocal::BeginLocalPhotoLoad(m_UniquePhotoId, m_pBufferContainingLocalPhoto))
			{
			case MEM_CARD_COMPLETE :
				m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_CHECK_LOAD;
				break;
			case MEM_CARD_BUSY :
				photoAssertf(0, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - didn't expect CSavegamePhotoLoadLocal::BeginLocalPhotoLoad to ever return MEM_CARD_BUSY");
				break;
			case MEM_CARD_ERROR :
				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_LOCAL_LOAD_JPEG_FAILED);
				m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
				break;
			}
		}
		break;

	case LOCAL_PHOTO_UPLOAD_PROGRESS_CHECK_LOAD :
		{
			CSavingMessage::BeginDisplaying(CSavingMessage::STORAGE_DEVICE_MESSAGE_CLOUD_LOADING);

			MemoryCardError LoadState = CSavegamePhotoLoadLocal::DoLocalPhotoLoad();
			if (LoadState == MEM_CARD_ERROR)
			{
				if (SAVE_GAME_DIALOG_PLAYER_HAS_SIGNED_OUT == CSavegameDialogScreens::GetMostRecentErrorCode())
				{
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - player has signed out");
					m_Status = MEM_CARD_ERROR;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CSavegamePhotoLoadLocal::DoLocalPhotoLoad() returned an error");
					m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
			else if (LoadState == MEM_CARD_COMPLETE)
			{
				photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CSavegamePhotoLoadLocal::DoLocalPhotoLoad() succeeded");

				m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_BEGIN_CREATE_UGC;
			}
		}
		break;

	case LOCAL_PHOTO_UPLOAD_PROGRESS_BEGIN_CREATE_UGC :
		{
			if (photoVerifyf(!UserContentManager::GetInstance().IsCreatePending(), "CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - BEGIN_CREATE_UGC - a Create is already pending"))
			{
				if (CSavegamePhotoMetadata::ShouldCorrectAkamaiOnUpload())
				{
					m_pBufferContainingLocalPhoto->CorrectAkamaiTag();
				}

				u8 *pJpegBuffer = m_pBufferContainingLocalPhoto->GetJpegBuffer();
				u32 sizeOfJpegBuffer = m_pBufferContainingLocalPhoto->GetExactSizeOfJpegData();
				const char *pTitle = m_pBufferContainingLocalPhoto->GetTitleString();
				const char *pDescription = m_pBufferContainingLocalPhoto->GetDescriptionString();
				const char *pMetadataString = m_pBufferContainingLocalPhoto->GetJsonBuffer();

				rlUgc::SourceFile srcFile(0, pJpegBuffer, sizeOfJpegBuffer);

				rlUgc::SourceFile *pSourceFile = &srcFile;
				s32 numberOfFiles = 1;

				// setting bPublish=false and numberOfFiles=0 as the first stage in uploading to CDN
				bool bPublish = false;	//	John Hynd says that this means "share so that others can see your photos"
				pSourceFile = NULL;
				numberOfFiles = 0;

				photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - BEGIN_CREATE_UGC - Title is %s, sizeOfJpegBuffer=%u, metadata string is %s", pTitle, sizeOfJpegBuffer, pMetadataString);

				if (UserContentManager::GetInstance().Create(pTitle, 
					pDescription, 
					pSourceFile,
					numberOfFiles,
					NULL, //tags
					pMetadataString, 
					RLUGC_CONTENT_TYPE_GTA5PHOTO, 
					bPublish))
				{
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - BEGIN_CREATE_UGC - UGC creation was successfully started");
					m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_CHECK_CREATE_UGC;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - BEGIN_CREATE_UGC - UGC creation failed to start");
					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_LIMELIGHT_UGC_CREATION_FAILED_TO_START);
					m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
			else
			{
				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_LIMELIGHT_UGC_CREATE_ALREADY_PENDING);
				m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
			}
		}
		break;

	case LOCAL_PHOTO_UPLOAD_PROGRESS_CHECK_CREATE_UGC :
		if (UserContentManager::GetInstance().HasCreateFinished())
		{
#if __BANK
			if (CPhotoManager::GetDelayPhotoUpload())
			{

			}
			else
#endif	//	__BANK
			{
				if (UserContentManager::GetInstance().DidCreateSucceed())
				{
					m_UploadPosixTime = UserContentManager::GetInstance().GetCreateCreatedDate();

					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_CREATE_UGC - UGC creation has completed successfully so parse content results for Limelight info");

					SaveGameDialogCode beginUploadErrorCode = SAVE_GAME_DIALOG_NONE;
					if (BeginCdnUpload(beginUploadErrorCode, cdnUploadHeaderResponsePath))
					{
						m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_CHECK_LIMELIGHT_UPLOAD;
					}
					else
					{
						photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_CREATE_UGC - BeginLimelightUpload() failed so delete the newly uploaded photo from UGC");

						const char *pContentId = UserContentManager::GetInstance().GetCreateContentID();
						if (photoVerifyf(pContentId, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_CREATE_UGC - failed to get the Content Id for the newly uploaded photo. I wanted to delete the content because BeginLimelightUpload() failed"))
						{
							UserContentManager::GetInstance().SetDeleted(pContentId, true, RLUGC_CONTENT_TYPE_GTA5PHOTO);
						}

						if (beginUploadErrorCode == SAVE_GAME_DIALOG_NONE)
						{
							CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_UGC_PHONE_PHOTO_SAVE_FAILED);
						}
						else
						{
							CSavegameDialogScreens::SetSaveGameError(beginUploadErrorCode);
						}
						m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
					}
				}
				else
				{
					m_NetStatusResultCode = UserContentManager::GetInstance().GetCreateResultCode();

					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_CREATE_UGC - UGC creation has failed with result code %d", m_NetStatusResultCode);
					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_LIMELIGHT_UGC_CREATION_FAILED);
					m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
		}
		break;

	case LOCAL_PHOTO_UPLOAD_CHECK_LIMELIGHT_UPLOAD :
		{
			if (!m_LimelightUploadStatus.Pending())
			{
				if (m_LimelightUploadStatus.Succeeded())
				{
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_LIMELIGHT_UPLOAD - Limelight upload has succeeded so I'll publish the new photo");

                    // m_CdnUploadResponseHeaderValueBuffer was filled in with the value of the response header with the name 
                    // cdnUploadHeaderResponsePath as part of the photo CDN upload task.
                    // Now we forward the value to the Publish task as an extra request header.
                    char cdnUploadPathHeader[256] = {0};

                    if (m_CdnUploadResponseHeaderValueBuffer[0] != '\0')
                    {
                        formatf(cdnUploadPathHeader, "%s: %s\r\n", cdnUploadHeaderResponsePath, m_CdnUploadResponseHeaderValueBuffer);
                    }

					//	What should I pass in for szBaseContentID?
					if (UserContentManager::GetInstance().Publish(m_ContentIdOfUGCPhoto, "", RLUGC_CONTENT_TYPE_GTA5PHOTO, cdnUploadPathHeader[0] != '\0' ? cdnUploadPathHeader : nullptr))
					{
						photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_LIMELIGHT_UPLOAD - publish has been successfully started");
						m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_CHECK_PUBLISH;
					}
					else
					{
						photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_LIMELIGHT_UPLOAD - publish failed to start");

						UserContentManager::GetInstance().SetDeleted(m_ContentIdOfUGCPhoto, true, RLUGC_CONTENT_TYPE_GTA5PHOTO);

						CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_LIMELIGHT_UGC_PUBLISH_FAILED_TO_START);
						m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
					}
				}
				else
				{
					m_NetStatusResultCode = m_LimelightUploadStatus.GetResultCode();

					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_LIMELIGHT_UPLOAD - Limelight upload has failed with result code %d so I'll delete the uploaded UGC", m_NetStatusResultCode);

					UserContentManager::GetInstance().SetDeleted(m_ContentIdOfUGCPhoto, true, RLUGC_CONTENT_TYPE_GTA5PHOTO);

					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_LIMELIGHT_UPLOAD_FAILED);
					m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
		}
		break;

	case LOCAL_PHOTO_UPLOAD_PROGRESS_CHECK_PUBLISH :
		{
			if (UserContentManager::GetInstance().HasModifyFinished())
			{
				if (UserContentManager::GetInstance().DidModifySucceed())
				{
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_PUBLISH - publish has succeeded so I'll add it to the cloud list");

					const char *pTitle = m_pBufferContainingLocalPhoto->GetTitleString();
					const char *pMetadataString = m_pBufferContainingLocalPhoto->GetJsonBuffer();

					CSavegamePhotoCloudList::AddToArray(m_ContentIdOfUGCPhoto, pTitle, pMetadataString, m_UploadPosixTime);

					m_Status = MEM_CARD_COMPLETE;
				}
				else
				{
					m_NetStatusResultCode = UserContentManager::GetInstance().GetModifyResultCode();

					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - CHECK_PUBLISH - publish has failed with result code %d so I'll delete the uploaded UGC", m_NetStatusResultCode);

					UserContentManager::GetInstance().SetDeleted(m_ContentIdOfUGCPhoto, true, RLUGC_CONTENT_TYPE_GTA5PHOTO);

					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_LIMELIGHT_UGC_PUBLISH_FAILED);
					m_UploadLocalPhotoProgress = LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS;
				}
			}
		}
		break;

//		LOCAL_PHOTO_UPLOAD_PROGRESS_WAIT_FOR_LOADING_MESSAGE_TO_FINISH,
	case LOCAL_PHOTO_UPLOAD_PROGRESS_HANDLE_ERRORS :
		{
			CSavingMessage::Clear();

			if (CSavegameDialogScreens::HandleSaveGameErrorCode())
			{
				m_Status = MEM_CARD_ERROR;
			}
		}
		break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		if (m_Status == MEM_CARD_ERROR)
		{
//			savegameWarningf("Error in CalculateSizeOfRequiredBuffer: code=%d", CSavegameDialogScreens::GetMostRecentErrorCode());
			photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - failed");
		}
		else if (m_Status == MEM_CARD_COMPLETE)
		{
			photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::Update - succeeded");
		}

		m_pBufferContainingLocalPhoto->FreeBuffer();

		CSavingMessage::Clear();

		EndLocalPhotoUpload();

		// The following is called for savegames. I'm not sure if it's needed for photos / MP stats.
		CSavegameDialogScreens::SetMessageAsProcessing(false);

		return true;
	}

	return false;
}


bool CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginCdnUpload(SaveGameDialogCode &returnErrorCode, const char* requestResponseHeaderValueToGet)
{
	returnErrorCode = SAVE_GAME_DIALOG_NONE;
	const char *pNewContentId = UserContentManager::GetInstance().GetCreateContentID();

	if (pNewContentId)
	{
		photoAssertf(strlen(pNewContentId) < RLUGC_MAX_CONTENTID_CHARS, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - pNewContentId has length %d. Expected it to be less than %u", (s32) strlen(pNewContentId), RLUGC_MAX_CONTENTID_CHARS);

		safecpy(m_ContentIdOfUGCPhoto, pNewContentId);

		const rlUgcMetadata *pUgcMetadata = UserContentManager::GetInstance().GetCreateResult();
		if (pUgcMetadata)
		{
			rlUgcGta5PhotoMetadataData photoMetadata;

			if (photoMetadata.SetMetadata(*pUgcMetadata))
			{
				u8 *pJpegBuffer = m_pBufferContainingLocalPhoto->GetJpegBuffer();
				u32 sizeOfJpegBuffer = m_pBufferContainingLocalPhoto->GetExactSizeOfJpegData();

				rlHttpCdnUploadPhotoTask *pTask = NULL;
				rlGetTaskManager()->CreateTask(&pTask);
				if(pTask)
				{
					char m_StagingUrl[512];
//					formatf(m_StagingUrl, "http://global.llp.lldns.net:8080/post/raw/%s", photoMetadata.GetStagingFileName());
					formatf(m_StagingUrl, "http://global.llp.lldns.net:8080/post/raw");

					const char *pStagingUrl = photoMetadata.GetStagingUrl();
					if (PARAM_useNewStagingUrl.Get())
					{
						pStagingUrl = m_StagingUrl;
					}

					safecpy(m_LimelightStagingFileName, photoMetadata.GetStagingFileName());
					safecpy(m_LimelightStagingAuthToken, photoMetadata.GetStagingAuthToken());

					//	Should I call m_LimelightUploadStatus.Reset(); here?
					if (rlTaskBase::Configure(pTask, "name", 
						pStagingUrl,
						photoMetadata.GetStagingAuthToken(), photoMetadata.GetStagingDirName(),
						photoMetadata.GetStagingFileName(), pJpegBuffer, sizeOfJpegBuffer,
						requestResponseHeaderValueToGet, m_CdnUploadResponseHeaderValueBuffer, (unsigned)sizeof(m_CdnUploadResponseHeaderValueBuffer), photoMetadata.UsesAkamai(),
						&m_LimelightUploadStatus))
					{
						if (rlGetTaskManager()->AddParallelTask(pTask))
						{
							return true;
						}
						else
						{
							returnErrorCode = SAVE_GAME_DIALOG_LIMELIGHT_ADD_PARALLEL_TASK_FAILED;
							photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - AddParallelTask failed for rlHttpLlnwUploadPhotoTask");
							photoAssertf(0, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - AddParallelTask failed for rlHttpLlnwUploadPhotoTask");
						}
					}
					else
					{
						returnErrorCode = SAVE_GAME_DIALOG_LIMELIGHT_CONFIGURE_FAILED;
						photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - Configure failed for rlHttpLlnwUploadPhotoTask");
						photoAssertf(0, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - Configure failed for rlHttpLlnwUploadPhotoTask");
					}
				}
				else
				{
					returnErrorCode = SAVE_GAME_DIALOG_LIMELIGHT_CREATE_TASK_FAILED;
					photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - failed to create a rlHttpLlnwUploadPhotoTask");
					photoAssertf(0, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - failed to create a rlHttpLlnwUploadPhotoTask");
				}
			}
			else
			{
				returnErrorCode = SAVE_GAME_DIALOG_LIMELIGHT_UGC_METADATA_PARSE_ERROR;
				photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - failed to parse Limelight photo data from metadata");
				photoAssertf(0, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - failed to parse Limelight photo data from metadata");
			}
		}
		else
		{
			returnErrorCode = SAVE_GAME_DIALOG_LIMELIGHT_GET_UGC_CREATE_RESULT_FAILED;
			photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - GetCreateResult() returned NULL");
			photoAssertf(0, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - GetCreateResult() returned NULL");
		}
	}
	else
	{
		returnErrorCode = SAVE_GAME_DIALOG_LIMELIGHT_GET_UGC_CREATE_CONTENT_ID_FAILED;
		photoDisplayf("CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - GetCreateContentID() returned NULL");
		photoAssertf(0, "CSavegameQueuedOperation_UploadLocalPhotoToCloud::BeginLimelightUpload - GetCreateContentID() returned NULL");
	}

	return false;
}

#else	//	__LOAD_LOCAL_PHOTOS

// CreateSortedListOfPhotos *********************************************************************************************

void CSavegameQueuedOperation_CreateSortedListOfPhotos::Init(bool bOnlyGetNumberOfPhotos, bool bDisplayWarningScreens)
{
	m_bOnlyGetNumberOfPhotos = bOnlyGetNumberOfPhotos;
	m_bDisplayWarningScreens = bDisplayWarningScreens;
	m_CreateSortedListOfPhotosProgress = CREATE_SORTED_LIST_OF_PHOTOS_REQUEST_CLOUD_DIRECTORY_CONTENTS;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_CreateSortedListOfPhotos::Update()
{
	switch (m_CreateSortedListOfPhotosProgress)
	{
		case CREATE_SORTED_LIST_OF_PHOTOS_REQUEST_CLOUD_DIRECTORY_CONTENTS :

			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_PH_RTRV	//	Retrieving Photos from Social Club

			if (CPhotoManager::RequestListOfCloudPhotos(m_bOnlyGetNumberOfPhotos))
			{
				m_CreateSortedListOfPhotosProgress = CREATE_SORTED_LIST_OF_PHOTOS_WAIT_FOR_CLOUD_DIRECTORY_REQUEST;
			}
			else
			{
				photoAssertf(0, "CSavegameQueuedOperation_CreateSortedListOfPhotos::Update - REQUEST_CLOUD_DIRECTORY_CONTENTS failed");
//				m_Status = MEM_CARD_ERROR;
				CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_BEGIN_CLOUD_LOAD_PHOTO_LIST_FAILED);
				m_CreateSortedListOfPhotosProgress = CREATE_SORTED_LIST_OF_PHOTOS_HANDLE_ERRORS;
			}
			break;

		case CREATE_SORTED_LIST_OF_PHOTOS_WAIT_FOR_CLOUD_DIRECTORY_REQUEST :
			photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfPhotos::Update - WAIT_FOR_CLOUD_DIRECTORY_REQUEST");
			if (CPhotoManager::GetIsCloudPhotoRequestPending(m_bOnlyGetNumberOfPhotos) == false)
			{
				if (CPhotoManager::GetHasCloudPhotoRequestSucceeded(m_bOnlyGetNumberOfPhotos))
				{
					photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfPhotos::Update - cloud request has completed");
					m_CreateSortedListOfPhotosProgress = CREATE_SORTED_LIST_OF_PHOTOS_CREATE_MERGED_LIST_OF_LOCAL_AND_CLOUD_PHOTOS;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_CreateSortedListOfPhotos::Update - cloud request has failed");
//					m_Status = MEM_CARD_ERROR;
					CSavegameDialogScreens::SetSaveGameError(SAVE_GAME_DIALOG_CHECK_CLOUD_LOAD_PHOTO_LIST_FAILED);
					m_CreateSortedListOfPhotosProgress = CREATE_SORTED_LIST_OF_PHOTOS_HANDLE_ERRORS;
				}
			}
			break;

		case CREATE_SORTED_LIST_OF_PHOTOS_CREATE_MERGED_LIST_OF_LOCAL_AND_CLOUD_PHOTOS :
			CPhotoManager::FillMergedListOfPhotos(m_bOnlyGetNumberOfPhotos);
			m_Status = MEM_CARD_COMPLETE;
			break;

		case CREATE_SORTED_LIST_OF_PHOTOS_HANDLE_ERRORS :
			if (!m_bDisplayWarningScreens || CSavegameDialogScreens::HandleSaveGameErrorCode())
			{
				CSavegameDialogScreens::ClearSaveGameError();
				m_Status = MEM_CARD_ERROR;
			}
			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		// Copied from CSavegameCheckFileExists::CheckFileExists which in turned copied it from CSavegameLoadBlock::CalculateSizeOfRequiredBuffer(). Not sure if it's necessary here.
// 		CSavegameDialogScreens::SetMessageAsProcessing(false);
// 
// 		Assertf( (m_bCreateListForSaving && (CGenericGameStorage::GetSaveOperation() == OPERATION_SCANNING_CONSOLE_FOR_SAVING_SAVEGAMES) ) 
// 			|| (!m_bCreateListForSaving && (CGenericGameStorage::GetSaveOperation() == OPERATION_SCANNING_CONSOLE_FOR_LOADING_SAVEGAMES) ), "CSavegameQueuedOperation_CreateSortedListOfPhotos::Update - SaveOperation should be either OPERATION_SCANNING_CONSOLE_FOR_SAVING_SAVEGAMES or OPERATION_SCANNING_CONSOLE_FOR_LOADING_SAVEGAMES");
// 
// 		CGenericGameStorage::SetSaveOperation(OPERATION_NONE);
		return true;
	}

	return false;
}

// End of CreateSortedListOfPhotos *********************************************************************************************

#endif	//	__LOAD_LOCAL_PHOTOS


// UploadMugshot *********************************************************************************************

void CSavegameQueuedOperation_UploadMugshot::Init(CPhotoBuffer *pPhotoBuffer, s32 mugshotCharacterIndex)
{
	if (photoVerifyf(pPhotoBuffer, "CSavegameQueuedOperation_UploadMugshot::Init - pPhotoBuffer is NULL"))
	{
		m_pBufferContainingMugshot = pPhotoBuffer;
		m_MugshotCharacterIndex = mugshotCharacterIndex;

		m_UploadMugshotProgress = MUGSHOT_UPLOAD_PROGRESS_BEGIN;		
	}
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_UploadMugshot::Update()
{
	switch (m_UploadMugshotProgress)
	{
	case MUGSHOT_UPLOAD_PROGRESS_BEGIN :
		if (CPhotoManager::RequestUploadOfMugshotPhoto(m_pBufferContainingMugshot, m_MugshotCharacterIndex))
		{
			savegameDisplayf("CSavegameQueuedOperation_UploadMugshot::Update - RequestUploadOfMugshotPhoto returned TRUE");
			m_UploadMugshotProgress = MUGSHOT_UPLOAD_PROGRESS_CHECK;
		}
		else
		{
			savegameDisplayf("CSavegameQueuedOperation_UploadMugshot::Update - RequestUploadOfMugshotPhoto returned FALSE");
			m_Status = MEM_CARD_ERROR;
		}
		break;

	case MUGSHOT_UPLOAD_PROGRESS_CHECK :
		m_Status = CPhotoManager::GetStatusOfUploadOfMugshotPhoto();
		break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		if (m_Status == MEM_CARD_ERROR)
		{
			photoDisplayf("CSavegameQueuedOperation_UploadMugshot::Update - failed");
		}
		else if (m_Status == MEM_CARD_COMPLETE)
		{
			photoDisplayf("CSavegameQueuedOperation_UploadMugshot::Update - succeeded");
		}

		CSavingMessage::Clear();

//		EndMugshotUpload();

		// The following is called for savegames. I'm not sure if it's needed for photos / MP stats.
		CSavegameDialogScreens::SetMessageAsProcessing(false);

		return true;
	}

	return false;
}

// End of UploadMugshot *********************************************************************************************


// DeleteFile *********************************************************************************************

void CSavegameQueuedOperation_DeleteFile::Init(const char *pFilename, bool bCloudFile, bool bIsAPhoto)
{
	s32 maxStringLength = SAVE_GAME_MAX_FILENAME_LENGTH_OF_LOCAL_FILE;
	if (bCloudFile)
	{
		maxStringLength = SAVE_GAME_MAX_FILENAME_LENGTH_OF_CLOUD_FILE;
	}

	if (photoVerifyf( (strlen(pFilename) < maxStringLength), "CSavegameQueuedOperation_DeleteFile::Init - filename %s has more than %d characters", pFilename, maxStringLength))
	{
		safecpy(m_FilenameOfFileToDelete, pFilename, maxStringLength);
		m_bCloudFile = bCloudFile;
		m_bIsAPhoto = bIsAPhoto;
		m_DeleteFileProgress = DELETE_FILE_PROGRESS_BEGIN;
	}
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_DeleteFile::Update()
{
	switch (m_DeleteFileProgress)
	{
		case DELETE_FILE_PROGRESS_BEGIN :
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_DEL	//	It doesn't look like anything is using the Delete operation now

				if (CSavegameDelete::Begin(m_FilenameOfFileToDelete, m_bCloudFile, m_bIsAPhoto))
				{
					photoDisplayf("CSavegameQueuedOperation_DeleteFile::Update - CSavegameDelete::Begin succeeded for %s", m_FilenameOfFileToDelete);
					m_DeleteFileProgress = DELETE_FILE_PROGRESS_CHECK;
				}
				else
				{
					photoDisplayf("CSavegameQueuedOperation_DeleteFile::Update - CSavegameDelete::Begin failed for %s", m_FilenameOfFileToDelete);
					m_Status = MEM_CARD_ERROR;
					return true;
				}
			}
			break;

		case DELETE_FILE_PROGRESS_CHECK :
			{
				switch (CSavegameDelete::Update())
				{
					case MEM_CARD_COMPLETE :
						photoDisplayf("CSavegameQueuedOperation_DeleteFile::Update - CSavegameDelete::Update succeeded for %s", m_FilenameOfFileToDelete);
						m_Status = MEM_CARD_COMPLETE;
						return true;
//						break;

					case MEM_CARD_BUSY :
						break;

					case MEM_CARD_ERROR :
						photoDisplayf("CSavegameQueuedOperation_DeleteFile::Update - CSavegameDelete::Update failed for %s", m_FilenameOfFileToDelete);
						m_Status = MEM_CARD_ERROR;
						return true;
//						break;
				}
			}
			break;
	}

	return false;
}

// End of DeleteFile *********************************************************************************************


// SaveLocalPhoto *********************************************************************************************

void CSavegameQueuedOperation_SaveLocalPhoto::Init(const CSavegamePhotoUniqueId &uniqueId, const CPhotoBuffer *pPhotoBuffer)
{
//	if (photoVerifyf(pUniqueId, "CSavegameQueuedOperation_SaveLocalPhoto::Init - pUniqueId is NULL"))
	{
		if (photoVerifyf(pPhotoBuffer, "CSavegameQueuedOperation_SaveLocalPhoto::Init - pPhotoBuffer is NULL"))
		{
			m_UniqueIdForFilename = uniqueId;
			m_pBufferToBeSaved = pPhotoBuffer;

			m_SaveLocalPhotoProgress = SAVE_LOCAL_PHOTO_PROGRESS_BEGIN;
		}
	}
}


//    Return true to Pop() from queue
bool CSavegameQueuedOperation_SaveLocalPhoto::Update()
{
	switch (m_SaveLocalPhotoProgress)
	{
		case SAVE_LOCAL_PHOTO_PROGRESS_BEGIN :
			switch (CSavegamePhotoSaveLocal::BeginSavePhotoLocal(m_UniqueIdForFilename, m_pBufferToBeSaved))
			{
			case MEM_CARD_COMPLETE :
				m_SaveLocalPhotoProgress = SAVE_LOCAL_PHOTO_PROGRESS_CHECK;
				break;
			case MEM_CARD_BUSY :
				savegameAssertf(0, "CSavegameQueuedOperation_SaveLocalPhoto::Update - didn't expect CSavegamePhotoSaveLocal::BeginSavePhotoLocal() to ever return MEM_CARD_BUSY");
				m_Status = MEM_CARD_ERROR;
				break;
			case MEM_CARD_ERROR :
				savegameAssertf(0, "CSavegameQueuedOperation_SaveLocalPhoto::Update - CSavegamePhotoSaveLocal::BeginSavePhotoLocal() returned MEM_CARD_ERROR");
				m_Status = MEM_CARD_ERROR;
				break;
			}

			break;

		case SAVE_LOCAL_PHOTO_PROGRESS_CHECK :
			switch (CSavegamePhotoSaveLocal::DoSavePhotoLocal())
			{
			case MEM_CARD_COMPLETE :
				CSavegamePhotoLocalList::InsertAtTopOfList(m_UniqueIdForFilename);

#if !__NO_OUTPUT
				photoDisplayf("CSavegameQueuedOperation_SaveLocalPhoto::Update - list of local photos after inserting unique photo Id %d is", m_UniqueIdForFilename.GetValue());
				CSavegamePhotoLocalList::DisplayContentsOfList();
#endif	//	!__NO_OUTPUT

				m_Status = MEM_CARD_COMPLETE;
				break;

			case MEM_CARD_BUSY :	 // the save is still in progress
				break;

			case MEM_CARD_ERROR :
				m_Status = MEM_CARD_ERROR;
				break;
			}

			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		return true;
	}

	return false;
}

// End of SaveLocalPhoto *********************************************************************************************


// LoadMostRecentSave *********************************************************************************************
void CSavegameQueuedOperation_LoadMostRecentSave::Init()
{
	m_LoadMostRecentSaveProgress = LOAD_PROGRESS_CHECK_IF_SIGNED_IN;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_LoadMostRecentSave::Update()
{
	switch (m_LoadMostRecentSaveProgress)
	{
		case LOAD_PROGRESS_CHECK_IF_SIGNED_IN :
		{
#if RSG_DURANGO
			if (CSavegameUsers::GetSignedInUser() && !CLiveManager::SignedInIntoNewProfileAfterSuspendMode())
#else
			if (CSavegameUsers::GetSignedInUser())
#endif
			{
				CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");

				CGenericGameStorage::SetSaveOperation(OPERATION_ENUMERATING_SAVEGAMES);
				CSavegameInitialChecks::BeginInitialChecks(false);

				m_LoadMostRecentSaveProgress = LOAD_PROGRESS_ENUMERATE_SAVEGAMES;
			}
			else
			{
				savegameDisplayf("CSavegameQueuedOperation_LoadMostRecentSave::Update - player is not signed in so start a new session");
				m_Status = MEM_CARD_ERROR;
			}
		}
		break;

		case LOAD_PROGRESS_ENUMERATE_SAVEGAMES :
		{
			MemoryCardError EnumerationState = CSavegameInitialChecks::InitialChecks();
			if (EnumerationState == MEM_CARD_ERROR)
			{
				savegameDisplayf("CSavegameQueuedOperation_LoadMostRecentSave::Update - enumeration of savegames has failed so start a new session");

				CGenericGameStorage::SetSaveOperation(OPERATION_NONE);

				m_Status = MEM_CARD_ERROR;
			}
			else if (EnumerationState == MEM_CARD_COMPLETE)
			{
				savegameDisplayf("CSavegameQueuedOperation_LoadMostRecentSave::Update - enumeration of savegames has succeeded so move on to finding the most recent save");

				CGenericGameStorage::SetSaveOperation(OPERATION_NONE);

				m_LoadMostRecentSaveProgress = LOAD_PROGRESS_FIND_MOST_RECENT_SAVE;
			}
		}
		break;

	case LOAD_PROGRESS_FIND_MOST_RECENT_SAVE :
		{
			m_IndexOfMostRecentSave = CSavegameList::FindMostRecentSavegame();

			if (m_IndexOfMostRecentSave >= 0)
			{
				savegameDisplayf("CSavegameQueuedOperation_LoadMostRecentSave::Update - most recent savegame slot is %d", m_IndexOfMostRecentSave);
				m_LoadMostRecentSaveProgress = LOAD_PROGRESS_BEGIN_LOAD;
			}
			else
			{
				savegameDisplayf("CSavegameQueuedOperation_LoadMostRecentSave::Update - CSavegameList::FindMostRecentSavegame() has failed to find a savegame so start a new session");
				m_Status = MEM_CARD_ERROR;
			}
		}
		break;

	case LOAD_PROGRESS_BEGIN_LOAD :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_LD_RPL

			if (MEM_CARD_ERROR == CSavegameList::BeginGameLoad(m_IndexOfMostRecentSave))
			{
				savegameDisplayf("CSavegameQueuedOperation_LoadMostRecentSave::Update - CSavegameList::BeginGameLoad() has failed so start a new session");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				camInterface::FadeOut(0);  // fade out the screen
				CGame::LoadSaveGame();

				m_LoadMostRecentSaveProgress = LOAD_PROGRESS_CHECK_LOAD;
			}
		}
		break;

	case LOAD_PROGRESS_CHECK_LOAD :
		{
			switch (CSavegameLoad::GenericLoad())
			{
			case MEM_CARD_COMPLETE:
				{
					camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading

					CGame::HandleLoadedSaveGame();
					savegameDisplayf("CSavegameQueuedOperation_LoadMostRecentSave::Update - setting status to MEM_CARD_COMPLETE");
					m_Status = MEM_CARD_COMPLETE;
				}
				break;

			case MEM_CARD_BUSY: // the load is still in progress
				break;

			case MEM_CARD_ERROR:
				savegameDisplayf("CSavegameQueuedOperation_LoadMostRecentSave::Update - CSavegameLoad::GenericLoad() has failed so start a new session");
				m_Status = MEM_CARD_ERROR;
				break;
			}
		}
		break;
	}

	if (m_Status == MEM_CARD_ERROR)
	{
		CGame::SetStateToIdle();

		camInterface::FadeOut(0);  // THIS FADE IS OK AS WE ARE STARTING A NEW GAME or loading
		CGame::StartNewGame(CGameLogic::GetCurrentLevelIndex());
		return true;
	}

	if (m_Status == MEM_CARD_COMPLETE)
	{
		return true;
	}

	return false;
}

// End of LoadMostRecentSave *********************************************************************************************


// CreateBackupOfAutosaveSDM *********************************************************************************************

#if USE_SAVE_DATA_MEMORY && !USE_DOWNLOAD0_FOR_AUTOSAVE_BACKUP
void CSavegameQueuedOperation_CreateBackupOfAutosaveSDM::Init()
{
	m_SlotToLoadFrom = AUTOSAVE_SLOT_FOR_EPISODE_ZERO;
	m_SlotToSaveTo = (m_SlotToLoadFrom + TOTAL_NUMBER_OF_SLOTS_FOR_SAVEGAMES);

	m_BackupProgress = AUTOSAVE_BACKUP_PROGRESS_BEGIN_LOAD;
}

//    Return true to Pop() from queue
bool CSavegameQueuedOperation_CreateBackupOfAutosaveSDM::Update()
{
	switch (m_BackupProgress)
	{
		case AUTOSAVE_BACKUP_PROGRESS_BEGIN_LOAD :
			{
				if (MEM_CARD_ERROR == CSavegameList::BeginGameLoad(m_SlotToLoadFrom))
				{
					m_Status = MEM_CARD_ERROR;
				}
				else
				{
					m_BackupProgress = AUTOSAVE_BACKUP_PROGRESS_CHECK_LOAD;
				}
			}
			break;

		case AUTOSAVE_BACKUP_PROGRESS_CHECK_LOAD :
			{
				switch (CSavegameLoad::GenericLoad())
				{
				case MEM_CARD_COMPLETE:
					{
						savegameDisplayf("CSavegameQueuedOperation_CreateBackupOfAutosaveSDM::Update - load has succeeded");
						CSavegameLoad::EndGenericLoad();
						m_BackupProgress = AUTOSAVE_BACKUP_PROGRESS_BEGIN_SAVE;
					}
					break;
				case MEM_CARD_BUSY: // the load is still in progress
					break;
				case MEM_CARD_ERROR:
					{
						savegameDisplayf("CSavegameQueuedOperation_CreateBackupOfAutosaveSDM::Update - load has failed");
						m_Status = MEM_CARD_ERROR;
					}
					break;
				}
			}
			break;

		case AUTOSAVE_BACKUP_PROGRESS_BEGIN_SAVE :
			{
				switch (CSavegameSave::BeginGameSave(m_SlotToSaveTo, SAVEGAME_SINGLE_PLAYER))
				{
				case MEM_CARD_COMPLETE :
					m_BackupProgress = AUTOSAVE_BACKUP_PROGRESS_CHECK_SAVE;
					break;
				case MEM_CARD_BUSY :
					savegameAssertf(0, "CSavegameQueuedOperation_CreateBackupOfAutosaveSDM::Update - didn't expect CSavegameSave::BeginGameSave to ever return MEM_CARD_BUSY");
					m_Status = MEM_CARD_ERROR;
					break;
				case MEM_CARD_ERROR :
					savegameAssertf(0, "CSavegameQueuedOperation_CreateBackupOfAutosaveSDM::Update - CSavegameSave::BeginGameSave failed");
					m_Status = MEM_CARD_ERROR;
					break;
				}
			}
			break;

		case AUTOSAVE_BACKUP_PROGRESS_CHECK_SAVE :
			{
				switch (CSavegameSave::GenericSave())
				{
				case MEM_CARD_COMPLETE :
					savegameDisplayf("CSavegameQueuedOperation_CreateBackupOfAutosaveSDM::Update - save has succeeded");
					m_Status = MEM_CARD_COMPLETE;
					break;

				case MEM_CARD_BUSY :	 // the save is still in progress
					break;

				case MEM_CARD_ERROR :
					savegameDisplayf("CSavegameQueuedOperation_CreateBackupOfAutosaveSDM::Update - save has failed");
					m_Status = MEM_CARD_ERROR;
					break;
				}
			}
			break;

// 		case AUTOSAVE_BACKUP_PROGRESS_HANDLE_ERRORS :
// 			{
// 				if (CSavegameDialogScreens::HandleSaveGameErrorCode())
// 				{
// 					CSavegameDialogScreens::ClearSaveGameError();
// 					m_Status = MEM_CARD_ERROR;
// 				}
// 			}
// 			break;
	}

	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		CGenericGameStorage::FreeBufferContainingContentsOfSavegameFile(SAVEGAME_SINGLE_PLAYER);

		return true;
	}

	return false;
}

#endif	//	USE_SAVE_DATA_MEMORY && !USE_DOWNLOAD0_FOR_AUTOSAVE_BACKUP

// End of CreateBackupOfAutosaveSDM *********************************************************************************************



#if __ALLOW_EXPORT_OF_SP_SAVEGAMES

// ExportSinglePlayerSavegame *********************************************************************************************

// Based on CSavegameQueuedOperation_ManualLoad
void CSavegameQueuedOperation_ExportSinglePlayerSavegame::Init()
{
	m_ExportSpSaveProgress = EXPORT_SP_SAVE_PROGRESS_BEGIN_SAVEGAME_LIST;

	m_bQuitAsSoonAsNoSavegameOperationsAreRunning = false;
	m_bNeedToCallEndGenericLoad = false;
}


bool CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update()
{
	switch (m_ExportSpSaveProgress)
	{
	case EXPORT_SP_SAVE_PROGRESS_BEGIN_SAVEGAME_LIST :
		CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_LOAD

		CSaveGameExport::SetIsExporting(true);

		if (!CSavegameFrontEnd::BeginSaveGameList())
		{
			Assertf(0, "CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - CSavegameFrontEnd::BeginSaveGameList failed");
			CPauseMenu::Close();
			savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - setting status to MEM_CARD_ERROR (1)");
			m_Status = MEM_CARD_ERROR;
		}
		else
		{
			m_ExportSpSaveProgress = EXPORT_SP_SAVE_PROGRESS_CHECK_SAVEGAME_LIST;
		}
		break;

	case EXPORT_SP_SAVE_PROGRESS_CHECK_SAVEGAME_LIST :
		{
			switch (CSavegameFrontEnd::SaveGameMenuCheck(m_bQuitAsSoonAsNoSavegameOperationsAreRunning))
			{
			case MEM_CARD_COMPLETE :
				{
					savegameAssertf(!CSavegameList::IsSaveGameSlotEmpty(CSavegameFrontEnd::GetSaveGameSlotToExport()), "CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - didn't expect slot %d to be empty", CSavegameFrontEnd::GetSaveGameSlotToExport());
					savegameAssertf(!CSavegameList::GetIsDamaged(CSavegameFrontEnd::GetSaveGameSlotToExport()), "CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - didn't expect slot %d to be damaged", CSavegameFrontEnd::GetSaveGameSlotToExport());
					m_ExportSpSaveProgress = EXPORT_SP_SAVE_PROGRESS_BEGIN_LOAD;
				}
				break;

			case MEM_CARD_BUSY :	//	still processing, do nothing
				break;

			case MEM_CARD_ERROR :
				CPauseMenu::BackOutOfUploadSavegamePanes();
				savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - setting status to MEM_CARD_ERROR (2)");
				m_Status = MEM_CARD_ERROR;
				break;
			}
		}
		break;

	case EXPORT_SP_SAVE_PROGRESS_BEGIN_LOAD :
		if (CSavegameList::BeginGameLoadForExport(CSavegameFrontEnd::GetSaveGameSlotToExport()) == MEM_CARD_ERROR)
		{
			CPauseMenu::AbandonLoadingOfSavedGame();	//	so clear bCloseAndStartSavedGame
			savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - setting status to MEM_CARD_ERROR (3)");
			m_Status = MEM_CARD_ERROR;
		}
		else
		{
			m_bNeedToCallEndGenericLoad = true;
			m_ExportSpSaveProgress = EXPORT_SP_SAVE_PROGRESS_CHECK_LOAD;
		}
		break;

	case EXPORT_SP_SAVE_PROGRESS_CHECK_LOAD :
		{
			switch (CSavegameLoad::GenericLoad())
			{
			case MEM_CARD_COMPLETE:
				{
					savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - load complete - moving on to BEGIN_EXPORT");
					//	Should I call CSavegameLoad::EndGenericLoad(); here? The disabled code in MANUAL_LOAD_PROGRESS_CHECK_LOAD_FOR_CLOUD_UPLOAD does.
					m_ExportSpSaveProgress = EXPORT_SP_SAVE_PROGRESS_BEGIN_EXPORT;
				}
				break;
			case MEM_CARD_BUSY: // the load is still in progress
				break;
			case MEM_CARD_ERROR:
				{
					CPauseMenu::AbandonLoadingOfSavedGame();	//	so clear bCloseAndStartSavedGame
					//	Should I call CSavegameLoad::EndGenericLoad(); here? The disabled code in MANUAL_LOAD_PROGRESS_CHECK_LOAD_FOR_CLOUD_UPLOAD does.
					savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - setting status to MEM_CARD_ERROR (4)");
					m_Status = MEM_CARD_ERROR;
				}
				break;
			}
		}
		break;

	case EXPORT_SP_SAVE_PROGRESS_BEGIN_EXPORT :
		{
			if (CSaveGameExport::BeginExport())
			{
				savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - BEGIN_EXPORT complete - moving on to CHECK_EXPORT");
				m_ExportSpSaveProgress = EXPORT_SP_SAVE_PROGRESS_CHECK_EXPORT;
			}
			else
			{
				CPauseMenu::AbandonLoadingOfSavedGame();	//	so clear bCloseAndStartSavedGame
				savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - setting status to MEM_CARD_ERROR (5)");
				m_Status = MEM_CARD_ERROR;
			}
		}
		break;

	case EXPORT_SP_SAVE_PROGRESS_CHECK_EXPORT :
		{
			switch (CSaveGameExport::UpdateExport())
			{
			case MEM_CARD_COMPLETE:
				{
					savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - CHECK_EXPORT - setting MEM_CARD_COMPLETE");
					m_Status = MEM_CARD_COMPLETE;
				}
				break;
			case MEM_CARD_BUSY: // the export is still in progress
				break;
			case MEM_CARD_ERROR:
				{
					CPauseMenu::AbandonLoadingOfSavedGame();	//	so clear bCloseAndStartSavedGame
					savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - setting status to MEM_CARD_ERROR (6)");
					m_Status = MEM_CARD_ERROR;
				}
				break;
			}
		}
		break;
	}


	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		CSaveGameExport::SetIsExporting(false);

		CSaveGameExport::FreeAllData();

		if (m_bNeedToCallEndGenericLoad)
		{
			m_bNeedToCallEndGenericLoad = false;
			CSavegameLoad::EndGenericLoad();
		}

		if (m_bQuitAsSoonAsNoSavegameOperationsAreRunning)
		{
			return true;
		}
		else
		{
			m_ExportSpSaveProgress = EXPORT_SP_SAVE_PROGRESS_BEGIN_SAVEGAME_LIST;
			savegameDisplayf("CSavegameQueuedOperation_ExportSinglePlayerSavegame::Update - setting status to MEM_CARD_BUSY (1)");
			m_Status = MEM_CARD_BUSY;
		}
	}

	return false;
}

#endif // __ALLOW_EXPORT_OF_SP_SAVEGAMES

// End of ExportSinglePlayerSavegame *********************************************************************************************

#if __ALLOW_IMPORT_OF_SP_SAVEGAMES

// ImportSinglePlayerSavegame *********************************************************************************************

void CSavegameQueuedOperation_ImportSinglePlayerSavegame::Init()
{
	m_ImportSpSaveProgress = IMPORT_SP_SAVE_PROGRESS_BEGIN_SAVEGAME_LIST;
	m_bImportSucceeded = false;

	m_bQuitAsSoonAsNoSavegameOperationsAreRunning = false;
}

//	Return true to Pop() from queue
bool CSavegameQueuedOperation_ImportSinglePlayerSavegame::Update()
{
	switch (m_ImportSpSaveProgress)
	{
	case IMPORT_SP_SAVE_PROGRESS_BEGIN_SAVEGAME_LIST :
		{
			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");	//	SG_HDG_SAVE

			CSaveGameImport::SetIsImporting(true);

			if (!CSavegameFrontEnd::BeginSaveGameList())
			{
				savegameAssertf(0, "CSavegameQueuedOperation_ImportSinglePlayerSavegame::Update - CSavegameFrontEnd::BeginSaveGameList failed");
				CPauseMenu::Close();
				savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegame::Update - setting status to MEM_CARD_ERROR (1)");
				m_Status = MEM_CARD_ERROR;
			}
			else
			{
				if (!CPauseMenu::GetNoValidSaveGameFiles())	//	sm_bNoValidSaveGameFiles will be true if the PS3 hard disk has been 
					//	scanned previously and there are no valid save games on it
				{
					CPauseMenu::LockMenuControl(true);
				}
				m_ImportSpSaveProgress = IMPORT_SP_SAVE_PROGRESS_CHECK_SAVEGAME_LIST;
			}
		}
		break;

	case IMPORT_SP_SAVE_PROGRESS_CHECK_SAVEGAME_LIST :
		{
			switch (CSavegameFrontEnd::SaveGameMenuCheck(m_bQuitAsSoonAsNoSavegameOperationsAreRunning))
			{
			case MEM_CARD_COMPLETE :
				{
					m_ImportSpSaveProgress = IMPORT_SP_SAVE_PROGRESS_BEGIN_IMPORT;
				}
				break;

			case MEM_CARD_BUSY :	//	still processing, do nothing
				break;

			case MEM_CARD_ERROR :
				CPauseMenu::UnlockMenuControl();	//	or should this be CPauseMenu::BackOutOfSaveGameList()?
				CPauseMenu::Close();
				savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegame::Update - setting status to MEM_CARD_ERROR (2)");
				m_Status = MEM_CARD_ERROR;
				break;
			}
		}
		break;

	case IMPORT_SP_SAVE_PROGRESS_BEGIN_IMPORT :
		{
			if (CSaveGameImport::BeginImport())
			{
				savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegame::Update - BEGIN_IMPORT complete - moving on to CHECK_IMPORT");
				m_ImportSpSaveProgress = IMPORT_SP_SAVE_PROGRESS_CHECK_IMPORT;
			}
			else
			{
				savegameErrorf("CSavegameQueuedOperation_ImportSinglePlayerSavegame::Update - CSaveGameImport::BeginImport() failed - Display an error message");
				m_ImportSpSaveProgress = IMPORT_SP_SAVE_PROGRESS_DISPLAY_RESULT_MESSAGE;
			}
		}
		break;

	case IMPORT_SP_SAVE_PROGRESS_CHECK_IMPORT :
		{
			switch (CSaveGameImport::UpdateImport())
			{
			case MEM_CARD_COMPLETE:
				{
					savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegame::Update - CSaveGameImport::UpdateImport() completed - moving on to DISPLAY_RESULT_MESSAGE");
					m_bImportSucceeded = true;
					m_ImportSpSaveProgress = IMPORT_SP_SAVE_PROGRESS_DISPLAY_RESULT_MESSAGE;

#if GEN9_STANDALONE_ENABLED
					CSaveMigration::GetSingleplayer().SetShouldMarkSingleplayerMigrationAsComplete();
#endif // GEN9_STANDALONE_ENABLED
				}
				break;
			case MEM_CARD_BUSY: // the import is still in progress
				break;
			case MEM_CARD_ERROR:
				{
					savegameErrorf("CSavegameQueuedOperation_ImportSinglePlayerSavegame::Update - CSaveGameImport::UpdateImport() failed - Display an error message");
					m_ImportSpSaveProgress = IMPORT_SP_SAVE_PROGRESS_DISPLAY_RESULT_MESSAGE;
				}
				break;
			}
		}
		break;

	case IMPORT_SP_SAVE_PROGRESS_DISPLAY_RESULT_MESSAGE :
		{
			bool ReturnSelection = false;
			if (m_bImportSucceeded)
			{
				if (CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_IMPORT_OF_SAVEGAME_SUCCEEDED, 0, &ReturnSelection))
				{
					CPauseMenu::Close();
					m_Status = MEM_CARD_COMPLETE;
				}
			}
			else
			{
				if (CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_IMPORT_OF_SAVEGAME_FAILED, 0, &ReturnSelection))
				{
					CPauseMenu::Close();
					m_Status = MEM_CARD_ERROR;
				}
			}
		}
		break;
	}


	if ( (m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE) )
	{
		CSaveGameImport::SetIsImporting(false);

		// CSaveGameImport::UpdateImport() should have dealt with freeing any data that it had allocated

		return true;
	}

	return false;
}

// End of ImportSinglePlayerSavegame *********************************************************************************************

// ImportSinglePlayerSavegameIntoFixedSlot *********************************************************************************************

void CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Init()
{
	m_ImportSpSaveIntoFixedSlotProgress = IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_BEGIN_IMPORT;
	m_bImportSucceeded = false;
	m_bLoadingOfImportedSaveSucceeded = false;

	m_bQuitAsSoonAsNoSavegameOperationsAreRunning = false;
}

bool CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::CopyDataImmediately(const u8 *pData, u32 dataSize)
{
	return CSaveGameImport::CreateCopyOfDownloadedData(pData, dataSize);
}

//	Return true to Pop() from queue
bool CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Update()
{
	const s32 slotToUseForImportedSave = (NUM_MANUAL_SAVE_SLOTS - 1);
	switch (m_ImportSpSaveIntoFixedSlotProgress)
	{
		case IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_BEGIN_IMPORT:
		{
			CSaveGameImport::SetIsImporting(true);

			// Rather than allowing the player to choose a slot, or finding a free slot, we just use the last manual 
			//		slot (even if it already contains a savegame)
			CSavegameFrontEnd::SetSaveGameSlotForImporting(slotToUseForImportedSave);

			if (CSaveGameImport::BeginImportOfDownloadedData())
			{
				savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Update - BEGIN_IMPORT complete - moving on to CHECK_IMPORT");
				m_ImportSpSaveIntoFixedSlotProgress = IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_CHECK_IMPORT;
			}
			else
			{
				savegameErrorf("CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Update - CSaveGameImport::BeginImportOfDownloadedData() failed - Display an error message");
				m_ImportSpSaveIntoFixedSlotProgress = IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_DISPLAY_ERROR_MESSAGE;
			}
		}
		break;

		case IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_CHECK_IMPORT:
		{
			switch (CSaveGameImport::UpdateImport())
			{
				case MEM_CARD_COMPLETE:
				{
					CSaveGameImport::SetIsImporting(false);

					savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Update - CSaveGameImport::UpdateImport() completed - moving on to BEGIN_LOAD");
					m_bImportSucceeded = true;
					m_ImportSpSaveIntoFixedSlotProgress = IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_BEGIN_LOAD;

#if GEN9_STANDALONE_ENABLED
					CSaveMigration::GetSingleplayer().SetShouldMarkSingleplayerMigrationAsComplete();
#endif // GEN9_STANDALONE_ENABLED
				}
				break;

				case MEM_CARD_BUSY: // the import is still in progress
					break;

				case MEM_CARD_ERROR:
				{
					CSaveGameImport::SetIsImporting(false);

					savegameErrorf("CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Update - CSaveGameImport::UpdateImport() failed - Display an error message");
					m_ImportSpSaveIntoFixedSlotProgress = IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_DISPLAY_ERROR_MESSAGE;
				}
				break;
			}
		}
		break;

		case IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_BEGIN_LOAD :
		{
			camInterface::FadeOut(0);
			CLoadingScreens::Init(LOADINGSCREEN_CONTEXT_LOADLEVEL, 0);

			// pause streaming any other misc processing
			CStreaming::SetIsPlayerPositioned(false);

			CSavegameDialogScreens::SetDialogBoxHeading("SG_HDNG");

			if (CSavegameList::BeginGameLoad(slotToUseForImportedSave) == MEM_CARD_ERROR)
			{
				savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Update - CSavegameList::BeginGameLoad() has failed so display an error message and start a new session");
				m_ImportSpSaveIntoFixedSlotProgress = IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_DISPLAY_ERROR_MESSAGE;
			}
			else
			{
				CGame::LoadSaveGame();

				m_ImportSpSaveIntoFixedSlotProgress = IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_CHECK_LOAD;
			}
		}
		break;

		case IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_CHECK_LOAD :
		{
			switch (CSavegameLoad::GenericLoad())
			{
			case MEM_CARD_COMPLETE:
			{
				m_bLoadingOfImportedSaveSucceeded = true;

				camInterface::FadeOut(0);

				CGame::HandleLoadedSaveGame();
				savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Update - setting status to MEM_CARD_COMPLETE");
				m_Status = MEM_CARD_COMPLETE;
			}
			break;

			case MEM_CARD_BUSY: // the load is still in progress
				break;

			case MEM_CARD_ERROR:
				savegameDisplayf("CSavegameQueuedOperation_ImportSinglePlayerSavegameIntoFixedSlot::Update - CSavegameLoad::GenericLoad() has failed so display an error message and start a new session");
				m_ImportSpSaveIntoFixedSlotProgress = IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_DISPLAY_ERROR_MESSAGE;
				break;
			}
		}
		break;

		case IMPORT_SP_SAVE_INTO_FIXED_SLOT_PROGRESS_DISPLAY_ERROR_MESSAGE :
		{
			bool ReturnSelection = false;
			if (m_bImportSucceeded && !m_bLoadingOfImportedSaveSucceeded)
			{
				if (CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_LOADING_OF_IMPORTED_SAVEGAME_FAILED, 0, &ReturnSelection))
				{
//					CPauseMenu::Close();
					m_Status = MEM_CARD_ERROR;
				}
			}
			else
			{
				if (CSavegameDialogScreens::HandleSaveGameDialogBox(SAVE_GAME_DIALOG_IMPORT_OF_SAVEGAME_FAILED, 0, &ReturnSelection))
				{
//					CPauseMenu::Close();
					m_Status = MEM_CARD_ERROR;
				}
			}

			if (m_Status == MEM_CARD_ERROR)
			{
				CGame::SetStateToIdle();

				camInterface::FadeOut(0);
				CGame::StartNewGame(CGameLogic::GetCurrentLevelIndex());
			}
		}
		break;
	}


	if ((m_Status == MEM_CARD_ERROR) || (m_Status == MEM_CARD_COMPLETE))
	{
		CSaveGameImport::SetIsImporting(false);

		// CSaveGameImport::UpdateImport() should have dealt with freeing any data that it had allocated

		return true;
	}

	return false;
}

// End of ImportSinglePlayerSavegameIntoFixedSlot *********************************************************************************************

#endif // __ALLOW_IMPORT_OF_SP_SAVEGAMES