// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "WsMemMgr.h"

 #include "inifile.h"

 #include "panics.h"

 #include "wstop.h"

 CWsMemoryManager * CWsMemoryManager::iStatic = NULL;

 CWsMemoryManager * CWsMemoryManager::Static()

 	{

 	return iStatic;

 	}

 CWsMemoryManager * CWsMemoryManager::NewLC()

 	{

 	CWsMemoryManager * self = new (ELeave) CWsMemoryManager;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	iStatic = self;

 	return iStatic;

 	}

 CWsMemoryManager::CWsMemoryManager()

 	{

 	iImpl = User::SwitchAllocator(this);

 	}

 CWsMemoryManager::~CWsMemoryManager()

 	{

 	WS_ASSERT_ALWAYS(this == User::SwitchAllocator(iImpl),EWsPanicMemoryManager);

 	iStatic = 0;

 	if (iReserve!=NULL)

 		{

 		Free(iReserve);

 		iReserve = NULL;

 		}	

 	}

 void CWsMemoryManager::ConstructL()

 	{

 	_LIT(KMemMgrReserve, "MEMORYRESERVE");

 	const TInt KDefaultMemMgrReserve = 1024;

 	if (!WsIniFile->FindVar(KMemMgrReserve, iReserveSize))

 		iReserveSize = KDefaultMemMgrReserve;

 	if (iReserveSize > 0)

 		iReserve = Alloc(iReserveSize);

 	}

 /**

 Implementing RAllocator

 */

 /**

 Alloc and ReAlloc attempt to obtain memory through CWsTop::ReleaseMemory when they run low.

 ReleaseMemory looks for blocks of memory that the window server doesn't need urgently and frees

 them.

 */

 TAny* CWsMemoryManager::Alloc(TInt aSize)

 	{

 	TBool keepTrying = ETrue;

 	do

 		{

 		if(iReleasing)

 			return iImpl->Alloc(aSize); //fallback on RAllocator

 		if(TAny* ret = iImpl->Alloc(aSize)) //normal case

 			return ret;

 		if(iReserveEnabled && iReserve && (aSize < iReserveSize))

 			{

 			Free(iReserve);

 			iReserve = NULL;

 			}

 		else

 			{

 			iReleasing = ETrue;

 			keepTrying = CWsTop::ReleaseMemory();

 			if(keepTrying)

  				{

  				const TInt reclaimed = Compress(); //Try to give back to the OS

  				}			

 			iReleasing = EFalse;

 			}

 		} while(keepTrying);

 	return NULL;

 	}

 TAny* CWsMemoryManager::ReAlloc(TAny* aPtr, TInt aSize, TInt aMode)

 	{

 	TBool keepTrying = ETrue;

 	do

 		{

 		if(iReleasing)

 			return iImpl->ReAlloc(aPtr, aSize, aMode); //fallback on RAllocator

 		if(TAny* ret = iImpl->ReAlloc(aPtr, aSize, aMode)) //normal case

 			return ret;

 		if(iReserveEnabled && iReserve && (aSize < iReserveSize))

 			{

 			Free(iReserve);

 			iReserve = NULL;

 			}

 		else

 			{

 			iReleasing = ETrue;

 			keepTrying = CWsTop::ReleaseMemory();

 			if(keepTrying)

  				{

  				const TInt reclaimed = Compress(); //Try to give back to the OS

  				}	

 			iReleasing = EFalse;

 			}

 		} while(keepTrying);

 	return NULL;

 	}

 /**

 The rest of these functions just call the default implementation

 */

 void CWsMemoryManager::Free(TAny* aPtr)

 	{

 	return iImpl->Free(aPtr);

 	}

 TInt CWsMemoryManager::AllocLen(const TAny* aCell) const

 	{

 	return iImpl->AllocLen(aCell);

 	}

 TInt CWsMemoryManager::Compress()

 	{

 	return iImpl->Compress();

 	}

 void CWsMemoryManager::Reset()

 	{

 	iImpl->Reset();

 	}

 TInt CWsMemoryManager::AllocSize(TInt& aTotalAllocSize) const

 	{

 	return iImpl->AllocSize(aTotalAllocSize);

 	}

 TInt CWsMemoryManager::Available(TInt& aBiggestBlock) const

 	{

 	return iImpl->Available(aBiggestBlock);

 	}

 TInt CWsMemoryManager::DebugFunction(TInt aFunc, TAny* a1, TAny* a2)

 	{

 	return iImpl->DebugFunction(aFunc,a1,a2);

 	}

 TInt CWsMemoryManager::Count() const

 	{

 	return iImpl->Count();

 	}

 /** This is a fairly dumb way to enable and disable the reserve, but we normally

 get away with it because wserv is high priority.  A better approach would be to

 use placement new into the reserve memory and manage it directly.  This would also

 allow us to track misbehaving code which allocated during OOM drawing and didn't

 free at the end.

 */

 void CWsMemoryManager::EnableReserve()

 	{

 	WS_ASSERT_DEBUG(!iReserveEnabled, EWsPanicMemoryManager);

 	iReserveEnabled = ETrue;

 	}

 void CWsMemoryManager::DisableReserve()

 	{

 	WS_ASSERT_DEBUG(iReserveEnabled, EWsPanicMemoryManager);

 	iReserveEnabled = EFalse;

 	if((!iReserve) && (iReserveSize > 0))

 		iReserve = Alloc(iReserveSize);

 	}