--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicscomposition/openwfsupport/inc/owftestexithelper.inl	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,135 @@
+// Copyright (c) 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:
+// A copy of shutdown cleanup functions that should be called  
+// to properly support openWF.
+// These methods are implemented and called from Window Server - WServ, CWsTop
+// but this copy can be called by any low-level unit tests that bypass WServ   
+// but need to provide the same clean-up behaviour.
+// @test
+// @internalTechnology
+// 
+// Currently, three things are cleaned up:
+// 1) Singleton API mutex in OpenWF implementation
+// 2) Singleton Find/Acquire mutext in Native Stream implementation
+// 3) EGL thread status 
+//
+// Note that while these cleanups are only required by OWF-C implementations,
+// the methods called should be harmless if called 
+// when some other composition solution is in action.
+#include <e32property.h>
+#include <EGL/egl.h>
+
+// IDs of p&s properties that optionally contain onexit callbacks
+// that may be used to release singletons owned by libraries at shutdown in order to make 
+// the memory leak tests work.
+// By convention, the ID is the same as the UID3 of the libary.
+static TBool gReleaseSingletonsOnExit = EFalse;
+static const TUid KOpenWfcImplCleanupKey = {0x10286FC4};     
+static const TUid KOpenWfcInteropCleanupKey = {0x10286FC5};
+
+
+static void DefineOwfSingletonKey(const TUid& aSingletonKey)
+/**
+ * Defines a new property for a singleton key. WServ must only process 
+ * singleton keys that it created to prevent a malicious process with the 
+ * WriteDeviceData capability causing arbitrary functions to be executed.
+ * 
+ * @param   aSingeltonKey   The UID of the singleton key to define.
+ */
+    {
+    RThread t;      
+    TUid category = { t.SecureId().iId };
+    RProperty prop;
+    
+    // Write access is restricted to THIS process
+    TInt err = prop.Define( category, aSingletonKey.iUid, 
+            RProperty::EByteArray, TSecurityPolicy( t.SecureId() ), 
+            TSecurityPolicy( t.SecureId() ), sizeof( TCallBack ) );
+    
+    if ( err == KErrNone || err == KErrAlreadyExists)
+        {
+        TCallBack cb( NULL, NULL );
+        TPckgC<TCallBack> cbPckg( cb );
+        
+        // Any error should cause the properties to be ignored
+        err = prop.Set( category, aSingletonKey.iUid, cbPckg );    
+        }      
+    //We presume that if property already exists it was previously set by this test code.
+    if ( err != KErrNone )
+        {
+        // A problem occured / the property already existed so for safety
+        // the release code should be skipped.
+        gReleaseSingletonsOnExit = EFalse;
+        }
+    
+    prop.Close();
+    t.Close();
+    }
+#define DefineOwfSingletonKeys DefineOwfSingletonKeys
+/** Call this method before starting the compositor.    
+ * 
+ */
+static void DefineOwfSingletonKeys()
+    {
+    // Define properties for singleton callbacks. This must only be done ONCE
+    // to ensure the properties can't be hijacked.
+    gReleaseSingletonsOnExit = ETrue;
+    DefineOwfSingletonKey(KOpenWfcInteropCleanupKey);
+    DefineOwfSingletonKey(KOpenWfcImplCleanupKey);
+    }
+
+static void DeleteOwfSingleton( const TUid& aSingletonKey )
+/**
+ * Deletes a singleton object that was created on WServ's main heap.
+ * 
+ * @pre     The ws plugins have not been unloaded.
+ * @param   aSingletonKey   The UID of the singleton which correponds to an
+ *                          RProperty within WServ's category.                       
+ */
+    {   
+    if ( gReleaseSingletonsOnExit )
+        {
+        RThread t;
+        TPckgBuf<TCallBack> cb;
+        RProperty prop; 
+        TInt err = prop.Get(TUid::Uid(t.SecureId().iId), aSingletonKey.iUid, cb);
+        if (err == KErrNone && cb.Length() == sizeof(TCallBack) && 
+                cb().iFunction && cb().iPtr == &User::Heap())
+            {
+            // Callback is only invoked if the heap for the singleton was the 
+            // WServ heap because the WServ memory leak tests only check this
+            // heap.
+            cb().CallBack();
+            }
+        // Errors are ignored because the purpose of this function is to free
+        // singletons in order top make memory leak checks pass.
+        prop.Close();
+        t.Close();
+        }
+    }
+/** Call this method to destroy OWF-C singletons on shut down
+ * 
+ */
+#define DeleteOwfSingletons DeleteOwfSingletons
+static void DeleteOwfSingletons()
+    {
+    // Free singletons on WServ heap created by libraries. Must be called
+    // BEFORE iPluginManager is deleted otherwise the library code could have
+    // been unloaded.
+    DeleteOwfSingleton(KOpenWfcImplCleanupKey);
+    DeleteOwfSingleton(KOpenWfcInteropCleanupKey);
+    /* Release any use of EGL by this thread. */
+    eglReleaseThread();
+    }
+