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

 // RWsBuffer class, handles buffering and flushing of window server commands

 // 

 //

 #include <e32std.h>

 #include "../SERVER/w32cmd.h"

 #include "CLIENT.H"

 #include "w32comm.h"

 // Global functions

 GLDEF_C void Assert(TW32Assert aAssert)

 	{

 	_LIT(KW32AssertCategory,"W32 Assert");

 	User::Panic(KW32AssertCategory,aAssert);

 	}

 GLDEF_C void Panic(TW32Panic aPanic)

 	{

 	_LIT(KW32PanicCategory,"W32");

 	User::Panic(KW32PanicCategory,aPanic);

 	}

 // Public functions

 RWsBuffer::RWsBuffer(RWsSession *aSession) : iSession(aSession), iManager(NULL),

 	#if defined(__AUTO_FLUSH)

 		iAutoFlush(ETrue),

 	#else

 		iAutoFlush(EFalse),

 	#endif

 	iBuf(NULL,0,0), iNext(NULL), iPreviousHandle(0), iBufSize(0), iMaxBufSize(EMinBufferSize),

 	#if defined(_DEBUG)

 	iAppendDataLength(0),

 	#endif

 	iDirectAcessCount(0), iInvalidBitmapArray(EFalse), iWindowSizeCache(NULL)

 	{

 	}

 TInt WsFbsDestroyCallBack(TAny* aBitmapHandle)

 	{

 	TInt* bitmapHandle=static_cast<TInt*>(aBitmapHandle);

 	RWsBuffer::FlushAllBuffers(aBitmapHandle ? *bitmapHandle : 0);

 	return(0);

 	}

 void RWsBuffer::SetCallBack()

 	{

 	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)

 		if (buffer==this)

 			return;	// Already linked

 	iNext=(RWsBuffer *)Dll::Tls();

 	Dll::SetTls(this);

 	if (iNext==NULL)	// First connection so set callback

 		RFbsSession::GetSession()->SetCallBack(TCallBack(WsFbsDestroyCallBack,NULL));

 	}

 void RWsBuffer::CancelCallBack()

 	{

 	RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();

 	if (buffer==this)

 		{

 		Dll::SetTls(iNext);

 		if (iNext==NULL)

 			RFbsSession::GetSession()->ResetCallBack();	// Last connection closing so cancel the callback

 		}

 	else

 		{

 		RWsBuffer *prev;

 		while(buffer)

 			{

 			prev=buffer;

 			buffer=buffer->iNext;

 			if (buffer==this)

 				{

 				prev->iNext=iNext;

 				break;

 				}

 			}

 		}

 	}

 void RWsBuffer::Close()

 	{

 	User::Free((TAny *)iBuf.Ptr());

 	if (iWindowSizeCache)

 	    {

 	    iWindowSizeCache->Close();

 	    delete iWindowSizeCache;

 	    iWindowSizeCache = NULL;

 	    }

 	}

 void RWsBuffer::Destroy()

 	{

 	Flush();

 	Close();

 	delete this;

 	}

 TInt RWsBuffer::Flush(const TIpcArgs* aIpcArgs,TBool aRequestFinish)

 	{

 	iBitmapArray.Reset();

 	iInvalidBitmapArray=EFalse;

 	if (iBuf.Length()==0)

 		{

 		return(KErrNone);

 		}

 	TIpcArgs ipcArgs;

 	if (aIpcArgs!=NULL)

 		{

 		ipcArgs=*aIpcArgs;

 		// check that the caller hasn't used the first slot

 		ipcArgs.Set(KBufferMessageSlot,TIpcArgs::ENothing);

 		__ASSERT_ALWAYS(Mem::Compare(REINTERPRET_CAST(const TUint8*, &ipcArgs), sizeof(TIpcArgs), REINTERPRET_CAST(const TUint8*, aIpcArgs), sizeof(TIpcArgs))==0,Panic(EW32PanicUsingReservedIpcSlot));

 		}

 	ipcArgs.Set(KBufferMessageSlot,&iBuf);

 	TInt ret;

 	if(aRequestFinish)

 		ret=iSession->DoFlush(ipcArgs);

 	else

 		ret=iSession->DoSyncMsgBuf(ipcArgs);

 	iBuf.Zero();

 	iPreviousHandle=0;

 	return(ret);

 	}

 void RWsBuffer::FlushAllBuffers(TInt aBitmapHandle)

 	{

 	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)

 		{

 		if(!aBitmapHandle || buffer->iInvalidBitmapArray || (buffer->iBitmapArray.FindInOrder(aBitmapHandle)!=KErrNotFound))

 			buffer->Flush();

 		}

 	}

 inline void RWsBuffer::SetAndLimitMaxBufSize(TInt aMaxBufSize)

 	{ // apply upper & lower limits to input buffer size

 	if (aMaxBufSize < EMinBufferSize)

 		{

 		iMaxBufSize = EMinBufferSize;

 		}

 	else if	(aMaxBufSize > EMaxBufferSize)

 		{

 		iMaxBufSize = EMaxBufferSize;

 		}

 	else

 		{

 		iMaxBufSize = aMaxBufSize;

 		}

 	}

 void RWsBuffer::SetBufferSizeL(TInt aBufSize)

 	{

 	SetAndLimitMaxBufSize(aBufSize);

 	ReAllocBufferL(iMaxBufSize);

 	}

 void RWsBuffer::SetMaxBufferSizeL(TInt aMaxBufSize)

 	{

 	SetAndLimitMaxBufSize(aMaxBufSize);

 	if (iMaxBufSize < iBufSize)

 		{ // shrink to new maximum

 		ReAllocBufferL(iMaxBufSize);

 		}

 	else

 		{

 		 // initial allocation should be (at least) a quarter of the requested size

 		TInt minSize = Max( (iMaxBufSize + 3) >> 2, EMinBufferSize);

 		if (minSize > iBufSize)

 			{ // new or enlarged buffer

 			ReAllocBufferL(minSize);

 			}

 		}

 	__ASSERT_DEBUG((iBufSize >= EMinBufferSize) && (iBufSize <= iMaxBufSize), Assert(EW32AssertBufferLogic));

 	}

 // Flush() buffer, try to ReAlloc, Leave if the ReAlloc fails.

 void RWsBuffer::ReAllocBufferL(TInt aNewSize)

 	{

 	if (aNewSize != iBufSize)

 		{

 		Flush();

 		if (!ReAllocBuffer(aNewSize))

 			{

 			User::LeaveNoMemory();

 			}

 		}

 	}

 TBool RWsBuffer::ReAllocBuffer(TInt aNewSize)

 	{

 	TUint8* ptr = const_cast<TUint8*>(iBuf.Ptr());

 	__ASSERT_DEBUG((iBufSize == 0) || (ptr != NULL), Assert(EW32AssertBufferLogic));

 	const TInt len = iBuf.Length();

 	TUint8* newPtr = static_cast<TUint8*>(User::ReAlloc(ptr, aNewSize));

 	if (newPtr != NULL)

 		{ // realloc was successful

 		iBuf.Set(newPtr, len, aNewSize);

 		iBufSize = aNewSize;

 		return ETrue;

 		}

 	return EFalse;

 	}

 /* Expand the buffer, to allow new drawing command to fit.

  Called either when trying to store additional commands to queue for Wserv, or

  the trying to send a command bigger than the current buffer size.

  Failure to expand the buffer is a minor problem in the first case but a big 

  problem in the second.

  @param aRequiredSpace Size of buffer increase required.

  @param aMsgSize If expanding the buffer fails then needs this value to know whether Flush() is good enough.

  @return ETrue if there is enough space, EFalse if not.

  */

 void RWsBuffer::GrowBuffer(TInt aRequiredSpace, TInt aMsgSize)

 	{

 	__ASSERT_DEBUG(iBufSize < iMaxBufSize, Assert(EW32AssertBufferLogic));

 	// maximum size will be big enough?

 	__ASSERT_ALWAYS(aMsgSize <= iMaxBufSize, Panic(EW32PanicDataExceedsBufferLength));

 	 // double or quad the current size, then limit it

 	TInt newSize = Min((iBufSize >= aRequiredSpace) ? iBufSize << 1 : iBufSize << 2, iMaxBufSize);

 	if (!ReAllocBuffer(newSize))

 		{ // OOM error

 		Flush();

 		if (aMsgSize > iBufSize)

 			{ // message is too big for buffer

 			Panic(EW32PanicDataExceedsBufferLength);

 			}

 		}

 	}

 TBool RWsBuffer::SetAutoFlush(TBool aState)

 	{

 	TBool old;

 	old=iAutoFlush;

 #if defined(__AUTO_FLUSH)

 	if (aState)

 #else

 	iAutoFlush=aState;

 	if (iAutoFlush)

 #endif

 		Flush();

 	return(old);

 	}

 TInt RWsBuffer::DoWrite(TInt aHandle, TUint aOpcode, TBool aFlush, const TIpcArgs* aIpcArgs, const TAny* aData, TInt aLength, const TAny* aData2, TInt aLength2)

 	{

 	__ASSERT_DEBUG(((TUint32) aOpcode) < 0x8000, Assert(EW32AssertIllegalOpcode));

 	__ASSERT_DEBUG((aLength&0x3) == 0, Assert(EW32AssertOddLengthData));

 	TInt xtra(0);

 	if (aLength2>0)

 		xtra = PadValue(aLength2);		// Round data upto a multiple of 4

 	const TInt msgSize = aLength + aLength2 + xtra + static_cast<TInt>(sizeof(TWsCmdHeader));

 	TInt available = iBuf.MaxLength() - iBuf.Length();

 	if (msgSize > available)

 		{

 		if (iBufSize >= iMaxBufSize)

 			{ // buffer is maximum size already

 			Flush();

 			}

 		else

 			{ // try to grow buffer

 			 if ( (iBuf.Length() + msgSize) > iMaxBufSize)

 				{ // growing alone will not make enough extra space

 				Flush();

 				available = iBufSize;

 				}

 			const TInt requiredSpace = msgSize - available;

 			if (requiredSpace > 0)

 				{

 				GrowBuffer(requiredSpace, msgSize);

 				}

 			}

 		}

 	TWsCmdHeader cmdHeader;

 	cmdHeader.iBase.iOpcode = (TInt16)aOpcode;

 	cmdHeader.iBase.iCmdLength = (TInt16)(aLength + aLength2 + xtra);

 	// For performance reasons we only pass in the handle if it is different

 	// from the previous command

 	if (aHandle == iPreviousHandle)

 		{

 		iBuf.Append((TUint8 *)&cmdHeader.iBase,sizeof(cmdHeader.iBase));

 		}

 	else

 		{

 		iPreviousHandle = aHandle;

 		cmdHeader.iBase.iOpcode|=EWsOpcodeHandle;

 		cmdHeader.iDestHandle = aHandle;

 		iBuf.Append((TUint8 *)&cmdHeader,sizeof(cmdHeader));

 		}

 	if (aLength)

 		{

 		iBuf.Append((TUint8 *)aData, aLength);

 		}

 	if (aLength2>0 && aData2!=NULL)

 		{

 		iBuf.Append((TUint8 *)aData2, aLength2);

 		iBuf.AppendFill(0,xtra);

 		}

 #if defined(_DEBUG)

 	else if (aLength2>0 && aData2==NULL)

 		{

 		iAppendDataLength = aLength2;

 		}

 #endif

 	if (aFlush)

 		{

 		return Flush(aIpcArgs);

 		}

 	return KErrNone;

 	}

 void RWsBuffer::Write(TInt handle,TUint opcode)

 	{

 	DoWrite(handle, opcode, iAutoFlush, NULL);

 	}

 /**

 Writes data sent in aData of length aLength1 for the specifed aOpcode

 into wserv buffer. It also takes an TIpcArgs by which you can send additional 

 data. But one thing needs to be noted that if aIpcArgs has some content then 

 this function flushes the wserv buffer.

 @param aHandle aHandle of class derived from MWsClientClass

 @param aOpcode Opcode for the current command

 @param aData Data to be added to the buffer

 @param aLength Length of the data to be added to buffer

 @param aIpcArgs Additional data sent from client to server. It has default argument NULL.

 				And if some data is sent in aIpcArgs, it flushes wserv buffer

 */

 void RWsBuffer::Write(TInt aHandle, TUint aOpcode, const TAny *aData, TInt aLength, const TIpcArgs* aIpcArgs/*=NULL*/)

 	{

 	TBool flush = (aIpcArgs != NULL ? ETrue : iAutoFlush);	// If aIpcArgs contains data then we do explicit flush

 	DoWrite(aHandle, aOpcode, flush, aIpcArgs, aData, aLength);

 	}

 /**

 Writes data sent in aData and aData2 of lengths aLength1 and aLength2 

 for the specifed aOpcode into wserv buffer. It also takes an TIpcArgs by which 

 you can send additional data. But one thing needs to be noted that if aIpcArgs 

 has some content then this function flushes the wserv buffer.

 @param aHandle Handle of class derived from MWsClientClass

 @param aOpcode Opcode for the current command

 @param aData Data to be added to the buffer

 @param aLength Length of the data to be added to buffer

 @param aData2 second Data to be added to the buffer

 @param aLength2 Length of the second data to be added to buffer

 @param aIpcArgs Additional data sent from client to server. It has default argument NULL.

 				And if some data is sent in aIpcArgs, it flushes wserv buffer

 */

 void RWsBuffer::Write(TInt aHandle, TUint aOpcode, const TAny *aData, TInt aLength, const TAny *aData2, TInt aLength2, const TIpcArgs* aIpcArgs/*=NULL*/)

 	{

 	__ASSERT_DEBUG(!((aIpcArgs != NULL) &&  (aLength2 > 0 && aData2 == NULL)), Assert(EW32AssertBufferLogic));

 	TBool flush = iAutoFlush;

 	if (aLength2 > 0 && aData2 == NULL)

 		{

 		flush = EFalse;		// if just length2 is sent then we should not flush

 		}

 	else if (aIpcArgs != NULL)

 		{

 		flush = ETrue;		// If aIpcArgs contains data then we do explicit flush

 		}

 	DoWrite(aHandle, aOpcode, flush, aIpcArgs, aData, aLength, aData2, aLength2);

 	}

 /**

 Appends data directly to wserv buffer for the current command. So this function 

 should be used after adding the current command. 

 @param aData Data to be added to the buffer

 @param aLength Length of the data to be added to buffer. Make sure that its length

 		is less than availabe buffer.

 @param aFinished EFalse, adds data to buffer and disables flushing even if auto flush is on, 

 				 basically this notfies that more data is pending to be added.

 				 ETrue, adds data to buffer and resume normal service for flushing

 				 ie. Signals that this is the last bit of data to be added

 Note: When data is added using this API, it pads out buffer to multiple of 4 bytes  

 */

 void RWsBuffer::AppendData(const TAny *aData,TInt aLength,TBool aFinished)

 	{

 	__ASSERT_ALWAYS(iBuf.MaxLength()-iBuf.Length()>=PaddedValue(aLength),Assert(EW32AssertBufferLogic));

 #if defined(_DEBUG)

 	// Check if this function is called only after setting iAppendDataLength

 	__ASSERT_DEBUG(iAppendDataLength > 0, Assert(EW32AssertBufferLogic));

 	// Check if length passed in is less then iAppendDataLength

 	__ASSERT_DEBUG(iAppendDataLength >= aLength, Assert(EW32AssertBufferLogic));

 	if (aFinished)

 		iAppendDataLength = 0; 

 	else

 		iAppendDataLength -= aLength;

 #endif

 	iBuf.Append((TUint8*)(aData),aLength);

 	iBuf.AppendFill(0,PadValue(iBuf.Length()));		// Padout out buffer to multiple of 4 bytes

 	if (aFinished && iAutoFlush)

 		Flush(NULL);

 	}

 TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TIpcArgs* aIpcArgs)

 	{

 	return DoWrite(handle, opcode, ETrue, aIpcArgs);

 	}

 TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TAny *pData, TInt length,const TIpcArgs* aIpcArgs)

 	{

 	return DoWrite(handle, opcode, ETrue, aIpcArgs, pData, length);

 	}

 TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TAny *pData,TInt length,const TAny *pData2,TInt length2,const TIpcArgs* aIpcArgs)

 	{

 	return DoWrite(handle, opcode, ETrue, aIpcArgs, pData, length, pData2, length2);

 	}

 TInt RWsBuffer::WriteReplyP(TInt aHandle, TUint aOpcode, const TWriteDescriptorType& aReplyBuffer)

 	{

 	TIpcArgs ipcArgs;

 	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);

 	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs);

 	}

 TInt RWsBuffer::WriteReplyP(TInt aHandle,TUint aOpcode,const TAny *aData,TInt aLength,const TWriteDescriptorType& aReplyBuffer)

 	{

 	TIpcArgs ipcArgs;

 	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);

 	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData, aLength);

 	}

 TInt RWsBuffer::WriteReplyP(TInt aHandle,TUint aOpcode,const TAny *aData1,TInt aLengthData1,const TAny *aData2,TInt aLengthData2,const TWriteDescriptorType& aReplyBuffer)

 	{

 	TIpcArgs ipcArgs;

 	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);

 	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData1, aLengthData1, aData2, aLengthData2);

 	}

 TInt RWsBuffer::WriteReplyWs(TUint opcode)

 //

 // Do a WriteReply using the sessions handle

 //

 	{

 	return(iSession->WriteReply(opcode));

 	}

 TInt RWsBuffer::WriteReplyWs(const TAny *pData, TInt aLength, TUint aOpcode)

 //

 // Do a WriteReply using the sessions handle

 //

 	{

 	return(iSession->WriteReply(pData,aLength,aOpcode));

 	}

 TInt RWsBuffer::WriteReplyWs(const TAny *pData, TInt aLength, const TAny *pData2, TInt aLength2, TUint aOpcode)

 //

 // Do a WriteReply using the sessions handle

 //

 	{

 	return(iSession->WriteReply(pData,aLength,pData2,aLength2,aOpcode));

 	}

 TInt RWsBuffer::WriteReplyByProvidingRemoteReadAccess(TInt aHandle,TUint aOpcode,const TAny *aData, TInt aLength,const TReadDescriptorType& aRemoteReadBuffer)

 	{

 	TIpcArgs ipcArgs;

 	aRemoteReadBuffer.SetDescriptorOnIpcArgs(ipcArgs);

 	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData, aLength);

 	}

 void RWsBuffer::AddToBitmapArray(TInt aBitmapHandle)

 	{

 	if(aBitmapHandle && !iInvalidBitmapArray)

 		{

 		if(iBitmapArray.InsertInOrder(aBitmapHandle)==KErrNoMemory)

 			iInvalidBitmapArray=ETrue;

 		}

 	}

 void RWsBuffer::SetWsGraphicManager(CWsGraphic::CManager* aManager)

 	{

 	__ASSERT_DEBUG(!WsGraphicManager(),Panic(EW32PanicGraphicInternal));

 	iManager = aManager;

 	}

 CWsGraphic::CManager* RWsBuffer::WsGraphicManager()

 	{

 	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)

 		if (buffer->iManager)

 			return buffer->iManager;	

 	return NULL; // does not yet exist

 	}

 void RWsBuffer::AsyncRequest(TInt aHandle, TUint aOpcode, TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;

 	__ASSERT_DEBUG((aOpcode&EWservMessAsynchronousService)==0, Assert(EW32AssertIllegalOpcode));

 	Flush(); 

 	const TInt function = EWservMessAsynchronousService | aOpcode;

 	TIpcArgs ipcArgs(aHandle);

 	iSession->SendReceive(function, ipcArgs, aStatus);

 	}

 void RWsBuffer::EnableWindowSizeCacheL()

     {

     if (iWindowSizeCache == NULL)

         {

         iWindowSizeCache = new (ELeave) RHashMap<TInt, TWindowSizeCacheEntry>();        

         }

     }