// Copyright (c) 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:
// EGL sync implementation

#include "eglapi.h"

const EGLint CEglSync::KSupportedFlags = EGL_SYNC_FLUSH_COMMANDS_BIT_KHR;

// ToDo get rid of these macros
#define EGL_SET_ERROR(e)                    { Instance().SetError(e); }
#define TEST_AND_RET(c, r, t)               { if (!(c)) { EGL_TRACE(t); return (r); } }
#define TEST_CLEANUP_RET(c, r, clnp, t)     { if (!(c)) { clnp; EGL_TRACE(t); return (r); } }
#define CHECK_AND_RET(c, e, r, t)           { if (!(c)) { EGL_SET_ERROR(e); EGL_TRACE(t); return (r); } }
#define CHECK_CLEANUP_RET(c, e, r, clnp, t) { if (!(c)) { EGL_SET_ERROR(e); clnp; EGL_TRACE(t); return (r); } }
#define RESET_EGL_ERROR()                   { EGL_SET_ERROR(EGL_SUCCESS); }

// ToDo use EGL Panics & panic messages
void SyncPanic(TInt aPanic)
    {
    _LIT(KPanic, "EGL SYNC");
    User::Panic(KPanic, aPanic);
    }

CEglSync* CEglSync::Create(RFastLock& aFrontLock, EGLSyncKHR aSync, EGLDisplay aDisplay, EGLenum aType)
    {
    CEglSync* sync= new CEglSync(aFrontLock, aSync, aDisplay, aType);
    TEST_AND_RET(sync != NULL, sync, "CEglSync::Create couldn't create the object");
    if (KErrNone == sync->Initialize())
        {
        EGL_TRACE("CEglSync::Create OK aDisplay=%d aSync=%d aSyncType=0x%x", aDisplay, aSync, aType);
        return sync;
        }
    else
        {
        EGL_TRACE("CEglSync::Create FAILED aDisplay=%d aSync=%d aSyncType=0x%x", aDisplay, aSync, aType);
        delete sync;
        return NULL;
        }
    }

TInt CEglSync::Initialize()
    {
    TInt err = KErrNone;
    err = iSyncMutex.CreateLocal();
    TEST_AND_RET(err == KErrNone, err, "CEglSync::Initialize failed to create mutex");
    err = iSyncCondVar.CreateLocal();
    TEST_AND_RET(err == KErrNone, err, "CEglSync::Initialize failed to create cond var");
    return err;
    }


CEglSync::CEglSync(RFastLock& aFrontLock, EGLSyncKHR aSync, EGLDisplay aDisplay, EGLenum aType):
iEglSync(aSync),
iDisplay(aDisplay),
iSyncType(aType),
iSyncState(EGL_UNSIGNALED_KHR),
iDestroyed(EGL_FALSE),
iWaiters(0),
iFrontLock(aFrontLock)
    {

    }

CEglSync::~CEglSync()
    {
    iSyncMutex.Close();
    iSyncCondVar.Close();
    EGL_TRACE("CEglSync::~CEglSync iDisplay=%d iEglSync=%d", iDisplay, iEglSync);
    }

EGLBoolean CEglSync::DestroySyncReady()
    {
    EGL_TRACE("CEglSync::DestroySync iDisplay=%d iEglSync=%d iWaiters=%d", iDisplay, iEglSync, iWaiters);
    iSyncMutex.Wait();
    if (iWaiters == 0)
        {
        EGL_TRACE("CEglSync::DestroySync READY TO DESTROY iDisplay=%d iEglSync=%d iWaiters=%d", iDisplay, iEglSync, iWaiters);
        iDestroyed = EGL_TRUE;
        return EGL_TRUE;
        }
    else if (!iDestroyed)
        {
        EGL_TRACE("CEglSync::DestroySync BROADCAST iDisplay=%d iEglSync=%d iWaiters=%d", iDisplay, iEglSync, iWaiters);
        iSyncCondVar.Broadcast();
        }
    iDestroyed = EGL_TRUE;
    iSyncMutex.Signal();
    return EGL_FALSE;
    }


EGLint CEglSync::SignalSync(EGLenum aMode)
    {
    EGL_TRACE("CEglSync::SignalSync aMode=%d", aMode);

    iSyncMutex.Wait();
    if (aMode != iSyncState)
        {
        iSyncState = aMode;
        if (aMode == EGL_SIGNALED_KHR)
            {
            iSyncCondVar.Broadcast();
            }
        }

    iSyncMutex.Signal();
    return EGL_SUCCESS;
    }

EGLint CEglSync::ClientWaitSync(EGLint aFlags, EGLTimeKHR aTimeout)
    {
    EGL_TRACE("CEglSync::ClientWaitSync aFlags=%d aTimeout=%d", aFlags, aTimeout);

    CHECK_CLEANUP_RET(!(aFlags & (~KSupportedFlags)),
                  EGL_BAD_PARAMETER,
                  EGL_FALSE,
                  iFrontLock.Signal();,
                  "CEglSync::ClientWaitSync bad flags parameter");

    iSyncMutex.Wait();
    iFrontLock.Signal();

    CHECK_CLEANUP_RET(!iDestroyed ,
                      EGL_BAD_PARAMETER,
                      EGL_FALSE,
                      iSyncMutex.Signal();,
                      "CEglSync::ClientWaitSync sync already destroyed");

    EGLint ret = (EGLint) EGL_FALSE;
    if (iSyncState == EGL_UNSIGNALED_KHR)
        {
        if (aTimeout && (aFlags & EGL_SYNC_FLUSH_COMMANDS_BIT_KHR) && (eglGetCurrentContext() != EGL_NO_CONTEXT))
            {
            switch(eglQueryAPI())
                {
                case EGL_OPENGL_ES_API:
                    //ToDo: make sure these cases are covered
                    //glFlush();
                    break;
                case EGL_OPENVG_API:
                    //ToDo: make sure these cases are covered
                    //vgFlush();
                    break;
                default:
                	SyncPanic(__LINE__);
                }
            }

        switch (aTimeout)
            {
            case 0:
                ret = EGL_TIMEOUT_EXPIRED_KHR;
                break;

            case EGL_FOREVER_KHR:
                {
                EGLint res = KErrNone;
                ++iWaiters;
                EGL_TRACE("CEglSync::ClientWaitSync iSyncCondVar.Wait");
                res = iSyncCondVar.Wait(iSyncMutex);
                --iWaiters;
                if (res == KErrNone)
                    {
                    ret = EGL_CONDITION_SATISFIED_KHR;
                    }
                else
                    {
                    ret = EGL_FALSE;
                    }
                break;
                }

            default:
                {
                    /*
                     * Since the supported range of timeout at function RCondVar::TimedWait(mutex, timeout)
                     * is 0 to KMaxTInt, looping mechanism below is used to support 64bit timeout.
                     */
                    EGLint res = KErrTimedOut;
                    EGL_TRACE("CEglSync::ClientWaitSync iSyncCondVar.TimedWait");
                    for(TInt64 timeoutMicroseconds = aTimeout/1000; (res == KErrTimedOut) && (timeoutMicroseconds > 0); timeoutMicroseconds -= KMaxTInt)
                        {
                        ++iWaiters;
                        res = iSyncCondVar.TimedWait(iSyncMutex, (timeoutMicroseconds > KMaxTInt) ? KMaxTInt:timeoutMicroseconds);
                        --iWaiters;
                        }
                    switch (res)
                        {
                        case KErrNone:
                            ret = EGL_CONDITION_SATISFIED_KHR;
                            break;
                        case KErrTimedOut:
                            ret = EGL_TIMEOUT_EXPIRED_KHR;
                            break;
                        default:
                            ret = EGL_FALSE;
                            break;
                        }
                    break;
                }
            }
        }
    else
        {
            ret = EGL_CONDITION_SATISFIED_KHR;
            EGL_TRACE("CEglSync::ClientWaitSync sync in signalled state");
        }
    if (iDestroyed && (iWaiters == 0))
        {
        EGL_TRACE("CEglSync::ClientWaitSync sync autodestroyed");
        delete this;
        }
    else
        {
        EGL_TRACE("CEglSync::ClientWaitSync release sync mutex");
        iSyncMutex.Signal();
        }
    EGL_TRACE("CEglSync::ClientWaitSync sync exit ret=0x%x", ret);
    return ret;
    }

EGLBoolean CEglSync::GetSyncAttrib(EGLint aAttribute, EGLint *aValue)
    {
    EGL_TRACE("CEglSync::GetSyncAttrib aAttribute=0x%x aValue", aValue);

    CHECK_AND_RET(aValue,
                  EGL_BAD_PARAMETER,
                  EGL_FALSE,
                  "CEglSync::GetSyncAttrib undefined parameter aValue is NUL");

    CHECK_AND_RET((aAttribute == EGL_SYNC_TYPE_KHR) || (aAttribute == EGL_SYNC_STATUS_KHR),
                  EGL_BAD_ATTRIBUTE,
                  EGL_FALSE,
                  "CEglSync::GetSyncAttrib unnexpected attribute parameter");


    iSyncMutex.Wait();
    EGLBoolean ret = EGL_FALSE;
    switch(aAttribute)
        {
        case EGL_SYNC_TYPE_KHR:
            {
            *aValue = iSyncType;
            ret = EGL_TRUE;
            break;
            }
        case EGL_SYNC_STATUS_KHR:
            {
            *aValue = iSyncState;
            ret = EGL_TRUE;
            break;
            }
        default:
            {
            EGL_SET_ERROR(EGL_BAD_ATTRIBUTE);
            }
        }
    iSyncMutex.Signal();
    return ret;
    }


CEglSyncExtension* CEglSyncExtension::Create(CGuestEGL& aEglInstance)
    {
    EGL_TRACE("CEglSyncExtension::Create");
    CEglSyncExtension* eglSyncExt= new CEglSyncExtension(aEglInstance);
    if (eglSyncExt && eglSyncExt->Construct())
        {
        return eglSyncExt;
        }

    delete eglSyncExt;
    return NULL;
    }

EGLBoolean CEglSyncExtension::Construct()
    {
    if  (iEglSyncMapLock.CreateLocal() == KErrNone)
        {
        EGL_TRACE("CEglSyncExtension::Construct OK");
        return EGL_TRUE;
        }

    EGL_TRACE("CEglSyncExtension::Construct FAILED");
    return EGL_FALSE;
    }

CEglSyncExtension::CEglSyncExtension(CGuestEGL& aEglInstance):
iEglSyncMap(),
iEglSyncId(0),
iEglInstance(aEglInstance)
    {

    }

CEglSyncExtension::~CEglSyncExtension()
    {
    if (iEglSyncMapLock.Handle())
        {
        iEglSyncMapLock.Wait();
        }

    EglDestroySync(EGL_NO_DISPLAY);

    iEglSyncMap.Close();
    iEglSyncMapLock.Close();
    }

TInt CEglSyncExtension::EglSyncDisplayCreate(EGLDisplay aDisplay)
    {
        return KErrNone;
    }

void CEglSyncExtension::EglDestroySync(EGLDisplay aDisplay)
	{
	EGL_TRACE("CEglSyncExtension::EglDestroySync");
	REglSyncHashMap::TIter iter(iEglSyncMap);

	while (iter.NextKey())
		{
		CEglSync* const* syncpp = NULL;
		syncpp = iter.CurrentValue();
		if (syncpp && *syncpp && ((aDisplay == EGL_NO_DISPLAY) || (*syncpp)->Display() == aDisplay))
			{
			const EGLint* key = iter.CurrentKey();
			EGLPANIC_ASSERT(key, EEglPanicTemp);
			if (aDisplay != EGL_NO_DISPLAY)
				{
				// we expect that the map is to be closed after removing the elements
				// therefore we can skip to remove the syncs from map
				if (KErrNone != iEglSyncMap.Remove(*key))
					{
					SyncPanic(__LINE__);
					}
				}
			if ((*syncpp)->DestroySyncReady())
				{
				delete *syncpp;
				}
			}
		}
	}

void CEglSyncExtension::EglSyncDisplayDestroy(EGLDisplay aDisplay)
    {
    iEglSyncMapLock.Wait();
    EglDestroySync(aDisplay);
    iEglSyncMapLock.Signal();
    }

EGLSyncKHR CEglSyncExtension::EglCreateSyncKHR(EGLDisplay aDisplay, EGLenum aType, const EGLint* aAttribList)
    {
    EGL_TRACE("CEglSyncExtension::EglCreateSyncKHR aDisplay=%d, aType=%d", aDisplay, aType);
    RESET_EGL_ERROR();

    CHECK_AND_RET(aType == EGL_SYNC_REUSABLE_KHR,
                  EGL_BAD_ATTRIBUTE,
                  EGL_NO_SYNC_KHR,
                  "CEglSyncExtension::EglCreateSyncKHR unsupported sync type");

    CHECK_AND_RET((aAttribList == NULL) || (*aAttribList == EGL_NONE),
                  EGL_BAD_ATTRIBUTE,
                  EGL_NO_SYNC_KHR,
                  "CEglSyncExtension::EglCreateSyncKHR invalid attribute list");

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    CHECK_AND_RET(lockErr == EGL_SUCCESS,
                      lockErr,
                      EGL_NO_SYNC_KHR,
                      "CEglSyncExtension::EglCreateSyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();
    ReleaseDisplayLock(aDisplay);

    EGLSyncKHR dispRet = CreateSync(aDisplay, aType);

    iEglSyncMapLock.Signal();
    CVghwUtils::SwitchFromVghwHeap(callerHeap);
    EGL_TRACE("CEglSyncExtension::EglCreateSyncKHR EXIT aDisplay=%d, sync=%d", aDisplay, dispRet);
    return dispRet;
    }

EGLBoolean CEglSyncExtension::EglDestroySyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync)
    {
    EGL_TRACE("CEglSyncExtension::EglDestroySyncKHR aDisplay=%d, aSync=%d", aDisplay, aSync);

    RESET_EGL_ERROR();

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    CHECK_AND_RET(lockErr == EGL_SUCCESS,
                      lockErr,
                      EGL_FALSE,
                      "CEglSyncExtension::EglDestroySyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();
    ReleaseDisplayLock(aDisplay);

    CEglSync** sync = iEglSyncMap.Find((EGLint)aSync);
    CHECK_CLEANUP_RET(sync && (*sync) && ((*sync)->Display() == aDisplay),
                      EGL_BAD_PARAMETER,
                      EGL_FALSE,
                      iEglSyncMapLock.Signal(),
                      "CEglSyncDisplayMap::EglDestroySyncKHR cannot find the sync");

    if (KErrNone != iEglSyncMap.Remove((EGLint)aSync))
        {
		SyncPanic(__LINE__);
        }

    if ((*sync)->DestroySyncReady())
        {
        delete *sync;
        }

    iEglSyncMapLock.Signal();

    CVghwUtils::SwitchFromVghwHeap(callerHeap);
    EGL_TRACE("CEglSyncExtension::EglDestroySyncKHR EXIT aDisplay=%d, aSync=%d ret=%s", aDisplay, aSync, "EGL_TRUE");
    return EGL_TRUE;
    }

EGLBoolean CEglSyncExtension::EglSignalSyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode)
    {
    EGL_TRACE("CEglSyncExtension::EglSignalSyncKHR aDisplay=%d, aSync=%d aMode=%d", aDisplay, aSync, aMode);
    EGLBoolean ret = EGL_FALSE;

    RESET_EGL_ERROR();

    CHECK_AND_RET((aMode == EGL_SIGNALED_KHR) || (aMode == EGL_UNSIGNALED_KHR),
                   EGL_BAD_PARAMETER,
                   ret,
                   "CEglSyncExtension::EglSignalSyncKHR unsupported sync mode");

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    CHECK_AND_RET(lockErr == EGL_SUCCESS,
                      lockErr,
                      EGL_FALSE,
                      "CEglSyncExtension::EglSignalSyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();
    ReleaseDisplayLock(aDisplay);

    CEglSync** sync= iEglSyncMap.Find((EGLint)aSync);

    CHECK_CLEANUP_RET(sync && (*sync) && ((*sync)->Display()==aDisplay),
                      EGL_BAD_PARAMETER,
                      EGL_FALSE,
                      iEglSyncMapLock.Signal(); CVghwUtils::SwitchFromVghwHeap(callerHeap);,
                      "CEglSyncExtension::EglSignalSyncKHR cannot find the lock");

    TEST_CLEANUP_RET((*sync)->Display() == EGL_SYNC_REUSABLE_KHR,
                     EGL_BAD_MATCH,
                     iEglSyncMapLock.Signal(); CVghwUtils::SwitchFromVghwHeap(callerHeap);,
                     "CEglSyncExtension::EglSignalSyncKHR bad sync type");

    EGLint signalRet = (*sync)->SignalSync(aMode);

    if (signalRet != EGL_SUCCESS)
        {
        EGL_SET_ERROR(ret);
        EGL_TRACE("CEglSyncExtension::EglSignalSyncKHR failed (%d)", ret);
        ret = EGL_FALSE;
        }
    else
        {
        ret = EGL_TRUE;
        }

    iEglSyncMapLock.Signal();
    CVghwUtils::SwitchFromVghwHeap(callerHeap);
    EGL_TRACE("CEglSyncExtension::EglSignalSyncKHR EXIT aDisplay=%d, aSync=%d ret=%s", aDisplay, aSync, ret ? "EGL_TRUE":"EGL_FALSE");
    return ret;
    }

EGLint CEglSyncExtension::Egl_Private_SignalSyncNOK(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode)
    {
    EGL_TRACE("CEglSyncExtension::EglPrivateSignalSyncKHR aDisplay=%d, aSync=%d aMode=%d", aDisplay, aSync, aMode);

    TEST_AND_RET((aMode == EGL_SIGNALED_KHR) || (aMode == EGL_UNSIGNALED_KHR),
                 EGL_BAD_PARAMETER,
                 "CEglSyncExtension::EglPrivateSignalSyncKHR unsupported sync mode");

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    TEST_AND_RET(lockErr == EGL_SUCCESS,
                     lockErr,
                     "CEglSyncExtension::EglPrivateSignalSyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();
    ReleaseDisplayLock(aDisplay);

    CEglSync** sync= iEglSyncMap.Find((EGLint)aSync);

    TEST_CLEANUP_RET(sync && (*sync) && ((*sync)->Display()==aDisplay),
                     EGL_BAD_PARAMETER,
                     iEglSyncMapLock.Signal(); CVghwUtils::SwitchFromVghwHeap(callerHeap);,
                     "CEglSyncExtension::EglPrivateSignalSyncKHR cannot find the lock");

    EGLint ret = (*sync)->SignalSync(aMode);

    if (ret != EGL_SUCCESS)
        {
        EGL_TRACE("CEglSyncExtension::EglPrivateSignalSyncKHR failed (%d)", ret);
        }

    iEglSyncMapLock.Signal();
    CVghwUtils::SwitchFromVghwHeap(callerHeap);
    EGL_TRACE("CEglSyncExtension::EglPrivateSignalSyncKHR EXIT aDisplay=%d, aSync=%d ret=%d", aDisplay, aSync, ret);
    return ret;
    }

EGLint CEglSyncExtension::EglClientWaitSyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLint aFlags, EGLTimeKHR aTimeout)
    {
    EGL_TRACE("CEglSyncExtension::EglClientWaitSyncKHR aDisplay=%d, aSync=%d aFlags=0x%x, aTimeout=%ld", aDisplay, aSync, aFlags, aTimeout);

    RESET_EGL_ERROR();

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    CHECK_AND_RET(lockErr == EGL_SUCCESS,
                      lockErr,
                      EGL_FALSE,
                      "CEglSyncExtension::EglClientWaitSyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();
    ReleaseDisplayLock(aDisplay);

    CEglSync** sync= iEglSyncMap.Find((EGLint)aSync);

    CHECK_CLEANUP_RET(sync && (*sync) && ((*sync)->Display()==aDisplay),
                      EGL_BAD_PARAMETER,
                      EGL_FALSE,
                      iEglSyncMapLock.Signal(); CVghwUtils::SwitchFromVghwHeap(callerHeap);,
                      "CEglSyncExtension::EglClientWaitSyncKHR cannot find the sync");

    EGLint ret = (*sync)->ClientWaitSync(aFlags, aTimeout);

    CVghwUtils::SwitchFromVghwHeap(callerHeap);
    EGL_TRACE("CEglSyncExtension::EglClientWaitSyncKHR EXIT aDisplay=%d, aSync=%d ret=%d", aDisplay, aSync, ret);
    return ret;
    }

EGLBoolean CEglSyncExtension::EglGetSyncAttribKHR(EGLDisplay aDisplay,
                                                  EGLSyncKHR aSync,
                                                  EGLint aAttribute,
                                                  EGLint* aValue)
    {
    EGL_TRACE("CEglSyncExtension::EglGetSyncAttribKHR aDisplay=%d, aSync=%d aAttribute=0x%x, aValue=0x%x", aDisplay,
                                                                                                           aSync,
                                                                                                           aAttribute,
                                                                                                           aValue);
    RESET_EGL_ERROR();

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    CHECK_AND_RET(lockErr == EGL_SUCCESS,
                      lockErr,
                      EGL_FALSE,
                      "CEglSyncExtension::EglGetSyncAttribKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();
    ReleaseDisplayLock(aDisplay);

    CEglSync** sync= iEglSyncMap.Find((EGLint)aSync);

    CHECK_CLEANUP_RET(sync && (*sync) && ((*sync)->Display()==aDisplay),
                      EGL_BAD_PARAMETER,
                      EGL_FALSE,
                      iEglSyncMapLock.Signal(); CVghwUtils::SwitchFromVghwHeap(callerHeap);,
                      "CEglSyncExtension::EglGetSyncAttribKHR cannot find the lock");


    EGLint ret = (*sync)->GetSyncAttrib(aAttribute, aValue);

    iEglSyncMapLock.Signal();

    CVghwUtils::SwitchFromVghwHeap(callerHeap);

    EGL_TRACE("CEglSyncExtension::EglGetSyncAttribKHR EXIT aDisplay=%d, aSync=%d ret=%s", aDisplay, aSync, ret ? "EGL_TRUE":"EGL_FALSE");
    return ret;
    }

EGLint CEglSyncExtension::FindAndLockDisplay(EGLDisplay aDisplay)
    {
    return iEglInstance.FindAndLockDisplay(aDisplay);
    }

void CEglSyncExtension::ReleaseDisplayLock(EGLDisplay aDisplay)
    {
    iEglInstance.ReleaseDisplayLock(aDisplay);
    }

EGLSyncKHR CEglSyncExtension::CreateSync(EGLDisplay aDisplay, EGLenum aType)
    {
    CEglSync* sync = CEglSync::Create(iEglSyncMapLock,
                                      (EGLSyncKHR)(++iEglSyncId),
                                      aDisplay,
                                      aType);

    CHECK_AND_RET(sync != NULL,
                  EGL_BAD_ALLOC,
                  EGL_NO_SYNC_KHR,
                  "CEglSyncDisplayMap::CreateSync failed to create sync");

    TInt err = KErrNone;
    err = iEglSyncMap.Insert(iEglSyncId, sync);

    CHECK_CLEANUP_RET(err == KErrNone,
                      EGL_BAD_ALLOC,
                      EGL_NO_SYNC_KHR,
                      delete sync,
                      "CEglSyncDisplayMap::CreateSync insert failed");

    return (EGLSyncKHR)iEglSyncId;
    }

EGLSyncKHR CEglSyncExtension::eglCreateSyncKHR(EGLDisplay aDisplay, EGLenum aType, const EGLint* aAttribList)
    {
    CEglSyncExtension* eglSyncInstance = Instance().EGLSyncExtension();
    CHECK_AND_RET(eglSyncInstance,
                  EGL_NOT_INITIALIZED,
                  EGL_NO_SYNC_KHR,
                  "CEglSyncExtension::eglCreateSyncKHR extension instance not created");

    return eglSyncInstance->EglCreateSyncKHR(aDisplay, aType, aAttribList);
    }

EGLBoolean CEglSyncExtension::eglDestroySyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync)
    {
    CEglSyncExtension* eglSyncInstance = Instance().EGLSyncExtension();
    CHECK_AND_RET(eglSyncInstance,
                  EGL_NOT_INITIALIZED,
                  EGL_FALSE,
                 "CEglSyncExtension::eglDestroySyncKHR extension instance not created");

    return eglSyncInstance->EglDestroySyncKHR(aDisplay, aSync);
    }

EGLint CEglSyncExtension::eglClientWaitSyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLint aFlags, EGLTimeKHR aTimeout)
    {
    CEglSyncExtension* eglSyncInstance = Instance().EGLSyncExtension();
    CHECK_AND_RET(eglSyncInstance,
                  EGL_NOT_INITIALIZED,
                  EGL_FALSE,
                 "CEglSyncExtension::eglGetSyncAttribKHR extension instance not created");

    return eglSyncInstance->EglClientWaitSyncKHR(aDisplay, aSync, aFlags, aTimeout);
    }

EGLBoolean CEglSyncExtension::eglSignalSyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode)
    {
    CEglSyncExtension* eglSyncInstance = Instance().EGLSyncExtension();
    CHECK_AND_RET(eglSyncInstance,
                  EGL_NOT_INITIALIZED,
                  EGL_FALSE,
                 "CEglSyncExtension::eglSignalSyncKHR extension instance not created");

    return eglSyncInstance->EglSignalSyncKHR(aDisplay, aSync, aMode);
    }


EGLBoolean CEglSyncExtension::eglGetSyncAttribKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLint aAttribute, EGLint* aValue)
    {
    CEglSyncExtension* eglSyncInstance = Instance().EGLSyncExtension();
    CHECK_AND_RET(eglSyncInstance,
                  EGL_NOT_INITIALIZED,
                  EGL_FALSE,
                 "CEglSyncExtension::eglGetSyncAttribKHR extension instance not created");

    return eglSyncInstance->EglGetSyncAttribKHR(aDisplay, aSync, aAttribute, aValue);
    }

EGLint CEglSyncExtension::egl_Private_SignalSyncNOK(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode)
    {
    CEglSyncExtension* eglSyncInstance = Instance().EGLSyncExtension();
    CHECK_AND_RET(eglSyncInstance,
                  EGL_NOT_INITIALIZED,
                  EGL_NOT_INITIALIZED,
                  "CEglSyncExtension::egl_Private_SignalSyncNOK extension instance not created");

    return eglSyncInstance->Egl_Private_SignalSyncNOK(aDisplay, aSync, aMode);
    }