FCL/sf/mw/remoteconn: comparison backupandrestore/backupengine/src/abserver.cpp

equal deleted inserted replaced

-:a5deb6b96675
+:63cf70d3ecd8
 #include "abserver.h"
 #include "absession.h"
 #include "absessionmap.h"
 #include "sbedataownermanager.h"
 #include "sbepanic.h"
-#include "sblog.h"
+#include "OstTraceDefinitions.h"
+#include "sbtrace.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "abserverTraces.h"
+#endif
 namespace conn
 	{
 	/** Active Backup security request ranges
 	This is a breakdown of the active backup requests into ranges
 	for security checking purposes.
 		: CPolicyServer(EPriorityNormal,myABPolicy), iDOM(aDOM)
 /**
 Class constructor
 */
 		{
+		OstTraceFunctionEntry0( CABSERVER_CABSERVER_CONS_ENTRY );
 		__ASSERT_DEBUG(iDOM, Panic(KErrArgument));
+		OstTraceFunctionExit0( CABSERVER_CABSERVER_CONS_EXIT );
 		}
 	CABServer::~CABServer()
 /**
 Class destructor
 */
 		{
+		OstTraceFunctionEntry0( CABSERVER_CABSERVER_DES_ENTRY );
 		delete iSessionMap;
+		OstTraceFunctionExit0( CABSERVER_CABSERVER_DES_EXIT );
 		}
 	CABServer* CABServer::NewLC(CDataOwnerManager* aDOM)
 	/**
 	Constructs a new instance of the CABServer, calls ConstructL,
 	and returns it to the caller leaving it on the cleanup stack.
 	@return The new instance of CABServer.
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_NEWLC_ENTRY );
 		CABServer* pSelf = new (ELeave) CABServer(aDOM);
 		CleanupStack::PushL(pSelf);
 		pSelf->ConstructL();
+		OstTraceFunctionExit0( CABSERVER_NEWLC_EXIT );
 		return pSelf;
 		}
 	void CABServer::ConstructL()
 	/**
 	Construct this instance of CABServer.
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_CONSTRUCTL_ENTRY );
 		iSessionMap = CABSessionMap::NewL();
 		//
 		// Start the server
 		StartL(KABServerName);
+		OstTraceFunctionExit0( CABSERVER_CONSTRUCTL_EXIT );
 		}
 	void CABServer::AddSession()
 	/** Increments the server session count.
 	Remove the element with key aSecureId from the session map
 	@param aSecureId The key of the element to be removed
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_REMOVEELEMENT_ENTRY );
 		iSessionMap->Delete(aSecureId);
+		OstTraceFunctionExit0( CABSERVER_REMOVEELEMENT_EXIT );
 		}
 	void CABServer::SupplyDataL(TSecureId aSID, TDriveNumber aDriveNumber, TTransferDataType aTransferType,
 		TDesC8& aBuffer, TBool aLastSection, TBool aSuppressInitDataOwner, TSecureId aProxySID)
 	/**
 	@param aLastSection Flag to indicate whether this is the last operation in a multi-part transfer
 	@param aSuppressInitDataOwner Suppress the initialisation of Data Owner
 	@param aProxySID The secure ID of the proxy
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_SUPPLYDATAL_ENTRY );
 		CABSession& session = iSessionMap->SessionL(aSID);
 		session.SupplyDataL(aDriveNumber, aTransferType, aBuffer, aLastSection, aSuppressInitDataOwner, aProxySID);
+		OstTraceFunctionExit0( CABSERVER_SUPPLYDATAL_EXIT );
 		}
 	void CABServer::RequestDataL(TSecureId aSID, TDriveNumber aDriveNumber, TTransferDataType aTransferType,
 		TPtr8& aBuffer, TBool& aLastSection, TBool aSuppressInitDataOwner, TSecureId aProxySID)
 	/**
 	@param aLastSection Flag to indicate whether this is the last operation in a multi-part transfer
 	@param aSuppressInitDataOwner Suppress the initialisation of Data Owner
 	@param aProxySID The secure ID of the proxy
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_REQUESTDATAL_ENTRY );
 		CABSession& session = iSessionMap->SessionL(aSID);
 		session.RequestDataL(aDriveNumber, aTransferType, aBuffer, aLastSection, aSuppressInitDataOwner, aProxySID);
+		OstTraceFunctionExit0( CABSERVER_REQUESTDATAL_EXIT );
 		}
 	void CABServer::GetExpectedDataSizeL(TSecureId aSID, TDriveNumber aDriveNumber, TUint& aSize)
 	/**
 	Get the expected size of the data that will be returned
 	@param aSID The secure ID of the data owner to signal
 	@param aDriveNumber The drive number that the data corresponds to
 	@param aSize The size of the data owner's data
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_GETEXPECTEDDATASIZEL_ENTRY );
 		CABSession& session = iSessionMap->SessionL(aSID);
 		session.GetExpectedDataSizeL(aDriveNumber, aSize);
+		OstTraceFunctionExit0( CABSERVER_GETEXPECTEDDATASIZEL_EXIT );
 		}
 	void CABServer::AllSnapshotsSuppliedL(TSecureId aSID)
 	/** Lets the client know that all its snapshots have been supplied
 	@param aSID The secure ID of the data owner to signal
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_ALLSNAPSHOTSSUPPLIEDL_ENTRY );
 		CABSession& session = iSessionMap->SessionL(aSID);
 		session.AllSnapshotsSuppliedL();
+		OstTraceFunctionExit0( CABSERVER_ALLSNAPSHOTSSUPPLIEDL_EXIT );
 		}
 	void CABServer::InvalidateABSessions()
 	/** Set each CABSession currently hold for each active backup
 	 * client as invalid, since there maybe some delay for the
 	 * arrival of disconnect request from client. Within this time,
 	 * this session can not be used for another backup/restore.
 	 */
 		{
+		OstTraceFunctionEntry0( CABSERVER_INVALIDATEABSESSIONS_ENTRY );
 		iSessionMap->InvalidateABSessions();
+		OstTraceFunctionExit0( CABSERVER_INVALIDATEABSESSIONS_EXIT );
 		}
 	TDataOwnerStatus CABServer::SessionReadyStateL(TSecureId aSID)
 	/**
 	Returns the status of the active backup client
 	@param aSID The SecureId of the session to query for
 	@return Data owner status of the session
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_SESSIONREADYSTATEL_ENTRY );
 		CABSession& session = iSessionMap->SessionL(aSID);
 		TDataOwnerStatus doStatus = EDataOwnerNotConnected;
 		if (session.Invalidated())
 			{
-			__LOG1("CABServer::SessionReadyStateL session for 0x%08x has been invalidated, return NotConnected",
+			OstTrace1(TRACE_NORMAL, CABSERVER_SESSIONREADYSTATEL, "session for 0x%08x has been invalidated, return NotConnected",
-					aSID.iId);
+aSID.iId);
+			OstTraceFunctionExit0( CABSERVER_SESSIONREADYSTATEL_EXIT );
 			return doStatus;
 			}
 		if (session.CallbackInterfaceAvailable())
 			{
-			__LOG2("CABServer::SessionReadyStateL session for 0x%08x already have interface, confirmed:%d ",
+			OstTraceExt2(TRACE_NORMAL, DUP1_CABSERVER_SESSIONREADYSTATEL, "session for 0x%08x already have interface, confirmed:%d ",
-					aSID.iId, session.ConfirmedReadyForBUR());
+aSID.iId, static_cast<TInt32>(session.ConfirmedReadyForBUR()));
 			doStatus = EDataOwnerNotReady;
 			if (session.ConfirmedReadyForBUR())
 				{
 				doStatus = EDataOwnerReady;
 				}
 			}
 		else
 			{
-			__LOG2("CABServer::SessionReadyStateL session for 0x%08x does not have interface, confimed:%d",
+			OstTraceExt2(TRACE_NORMAL, DUP2_CABSERVER_SESSIONREADYSTATEL, "session for 0x%08x does not have interface, confimed:%d",
-								aSID.iId, session.ConfirmedReadyForBUR());
+aSID.iId, static_cast<TInt32>(session.ConfirmedReadyForBUR()));
 			doStatus = EDataOwnerNotReady;
 			if (session.ConfirmedReadyForBUR())
 				{
 				doStatus = EDataOwnerReadyNoImpl;
 				}
 			}
+		OstTraceFunctionExit0( DUP1_CABSERVER_SESSIONREADYSTATEL_EXIT );
 		return doStatus;
 		}
 	void CABServer::RestoreCompleteL(TSecureId aSID, TDriveNumber aDrive)
 	/**
 	@param aSID The secure Id of the active client for which the restore has completed
 	@param aDrive The drive number for which the restore has completed
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_RESTORECOMPLETEL_ENTRY );
 		CABSession& session = iSessionMap->SessionL(aSID);
 		session.RestoreCompleteL(aDrive);
+		OstTraceFunctionExit0( CABSERVER_RESTORECOMPLETEL_EXIT );
 		}
 	CSession2* CABServer::NewSessionL(const TVersion& aVersion,
 		const RMessage2& aMessage) const
 	/** Constructs a new AB session.
 	@param aMessage Is ignored
 	@return A new instance of CABSession
 	@leave KErrNotSupported if the version passed in aVersion is not the same as this one
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_NEWSESSIONL_ENTRY );
 		TVersion thisVersion(KABMajorVersionNumber,
 								KABMinorVersionNumber,
 								KABBuildVersionNumber);
 	    if (!User::QueryVersionSupported(thisVersion, aVersion))
 			{
+	        OstTrace0(TRACE_ERROR, CABSERVER_NEWSESSIONL, "Leave: KErrNotSupported");
 			User::Leave(KErrNotSupported);
 			}
 		TSecureId sid = aMessage.SecureId();
 		// The map creates the session and a map entry, then session ownership is passed to the server
-		return &(iSessionMap->CreateL(sid));
+		CSession2* newSession = &(iSessionMap->CreateL(sid));
+		OstTraceFunctionExit0( CABSERVER_NEWSESSIONL_EXIT );
+		return newSession;
 		}
 	TInt CABServer::RunError(TInt aError)
 	/** Called when this active objects RunL leaves.
 @param aError  Standard Symbian OS error code
 	@return The error code to be passed back to the active scheduler framework.
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_RUNERROR_ENTRY );
 		//
 		// A Bad descriptor is a bad client - panic it.
 		if(aError == KErrBadDescriptor)
 			{
 			PanicClient(KErrBadDescriptor);
 		//
 		// Complete the message and continue handling requests.
 		Message().Complete(aError);
 		ReStart();
+		OstTraceFunctionExit0( CABSERVER_RUNERROR_EXIT );
 		return KErrNone;
 		}
 	void CABServer::PanicClient(TInt aPanic) const
 	/** Panic a client.
 	@param aPanic The panic code.
 	*/
 		{
+		OstTraceFunctionEntry0( CABSERVER_PANICCLIENT_ENTRY );
 		__DEBUGGER()
 		_LIT(KPanicCategory,"AB Server");
 		RThread client;
 		Message().Client(client);
 		client.Panic(KPanicCategory, aPanic);
+		OstTraceFunctionExit0( CABSERVER_PANICCLIENT_EXIT );
 		}
 	} // end namespace

changeset 47	63cf70d3ecd8
parent 33	883e91c086aa