// Copyright (c) 1997-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:
//

#if !defined(__MBufManager_h__)
#define __MBufManager_h__

#include <comms-infras/mbufsizeallocator.h>	// for MBufSizeAllocator

/**
MBuf Private Heap Limits

@internalTechnology
*/
const TUint KMBufDefaultHeapSize	= 256 * 1024;

class Nif;
class CRequestAsyncAlloc;
class CMBufPoolManager;
class CMBufMemoryAllocator;

class CMBufManager : public CBase
/**
@internalTechnology
*/
	{
friend class Nif;

private:
	CMBufManager();
public:
	IMPORT_C ~CMBufManager();
	IMPORT_C static CMBufManager* NewL(TInt aMaxHeapSize, MMBufSizeAllocator* &aMBufSizeAllocator);

	IMPORT_C RMBuf* AllocL(TInt aSize);
	IMPORT_C RMBuf* Alloc(TInt aSize);

	IMPORT_C void Free(RMBuf* aMBuf);
	IMPORT_C static void Panic(TMBufPanic aPanic);
	
	void CallBackAfterFree();

	void StartRequest(RMBufAsyncRequest& aRequest);
	void CancelRequest(RMBufAsyncRequest& aRequest);

	static CDeltaTimer* Timer();

	// Used to reference the single process-wide MBufManager from different threads+DLLs
	// Don't try to inline these - if TLS is in use then they need to be in this DLL
	IMPORT_C static CMBufManager* Context(); // Panics if no context!
	// A new thread/DLL needs to call this when the TLS handling is in use, ie in the
	// thread startup function, having obtained a pointer to the CMBufManager somehow
	// (eg caller passed in). Consider it as the thread/dll introducing itself to the
	// MBufMgr. "Pleased to meet you..."
	IMPORT_C void SetContext();

	RMBuf* Alloc(TInt aSize, TInt aMinMBufSize);
	RMBuf* Alloc(TInt aSize, TInt aMinMBufSize, TInt aMaxMBufSize);
	RMBuf* Alloc(TInt aSize, TInt aMinMBufSize, TInt aMaxMBufSize, TBool aIsAllocPool);
	RMBuf* Alloc(TInt aSize, const RMBufChain& aMBufChain);

	// Metrics
	TInt BytesAvailable() const;
	TInt BytesAvailable(TInt aSize) const;
	TInt NextMBufSize(TInt aSize) const;
	TInt LargestMBufSize() const;
	
	void WatchDogReset();
	
private:

	void ConstructL(TInt aMaxHeapSize);

	static TInt WatchDogExpire(TAny* aPtr);
	static TInt FreeCallBack(TAny* aPtr);
	void CompleteAsyncAllocs(TBool aIsAllocPool);

private:

	RWorkerLock iAsynAllocLock;

    CMBufPoolManager* iMBufPoolManager;

	TDblQue<RMBufAsyncRequest> iAllocsPending;
	CDeltaTimer* iTimer;					// The global delta timer.
	TThreadId iTimerThreadId;
	TDeltaTimerEntry iWatchDog;
	TBool iWatchDogIsPending;
	CAsyncCallBack* iFreeCB;
	CRequestAsyncAlloc* iRequestAsyncAlloc;

public:
	IMPORT_C static void __DbgCheckChain(RMBuf* aMBuf, TMBufType aType, TInt aLength, TInt aSize);
	IMPORT_C TInt __DbgCheckBuffer(RMBuf* aBuf);
    IMPORT_C RMBuf* __DbgMBufChain();
	IMPORT_C RMBuf* __DbgMBufChain(TUint aMBufSize);
	IMPORT_C void __DbgSetPoolLimit(TInt aCount);
	IMPORT_C void __DbgSetPoolLimit(TInt aCount, TUint aMBufSize);
	IMPORT_C void __DbgSetFailAfter(TInt aCount=0);
	IMPORT_C TUint __DbgGetBufSpace();
	IMPORT_C TUint __DbgGetBufSpace(TUint aMBufSize);
	IMPORT_C TUint __DbgGetBufTotal();
	IMPORT_C TUint __DbgGetBufTotal(TUint aMBufSize);
	IMPORT_C TInt __DbgGetHeapSize();

private:
	TInt iDbgFailAfter;		// fail allocation request of pool within pool chain

#ifdef SYMBIAN_NETWORKING_PERFMETRICS
	static TBool AddToPerfLog(TAny* aSelf, TDes8& aBuffer, TDes8Overflow* aOverflowHandler);

	enum
		{
		KBucketSize = 128,	// Should be a power of 2 for better perf
		KNumBuckets = 13
		};
	TUint iBuckets[KNumBuckets];
	TUint iNumOOBs;
#endif
	};

#endif