--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/httpexamples/nwsswsptrhnd/CNwssWspCOEventDispatcher.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,218 @@
+// Copyright (c) 2002-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:
+//
+
+
+// Local includes
+#include "cnwsstranslookuptable.h"
+#include "mnwsssessioneventhandler.h"
+#include "mnwsstransactioneventhandler.h"
+#include "mnwssoomhandler.h"
+#include "tnwsswsptrhndpanic.h"
+#include "testoom.h"
+
+// Class signature
+#include "cnwsswspcoeventdispatcher.h"
+
+	
+
+CNwssWspCOEventDispatcher* CNwssWspCOEventDispatcher::NewL(
+											RWSPCOConn& aWspSession,
+											MNwssSessionEventHandler& aSessEventHnd,
+											MNwssTransactionEventHandler& aTransEventHnd,
+										    MNwssOomHandler& aOutOfMemoryHnd
+											)
+	{
+	return new(ELeave)CNwssWspCOEventDispatcher(aWspSession, aSessEventHnd,
+												aTransEventHnd, aOutOfMemoryHnd);
+	}
+
+CNwssWspCOEventDispatcher::~CNwssWspCOEventDispatcher()
+	{
+	Cancel();
+	}
+
+CNwssWspCOEventDispatcher::CNwssWspCOEventDispatcher(
+										RWSPCOConn& aWspSession,
+		 								MNwssSessionEventHandler& aSessEventHnd,
+										MNwssTransactionEventHandler& aTransEventHnd,
+										MNwssOomHandler& aOutOfMemoryHnd
+										)
+	: CActive(CActive::EPriorityHigh),
+	  iWspSession(aWspSession), iSessEventHnd(aSessEventHnd),
+	  iTransEventHnd(aTransEventHnd), iOutOfMemoryHnd(aOutOfMemoryHnd)
+	{
+	CActiveScheduler::Add(this);
+	}
+
+void CNwssWspCOEventDispatcher::Start()
+	{
+	if (!IsActive())
+		{
+		iWspSession.GetEvent(iWspEvent, iTransaction, iStatus);
+		SetActive();
+		}
+	}
+
+void CNwssWspCOEventDispatcher::RunL()
+	{
+	RWSPCOConn::TEventType event = (RWSPCOConn::TEventType)iWspEvent();
+
+	// Obtain the transaction ID for transaction events
+	iTrId = KErrNotFound;
+	if ( (event == RWSPCOConn::EMethodInvoke_cnf_t) ||
+		 (event == RWSPCOConn::EMethodResult_ind_t) ||
+		 (event == RWSPCOConn::EAbort_ind_t) )
+		{
+		__TESTOOMD(stkErr, iTransaction.Id(iTrId));
+		User::LeaveIfError(stkErr);
+		}
+
+	// Testing only - simulate a WAP Stack OOM which would cause this AO to complete with KErrNoMemory
+	TInt status = iStatus.Int();
+#if defined (_DEBUG) && defined(__UNIT_TESTING__)
+	TAny* _a = User::Alloc(sizeof(TInt));
+	User::Free(_a);
+	if (_a == NULL)
+		status = KErrNoMemory;
+#endif
+	User::LeaveIfError(status);
+
+	// Request the next event before processing this one.  It is important to do this here,
+	// and not after the following event handling - since the handler may decide to cancel this
+	// dispatcher as a result of the event, or even close iWspSession.
+	Start();
+
+	// Act according to the event type
+	switch (event)
+		{
+		// dispatch session events to the session event handler
+		case RWSPCOConn::EDisconnect_ind_s:
+			{
+			__DEBUGTESTLEAVE
+			iSessEventHnd.HandleDisconnectIndL();
+			} break;
+		case RWSPCOConn::ESuspend_ind_s:
+			{
+			__DEBUGTESTLEAVE
+			iSessEventHnd.HandleSuspendIndL();
+			} break;
+		case RWSPCOConn::EResume_cnf_s:
+			{
+			__DEBUGTESTLEAVE
+			iSessEventHnd.HandleResumeCnfL();
+			} break;
+		case RWSPCOConn::EConnect_cnf_s:
+			{
+			__DEBUGTESTLEAVE
+			iSessEventHnd.HandleConnectCnfL();
+			} break;
+		case RWSPCOConn::ERedirect_ind_s:
+			{
+			__DEBUGTESTLEAVE
+			iSessEventHnd.HandleRedirectIndL();
+			} break;
+		// dispatch transaction events to the transaction event handler
+		case RWSPCOConn::EMethodInvoke_cnf_t:
+			{
+			__DEBUGTESTLEAVE
+			iTransEventHnd.HandleMethodInvokeCnfL(iTrId);
+			} break;
+		case RWSPCOConn::EMethodResult_ind_t:
+			{
+			__DEBUGTESTLEAVE
+			iTransEventHnd.HandleMethodResultIndL(iTrId);
+			} break;
+		case RWSPCOConn::EAbort_ind_t:
+			{
+			__DEBUGTESTLEAVE
+			iTransEventHnd.HandleAbortIndL(iTrId);
+			} break;
+		// push events are not supported, and should indeed never arise if the
+		// capability negotiations with the WAP proxy have been successful
+		case RWSPCOConn::EPush_ind_t:
+		case RWSPCOConn::EConfirmedPush_ind_t:
+			{
+			TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::ECOPushNotSupported);
+			} break;
+		// exception event is treated like a session event
+		case RWSPCOConn::EException_ind_e:
+			{
+			__DEBUGTESTLEAVE
+			iSessEventHnd.HandleExceptionIndL();
+			} break;
+		default: 
+			{
+			TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::EUnknownWspEvent);
+			} break;
+		};
+	}
+
+TInt CNwssWspCOEventDispatcher::RunError(TInt aError)
+	{
+	// Handle errors according to event type: if it's a transaction event, then send an AbortInd
+	// for it. If it's a session event, then send DisconnectInd.
+	RWSPCOConn::TEventType event = (RWSPCOConn::TEventType)iWspEvent();
+	TInt err = KErrNone;
+
+	// Act according to the event type
+	switch (event)
+		{
+		case RWSPCOConn::ESuspend_ind_s:
+		case RWSPCOConn::EResume_cnf_s:
+		case RWSPCOConn::EConnect_cnf_s:
+		case RWSPCOConn::ERedirect_ind_s:
+		case RWSPCOConn::EDisconnect_ind_s:
+			{
+			if (aError != KErrNoMemory)
+				TRAP(err, __DEBUGTESTLEAVE \
+						  iSessEventHnd.HandleDisconnectIndL());
+			if ((aError == KErrNoMemory) || (err == KErrNoMemory))
+				{
+				// We need to disconnect the WAP stack if there is any risk of
+				// the client and WAP stack's session state becoming different
+				TBool disconStack = ( (event != RWSPCOConn::EDisconnect_ind_s) &&
+									  (event != RWSPCOConn::ERedirect_ind_s) );
+				iOutOfMemoryHnd.SendOomDisconnect(disconStack);
+				}
+			} break;
+		case RWSPCOConn::EMethodInvoke_cnf_t:
+		case RWSPCOConn::EMethodResult_ind_t:
+		case RWSPCOConn::EAbort_ind_t:
+			{
+			if (iTrId != KErrNotFound) // if we don't have a transaction ID we can't do anything
+				{
+				if (aError != KErrNoMemory)
+					TRAP(err, __DEBUGTESTLEAVE \
+							  iTransEventHnd.HandleAbortIndL(iTrId));
+				if ((aError == KErrNoMemory) || (err == KErrNoMemory))
+					iOutOfMemoryHnd.SendOomMethodAbort(iTrId, EFalse);
+				}
+			else
+				{
+				// We had an error whilst processing a transaction event, but we couldn't obtain
+				// the transaction ID - so we'll have to disconnect the session instead.
+				iOutOfMemoryHnd.SendOomDisconnect(ETrue);
+				}
+			} break;
+		default:
+			; // ignore - nothing else we can do
+		};
+	return KErrNone;
+	}
+
+void CNwssWspCOEventDispatcher::DoCancel()
+	{
+	iWspSession.CancelGetEvent();
+	}