// 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();
    }