// 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:

// Reference EGL implementation to support EGL sync objects and OpenWF extensions

#include "eglprivate.h"

CEglDisplay::CEglDisplay(RHeap& aHeap):

    iHandle(KEglDefaultDisplayHandle),

	iHeap(aHeap)

	{

	}

CEglDisplay::~CEglDisplay()

	{

	Terminate();

	if (iSyncObjList)

	    {

        __ASSERT_DEBUG(iSyncObjList->Count() == 0, User::Panic(KEglPanicCategory, EEglPanicOutstandingSyncObj));

        // we're about to free hash map and its underlying memory, make sure EGL shared heap is used

        RHeap* callerHeap = User::SwitchHeap(&iHeap);

        iSyncObjList->Close();

        delete iSyncObjList;

        User::SwitchHeap(callerHeap);

	    }

	}

TInt CEglDisplay::Initialize()

	{

	TInt err = KErrNone;

	if (iIsInitialized)

		{

		return err;

		}

	// hash map is only created once, check that when re-initialising display

	if (iSyncObjList)

	    {

	    iIsInitialized = ETrue;

	    }

	else

	    {

	    // make sure underlying hash implementation memory is allocated in share heap

	    //

        RHeap* callerHeap = User::SwitchHeap(&iHeap);

        iSyncObjList = new REglSyncHashMap;

        if (iSyncObjList)

            {

            iIsInitialized = ETrue;

            }

        else

            {

            err = KErrNoMemory;

            }

        User::SwitchHeap(callerHeap);        

	    }

	return err;

	}

void CEglDisplay::Terminate()

	{

	if (!iIsInitialized)

		{

		return;

		}

    REglSyncHashMap::TIter iter(*iSyncObjList);

    // iter begin at index -1, must move it once to get to first item

    while (iter.NextKey())

        {

        CEglSync** ppSyncObj = iter.CurrentValue();

        __ASSERT_DEBUG(ppSyncObj, User::Panic(KEglPanicCategory, EEglPanicInvalidSyncObj));

        // In a regular iteration, we should not modify the hash map itself while it is being iterated.

        // However, this is not a regular iteration, we need to remove destroyed object from

        // this hash map without using additional memory e.g. copying destroyed object key temporarily.

        // The reason we do not want to do that is because allocating memory can fail and Terminate

        // must not fail.

        CEglSync* syncObj = *ppSyncObj;

        // Destroy() will switch current heap to the EGL shared heap and restore it back.

        // It will also remove the sync object from hash map, but not necessarily delete it (because

        // some other threads may still use it)

        syncObj->Destroy();

        iter.Reset();

        }

	iIsInitialized = EFalse;

	}

CEglSync* CEglDisplay::FindSyncObj(EGLSyncKHR aObj) const

	{

	__ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));

	const TInt key = reinterpret_cast<TInt>(aObj);

	CEglSync** ppso = iSyncObjList->Find(key);

	CEglSync* syncObj = ppso ? *ppso : NULL;

	return syncObj;

	}

CEglSync* CEglDisplay::CreateSyncObj()

	{

    __ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));

    CEglSync* syncObj = CEglSync::Create(*this);

    return syncObj;

	}

TInt CEglDisplay::DestroySyncObj(EGLSyncKHR aSyncObj)

	{

    __ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));

    CEglSync* syncObj = reinterpret_cast<CEglSync*>(aSyncObj);

    const TInt key = reinterpret_cast<TInt>(syncObj);

    CEglSync** ppso = iSyncObjList->Find(key);

    if (!ppso)

        {

        return KErrNotFound;

        }

    // Destroy() will not delete sync obj or remove it from the list if it is still being used in other threads

    // if there is no more reference to this sync obj when Destroy() is called, it will delete the object and remove it from the list

    __ASSERT_DEBUG(syncObj == *ppso, User::Panic(KEglPanicCategory, EEglPanicInvalidSyncObj));

    syncObj->Destroy();

    return KErrNone;

	}

TInt CEglDisplay::RegisterSyncObj(CEglSync& aSyncObj)

    {

    __ASSERT_DEBUG(&iHeap == &User::Heap(), User::Panic(KEglPanicCategory, EEglPanicInvalidHeap));

    __ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));

    const TInt key = reinterpret_cast<TInt>(&aSyncObj);

    const TInt err = iSyncObjList->Insert(key, &aSyncObj);

    return err;

    }

void CEglDisplay::UnregisterSyncObj(CEglSync& aSyncObj)

    {

    __ASSERT_DEBUG(&iHeap == &User::Heap(), User::Panic(KEglPanicCategory, EEglPanicInvalidHeap));

    __ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));

    const TInt key = reinterpret_cast<TInt>(&aSyncObj);

    const TInt err = iSyncObjList->Remove(key);

    // the only possible error is KErrNotFound which should never happen in our case

    __ASSERT_DEBUG(err == KErrNone, User::Panic(KEglPanicCategory, EEglPanicInvalidSyncObj));

    }