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

//

/**

 @file

*/

#include "wsgcedebugsession.h"

RWsDebugSession::RWsDebugSession(TInt aScreenNo /*= -1*/):

	iScreenNo(aScreenNo),

	iSurfaceUpdateSerial(-1)

	{

	iSurfaceListBuffer.CreateMax(48);

	}

RWsDebugSession::~RWsDebugSession()

	{

	iSurfaceListBuffer.Close();

	}

TBool RWsDebugSession::ResetUpdated()

	{

	TInt surfaceUpdateSerial=DebugInfo(EWsDebugSerialSurfacesUpdated,iScreenNo);

	TBool retVal=(iSurfaceUpdateSerial!=surfaceUpdateSerial);

	iSurfaceUpdateSerial=surfaceUpdateSerial;

	return retVal;

	}

TInt RWsDebugSession::ResetUpdatedAndGetSurfaceWindowList(const TWsDebugWindowId * & aWinList)

	{

	iSurfaceUpdateSerial=DebugInfo(EWsDebugSerialSurfacesUpdated,iScreenNo);

	TInt reqSize=DebugInfo(EWsDebugSurfaceWindowList,iSurfaceListBuffer,iScreenNo);

	while (reqSize>iSurfaceListBuffer.MaxLength())

		{

		iSurfaceListBuffer.Close();

		iSurfaceListBuffer.CreateMax(reqSize);

		iSurfaceUpdateSerial=DebugInfo(EWsDebugSerialSurfacesUpdated,iScreenNo);

		reqSize=DebugInfo(EWsDebugSurfaceWindowList,iSurfaceListBuffer,iScreenNo);

		}

	if (reqSize==KErrCancel)

		{

		aWinList=NULL;

		return 0;

		}

	else

		{

		aWinList=(TWsDebugWindowId*)iSurfaceListBuffer.Ptr();

		return reqSize/sizeof(TWsDebugWindowId);

		}

	}

/**

 * Stream data into the provided buffer and point the return object pointer to it.

 * The pointer is left null if the method returns an error code or the buffer is too small.

 * The ret5urn code reports 

 * 

 **/

TInt	RWsDebugSession::DebugInfo(TWsDebugInfoFunc aFunction, TInt aParam, TDes8& aHostBuffer,const void*&aReturnedObject,TInt aObjectSize)const

	{

	aHostBuffer.SetMax();

	TInt reqSize=DebugInfo(aFunction,aHostBuffer,aParam);

	aReturnedObject=NULL;

	if (reqSize<0)

		{

		return reqSize;	//Error code is transmitted unmolested

		}

	if (reqSize==0)		//Size 0 is transformed to max

		reqSize=aHostBuffer.MaxLength();

	if ((reqSize%aObjectSize)!=0)

		{				//Size not multiple of object --> error

		return KErrCorrupt;

		}

	if (reqSize<=aHostBuffer.MaxLength())

		{		//Pointer is only set if data fits buffer

		aReturnedObject=(const void*)aHostBuffer.Ptr();

		}

	reqSize/=aObjectSize;	//Return the exact number of objects filled

	return reqSize;

	}

/**

 * Stream the reply data via the buffer associated with the region.

 * Some protected accessor optimisation used to manage the reported size of the region after streaming.

 * 

 **/

TInt	RWsDebugSession::DebugInfo(TWsDebugInfoFunc aFunction, TInt aParam, TRegion& aPreAllocatedReturnedRegion)const

	{

	//Attempt to fit the received data in the preexisting region buffer...

	class XRegion:public TRegion

		{

		public:

			using TRegion::AppendRect;

		//	using TRegion::SetListSize;

			using TRegion::RectangleListW;

			TInt MaxSize()				

				{ return iAllocedRects;	}

			void  SetListSize(TInt aNewSize)	//DANGER no error checking!!!				

				{ iCount=aNewSize;	}

		}& preAllocatedReturnedRegion=(XRegion&)aPreAllocatedReturnedRegion;

	typedef TRect TElt;

	TInt reqSize=preAllocatedReturnedRegion.MaxSize();

	const TElt* elements=preAllocatedReturnedRegion.RectangleListW();

	TInt lenBytes=reqSize*sizeof(TElt);

	TPtr8 pBuff((TUint8*)elements,lenBytes,lenBytes);

	reqSize=DebugInfo(aFunction,aParam,pBuff,elements);

	if (elements)

		{

		if (reqSize==0)

			{

			reqSize=preAllocatedReturnedRegion.MaxSize();

			}

		preAllocatedReturnedRegion.SetListSize(reqSize);

		return reqSize;

		}

	//If data does not fit in preexisting buffer

	//Use a temp array instead

	//Still try to block copy into the existing capacity

	//I think this use of region copy is more efficient than appending,

	//and definitely better than unioning the elements.

	if (reqSize>=0)

		{

		TInt breakLoop=10;

		do	{

			TElt* tempbuff=new TElt[reqSize];

			if (tempbuff==NULL)

				{

				reqSize=KErrNoMemory;

				break;

				}

			elements=tempbuff;

			TInt lenBytes=reqSize*sizeof(TElt);

			TPtr8 pBuff((TUint8*)elements,lenBytes,lenBytes);

			TInt reqSize2=DebugInfo(aFunction,aParam,pBuff,elements);

			if (reqSize2!=0)

				reqSize=reqSize2;

			if (elements)

				{

				RRegion r(reqSize,tempbuff);	//note this region does not own its memory so should not be closed!

				aPreAllocatedReturnedRegion.Copy(r);

				if (aPreAllocatedReturnedRegion.CheckError())

					reqSize=KErrNoMemory;

				}

			delete[] tempbuff;

			}while (reqSize>0 && elements==NULL && --breakLoop);

		}

	if (reqSize>=0 && elements==NULL)

		{

		preAllocatedReturnedRegion.ForceError();

		reqSize=KErrTimedOut;

		}

	if (reqSize<0)

		{

		if (reqSize==KErrCancel)

			{

			preAllocatedReturnedRegion.Clear();

			}

		else

			{

			preAllocatedReturnedRegion.ForceError();

			}

		}

	return reqSize;

	}