--- a/egl/eglinterface/include/1.4/eglext.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/eglinterface/include/1.4/eglext.h	Wed Aug 18 11:05:09 2010 +0300
@@ -263,17 +263,17 @@
 EGLAPI EGLBoolean EGLAPIENTRY eglEndpointCancelNotificationNOK(EGLDisplay dpy, EGLEndpointNOK endpoint);
 #endif
 
-typedef EGLEndpointNOK ( *PFNEGLCREATEENDPOINTNOKPROC) (EGLDisplay dpy, EGLenum type, EGLenum source_type, EGLEndpointSourceNOK source, const EGLint* attrib_list);
-typedef EGLBoolean ( *PFNEGLDESTROYENDPOINTNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint);
-typedef EGLint ( *PFNEGLGETENDPOINTATTRIBNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint attrib);
-typedef EGLBoolean ( *PFNEGLSETENDPOINTATTRIBNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint attrib, EGLint value);
-typedef EGLBoolean ( *PFNEGLENDPOINTBEGINSTREAMINGNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint);
-typedef EGLBoolean ( *PFNEGLENDPOINTENDSTREAMINGNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint);
-typedef EGLImageKHR  ( *PFNEGLACQUIREIMAGENOKPROC)(EGLDisplay dpy, EGLEndpointNOK endpoint);
-typedef EGLBoolean ( *PFNEGLRELEASEIMAGENOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint, EGLImageKHR image, EGLenum api);
-typedef EGLint ( *PFNEGLGETENDPOINTDIRTYAREANOKPROC) (EGLDisplay dpy,  EGLEndpointNOK endpoint, EGLint* rects, EGLint start_rect, EGLint max_rects,  EGLBoolean collapse); 
-typedef EGLBoolean ( *PFNEGLENDPOINTREQUESTNOTIFICATIONNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint, EGLTRequestStatusNOK sync);
-typedef EGLBoolean ( *PFNEGLENDPOINTCANCELNOTIFICATIONNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint);
+typedef EGLEndpointNOK (EGLAPIENTRYP PFNEGLCREATEENDPOINTNOKPROC) (EGLDisplay dpy, EGLenum type, EGLenum source_type, EGLEndpointSourceNOK source, const EGLint* attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYENDPOINTNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint);
+typedef EGLint (EGLAPIENTRYP PFNEGLGETENDPOINTATTRIBNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint attrib);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETENDPOINTATTRIBNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint attrib, EGLint value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLENDPOINTBEGINSTREAMINGNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLENDPOINTENDSTREAMINGNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint);
+typedef EGLImageKHR  (EGLAPIENTRYP PFNEGLACQUIREIMAGENOKPROC)(EGLDisplay dpy, EGLEndpointNOK endpoint);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLRELEASEIMAGENOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint, EGLImageKHR image, EGLenum api);
+typedef EGLint (EGLAPIENTRYP PFNEGLGETENDPOINTDIRTYAREANOKPROC) (EGLDisplay dpy,  EGLEndpointNOK endpoint, EGLint* rects, EGLint start_rect, EGLint max_rects,  EGLBoolean collapse); 
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLENDPOINTREQUESTNOTIFICATIONNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint, EGLTRequestStatusNOK sync);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLENDPOINTCANCELNOTIFICATIONNOKPROC) (EGLDisplay dpy, EGLEndpointNOK endpoint);
 #endif
 
 #ifndef EGL_SYMBIAN_COMPOSITION

--- a/egl/egltest/bwins/egltestcommonu.def	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/bwins/egltestcommonu.def	Wed Aug 18 11:05:09 2010 +0300
@@ -84,7 +84,7 @@
 	?CheckExpectedError@CTestEglSession@@QAEHH@Z @ 83 NONAME ; int CTestEglSession::CheckExpectedError(int)
 	?GetVgFormat@CEglTestCommonIniSettings@@QAE?AW4VGImageFormat@@ABVTDesC16@@H@Z @ 84 NONAME ; enum VGImageFormat CEglTestCommonIniSettings::GetVgFormat(class TDesC16 const &, int)
 	?CleanupSurfaceFbsBitmapL@CTestEglSession@@QAEXXZ @ 85 NONAME ; void CTestEglSession::CleanupSurfaceFbsBitmapL(void)
-	?CreateWindowSurfaceAndMakeCurrentL@CTestEglSession@@QAEXHAAVRWindow@@HHH@Z @ 86 NONAME ; void CTestEglSession::CreateWindowSurfaceAndMakeCurrentL(int, class RWindow &, int, int, int)
+	?CreateWindowSurfaceAndMakeCurrentL@CTestEglSession@@QAEXHAAVRWindow@@HHHPAH@Z	 @ 86 NONAME ; void CTestEglSession::CreateWindowSurfaceAndMakeCurrentL(int, class RWindow &, int, int, int, int*)
 	?CloseSgDriver@CTestEglSession@@QAEXXZ @ 87 NONAME ; void CTestEglSession::CloseSgDriver(void)
 	?doTestStepPreambleL@CEglTestStep@@UAE?AW4TVerdict@@XZ @ 88 NONAME ; enum TVerdict CEglTestStep::doTestStepPreambleL(void)
 	??0CTestEglSession@@IAE@AAVCTestExecuteLogger@@AAHH@Z @ 89 NONAME ; CTestEglSession::CTestEglSession(class CTestExecuteLogger &, int &, int)
@@ -119,4 +119,3 @@
 	?GetThresholdGPUUsedMemory@CEglTestCommonIniSettings@@QAEHABVTDesC16@@@Z @ 118 NONAME ; int CEglTestCommonIniSettings::GetThresholdGPUUsedMemory(class TDesC16 const &)
 	?GetThresholdLastIteration@CEglTestCommonIniSettings@@QAEHABVTDesC16@@@Z @ 119 NONAME ; int CEglTestCommonIniSettings::GetThresholdLastIteration(class TDesC16 const &)
 	?GetWindowSize@CEglTestCommonIniSettings@@QAE?AVTSize@@ABVTDesC16@@@Z @ 120 NONAME ; class TSize CEglTestCommonIniSettings::GetWindowSize(class TDesC16 const &)
-

--- a/egl/egltest/eabi/egltestcommonu.def	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/eabi/egltestcommonu.def	Wed Aug 18 11:05:09 2010 +0300
@@ -82,7 +82,7 @@
 	_ZN15CTestEglSession31TryUsePixmapCFbsBitmapOpenGlesLEiRK5TSize12TDisplayModei @ 81 NONAME
 	_ZN15CTestEglSession34CreatePixmapSurfaceAndMakeCurrentLEiRK12TSgImageInfoNS_18TResourceCloseRuleEii @ 82 NONAME
 	_ZN15CTestEglSession34CreatePixmapSurfaceAndMakeCurrentLEiRK5TSize12TDisplayModeii @ 83 NONAME
-	_ZN15CTestEglSession34CreateWindowSurfaceAndMakeCurrentLEiR7RWindowiii @ 84 NONAME
+	_ZN15CTestEglSession34CreateWindowSurfaceAndMakeCurrentLEiR7RWindowiiiPi @ 84 NONAME
 	_ZN15CTestEglSession35CreatePbufferSurfaceAndMakeCurrentLEiRK5TSizeii @ 85 NONAME
 	_ZN15CTestEglSession42CreatePixmapSurfaceAndMakeCurrentAndMatchLERK12TSgImageInfoNS_18TResourceCloseRuleEii @ 86 NONAME
 	_ZN15CTestEglSession42CreatePixmapSurfaceAndMakeCurrentAndMatchLERK5TSize12TDisplayModeii @ 87 NONAME
@@ -138,4 +138,3 @@
 	_ZN25CEglTestCommonIniSettings13GetWindowSizeERK7TDesC16 @ 137 NONAME
 	_ZN25CEglTestCommonIniSettings25GetThresholdGPUUsedMemoryERK7TDesC16 @ 138 NONAME
 	_ZN25CEglTestCommonIniSettings25GetThresholdLastIterationERK7TDesC16 @ 139 NONAME
-

--- a/egl/egltest/endpointtestsuite/automated/group/eglendpointlifetimetesthelper.mmp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/group/eglendpointlifetimetesthelper.mmp	Wed Aug 18 11:05:09 2010 +0300
@@ -46,7 +46,8 @@
 LIBRARY					rfileloggerclient.lib
 LIBRARY                 euser.lib
 LIBRARY                 libEGL.lib
-library         		libOpenVG.lib
+LIBRARY         		libOpenVG.lib
+LIBRARY                 libOpenVGU.lib
 LIBRARY                 testexecuteutils.lib
 LIBRARY                 testexecutelogclient.lib
 LIBRARY                 ws32.lib

--- a/egl/egltest/endpointtestsuite/automated/group/eglendpointremotetest.mmp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/group/eglendpointremotetest.mmp	Wed Aug 18 11:05:09 2010 +0300
@@ -49,11 +49,14 @@
 SOURCEPATH			../tsrc
 SOURCE				egltest_endpointapiexposure_remote.cpp
 SOURCE				egltest_endpointtearing_remote.cpp
+SOURCE				egltest_threadedstress_remote.cpp
+SOURCE				egltest_releaseimagegles_remote.cpp
 
 // Utility code. 
 SOURCE				egltest_endpoint_images.cpp
 SOURCE				egltest_surface.cpp 
 SOURCE				egltest_endpoint_engine_remote.cpp
+SOURCE				egltest_threadmonitor.cpp
 
 LIBRARY				euser.lib
 LIBRARY				estor.lib
@@ -63,6 +66,7 @@
 library             fbscli.lib
 LIBRARY             gdi.lib
 library         	libOpenVG.lib
+LIBRARY             libOpenVGU.lib
 library 			surfacemanager.lib
 library             surfaceupdateclient.lib
 

--- a/egl/egltest/endpointtestsuite/automated/group/eglendpointtestserver.mmp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/group/eglendpointtestserver.mmp	Wed Aug 18 11:05:09 2010 +0300
@@ -1,4 +1,4 @@
-// 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"
@@ -56,6 +56,11 @@
 SOURCE					egltest_endpointstreamingtests_local.cpp
 SOURCE					egltest_endpointnotification.cpp
 SOURCE					egltest_endpointdirtyarea.cpp
+SOURCE 					egltest_endpoint_stress_engine.cpp 
+SOURCE					egltest_endpoint_stresstests.cpp
+SOURCE					egltest_endpoint_stressload.cpp
+SOURCE					egltest_threadedstress_local.cpp
+SOURCE					egltest_releaseimagegles_local.cpp
 
 SOURCEPATH				../scripts
 DOCUMENT				egltest_t_endpoint.script
@@ -63,7 +68,8 @@
 LIBRARY					rfileloggerclient.lib
 LIBRARY                 euser.lib
 LIBRARY                 libEGL.lib
-library         		libOpenVG.lib
+LIBRARY         		libOpenVG.lib
+LIBRARY                 libOpenVGU.lib
 LIBRARY                 testexecuteutils.lib
 LIBRARY                 testexecutelogclient.lib
 LIBRARY                 ws32.lib

--- a/egl/egltest/endpointtestsuite/automated/inc/eglendpointwrap.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/inc/eglendpointwrap.h	Wed Aug 18 11:05:09 2010 +0300
@@ -40,7 +40,7 @@
  * were resolved. Trying to use one of the endpoint functions in the event of a
  * construction error will result in a panic.
  */
-class TEglEndpointWrap : public CBase
+class TEglEndpointWrap
     {
 public:
     TEglEndpointWrap();

--- a/egl/egltest/endpointtestsuite/automated/inc/egltest_commscommon.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/inc/egltest_commscommon.h	Wed Aug 18 11:05:09 2010 +0300
@@ -70,6 +70,15 @@
 
     //Image Tearing Test.
     ETestUidEndpointTearing,
+    
+    //Multithreaded stress tests.
+    ETestUidEndpointThreadStress,
+    
+    //Release Image with Gles context tests.
+    ETestUidEndpointReleaseImageGles,
+    
+    // vgThreading test.
+    ETestUidVgThreading,
     };
 
 
@@ -91,6 +100,16 @@
     TSurfaceId iSurfaceId;
     };
 
+struct TTestEndpointThreadStress
+    {
+    TInt iNumThreads;
+    };
+
+struct TTestEndpointReleaseImageGles
+    {
+    TBool iUseValidGlesContext;
+    };
+
 
 //Union for all of the structs that tests use to pass
 //params between the local side and the remote side.
@@ -101,9 +120,18 @@
 
     //Endpoint engine data.
     TTestEndpointEngine iEndpointEngine;
+    
+    // Endpoint Engine configuration data.
+    TTestEndpointEngineConfig iEndpointEngineConfig;
 
     //Image Tearing Test.
     TTestEndpointTearing iEndpointTearing;
+    
+    //Multithreaded stress tests.
+    TTestEndpointThreadStress iEndpointThreadStress;
+    
+    //Release Image with Gles context tests.
+    TTestEndpointReleaseImageGles iEndpointReleaseImageGles;
     };
 
 

--- a/egl/egltest/endpointtestsuite/automated/inc/localtestbase.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/inc/localtestbase.h	Wed Aug 18 11:05:09 2010 +0300
@@ -31,7 +31,7 @@
 
 
 // Entry point
-GLDEF_C TInt E32Main(void);
+GLDEF_C TInt E32Main();
 
 /**
 CEglEndpointTestServer	Server encapsulates the functionality required to execute Test Execute based test cases for the EGL endpoint extension.

--- a/egl/egltest/endpointtestsuite/automated/inc/remotetestbase.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/inc/remotetestbase.h	Wed Aug 18 11:05:09 2010 +0300
@@ -155,6 +155,8 @@
     virtual TRemoteTestVerdict DoRunRemoteTestCaseL(TInt aTestCase, const TRemoteTestParams& aMessageIn) = 0;
     virtual TRemoteTestVerdict DoEndRemoteTestStepL(const TRemoteTestParams& aMessageIn);
 
+    virtual TInt Timeout() const;
+    
     void Log(const TText8* aFile, TInt aLine, TInt aSeverity, TRefByValue<const TDesC> aFmt, ...);
     const TEglEndpointWrap& EglEndpoint() const;
 

--- a/egl/egltest/endpointtestsuite/automated/rom/egltestendpointauto.iby	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/rom/egltestendpointauto.iby	Wed Aug 18 11:05:09 2010 +0300
@@ -26,8 +26,8 @@
 ECOM_PLUGIN(eglendpointremotetest.dll,eglendpointremotetest.rsc)
 #endif
 
-file=ABI_DIR\DEBUG_DIR\eglendpointtestserver.exe                        sys\bin\eglendpointtestserver.exe
-file=ABI_DIR\DEBUG_DIR\eglendpointlifetimetesthelper.exe                sys\bin\eglendpointlifetimetesthelper.exe
+file=ABI_DIR\BUILD_DIR\eglendpointtestserver.exe                        sys\bin\eglendpointtestserver.exe
+file=ABI_DIR\BUILD_DIR\eglendpointlifetimetesthelper.exe                sys\bin\eglendpointlifetimetesthelper.exe
 // tef scripts
 data=DATAZ_\egltest\egltest_t_endpoint.script                    \egltest\egltest_t_endpoint.script
 data=DATAZ_\resource\apps\egltest_endpoint\image1.mbm 			 \resource\apps\egltest_endpoint\image1.mbm

--- a/egl/egltest/endpointtestsuite/automated/scripts/egltest_t_endpoint.script	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/scripts/egltest_t_endpoint.script	Wed Aug 18 11:05:09 2010 +0300
@@ -16,14 +16,10 @@
 PRINT Run EGL endpoint tests.
 LOAD_SUITE eglendpointtestserver
 
-//The remote side of the framework is hard coded to timeout after 10 seconds,
-//So any remote portion of a test that lasts longer than 10 seconds will
-//cause the whole test to timeout. This can be changed in remotetestbase.cpp.
-//The timeouts passed to TEF below MUST always be bigger than that used for
-//the remote side (currently 10 seconds).
+//Note: Tests should be sorted by "increasing dependency", so that the 
+//most basic functionality tests are done first.
 
-// Note: Tests should be sorted by "increasing dependency", so that the 
-// most basic functionality tests are done first. 
+//Functional Tests.
 RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointApiExposure
 RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointCreate
 RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointStreaming
@@ -37,3 +33,10 @@
 RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointStreamingTests
 RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointStreamingDispXTimesInStream
 RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointDirtyArea
+RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointReleaseImageGles
+
+//Stress Tests.
+RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointCrazyThreading
+// RUN_TEST_STEP 300 eglendpointtestserver EGL_EndpointOutOfHeapMemory
+RUN_TEST_STEP 1200 eglendpointtestserver EGL_EndpointStressLoad
+RUN_TEST_STEP 1200 eglendpointtestserver EGL_EndpointStressTests

--- a/egl/egltest/endpointtestsuite/automated/src/eglendpointwrap.cpp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/src/eglendpointwrap.cpp	Wed Aug 18 11:05:09 2010 +0300
@@ -24,7 +24,6 @@
 #include "egltest_commscommon.h"
 
 
-
 /*
  * TEglEndpointWrap is a simple class that presents all of the EGL endpoint
  * extension functions without the user needing to perform an eglGetProcAddress()
@@ -74,7 +73,8 @@
     }
 
 
-EGLEndpointNOK TEglEndpointWrap::CreateEndpoint(EGLDisplay dpy, EGLenum type, EGLenum source_type, EGLEndpointSourceNOK source, const EGLint *attrib_list) const
+EGLEndpointNOK TEglEndpointWrap::CreateEndpoint(EGLDisplay dpy, EGLenum type, EGLenum source_type, 
+                                                EGLEndpointSourceNOK source, const EGLint *attrib_list) const
     {
     ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());
     return ipfnEglCreateEndpointNOK(dpy, type, source_type, source, attrib_list);
@@ -130,7 +130,8 @@
     }
 
 
-EGLint TEglEndpointWrap::GetEndpointDirtyArea(EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint* rects, EGLint start_rect, EGLint max_rects, EGLBoolean collapse) const
+EGLint TEglEndpointWrap::GetEndpointDirtyArea(EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint* rects, 
+                                              EGLint start_rect, EGLint max_rects, EGLBoolean collapse) const
     {
     ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());
     return ipfnEglGetEndpointDirtyAreaNOK(dpy, endpoint, rects, start_rect, max_rects, collapse);

--- a/egl/egltest/endpointtestsuite/automated/src/egltest_localteststepfactory.cpp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/src/egltest_localteststepfactory.cpp	Wed Aug 18 11:05:09 2010 +0300
@@ -30,6 +30,10 @@
 #include "egltest_endpointstreamingtests.h"
 #include "egltest_endpointnotification.h"
 #include "egltest_endpointdirtyarea.h"
+#include "egltest_endpoint_stresstests.h"
+#include "egltest_endpoint_stressload.h"
+#include "egltest_threadedstress.h"
+#include "egltest_releaseimagegles.h"
 
 //LocalTestStep factory.
 CTestStep* CEglEndpointTestServer::CreateTestStep(const TDesC& aStepName)
@@ -86,7 +90,27 @@
         {
         return new CEglTest_LocalTestStep_EndpointDirtyArea;
         }
-
+    if (aStepName == KEGL_EndpointStressTests)
+        {
+        return CEglTest_TestStep_StressTests::New();
+        }
+    if (aStepName == KEGL_EndpointStressLoad)
+        {
+        return CEglTest_TestStep_StressLoad::New();
+        }
+    if (aStepName == KEGL_EndpointCrazyThreading)
+        {
+        return new CEglTest_LocalTestStep_EndpointCrazyThreading();
+        }
+    if (aStepName == KEGL_EndpointOutOfHeapMemory)
+        {
+        return new CEglTest_LocalTestStep_EndpointOutOfHeapMemory();
+        }
+    if (aStepName == KEGL_EndpointReleaseImageGles)
+        {
+        return new CEglTest_LocalTestStep_EndpointReleaseImageGles();
+        }
+    
     return NULL;
     }
 

--- a/egl/egltest/endpointtestsuite/automated/src/egltest_remoteteststepfactory.cpp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/src/egltest_remoteteststepfactory.cpp	Wed Aug 18 11:05:09 2010 +0300
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 2009-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"
@@ -22,6 +22,8 @@
 #include "egltest_endpointapiexposure.h"
 #include "egltest_endpoint_engine.h"
 #include "egltest_endpointtearing.h"
+#include "egltest_threadedstress.h"
+#include "egltest_releaseimagegles.h"
 
 
 //RemoteTestStep Factory.
@@ -29,10 +31,12 @@
     {
     switch (aTestUid)
         {
-        case ETestUidEndpointApiExposure:   return new (ELeave) CEglTest_RemoteTestStep_EndpointApiExposure();
-        case ETestUidEndpointEngine:        return new (ELeave) CEgltest_Remote_Engine();
-        case ETestUidEndpointTearing:       return new (ELeave) CEglTest_RemoteTestStep_EndpointTearing();
-        default:                            User::Leave(KErrUnknown);
+        case ETestUidEndpointApiExposure:       return new (ELeave) CEglTest_RemoteTestStep_EndpointApiExposure();
+        case ETestUidEndpointEngine:            return new (ELeave) CEgltest_Remote_Engine();
+        case ETestUidEndpointTearing:           return new (ELeave) CEglTest_RemoteTestStep_EndpointTearing();
+        case ETestUidEndpointThreadStress:      return new (ELeave) CEglTest_RemoteTestStep_EndpointThreadStress();
+        case ETestUidEndpointReleaseImageGles:  return new (ELeave) CEglTest_RemoteTestStep_EndpointReleaseImageGles();
+        default:                                User::Leave(KErrUnknown);
         }
 
     //Stop the warning.

--- a/egl/egltest/endpointtestsuite/automated/src/localtestbase.cpp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/src/localtestbase.cpp	Wed Aug 18 11:05:09 2010 +0300
@@ -71,6 +71,7 @@
     
     DoPostambleL();
     delete iResultLog;
+    iResultLog = NULL;
     iResultOutQueue.Close();
     iParamsInQueue.Close();
     return EPass;
@@ -405,7 +406,8 @@
 
 void CTestIdResultLogger::LogResult(TVerdict aVerdict)
     {
-    TBuf<20> verdict;
+    const TInt KMaxVerdictLength = 20;
+    TBuf<KMaxVerdictLength> verdict;
     switch(aVerdict)
         {
         case EPass:           verdict.Append(_L("PASS"));            break;
@@ -432,24 +434,21 @@
 
 TInt CTestIdResultLogger::PanicMonitorMain(TAny* aSelf)
     {
+    CTestIdResultLogger* self = static_cast<CTestIdResultLogger*>(aSelf);
+    
+    //Create cleanup stack.
     CTrapCleanup* cleanup = CTrapCleanup::New();
-
-    TRAPD(err,
-        //Create active scheduler.
-        CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
-        CleanupStack::PushL(scheduler);
-        CActiveScheduler::Install(scheduler);
-
-        //Run MainL.
-        CTestIdResultLogger* self = static_cast<CTestIdResultLogger*>(aSelf);
-        self->PanicMonitorMainL();
-
-        //Clean up.
-        CleanupStack::PopAndDestroy(scheduler);
-        );
+    ASSERT(cleanup);
     
+    //Create active scheduler.
+    CActiveScheduler* scheduler = new CActiveScheduler();
+    ASSERT(scheduler);
+    CActiveScheduler::Install(scheduler);
+    
+    TRAPD(err,  self->PanicMonitorMainL());
     __ASSERT_ALWAYS(err == KErrNone, User::Invariant());
-
+    
+    delete scheduler;
     delete cleanup;
     return KErrNone;
     }
@@ -541,7 +540,7 @@
 	{
 	__UHEAP_MARK;
 	CTrapCleanup* cleanup = CTrapCleanup::New();
-	if(cleanup == NULL)
+	if(!cleanup)
 		{
 		return KErrNoMemory;
 		}

--- a/egl/egltest/endpointtestsuite/automated/src/remotetestbase.cpp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/src/remotetestbase.cpp	Wed Aug 18 11:05:09 2010 +0300
@@ -34,9 +34,11 @@
 #include <e32math.h>
 
 
-// Timout for remote test steps. This MUST be smaller
+// Default timout for remote test steps. This MUST be smaller
 // than any timeout passed to TEF for the local test step
-// in the script file.
+// in the script file. Remote test steps can override this 
+// value by implementing the Timeout() function in their 
+// derrived class.
 const TInt KRemoteTestStepTimeout = 10 * 1000000;
 
 
@@ -68,6 +70,7 @@
 
 CTimeoutTimer::~CTimeoutTimer()
     {
+    Cancel();
     }
 
 
@@ -315,7 +318,7 @@
         }
 
     //Activate the TimoutTimer, TestCaseListener and WorkerListener.
-    iTimeoutTimer->After(KRemoteTestStepTimeout);
+    iTimeoutTimer->After(iCurTestStep->Timeout());
     iTestCaseListener->Listen();
     iWorkerListener->Listen(iCurWorker);
 
@@ -464,7 +467,7 @@
 void CRemoteTestEnv::DoEglHeapMark()
     {
 #if USE_EGLHEAP_CHECKING
-    typedef void (*TEglDebugHeapMarkStartPtr)(void);
+    typedef void (*TEglDebugHeapMarkStartPtr)();
 
     TEglDebugHeapMarkStartPtr  heapMarkStart = reinterpret_cast<TEglDebugHeapMarkStartPtr>(eglGetProcAddress("egliDebugHeapMarkStart"));
     if (heapMarkStart)
@@ -562,23 +565,21 @@
 TInt CRemoteTestEnv::TestThreadEntryPoint(TAny* aSelf)
     {
     CRemoteTestEnv* self = static_cast<CRemoteTestEnv*>(aSelf);
+    
+    //Create cleanup stack.
     CTrapCleanup* cleanup = CTrapCleanup::New();
-
-    TRAPD(err,
-        //Create active scheduler.
-        CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
-        CleanupStack::PushL(scheduler);
-        CActiveScheduler::Install(scheduler);
-
-        //Run the current test step.
-        self->RunCurrentTestStepL();
-
-        //Clean up.
-        CleanupStack::PopAndDestroy(scheduler);
-        );
-
+    ASSERT(cleanup);
+    
+    //Create active scheduler.
+    CActiveScheduler* scheduler = new CActiveScheduler();
+    ASSERT(scheduler);
+    CActiveScheduler::Install(scheduler);
+    
+    TRAPD(err, self->RunCurrentTestStepL());
     __ASSERT_ALWAYS(err == KErrNone, User::Invariant());
 
+    //Clean up.
+    delete scheduler;
     delete cleanup;
     return KErrNone;
     }
@@ -637,6 +638,12 @@
     }
 
 
+TInt CRemoteTestStepBase::Timeout() const
+    {
+    return KRemoteTestStepTimeout;
+    }
+
+
 class TOverflowTruncate : public TDesOverflow
     {
 public:

--- a/egl/egltest/endpointtestsuite/automated/src/renderstage.cpp	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/src/renderstage.cpp	Wed Aug 18 11:05:09 2010 +0300
@@ -93,31 +93,25 @@
 TInt CRenderStage::TestEnvThreadEntryPoint(TAny* /*aSelf*/)
     {
     RDebug::Printf("CRenderStage: Entering Test Environment Thread...");
-
+    
+    //Create cleanup stack.
     CTrapCleanup* cleanup = CTrapCleanup::New();
-
-    TRAPD(err,
-        //Create active scheduler.
-        CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
-        CleanupStack::PushL(scheduler);
-        CActiveScheduler::Install(scheduler);
+    ASSERT(cleanup);
+    
+    //Create active scheduler.
+    CActiveScheduler* scheduler = new CActiveScheduler();
+    ASSERT(scheduler);
+    CActiveScheduler::Install(scheduler);
+    
+    //Create a CRemoteTestEnv.
+    CRemoteTestEnv* testEnv = NULL;
+    TRAPD(err, testEnv = CRemoteTestEnv::NewL());
+    __ASSERT_ALWAYS(err == KErrNone, User::Invariant());
+    testEnv->StartReceivingCmds();
 
-        //Create a CRemoteTestEnv.
-        CRemoteTestEnv* testEnv = CRemoteTestEnv::NewL();
-        CleanupStack::PushL(testEnv);
-        testEnv->StartReceivingCmds();
-
-        //Clean up.
-        CleanupStack::PopAndDestroy(2, scheduler);
-        );
-
-    if(err != KErrNone)
-        {
-        User::Invariant();
-        }
-
+    //Clean up.
+    delete scheduler;
     delete cleanup;
-
     RDebug::Printf("CRenderStage: Leaving Test Environment Thread...");
     return KErrNone;
     }

--- a/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_engine.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_engine.h	Wed Aug 18 11:05:09 2010 +0300
@@ -29,23 +29,20 @@
 #include "egltest_endpoint_engine_types.h"
 #include "egltest_endpoint_images.h"
 
-
-#define ENGINE_ASSERT(x) DoEngineAssert(x, #x, __FILE__, __LINE__)
+#define ENGINE_ASSERT(x) DoEngineAssert((x) != 0, #x, __FILE__, __LINE__)
 
 static inline void DoEngineAssert(TInt aX, const char *aXStr, 
         const char *aFile, TInt aLine)
     {
     if (!aX)
         {
-        RDebug::Printf("ENGINE_ASSERT(%s) failed (value %d) at %s:%d\n",
+        RDebug::Printf("EGL_ENDPOINT_TEST_ENGINE ASSERT(%s) failed (value %d) at %s:%d\n",
                 aXStr, aX, aFile, aLine);
         User::Panic(_L("ENGINE_ASSERT"), aLine);
         }
     }
 
 
-
-
 // This could be wrapped in #if/#else to allow us to generate non-unicode text content.
 #define TESTIDS(x)  _S(x)
 #define CASETITLE(x)  _S(x)
@@ -85,10 +82,12 @@
     TVerdict             iBufferCountVerdict;
     // Get Surface parameter reply.
     TSurfaceParamsRemote iSurfaceParams;
-    // To check that we are in sync - it should match the request!
+    // To check that we are in sync - it should match the request.
     TEngineCases         iCase;
     };
 
+const TInt KMaxLoadThreads = 4;
+
 NONSHARABLE_CLASS(CEgltest_Local_Engine): public CLocalTestStepBase
     {
 private:
@@ -104,31 +103,41 @@
     virtual TVerdict doTestStepL();
     virtual void DoPreambleL();
     virtual void DoPostambleL();
+    void SetTestCasesL(const TTestCases * const aTestCases, TInt aNumCases);
     
 private:
-    void RunTestCaseL(const TTestCases &aTestCase);
-    void LogDump(const TEngineTestCase &aItem);
-    void RunOneTestCaseL(const TTestCase& aTestCase, TSurfaceType aSurfType);
-    void RunSingleCaseL(const TTestCase& aTestCase, TSurfaceType aSurfType);
+    void RunTestCase(const TTestCases &aTestCase);
+    void RunOneTestCase(const TTestCase& aTestCase, TSurfaceType aSurfType);
     void SendLocalTestCase(const TRemoteTestParams &aParams);
-    TVerdict RunRemoteTestCase(TInt aTestCase, const TRemoteTestParams& aMessageIn);
-    void RunLocalTestCase(const TRemoteTestParams& aMessageIn, TExecResult& aResult);
     void RunLocalTestCase(TEngineCases aCase);
     void DoSyncToLocal();
     void GetLocalResult(TExecResult& aResult, TEngineCases aCase);
     void DoMonitorThreadEntry();
     void ForwardPanic(RThread& aThread, RThread& aOtherThread, TRequestStatus &aStatus);
     static TInt MonitorThreadEntry(TAny *aParam);
+    void RunControllerLocalAndRemoteL(const TEngineTestCase&, const TRemoteTestParams& params);
+    
+protected:
+    void RunLocalTestCase(const TRemoteTestParams& aMessageIn, TExecResult& aResult);
+    TVerdict RunRemoteTestCase(TInt aTestCase, const TRemoteTestParams& aMessageIn);
+    void RunSingleCaseL(const TTestCase& aTestCase, TSurfaceType aSurfType);
+    void CommonPreambleL();
+    CEgltest_Local_Engine();
+    // The StartThread and EndThread needs to be overridden in the 
+    // implementation to provide a good functionality. 
+    virtual void StartThreadL(TInt aThreadNumber);
+    virtual void EndThread(TInt aThreadNumber);
     
 protected:
     const TTestCases*                  iTestCases;
-    const TInt                         iNumCases;
+    TInt                               iNumCases;
     RThread                            iExecThread;
     RThread                            iMonitorThread;
     RThread                            iControllerThread;  // Controller thread
     RMsgQueue<TExecResult>             iExecResultOutQueue;
     RMsgQueue<TRemoteTestParamsPacket> iExecParamsInQueue;
     TExecState                         iExecState;
+    TBool                              iLogging;
     };
 
 
@@ -139,6 +148,13 @@
     EGLImageKHR    iImage;
     };
 
+
+struct TAvailableMemory
+    {
+    TInt iHeapMemAvailable;
+    TInt iGpuMemAvailable;
+    };
+
 // Base class that allows "script" style exectution of testcases.
 NONSHARABLE_CLASS(CEgltest_Remote_Engine): public CRemoteTestStepBase
     {
@@ -166,6 +182,23 @@
     void GetEndpointDirtyAreaL(const TRemoteTestParams& aParams, const TRemoteTestArgs& aArgs);
     void DoCheckRectsL(EGLint *aActualRects, EGLint aRectCount, EGLint aMaxRects,
                        TInt aRectsIndex, const TRect aSurfacRect);
+    void CheckForMemoryLeaks();
+    void CheckForMemoryLeaksFinish();
+    
+    TInt FillGpuMemory();
+    TInt CalculateAvailableGPUMemory();
+    TInt CalculateAvailableHeapMemory();
+    
+    // Thread entry points for "load" threads.
+    static TInt LoadHeapMemory(TAny *);
+    void LoadHeapMemoryL();
+    static TInt LoadGpuMemory(TAny *);
+    void LoadGpuMemoryL();
+
+    void StartThreadL(TInt aThreadNumber);
+    void EndThread(TInt aThreadNumber);
+    TThreadFunction GetThreadFunction(TInt aThreadNumber);
+
 private:
     EGLEndpointNOK iEndpoints[KMaxEndpoints];
     EGLImageKHR iEglImage[KMaxEndpoints];
@@ -174,6 +207,22 @@
     TRemoteTestVerdict iTestVerdict;
     TBool iLogging;
     CEglWindowSurface *iSurface;
+    // when this flag is set, errors discovered during a test-step is logged.
+    // This is normally true, but for stress tests [etc], it can be turned
+    // off so that when a test is set up to run 1000 times, but only succeeds
+    // X times, we don't get "error, something failed", when we really didn't
+    // get an error.
+    TBool iLogErrors;
+    
+    // Tracking memory available. 
+    RArray<TAvailableMemory> iMemoryStats;
+    
+    // Variables to keep track of load-threads.
+    RThread iLoadThread[KMaxLoadThreads];
+    TBool   iStopThreadFlag[KMaxLoadThreads]; 
+    
+    RHeap* iMainThreadHeap;
+    PFNEGLQUERYPROFILINGDATANOKPROC ipfnEglQueryProfilingDataNOK;
     };
 
 
@@ -216,10 +265,31 @@
 	  CASE(EGetSurfaceParamsCase);
 	  CASE(EFinishedCase);
 	  CASE(ECreateVgImageCase);
+      CASE(EDestroySurfaceCase);
+      CASE(EStartLoadThreadCase);
+      CASE(EEndLoadThreadCase);
+      CASE(ECheckForMemoryLeaks);
+      CASE(ECheckForMemoryLeaksFinish);
         }
     return caseName;
     }
 
 #undef CASE
 
+
+inline void LogDump(CTestExecuteLogger &aLogger, const TEngineTestCase& aCase)
+{
+    const TText *caseName = EngineCaseName(aCase.iCase);
+    aLogger.LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo,
+                    _L("Performing subcase %d (%s), with flags=%d, err=%04x endpointidx=%d, image=%d, args=(%d, %d)"),
+                    aCase.iCase,
+                    caseName,
+                    aCase.iFlags,
+                    aCase.iErrorExpected,
+                    aCase.iEndpointIndex,
+                    aCase.iImageIndex,
+                    aCase.iArg1, aCase.iArg2);
+}
+
+
 #endif // __EGLTEST_ENDPOINT_ENGINE_H__

--- a/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_engine_execthread.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_engine_execthread.h	Wed Aug 18 11:05:09 2010 +0300
@@ -27,6 +27,8 @@
 _LIT(KExecResultQueueName, "EGLEndpointExecTestEnvResultQueue");
 _LIT(KExecParamsQueueName, "EGLEndpointExecTestEnvParamsQueue");
 
+// For description of the work done as part of this class, see the 
+// egltest_endpoint_engine_execthread.cpp
 NONSHARABLE_CLASS(CEgltest_Local_Engine_Exec): public CBase
     {
 public:
@@ -36,7 +38,7 @@
     static CEgltest_Local_Engine_Exec* NewL();
     CTestExecuteLogger &Logger() { return iLogger; }
     void SetTestStepResult(TVerdict aVerdict);
-    TVerdict TestStepResult(void) const;
+    TVerdict TestStepResult() const;
     void TidyUp();
     void SetUpL();
     
@@ -45,7 +47,6 @@
     static void ThreadEntryL();
     TInt ThreadLoopL();
     void ConstructL();
-    void LogDump(const TEngineTestCase& aCase);
     void SendResult(const TExecResult &aResult);
     
 private:

--- a/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_engine_types.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_engine_types.h	Wed Aug 18 11:05:09 2010 +0300
@@ -56,7 +56,7 @@
     // iEndpointIndex indicates which surface to use.
     // iImageIndex index to the rectangle set to pass in as "dirty rectangles".
     //             if index = 0, then a NULL is passed - indicating full surface 
-    //             (no other value currently supported)!
+    //             (no other value currently supported).
     // iFlags: ENoWait: complete immediately, rather than wait for displayed 
     //                  notification (only valid for non-EGL surfaces).
     //         ENoSync: Do not wait for contentupdate to complete, instead, 
@@ -105,7 +105,7 @@
     ECreateSurfaceCase = 11,
 
     // EDrawContentCase
-    // Also draws an image before swapping.
+    // Draws an image.
     // iEndpointIndex indicates the surface to draw to.
     // iImageIndex is the index of the image to be drawn.
     EDrawContentCase = 12,
@@ -206,19 +206,76 @@
     // RWindow component that is part of an EGL surface in the thread that
     // created the RWindow.
     EGetSurfaceParamsCase = 26, 
+    
+    // EDestroySurfaceCase
+    // Opposite of ECreatSurfaceCase.
+    // iEndpointIndex indicates which surface object
+    EDestroySurfaceCase = 27,
+    
+    // EStartLoadThreadCase
+    // For tests that have some sort of second thread that does "loading" 
+    // (e.g. heavy drawing or using up memory), this will start that thread.
+    // iEndpointIndex is the thread number. 
+    // Note, relies on the thread implementing a StartLoadThread() function -
+    // default implementation will panic.
+    EStartLoadThreadCase = 28,
+    
+    // EEndLoadThreadCase
+    // For tests that have some sort of second thread that does "loading" 
+    // (e.g. heavy drawing or using up memory), this will end the thread.
+    // iEndpointIndex is the thread number. 
+    // Note, relies on the thread implementing a EndLoadThread() function -
+    // default implementation will panic.
+    EEndLoadThreadCase = 29,
+    
+    // ECheckForMemoryLeaks
+    // Used by tests that perform for example out-of-memory testing. 
+    // Executed on the in the remote engine code. 
+    // The amount of memory available is stored in an array, and when 
+    // the ECheckForMemoryLeaksFinish is called, the statistics is
+    // calculated abd deternubed if there is a leak or not. 
+    ECheckForMemoryLeaks = 30,
+    
+    // ECheckForMemoryLeaksFinish
+    // Check the collected data from ECheckForMemoryLeaks, and determine the
+    // trend of memory usage. 
+    // See ECheckForMemoryLeaks
+    ECheckForMemoryLeaksFinish = 31,
+    
+    // ESpecialEglHeapCase
+    // Configure a heap for the EGL calls. 
+    // This is used to allow egl calls to be done with a heap that is full.
+    // iEndpointIndex = min size
+    // iImageIndex = max size
+    // IMPORTANT NOTE: This HAS TO BE the first case sent to the remote engine. 
+    ESpecialEglHeapCase = 32,
 
+    
     ///
     /// Debug cases
     ///
     // EBreakPointCase
     // Used for debugging.
-    // iFlags = EDebugLocal, EDebugRemote - break local and/or remote side engine.
+    // iFlags = EDebugExecThread, EDebugController, EDebugRemote - break 
+    // exec_thread, controller and/or remote part of engine.
     EBreakPointCase = 64,
 
     // ELogEnableCase
     // Logging enable - all items executed after this point are written out, including data parameters.
     // iFlags = EDebugLocal, EDebugRemote - log on local/remote side.
     ELogEnableCase = 65,
+
+    ///////////////////////////////////////////////////////
+    // Control messages - "done", "sync", etc.
+    ///////////////////////////////////////////////////////
+    
+    // ESetVerdictCase
+    // Used to set the relevant threads "teststepresult".
+    // Flags indicate which thread is updated.
+    // iEndpointIndex = verdict to set. 
+    // Note: Remote value is not using the ERtvXXX values, the standard
+    // values in Test Framework are translated in the remote step.
+    ESetVerdictCase = 996,
     
     // ESyncLocalCase
     // Used for synchronizing the local execution thread. 
@@ -228,7 +285,8 @@
 
     // EPanicCase
     // Cause panic on local or remote side. Used for testing purposes only.
-    // iFlags = EDebugLocal, EDebugRemote - choose between local/remote side.
+    // iFlags = EDebugExecThread, EDebugController, EDebugRemote - break 
+    // exec_thread, controller and/or remote part of engine.
     EPanicCase = 998,
 
     // EIllegalCase
@@ -236,7 +294,7 @@
     // statement for this in the engine, it should be treated as a "unknown" case,
     // and cause any test to fail in the same way as if an unused value was put
     // in the table. Used for testing purposes, and can also be used to make a
-    // particular test fail on purpose (e.g. due to production code bugs!)
+    // particular test fail on purpose (e.g. due to production code bugs).
     // All arguments ignored.
     EIllegalCase = 999,
 
@@ -265,10 +323,19 @@
     ENoWait             = 1 << 14,
     ENoSync             = 1 << 15,
 
-    // Debug flags
-    EDebugLocal         = 1 << 16,
+    // Debug flags - perform operation on "Local"
+    EDebugExecThread      = 1 << 16,
     EDebugRemote        = 1 << 17,
     EDebugController    = 1 << 18,
+    
+    // ThreadingFlags - just rename the debug flags, because it's actually the
+    // same thing. We _RELY_ on this being the same to simplify the code in 
+    // the controller thread.
+    // Note: the lack of "execthread" is intentional. Since controller and exec
+    // are in the same process, there is no reason to use the ExecThread to 
+    // start a new thread. ??This may need to be changed int he future.??
+    EThreadRemote       = EDebugRemote,
+    EThreadController   = EDebugController,
     };
 
 enum TEngineFlagsMask
@@ -284,15 +351,23 @@
                           EUseBadApi           |
                           EUseBadSync          |
                           EUseBadRects         |
-                          0   // So that it's easier to merge!
+                          0   // So that it's easier to merge.
     };
 
 
+enum TRemoteThreadEngineThread
+    {
+    EUnknownThread = 0,
+    EThreadLoadHeapMemory = 1,
+    EThreadLoadGpuMemory = 2,
+    EThreadLoadGpuProcessor = 3,
+    };
+
 struct TEngineTestCase
     {
-    TEngineCases iCase;
+    TEngineCases iCase;             // Command to execute. See TEngineCases for details.
     TInt         iFlags;            // Flags to indicate for example bad parameters (TEngineFlags).
-    TInt         iErrorExpected;    // What value is expected in eglGetError()?
+    TInt         iErrorExpected;    // The value that eglGetError() is expected to return.
     TInt         iEndpointIndex;    // Index to the endpoint to use.
     TInt         iImageIndex;       // Index to image to draw/compare(egltest_endpoint_images)
     TInt         iArg1;             // E.g. GetAttrib or SetAttrib attrib.
@@ -306,19 +381,44 @@
     TEngineTestCase      iEngineTestCase;
     };
 
+// Passed to StartRemoteTestStep() during test startup.
+struct TTestEndpointEngineConfig
+    {
+    TBool iLogErrors; 
+    };
+
+// Number of small steps that each test is allowed to contain. Since each test
+// that uses the engine has at least one table like this, increasing this 
+// hugely will increase the overall  memory usage of the application (each 
+// entry is about 28 bytes). So, don't go multiplying by 10 or some such
+// unless there is a REAL need for that.
+// THe current tables take up approximately 28 * 80 = 2240 bytes.
+// As of right now, there are about 100 tests -> 220KB of tables.
 const TInt KMaxCases    = 80;
+
 // Should be PLENTY of endpoints [also used for surfaces, images and other
-// objects that have roughly 1:1 mapping with endpoints.
-const TInt KMaxEndpoints = 400;
+// objects that have roughly 1:1 mapping with endpoints. This is dynamically
+// allocated in the constructor of the engine class.
+const TInt KMaxEndpoints = 1000;
+
+// Max number of surfacetypes we expect to be listed. 
+// This can be increased as and when needed. 
+const TInt KMaxSurfaceList = 4;   
+
+struct TTestCaseBase
+    {
+    const TText*       iRelatedTestIds;
+    const TText*       iName;
+    TInt               iSurfaceTypeCount;
+    TSurfaceType       iSurfaceTypeList[KMaxSurfaceList];
+    };
 
 // Structure for lists of cases to execute
 struct TTestCase
     {
-    const TText*    iRelatedTestIds;
-    const TText*    iName;
-    TInt            iSurfaceTypeCount;
-    TSurfaceType    iSurfaceTypeList[ESurfTypeMaxTypes];
-    TEngineTestCase iEngineTestCase[KMaxCases];
+    // Use anonymous struct to avoid changing code all over the place.
+    TTestCaseBase      iBase;
+    TEngineTestCase    iEngineTestCase[KMaxCases];
     };
 
 struct TTestCases
@@ -327,5 +427,4 @@
     TInt             iCount;
     };
 
-
 #endif

--- a/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_images.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_images.h	Wed Aug 18 11:05:09 2010 +0300
@@ -85,6 +85,7 @@
 class CTestVgEglImage: public CTestVgImage
     {
 public:
+    static CTestVgEglImage *New(EGLImageKHR aEglImage);
     static CTestVgEglImage *NewL(EGLImageKHR aEglImage);
 private:
     void ConstructL(EGLImageKHR aEglImage);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_stress_engine.h	Wed Aug 18 11:05:09 2010 +0300
@@ -0,0 +1,248 @@
+// 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:
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#ifndef __EGLTEST_ENDPOINT_STRESS_ENGINE_H__
+#define __EGLTEST_ENDPOINT_STRESS_ENGINE_H__
+
+#include "egltest_endpoint_engine_types.h"
+#include "egltest_endpoint_engine.h"
+#include "localtestbase.h"
+
+#define TESTTABLE(x) sizeof(x) / sizeof(x[0]), x
+
+// This file provides extensions to the egltest engine functionality to 
+// support stress tests that aren't practical to do as small tables. The main
+// point is to support copying a set of table entries many times.
+// Number of sections we expect is needed. This is just an arbitrary value, and a 
+// larger value can be used. 
+const TInt KMaxSections = 10;
+
+// Max parameters must be a 2^n number so that we can use binary and magig...
+const TInt KMaxParams = 4;
+// Log2 of KMaxParams
+const TInt KMaxParamsLog2 = 2;
+
+
+// Parameter types. Used to build tables at compile time and passed to factory
+// function to request the implementation object for that iterator.
+enum TParamType
+    {
+    EParamTypeNone = 0,
+    EParamTypeIterator,
+    EParamTypeTable,
+    EParamTypeRandomizer
+    };
+
+// Parameter declaration. Used to build tables at compile time. 
+struct TParamDeclaration
+    {
+    TParamType iType;
+    TInt       iInit;       
+    TInt       iEnd;
+    TInt       iStep;
+    };
+
+// These enums define what should be done when there's
+// a failure in a stress test section.
+enum TOnErrorPolicy
+    {
+    // Unknown - this is not a policy, but a placeholder for "uninitialized"
+    EOnErrorPolicyUnknown,
+    // Break - this policy is where a failure causes a section to be broken,
+    // that is, we skip to the next section and remember the number of times this
+    // section was run. 
+    EOnErrorPolicyBreak,
+    // Continue - ignore errors, and continue.
+    EOnErrorPolicyContinue,
+    // Fail - errors lead to failing the test.
+    EOnErrorPolicyFail
+    };
+
+// The basic component for producing many table entries from a short table.
+struct TStressTestSection
+    {
+    // Number of iterations to run.
+    TInt iIterations;
+    // What to do when we have a "fail" during the stress test...
+    TOnErrorPolicy iErrorPolicy;
+    // Parameter declarations
+    TParamDeclaration iParams[KMaxParams];
+    // The actual test cases.
+    TEngineTestCase iEngineTestCase[KMaxCases];
+    };
+
+
+// Used to create a list of TStessTestSections.
+// 
+// A typical stress test table would have a epilog, body and prolog, where
+// the epilog and prolog are copied once to the table, and the body copied
+// many times over. Sometimes, there may be a test that for example creates
+// a large number of endpoints, then does something and then cleans up the
+// endpoints. This would have 5 sections: 
+// prolog to start things off copied once. 
+// creation of endpoints (body part 1), copied n times.
+// do some work with endpoints (body part 2), copied n times.
+// cleanup of endpoints (body part 3), copied n times. 
+// epilog to clean up final items, copied once.
+struct TStressTestTable
+    {
+    TTestCaseBase             iTestCaseBase;
+    TUint                     iNumSections;
+    const TStressTestSection* iSections;
+    };
+
+
+// A collection of constant values for the purpose of marking/extracting the
+// parameter index.
+enum TExpandEntryFlags 
+    {
+    EParamBitsInInt  = 32,
+    EExpandParamBit = EParamBitsInInt-1,
+    EExpandParamFlag = 1 << 31,
+    EParamShift      = (30-KMaxParamsLog2),
+    EParamMask       = ((KMaxParams-1) << EParamShift),
+    EAllFlags = EExpandParamFlag | EParamMask,
+    ERemoveFlagsMask = ~EAllFlags,
+    };
+
+NONSHARABLE_CLASS(CStressParam) : CBase
+    {
+public:
+    virtual void Initialize(TInt aInit, TInt aEnd, TInt aStep) = 0;
+    virtual void Next() = 0;
+    virtual TInt Value() = 0;
+    virtual ~CStressParam();
+    static CStressParam *Factory(const TParamDeclaration &aParamDecl);
+    
+    };
+
+NONSHARABLE_CLASS(CStressParamIterator) : public CStressParam 
+    {
+public:
+    CStressParamIterator();
+    ~CStressParamIterator();
+    virtual void Initialize(TInt aInit, TInt aEnd, TInt aStep);
+    virtual void Next();
+    virtual TInt Value();
+private:
+    TInt iIterator;
+    TInt iInit;
+    TInt iEnd;
+    TInt iStep;
+    };
+
+NONSHARABLE_CLASS(CStressParamTable) : public CStressParam 
+    {
+public:
+    CStressParamTable();
+    ~CStressParamTable();
+    virtual void Initialize(TInt aTable, TInt aCount, TInt /* aUnused */);
+    virtual void Next();
+    virtual TInt Value();
+private:
+    TInt  iIndex;
+    TInt* iTable;
+    TInt  iCount;
+    };
+
+NONSHARABLE_CLASS(CStressParamRandomizer) : public CStressParam
+    {
+public:
+    CStressParamRandomizer();
+    ~CStressParamRandomizer();
+    virtual void Initialize(TInt aMin, TInt aMax, TInt aMul);
+    virtual void Next();
+    virtual TInt Value();
+private:
+    TInt  iMin;
+    TInt  iMax;
+    TInt  iMul;
+    TInt  iCurrent;
+    };
+
+#define PARAM_DECL(type, init, end, step) { type, init, end, step }
+// Iterator parameter: Goes from init to end in step increments. If the total
+// loop is bigger than (end - init), it restarts on init. 
+#define PARAM_DECL_ITER(init, end, step) PARAM_DECL(EParamTypeIterator, init, end, step)
+// Table iterator. Steps over table. Rstarts at index 0 when going past the end. 
+#define PARAM_DECL_TABLE(table) \
+    PARAM_DECL(EParamTypeTable, (TInt)table, sizeof(table)/sizeof(table[0]), 0)
+// Random generator. generates an integer in the range [min..max[ then 
+// multiples by mul. 
+// Example: PARAM_DECL_RANDOM(2, 6, 3) will generate numbers that are multiples 
+// of three in the range 6..15. 
+#define PARAM_DECL_RANDOM(min, max, mul) PARAM_DECL(EParamTypeRandom, min, max, mul)
+
+#define NO_PARAMS  { EParamTypeNone, 0, 0, 0 }
+
+// Make Parameter entry
+#define PARAM(n, offset) (EExpandParamFlag | (n << EParamShift) | offset)
+#define PARAM0(offset)   PARAM(0, offset)
+#define PARAM1(offset)   PARAM(1, offset)
+#define PARAM2(offset)   PARAM(2, offset)
+#define PARAM3(offset)   PARAM(3, offset)
+
+class CTestExecuteLogger;
+
+// A class to allow tests that run many operations to be written as tables
+// without having very long tables. Instead the table structure is (as 
+// described for the TStressTestTable), consists of a generic header and
+// multiple sections of table that have a "number of times to run" counter. 
+
+// To allow for these changes to the table structure, we derive the 
+// CEgttest_Local_Engine class, but provide alternative solutions for a few of
+// A class to build stress tests. 
+NONSHARABLE_CLASS(CStressTestEngine): public CEgltest_Local_Engine
+    {
+public:
+    static CStressTestEngine *NewL(const TStressTestTable aStressTable[], TUint aNumTables);
+    ~CStressTestEngine();
+    TVerdict doTestStepL();
+    CStressTestEngine();
+    virtual void DoPreambleL();
+    virtual void DoPostambleL();
+    
+protected:
+    void ConstructL(const TStressTestTable aStressTable[], TUint aNumTables);
+    void StartThreadL(TInt aThreadNumber);
+    void EndThread(TInt aThreadNumber);
+    virtual TThreadFunction GetThreadFunction(TInt aThreadNumber);
+    
+private:
+    void ModifyL(TEngineTestCase &aTestCase);
+    void DoModifyL(TInt &aItem);
+    
+    void CreateParams(const TStressTestSection &aSection);
+    void DestroyParams();
+    void NextParams();
+    TBool HandleError(const TStressTestSection &section, TInt aCopy, 
+            TInt aCopies, TInt aCurSection, TInt &aPreviousCopiesRun);
+    void UpdateVerdict(TVerdict aVerdict);
+    
+private:
+    const TStressTestTable *iStressTable;
+    CStressParam *iParams[KMaxParams];
+protected:
+    RThread iLoadThread[KMaxLoadThreads];
+    TBool   iStopThreadFlag[KMaxLoadThreads];
+    };
+
+#endif // __EGLTEST_ENDPOINT_STRESS_ENGINE_H__

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_stressload.h	Wed Aug 18 11:05:09 2010 +0300
@@ -0,0 +1,42 @@
+// 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:
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include "egltest_endpoint_stress_engine.h"
+#include "egltest_endpoint_engine.h"
+
+_LIT(KEGL_EndpointStressLoad, "EGL_EndpointStressLoad");
+
+
+NONSHARABLE_CLASS(CEglTest_TestStep_StressLoad): public CStressTestEngine
+    {
+public:
+    static CEglTest_TestStep_StressLoad *New();
+
+protected:
+    TThreadFunction GetThreadFunction(TInt aThreadNumber);
+private:
+    CEglTest_TestStep_StressLoad();
+    static TInt LoadGpuProcessor(TAny *aSelf);
+    void LoadGpuProcessorL();
+    static TInt LoadGpuMemory(TAny *aSelf);
+    void LoadGpuMemoryL();
+
+private:
+    EGLDisplay iDisplay;
+    };

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_endpoint_stresstests.h	Wed Aug 18 11:05:09 2010 +0300
@@ -0,0 +1,42 @@
+// 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:
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include "egltest_endpoint_stress_engine.h"
+#include "egltest_endpoint_engine.h"
+
+_LIT(KEGL_EndpointStressTests, "EGL_EndpointStressTests");
+
+
+NONSHARABLE_CLASS(CEglTest_TestStep_StressTests): public CStressTestEngine
+    {
+public:
+    static CEglTest_TestStep_StressTests *New();
+private:
+    CEglTest_TestStep_StressTests();
+    };
+
+NONSHARABLE_CLASS(CEglTest_TestStep_StressTests2): public CStressTestEngine
+    {
+public:
+    static CEglTest_TestStep_StressTests2 *New();
+private:
+    CEglTest_TestStep_StressTests2();
+    };

--- a/egl/egltest/endpointtestsuite/automated/tinc/egltest_parameters.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_parameters.h	Wed Aug 18 11:05:09 2010 +0300
@@ -188,7 +188,6 @@
                 break;
                 }
             }
-        // Can/should we use "search" here?
         // Check if it's already in the list - no point in testing the same value more than once.
         for(TInt j = 0; useCurParam && j < iParams.Count(); j++)
             {

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_releaseimagegles.h	Wed Aug 18 11:05:09 2010 +0300
@@ -0,0 +1,67 @@
+/*
+* 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: 
+*
+*/
+
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+
+#ifndef __EGLTEST_RELEASEIMAGEGLES_H__
+#define __EGLTEST_RELEASEIMAGEGLES_H__
+
+
+#include "localtestbase.h"
+#include "remotetestbase.h"
+
+
+_LIT(KEGL_EndpointReleaseImageGles, "EGL_EndpointReleaseImageGles");
+NONSHARABLE_CLASS(CEglTest_LocalTestStep_EndpointReleaseImageGles) : public CLocalTestStepBase
+    {
+public:
+CEglTest_LocalTestStep_EndpointReleaseImageGles();
+    ~CEglTest_LocalTestStep_EndpointReleaseImageGles();
+    void DoPreambleL();
+    void DoPostambleL();
+    TVerdict doTestStepL();
+    };
+
+
+NONSHARABLE_CLASS(CEglTest_RemoteTestStep_EndpointReleaseImageGles) : public CRemoteTestStepBase
+    {
+public:
+    CEglTest_RemoteTestStep_EndpointReleaseImageGles();
+    ~CEglTest_RemoteTestStep_EndpointReleaseImageGles();
+    
+    virtual TRemoteTestVerdict DoRunRemoteTestCaseL(TInt aTestCase, const TRemoteTestParams& aParams);
+    virtual TRemoteTestVerdict DoStartRemoteTestStepL(const TRemoteTestParams& aMessageIn);
+    virtual TRemoteTestVerdict DoEndRemoteTestStepL(const TRemoteTestParams& aMessageIn);
+    
+private:
+    TRemoteTestVerdict GlesContextTestCaseL(const TRemoteTestParams& aParams);
+    TRemoteTestVerdict DoGlesContextTestCaseL(const TRemoteTestParams& aParams);
+    
+private:
+    EGLDisplay iDisplay;
+    CSurface* iSurface;
+    EGLEndpointNOK iEndpoint;
+    };
+
+
+#endif

--- a/egl/egltest/endpointtestsuite/automated/tinc/egltest_surface.h	Tue Jul 06 15:45:57 2010 +0300
+++ b/egl/egltest/endpointtestsuite/automated/tinc/egltest_surface.h	Wed Aug 18 11:05:09 2010 +0300
@@ -36,6 +36,7 @@
     ESurfTypeRaw,
     ESurfTypeEglWindow,
     ESurfTypeRawSingleBuffered,
+    ESurfTypePBuffer,
     ESurfTypeMaxTypes  // Should be the last enum.
     };
 
@@ -49,6 +50,9 @@
     EUnusualStrideSurface,
     EUnalignedPixelSizeSurface,
     ELargeSurface,
+    ELargestPossibleSurface,
+    ESmallSurface,
+    ETinySurface
     };
 
 // Notification enums - allows us to use one function to request several notifications.
@@ -86,6 +90,7 @@
     };
 
 
+
 //Interface for creating, drawing to and submitting content for a surface
 //Derived classes can implement different types of surface, that can be
 //used in the same test code. Ie surface manager surface (raw), egl window
@@ -93,21 +98,31 @@
 class CSurface: public CBase
     {
 public:
-    virtual void CreateL(TInt aIndex) = 0;
+    // This function is kept for compatibility - new code should use offset
+    // form of CreateL... 
+    virtual void CreateL(TInt aIndex);
+    // Allow an offset for the top left corner of the surface on screen. 
+    virtual void CreateL(TInt aIndex, const TPoint& aOffset) = 0;
     virtual void DrawContentL(TInt aImageIndex) = 0;
     virtual void DrawContentL(const TRgb& aColour) = 0;
-    virtual void SubmitContentL(TBool aShouldWaitForDisplay, TInt aRectIndex = 0) = 0;
+    virtual void DrawComplexL(const TRgb& aColour) = 0;
+    virtual TInt SubmitContent(TBool aShouldWaitForDisplay, TInt aRectIndex = 0) = 0;
     virtual TSurfaceId SurfaceId() const = 0;
     virtual void GetSurfaceParamsL(TSurfaceParamsRemote &aParams) = 0;
     virtual const TText *GetSurfaceTypeStr() const = 0;
     virtual TInt Notify(TNotification aWhen, TRequestStatus &aStatus, TUint32 aXTimes) = 0;
     virtual TInt WaitFor(TNotification aWhen, TRequestStatus &aStatus, TInt aTimeoutInMicroseconds, TUint32& aTimeStamp) = 0;
+    virtual TInt SizeInBytes() const;
+   
+    
+    TSize Size();
 
 public:
     // Factory function to create a surface of aSurfType.
     static CSurface *SurfaceFactoryL(TSurfaceType aSurfType);
 protected:
-    TInt iParamIndex;
+    TInt  iParamIndex;
+    TSize iActualSize;
     };
 
 
@@ -118,12 +133,12 @@
     static CRawSurface* NewL();
     ~CRawSurface();
 
-    //From CSurface.
-    void CreateL(TInt aIndex);
-    void GetSurfAttribs(RSurfaceManager::TSurfaceCreationAttributesBuf &aSurfaceAttribs, TInt aIndex);
+    // From CSurface
+    virtual void CreateL(TInt aIndex, const TPoint& aOffset);
     void DrawContentL(TInt aIndex);
     void DrawContentL(const TRgb& aColour);
-    void SubmitContentL(TBool aShouldWaitForDisplay, TInt aRectIndex = 0);
+    void DrawComplexL(const TRgb& aColour);
+    TInt SubmitContent(TBool aShouldWaitForDisplay, TInt aRectIndex = 0);
     TSurfaceId SurfaceId() const;
     void GetSurfaceParamsL(TSurfaceParamsRemote &aParams);
     virtual const TText *GetSurfaceTypeStr() const;
@@ -134,24 +149,25 @@
     CRawSurface();
     void ConstructL();
     TUint8* MapSurfaceAndGetInfoLC(RSurfaceManager::TSurfaceInfoV01& aInfo);
+    void GetSurfAttribs(RSurfaceManager::TSurfaceCreationAttributesBuf &aSurfaceAttribs, TInt aIndex, TInt aSizeIndex);
 
 private:
     static TInt PixelSize(TUidPixelFormat aPixelFormat);
     static TRequestStatus *GetRequestPtr(TNotification aWhen);
 
 private:
-    RSurfaceUpdateSession iSurfaceUpdate;
-    TRequestStatus        iAvailable;
-    TRequestStatus        iDisplayed;
-    TRequestStatus        iDisplayedXTimes;
-    TTimeStamp            iTimeStamp;
-    TInt                  iDrawBuffer;
-    RChunk                iSurfaceChunk;
+    RSurfaceUpdateSession  iSurfaceUpdate;
+    TRequestStatus         iAvailable;
+    TRequestStatus         iDisplayed;
+    TRequestStatus         iDisplayedXTimes;
+    TTimeStamp             iTimeStamp;
+    TInt                   iDrawBuffer;
+    RChunk                 iSurfaceChunk;
 
 protected:
-    TInt                  iBuffers;
-    RSurfaceManager       iSurfaceManager;
-    TSurfaceId            iSurfaceId;
+    TInt                   iBuffers;
+    RSurfaceManager        iSurfaceManager;
+    TSurfaceId             iSurfaceId;
     };
 
 // Simple wrapper to enable a list of "singlebuffer" in the list of buffer types.
@@ -161,8 +177,7 @@
     static CRawSingleBufferSurface* NewL();
     ~CRawSingleBufferSurface();
 
-    //From CSurface.
-    void CreateL(TInt aIndex);
+    virtual void CreateL(TInt aIndex, const TPoint& aOffset);
     virtual const TText *GetSurfaceTypeStr() const;
     };
 
@@ -170,34 +185,66 @@
 class CWindow;
 class CTestVgImage;
 
-class CEglWindowSurface : public CSurface
+class CEglSurfaceBase : public CSurface
+    {
+public:
+    void CreateL(TInt aIndex, const TPoint& aOffset);
+    void DrawContentL(TInt aImageIndex);
+    void DrawContentL(const TRgb& aColour);
+    void DrawComplexL(const TRgb& aColour);
+    TInt SubmitContent(TBool aShouldWaitForDisplay, TInt aRectIndex = 0);
+    TInt Activate();
+    void ActivateL();
+    void GetSurfaceParamsL(TSurfaceParamsRemote &aParams);
+    virtual TInt Notify(TNotification aWhen, TRequestStatus &aStatus, TUint32 aXTimes);
+    virtual TInt WaitFor(TNotification aWhen, TRequestStatus &aStatus, TInt aTimeoutInMicroseconds, TUint32& aTimeStamp);
+
+protected:
+    void BaseCreateL(TInt aIndex, EGLint aSurfaceType);
+    virtual void DoCreateL(TInt aIndex, const TPoint& aOffset, TInt aSizeIndex) = 0;
+    void Destroy();
+
+protected:
+    EGLContext iContext;
+    EGLSurface iSurface;
+    EGLDisplay iDisplay;
+    EGLConfig  iConfig;
+    };
+
+class CEglWindowSurface : public CEglSurfaceBase
     {
 public:
     static CEglWindowSurface* NewL();
     ~CEglWindowSurface();
 
-    void CreateL(TInt aIndex);
-    void DrawContentL(TInt aImageIndex);
-    void DrawContentL(const TRgb& aColour);
-    void SubmitContentL(TBool aShouldWaitForDisplay, TInt aRectIndex = 0);
-    void ActivateL();
     TSurfaceId SurfaceId() const;
-    void GetSurfaceParamsL(TSurfaceParamsRemote &aParams);
     virtual const TText *GetSurfaceTypeStr() const;
-    virtual TInt Notify(TNotification aWhen, TRequestStatus &aStatus, TUint32 aXTimes);
-    virtual TInt WaitFor(TNotification aWhen, TRequestStatus &aStatus, TInt aTimeoutInMicroseconds, TUint32& aTimeStamp);
 
 private:
     CEglWindowSurface();
+    void DoCreateL(TInt aIndex, const TPoint& aOffset, TInt aSizeIndex);
     void ConstructL();
 
 private:
-    EGLContext iContext;
-    EGLSurface iSurface;
-    EGLDisplay iDisplay;
     CWindow*   iWindow;
     };
 
+class CEglPBufferSurface : public CEglSurfaceBase
+    {
+public:
+    static CEglPBufferSurface* NewL();
+    ~CEglPBufferSurface();
+    TSurfaceId SurfaceId() const;
+
+    virtual const TText *GetSurfaceTypeStr() const;
+
+    TInt SizeInBytes() const;
+
+private:
+    CEglPBufferSurface();
+    void ConstructL();
+    void DoCreateL(TInt aIndex, const TPoint& aOffset, TInt aSizeIndex);
+    };
 
 
 #endif