FCL/sf/os/graphics: comparison graphicscomposition/surfaceupdate/src/surfaceupdateserver.cpp

equal deleted inserted replaced

-:8b609b439da2
+:0fecfaa711d2
-// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 2006-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".
 #ifdef TEST_SURFACE_UPDATE
 #include "surfaceupdatetest.h"
 #endif
 const TUint KDefaultHeapSize=0x10000;
+void *gProvider = NULL;
+RFastLock gProviderFastLock;
 /**
 The server maintains session with the clients.
 It starts during the initialization of the Content update receiver thread.
 */
 */
 CUpdateReceiverNotificationBatch* CSurfaceUpdateSession::UpdateReceiverNotificationBatchL()
 	{
 	TInt numElement = iUpdateReceiverNotificationBatches.Count();
 	CUpdateReceiverNotificationBatch* notifier = NULL;
+	CSurfaceUpdateServer* server = (CSurfaceUpdateServer*) Server();
 	for(TInt index = 0; index < numElement; index++)
 		{
 		notifier = iUpdateReceiverNotificationBatches[index];
 		if(notifier->iType == EUpdateSrvReusable)
 			{
 			__ASSERT_ALWAYS(notifier->iMsg.IsNull(), CSurfaceUpdateServer::PanicServer(EUpdateServPanicDataIntegrity));
+notifier->SetNumUpdateReceivers(server->NumUpdateReceivers());
 			if(numElement > index + 1)
 				{
 			//to improve a search, append the element to the end of the array
 				iUpdateReceiverNotificationBatches.Remove(index);
 				iUpdateReceiverNotificationBatches.AppendL(notifier);
 				}
 			return notifier;
 			}
 		}
-	CSurfaceUpdateServer* server = (CSurfaceUpdateServer*) Server();
 	notifier = new (ELeave) CUpdateReceiverNotificationBatch(this, server->NumUpdateReceivers());
 	CleanupStack::PushL(notifier);
 	iUpdateReceiverNotificationBatches.AppendL(notifier);
 	CleanupStack::Pop();
 		(static_cast<CSurfaceUpdateServer*> (server))-> iNumberPendingNotification++;
 		}
 	}
 #endif
+/**
+Set number of UpdateReceivers - called when update receivers are added/removed.
+@param aNumUpdateReceivers - new number of update receivers for the batch.
+*/
+void CUpdateReceiverNotificationBatch::SetNumUpdateReceivers(TInt aNumUpdateReceivers)
+{
+__ASSERT_DEBUG(aNumUpdateReceivers >= 0 && aNumUpdateReceivers < 1000 /* arbitrary "large" limit */,
+CSurfaceUpdateServer::PanicServer(EUpdateServPanicDataIntegrity));
+__ASSERT_DEBUG(iType == EUpdateSrvReusable,
+CSurfaceUpdateServer::PanicServer(EUpdateServPanicDataIntegrity));
+iNumUpdateReceivers = aNumUpdateReceivers;
+}
 /**
 The class will be used by composition receiver
 */
 CSurfaceUpdateServerProvider* CSurfaceUpdateServerProvider::NewL(CActive::TPriority aPriority, CSurfaceUpdateServer* aServer)
 #ifdef TEST_SURFACE_UPDATE
 	RThread thread;
 	if(thread.Open(iThreadId) == KErrNone)
 		{
+	    TInt err = gProviderFastLock.CreateLocal();
+	    __ASSERT_ALWAYS(err == KErrNone || err == KErrAlreadyExists, CSurfaceUpdateServer::PanicServer(EUpdateServPanicGlobalFastLock));
+	    gProviderFastLock.Wait();
+	    gProvider = NULL;
 		if (iServer)
 			{
 			while((static_cast<CSurfaceUpdateServer*> (iServer))-> iNumberPendingNotification)
 				User::After(TTimeIntervalMicroSeconds32(1000));
 			}
 		TRequestStatus status1;
 		thread.Logon(status1);
 		User::WaitForRequest(status1);
 		thread.Close();
-		Dll::SetTls(NULL);
+	gProviderFastLock.Close();
 		}
 #endif
 	}
 /**
 		which will be set when the server is started. The variable will be used to registry
 		composition receiver instances. The caller doesn't acquire the ownership of this instance,
 		thus mustn't delete it. The pointer will be valid until server is operating,
 		i.e. system is up.
-@panic KErrAccessDenied	If is called from process other than WSERV.
 @return KErrNone if an operation is successful, any other system error codes otherwise
 */
 EXPORT_C TInt StartSurfaceUpdateServer(MSurfaceUpdateServerProvider*& aSurfaceUpdateServerProvider)
 	{
 #ifndef TEST_SURFACE_UPDATE
-	RProcess process;
-	TUidType uidType = process.Type();
-	const TInt32 KWservUid = 268450592;
-	const TUid& uid1 = uidType[2];
-	if(uid1.iUid != KWservUid) //only wserv process can start the server
-		{// some malicious client tries to launch the server
-		process.Panic(_L("Access denied"), KErrAccessDenied);
-		return KErrAccessDenied;
-		}
 	TPtrC serverName(KSurfaceUpdateServerName);
 #else
 	TPtrC serverName(KTestSurfaceUpdateServerName);
 #endif
-	TAny *provider = Dll::Tls();
+	//locking
+	TInt err = gProviderFastLock.CreateLocal();
+	if (err != KErrNone && err != KErrAlreadyExists)
+	    {
+return err;
+	    }
+	gProviderFastLock.Wait();
+	TAny *provider = gProvider;
 	if(provider)
 		{
 		aSurfaceUpdateServerProvider = static_cast <MSurfaceUpdateServerProvider*> (provider);
+		gProviderFastLock.Signal();
 		return KErrNone;
 		}
 	TFullName   name;
 	RThread serverThread;
 	TInt res = KErrAlreadyExists;
 		TBuf<32> buf;
 		tm.UniversalTime();
 		TRAP(res, tm.FormatL(buf, _L("_%H%T%S%C")));
 		if(res != KErrNone)
 			{
+			gProviderFastLock.Signal();
 			return res;
 			}
 		TBuf<128> threadName(serverName);
 		threadName.Append(buf); //guarantee uniqueness  of the thread name
 		  // Create the thread for the server.
 			serverThread.SetPriority(priority); // The same as the priority of the creating thread
 			serverThread.Rendezvous(rendezvousStatus);
 			serverThread.Resume();
 			User::WaitForRequest(rendezvousStatus);
 			res = rendezvousStatus.Int();
-			Dll::SetTls(aSurfaceUpdateServerProvider);
+			gProvider = aSurfaceUpdateServerProvider;
 			}
 // The thread has not been created - clearly there's been a problem.
 		else
 			{
 			serverThread.Close();
 			}
 		}
+gProviderFastLock.Signal();
 		return res;
 	}

branch	GCC_SURGE
changeset 125	0fecfaa711d2
parent 110	7f25ef56562d