diff -r 000000000000 -r bde4ae8d615e os/graphics/windowing/windowserver/nga/CLIENT/RBUFFER.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/graphics/windowing/windowserver/nga/CLIENT/RBUFFER.CPP	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,539 @@
+// 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>();        
+        }
+    }