FCL/sf/mw/websrv: comparison webservices/wscore/src/senclientsession.cpp

equal deleted inserted replaced

-:abb636afedf7
+:a1df79fa35b4
 #include "senwspattern.h"
 #include <SenIdentityProvider.h>
 #include <SenXmlUtils.h>
 #include <SenXmlProperties.h>
-#include <xmlengnodelist.h>
+#include <xml/dom/xmlengnodelist.h>
 #include <defaultcaps.hrh>
 #include "senclientsession.h"
 #include "senservicemanagerdefines.h"       // IPC enumerations
 #include "msencoreservicemanager.h"
 #include "senlayeredtransportproperties.h"  // internal Framework\inc
 #include "senmessagecontext.h"              // internal Framework\inc
 #include "SenSoapEnvelope2.h"
 #include "sensoapmessagedom2.h"
-#include "xmlengchunkcontainer.h"
+#include <xml/dom/xmlengchunkcontainer.h>
-#include "xmlengfilecontainer.h"
+#include <xml/dom/xmlengfilecontainer.h>
-#include "xmlengdeserializer.h"
+#include <xml/dom/xmlengdeserializer.h>
 #include "SenParser.h"
 #include "seninternalcredential.h"
 #include "senservercontext.h"
 #include "senapplicationcontext.h"
 #include "senclientcontext.h"
 }
 resHandler->iNext = iFirst;
 iFirst = resHandler;
 CActiveScheduler::Add(resHandler);
-resHandler->SetActive();
+if(!resHandler->IsActive())
+	resHandler->SetActive();
 resHandler->iStatus = KRequestPending;
 TIpcArgs args(&resHandler->iProgressData, resHandler->iSoapOrCid);
 SendReceive(ESenCliServTransferProgress, args, resHandler->iStatus);
 }
 {
 resHandler->Cancel();
 CSenMessageResourceHandler* tmp = resHandler;
 resHandler = resHandler->iNext;
 delete tmp;
+tmp = NULL;
 }
 RSessionBase::Close();
 }
 TInt RSenConnectionServerSession::InitProgressObserver(const RMessage2& aMessage)
 		{
 		caSync->Start();
 		SendReceive(ESenCliServPrefferedCarrierAvailable, args, caSync->iStatus);
 retVal = caSync->iStatus.Int();
 		delete caSync;
+		caSync = NULL;
 		}
 	return retVal;
 	}
 {
 caSync->Start();
 SendReceive(ESenCliServNewCarrierActive, args, caSync->iStatus);
 retVal = caSync->iStatus.Int();
 delete caSync;
+caSync = NULL;
 }
 return retVal;
 }
 TInt RSenConnectionServerSession::MobilityError( TInt& aError )
 {
 caSync->Start();
 SendReceive(ESenCliServMobilityError, args, caSync->iStatus);
 retVal = caSync->iStatus.Int();
 delete caSync;
+caSync = NULL;
 }
 return retVal;
 }
 #endif //__ENABLE_ALR__
 		caSync->Start();
 		Mem::FillZ(&asWait, sizeof(asWait));
 		asWait.Start();
 		retVal = caSync->iStatus.Int();
 		delete caSync;
+		caSync = NULL;
 		}
 	return retVal;
 	}
 CSenConnAgentSync::CSenConnAgentSync(): CActive(EPriorityStandard)
 	{
 	}
 void CSenConnAgentSync::Start()
 	{
-	SetActive();
+	if(!IsActive())
+		SetActive();
 	}
 CSenClientSession* CSenClientSession::NewL(MSenServiceManager& aServer, CSenServerContext& aCtx)
 {
 CSenClientSession* self = CSenClientSession::NewLC(aServer, aCtx);
 }
 case ESenServGetIdentityProviders:
 	{
 	CSLOG_L(iConnectionID,KMinLogLevel ,"ESenServGetIdentityProviders");
 	IdentityProviders(aMessage);
+	       	CSLOG_L(iConnectionID,KMinLogLevel ,"ESenServGetIdentityProviders Completed");
 	break;
 	}
 default:
 {
 CSLOG(iConnectionID, KMinLogLevel ,(_L("default")));
 }
 TInt CSenClientSession::ParseMessageL(TInt aTransactionId,
 const TDesC8& aRequest,
 CSenAtomEntry& aAtomEntry)
 {
-	CSLOG_L(iConnectionID, KMinLogLevel ,"CSenClientSession::ParseMessageL");
+	CSLOG_L(iConnectionID, KMinLogLevel ,"CSenClientSession::ParseMessageL(aTransactionId, aRequest, aAtomEntry)");
 CSenParser* pParser = CSenParser::NewLC();
 pParser->EnableFeature(EReportNamespaceMapping);
 	pParser->ParseL(aRequest, aAtomEntry);
 	// handle binary containers (BLOBs / attachments)
 }
 }
 }
 CleanupStack::PopAndDestroy(pParser);
+CSLOG_L(iConnectionID, KMinLogLevel ,"CSenClientSession::ParseMessageL(aTransactionId, aRequest, aAtomEntry) Completed");
 return KErrNone;
 }
 TInt CSenClientSession::ParseMessageL(TInt aTransactionId,
 const TDesC8& aRequest,
 CSenSoapEnvelope2& aSoapEnvelope)
 {
-CSLOG_L(iConnectionID, KMinLogLevel , "CSenClientSession::ParseMessageL");
+CSLOG_L(iConnectionID, KMinLogLevel , "CSenClientSession::ParseMessageL(aTransactionId, aRequest, aSoapEnvelope)");
 CSenParser* pParser = CSenParser::NewLC();
 pParser->EnableFeature(EReportNamespaceMapping);
 	pParser->ParseL(aRequest, aSoapEnvelope);
 		}
 CleanupStack::PopAndDestroy(&elementArray);
 }
 }
 CleanupStack::PopAndDestroy(pParser);
+CSLOG_L(iConnectionID, KMinLogLevel , "CSenClientSession::ParseMessageL(aTransactionId, aRequest, aSoapEnvelope) Completed");
 return retVal;
 }
 TInt CSenClientSession::SearchMsgChunk( const RMessage2& aMessage, CSenChunk*& aHit )
 {
 if ( pErrorMsg )
 {
 CleanupStack::PushL( pErrorMsg );
 }
 aSenChunk.ChunkHeader().SetContextId(transactionId); // temporary
-CSLOG_FORMAT((iConnectionID, KNormalLogLevel , _L8("SendMsgL - SetContextId: %d"), transactionId));
+CSLOG_FORMAT((iConnectionID, KMinLogLevel , _L8("SendMsgL - SetContextId: %d"), transactionId));
 }
 else
 {
 // "Add to ctx" -setter method failed, delete orphan msg:
 CleanupStack::PopAndDestroy(pSoapMessage);
 delete msg;
 return err;
 }
 void CSenClientSession::AddCredentialL( const RMessage2& aMessage )
 {
+CSLOG(iConnectionID, KMinLogLevel ,(_L("CSenClientSession::AddCredentialL()")));
 TInt retVal(KErrNone);
 CSenChunk* pSenChunk = NULL;
 pSenChunk = CSenChunk::NewLC(KNullDesC);
 pSenChunk->SetLogger(Log());
 	// Following takes the ownership of pIdp and pCredential
 iManager.AddCredentialL(pIdP, pCredential, retVal);
 	RWSDescriptionArray aMatches;
-	iManager.ServiceDescriptionsL(aMatches,*pSD);
+iManager.ServiceDescriptionsL(aMatches,*pSD);
-	CleanupClosePushL(aMatches);
+		CleanupClosePushL(aMatches);
 	for(TInt i = 0; i < aMatches.Count(); i++)
-	{
+		{
-		((CSenWebServiceSession*)aMatches[i])->AddCredentialObserverL(*pCredential);
+	if(((CSenWebServiceSession*)aMatches[i]) && pCredential)
-	}
+{
+	                      CSLOG_FORMAT((iConnectionID, KMinLogLevel , _L8("SD Type is = %d"), aMatches[i]->DescriptionClassType()));
+if( aMatches[i]->HasSuperClass( MSenServiceDescription::EServiceSession ) )
+	{
+CSLOG(iConnectionID, KMinLogLevel ,(_L("CSenClientSession::AddCredentialL() - Calling AddCredentialObserverL()")));
+((CSenWebServiceSession*)aMatches[i])->AddCredentialObserverL(*pCredential);
+CSLOG(iConnectionID, KMinLogLevel ,(_L("CSenClientSession::AddCredentialL() - Completed AddCredentialObserverL()")));
+	}
+else
+	{
+	CSLOG(iConnectionID, KMinLogLevel ,(_L("CSenClientSession::AddCredentialL() - SD is not the session object !!! ")));
+	}
+}
+		}
 CleanupStack::PopAndDestroy(&aMatches);
 CleanupStack::Pop(pCredential);
 CleanupStack::Pop(pIdP);
 }
 CleanupStack::PopAndDestroy(pSenChunk);
 aMessage.Complete(retVal);
+CSLOG(iConnectionID, KMinLogLevel ,(_L("CSenClientSession::AddCredentialL() Completed")));
 }
 void CSenClientSession::CredentialsL( const RMessage2& aMessage )
 {
 _LIT8(KNoProperties, "-");
 {
 TInt* pTxnId = txnIds[i];
 TInt cancelledTxnId(*pTxnId);
 txnIds.Remove(i);
 delete pTxnId;
+pTxnId = NULL;
 CSLOG_FORMAT((iConnectionID, KNormalLogLevel , _L8("- Now processing txn with id %d"), cancelledTxnId));
 // Attempt to cancel the actual activity on the transport layer.
 // Note that even if transport will not cancel this transaction,
 if ( retVal == KErrNone )
 {
 const RPointerArray<CSenIdentityProvider> pIdps = ((MSenCoreServiceManager&)iManager).IdentityProvidersL();
 const TInt count = pIdps.Count();
+CSLOG_FORMAT((iConnectionID, KMinLogLevel , _L8("- TOTAL IDP Found: %d"), count));
 // Calculate required heap allocation size:
 TInt size(0);
 if(count>0)
 {
 pBuf = NULL;
 }
 CSLOG_L(iConnectionID,KMaxLogLevel ,"- Requested descriptions:");
 CSLOG_ALL(iConnectionID,KMaxLogLevel ,(*pIdPrs));
+		     CSLOG_L(iConnectionID,KMinLogLevel ,"CSenClientSession::IdentityProviders completed");
 }
 #ifdef _SENDEBUG
 else
 {
-CSLOG_FORMAT((iConnectionID, KNormalLogLevel , _L8("- AllocDescToRMsgL failed: %d"), retVal));
+CSLOG_FORMAT((iConnectionID, KMinLogLevel , _L8("- AllocDescToRMsgL failed: %d"), retVal));
 }
 #endif // _SENDEBUG
 }
 CleanupStack::PopAndDestroy(pSenChunk); // Close SenChunk

changeset 23	a1df79fa35b4
parent 1	272b002df977