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

equal deleted inserted replaced

-:a5deb6b96675
+:63cf70d3ecd8
 #include "sbeclientsession.h"
 #include "sbeclientserver.h"
 #include <connect/sbtypes.h>
 #include "sbepanic.h"
+#include "OstTraceDefinitions.h"
+#include "sbtrace.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "sbeclientsessionTraces.h"
+#endif
 namespace conn
 	{
 	RSBEClientSession* RSBEClientSession::NewL()
 	/** Symbian OS constructor
 	@return pointer to an instantiated RSBEClientSession object */
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_NEWL_ENTRY );
 		RSBEClientSession* self = new (ELeave) RSBEClientSession();
 		CleanupStack::PushL(self);
 		self->ConstructL();
 		CleanupStack::Pop(self);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_NEWL_EXIT );
 		return self;
 		}
 	void RSBEClientSession::ConstructL()
 	/** Symbian second phase constructor */
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_CONSTRUCTL_ENTRY );
 iGSHInterface = CHeapWrapper::NewL();
+		OstTraceFunctionExit0( RSBECLIENTSESSION_CONSTRUCTL_EXIT );
 		}
 	RSBEClientSession::RSBEClientSession() : iCallbackHandler(NULL)
 	/** Class constructor. */
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_RSBECLIENTSESSION_CONS_ENTRY );
+		OstTraceFunctionExit0( RSBECLIENTSESSION_RSBECLIENTSESSION_CONS_EXIT );
 		}
 	RSBEClientSession::~RSBEClientSession()
 	/** Class destructor. */
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_RSBECLIENTSESSION_DES_ENTRY );
 		delete iGSHInterface;
 		delete iCallbackHandler;
+		OstTraceFunctionExit0( RSBECLIENTSESSION_RSBECLIENTSESSION_DES_EXIT );
 		}
 	void RSBEClientSession::Close()
 	/** Closes the Secure Backup Engine handle. */
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_CLOSE_ENTRY );
 		iGlobalSharedHeap.Close();
 		RSessionBase::Close();
+		OstTraceFunctionExit0( RSBECLIENTSESSION_CLOSE_EXIT );
 		}
 	TInt RSBEClientSession::Connect()
 	/** Connects the handle to the Secure Backup Engine.
 	@return KErrNone if successful, KErrCouldNotConnect otherwise
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_CONNECT_ENTRY );
 TInt nRetry = KSBERetryCount;
 		TInt nRet = KErrNotFound;
 		while(nRetry > 0 && nRet != KErrNone)
 			{
 		if (nRet == KErrNone)
 			{
 			nRet = GetGlobalSharedHeapHandle();
 			}
+		OstTraceFunctionExit0( RSBECLIENTSESSION_CONNECT_EXIT );
 		return nRet;
 		}
 	TVersion RSBEClientSession::Version() const
 	/** Returns the version of this API
 	with the SBE server (as its not running).
 	@return Standard Symbian OS code from RProcess/RThread create.
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_STARTSERVER_ENTRY );
 //
 		// Servers UID
 		const TUidType serverUid(KNullUid, KNullUid, KSBServerUID3);
 		RProcess server;
 	TInt nRet=server.Create(KSBImageName,KNullDesC,serverUid);
 	if (nRet != KErrNone)
 	    {
+		OstTraceFunctionExit0( RSBECLIENTSESSION_STARTSERVER_EXIT );
 		return nRet;
 		}
 	TRequestStatus stat;
 	server.Rendezvous(stat);
 	else
 		{
 		server.Resume();
 		}
 	User::WaitForRequest(stat);
-	return (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
+	nRet = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
+	OstTraceFunctionExit0( DUP1_RSBECLIENTSESSION_STARTSERVER_EXIT );
+	return nRet;
 		}
 	void RSBEClientSession::ListOfDataOwnersL(RPointerArray<CDataOwnerInfo>& aDataOwners)
 	@param aDataOwners Pointer array holding the list of Data owners requiring backup functionality.
 			Any items present in this array will be lost
 	*/
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_LISTOFDATAOWNERSL_ENTRY );
 		// Get the server to construct the flattened array and return the size of it
 		TInt result = SendReceive(ESBEMsgPrepDataOwnerInfo);
-		User::LeaveIfError(result);
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_LISTOFDATAOWNERSL, "Leave: %d", result));
 		iDataOwnersArray = &aDataOwners;
 		PopulateListOfDataOwnersL(result);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_LISTOFDATAOWNERSL_EXIT );
 		}
 	void RSBEClientSession::PublicFileListL(TDriveNumber aDrive, CSBGenericDataType& aGenericDataType,
 												RFileArray& aFiles)
 	/**
 	@param aGenericDataType Reference to the generic data type that is being passed to the SBEngine.
 	@param aFiles An empty array of file information that will be filled with details of the public files
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_PUBLICFILELISTL_ENTRY );
 		// request the public file list
 		TInt result = SendReceive(ESBEMsgPrepPublicFiles, TIpcArgs(aDrive,
 						&(aGenericDataType.Externalise())));
-		User::LeaveIfError(result);
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_PUBLICFILELISTL, "Leave: %d", result));
 		iFileArray = &aFiles;
 		PopulatePublicFileListL(result);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_PUBLICFILELISTL_EXIT );
 		}
 	void RSBEClientSession::RawPublicFileListL(	TDriveNumber aDrive,
 												CSBGenericDataType& aGenericDataType,
 												RRestoreFileFilterArray& aFileFilter)
 	@param aFileFilter Empty array that will be filled with the files/directories to be backed up
 	on return
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_RAWPUBLICFILELISTL_ENTRY );
 // ensure that the array is cleared out before populating with externalised data
 		aFileFilter.Reset();
 		TPckgC<TDriveNumber> drive(aDrive);
 		// request the public file list
 		TInt result = SendReceive(ESBEMsgPrepPublicFilesRaw, TIpcArgs(&drive,
 				&(aGenericDataType.Externalise())));
-		User::LeaveIfError(result);
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_RAWPUBLICFILELISTL, "Leave: %d", result));
 		// Create a descriptor big enough for the array to be externalised into
 		HBufC8* pFileArray = HBufC8::NewL(result);
 		CleanupStack::PushL(pFileArray);
 		TPtr8 fileArray(pFileArray->Des());
-		User::LeaveIfError(SendReceive(ESBEMsgGetPublicFilesRaw, TIpcArgs(&fileArray)));
+		result = SendReceive(ESBEMsgGetPublicFilesRaw, TIpcArgs(&fileArray));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, DUP1_RSBECLIENTSESSION_RAWPUBLICFILELISTL, "Leave: %d", result));
 		RRestoreFileFilterArray* pFileFilter = RRestoreFileFilterArray::InternaliseL(fileArray);
 		CleanupStack::PushL(pFileFilter);
 		CleanupClosePushL(*pFileFilter);
 			} // for x
 		CleanupStack::PopAndDestroy(pFileFilter); // CleanupClosePushL(*pFileFilter)
 		CleanupStack::PopAndDestroy(pFileFilter); // CleanupStack::PushL(pFileFilter)
 		CleanupStack::PopAndDestroy(pFileArray);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_RAWPUBLICFILELISTL_EXIT );
 		}
 	void RSBEClientSession::PublicFileListXMLL(TDriveNumber aDrive, TSecureId aSID, HBufC*& aFileList)
 	/**
 	Get the list of public files in XML format
 	@param aSID The SID of the data owner to get the public files for
 	@param aFileList The descriptor to populate on return should be NULL
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_PUBLICFILELISTXMLL_ENTRY );
 TPckgC<TDriveNumber> drive(aDrive);
 		TPckgC<TSecureId> sid(aSID);
 		// request the public file list
 		TInt result = SendReceive(ESBEMsgPrepPublicFilesXML, TIpcArgs(&drive, &sid));
-		User::LeaveIfError(result);
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_PUBLICFILELISTXMLL, "Leave: %d", result));
 		// Create a descriptor big enough for the array to be externalised into
 		aFileList = HBufC::NewL(result);
 		TPtr fileList(aFileList->Des());
-		User::LeaveIfError(SendReceive(ESBEMsgPrepPublicFilesXML, TIpcArgs(&fileList)));
+		result = SendReceive(ESBEMsgPrepPublicFilesXML, TIpcArgs(&fileList));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, DUP1_RSBECLIENTSESSION_PUBLICFILELISTXMLL, "Leave: %d", result));
+		OstTraceFunctionExit0( RSBECLIENTSESSION_PUBLICFILELISTXMLL_EXIT );
 		}
 	void RSBEClientSession::SetBURModeL(const TDriveList& aDriveList, TBURPartType aBURType,
 						  TBackupIncType aBackupIncType)
 	/**
 	@param aBURType Set the device into Full/Partial BUR or normal operation
 	@param aBackupIncType Base/Incremental backup
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
-		User::LeaveIfError(SendReceive(ESBEMsgSetBURMode, TIpcArgs(&aDriveList, aBURType, aBackupIncType)));
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_SETBURMODEL_ENTRY );
+		TInt result = SendReceive(ESBEMsgSetBURMode, TIpcArgs(&aDriveList, aBURType, aBackupIncType));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_SETBURMODEL, "Leave: %d", result));
+		OstTraceFunctionExit0( RSBECLIENTSESSION_SETBURMODEL_EXIT );
 		}
 	void RSBEClientSession::SetSIDListForPartialBURL(RSIDArray& aSIDs)
 	/**
 	If a partial backup is required then this sets the list of data owners.
 	@param aSIDs array of affected data owners.
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_SETSIDLISTFORPARTIALBURL_ENTRY );
 HBufC8* pFlattenedArray = aSIDs.ExternaliseL();
 		CleanupStack::PushL(pFlattenedArray);
 		TPtrC8 flatArray(pFlattenedArray->Des());
-		User::LeaveIfError(SendReceive(ESBEMsgSetSIDListPartial, TIpcArgs(&flatArray)));
+		TInt result = SendReceive(ESBEMsgSetSIDListPartial, TIpcArgs(&flatArray));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_SETSIDLISTFORPARTIALBURL, "Leave: %d", result));
 		CleanupStack::PopAndDestroy(pFlattenedArray);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_SETSIDLISTFORPARTIALBURL_EXIT );
 		}
 	void RSBEClientSession::SIDStatusL(RSIDStatusArray& aSIDStatus)
 	/**
 	Gets the status of a set of data owners.
 	@param aSIDStatus an array of structures for information about data owners. On return
 	the status information is filled in.
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_SIDSTATUSL_ENTRY );
 HBufC8* pExternalisedArray = aSIDStatus.ExternaliseL();
 		CleanupStack::PushL(pExternalisedArray);
 		TPtr8 externArray(pExternalisedArray->Des());
-		User::LeaveIfError(SendReceive(ESBEMsgPrepSIDStatus, TIpcArgs(&externArray)));
+		TInt result = SendReceive(ESBEMsgPrepSIDStatus, TIpcArgs(&externArray));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_SIDSTATUSL, "Leave: %d", result));
 		// Reset the descriptor, ready for getting the returned externalised array
 		externArray.Zero();
-		User::LeaveIfError(SendReceive(ESBEMsgGetSIDStatus, TIpcArgs(&externArray)));
+		result = SendReceive(ESBEMsgGetSIDStatus, TIpcArgs(&externArray));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, DUP1_RSBECLIENTSESSION_SIDSTATUSL, "Leave: %d", result));
 		RSIDStatusArray* pInternalisedArray = RSIDStatusArray::InternaliseL(externArray);
 		CleanupStack::PopAndDestroy(pExternalisedArray); // pExternalisedArray
 		CleanupStack::PushL(pInternalisedArray);
 			{
 			aSIDStatus.AppendL((*pInternalisedArray)[index]);
 			}
 		CleanupStack::PopAndDestroy(pInternalisedArray);	// pInternalisedArray->Close()
 		CleanupStack::PopAndDestroy(pInternalisedArray); // pInternalisedArray
+		OstTraceFunctionExit0( RSBECLIENTSESSION_SIDSTATUSL_EXIT );
 		}
 	TPtr8& RSBEClientSession::TransferDataAddressL()
 	/**
 	Provides access to the base of the global chunk used to transfer data between
 	@param aGenericTransferType Pointer reference that a Generic Transfer Type is allocated to
 	@param aFinished Flag that will be set to ETrue if the data on the GSH is the last in the series
 	@return Pointer to the start of the buffer for reading
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_TRANSFERDATAINFOL_ENTRY );
 TPtrC8& returnedBuf = iGSHInterface->ReadBufferL(iGlobalSharedHeap);
 		TDesC8& genTypeBuffer = iGSHInterface->Header(iGlobalSharedHeap).GenericTransferTypeBuffer();
 		if (genTypeBuffer.Size() == 0)
 			{
+		    OstTrace0(TRACE_ERROR, RSBECLIENTSESSION_TRANSFERDATAINFOL, "Leave: KErrNotReady");
 			User::Leave(KErrNotReady);
 			}
 		// Create a new client-side transfer type and pass ownership
 		aGenericTransferType = CSBGenericTransferType::NewL(genTypeBuffer);
 		aFinished = iGSHInterface->Header(iGlobalSharedHeap).iFinished;
 		CleanupStack::Pop(aGenericTransferType);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_TRANSFERDATAINFOL_EXIT );
 		return returnedBuf;
 		}
 	TInt RSBEClientSession::GetGlobalSharedHeapHandle()
 	/**
 	sets the member RChunk with it.
 	@return An error code resulting from the server request for the handle, KErrNone if ok
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_GETGLOBALSHAREDHEAPHANDLE_ENTRY );
 TInt ret = SendReceive(ESBEMsgGetGSHHandle);
 		// ret is negative if an error has ocurred
 		if (ret > KErrNone)
 			{
 			// Since a handle was returned, there were no errors
 			ret = KErrNone;
 			}
+		OstTraceFunctionExit0( RSBECLIENTSESSION_GETGLOBALSHAREDHEAPHANDLE_EXIT );
 		return ret;
 		}
 	void RSBEClientSession::RequestDataL(CSBGenericTransferType& aGenericTransferType,
 		TRequestStatus& aStatus)
 	@param aGenericTransferType Reference to the identifier of the data requested
 	@param aStatus TRequestStatus object used by the server to signal the client that a response
 	is ready
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_REQUESTDATAL_ENTRY );
 const TDesC8& transBuf = aGenericTransferType.Externalise();
 		SendReceive(ESBEMsgRequestDataAsync, TIpcArgs(&transBuf), aStatus);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_REQUESTDATAL_EXIT );
 		}
 	void RSBEClientSession::RequestDataL(CSBGenericTransferType& aGenericTransferType)
 	/**
 	Synchronous request of the Secure Backup Engine to supply data for a particular data owner.
 	@param aGenericTransferType Reference to the identifier of the data requested
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
-User::LeaveIfError(SendReceive(ESBEMsgRequestDataSync,
+OstTraceFunctionEntry0( DUP1_RSBECLIENTSESSION_REQUESTDATAL_ENTRY );
-			TIpcArgs(&(aGenericTransferType.Externalise()))));
+TInt result = SendReceive(ESBEMsgRequestDataSync, TIpcArgs(&(aGenericTransferType.Externalise())));
+LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, DUP1_RSBECLIENTSESSION_REQUESTDATAL, "Leave: %d", result));
+		OstTraceFunctionExit0( DUP1_RSBECLIENTSESSION_REQUESTDATAL_EXIT );
 		}
 	void RSBEClientSession::SupplyDataL(CSBGenericTransferType& aGenericTransferType,
 		TBool aFinished, TRequestStatus& aStatus)
 	/**
 	@param aFinished ETrue indicates that additional SupplyDataL calls will be made as
 	part of this transfer operation
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_SUPPLYDATAL_ENTRY );
 iGSHInterface->Header(iGlobalSharedHeap).GenericTransferTypeBuffer()
 			= aGenericTransferType.Externalise();
 		SendReceive(ESBEMsgSupplyDataSync, TIpcArgs(aFinished), aStatus);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_SUPPLYDATAL_EXIT );
 		}
 	void RSBEClientSession::SupplyDataL(CSBGenericTransferType& aGenericTransferType,
 		TBool aFinished)
 	/**
 	@param aFinished ETrue indicates that additional SupplyDataL calls will be made as
 	part of this transfer operation
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
+OstTraceFunctionEntry0( DUP1_RSBECLIENTSESSION_SUPPLYDATAL_ENTRY );
 iGSHInterface->Header(iGlobalSharedHeap).GenericTransferTypeBuffer()
 			= aGenericTransferType.Externalise();
-		User::LeaveIfError(SendReceive(ESBEMsgSupplyDataSync, TIpcArgs(aFinished)));
+TInt result = SendReceive(ESBEMsgSupplyDataSync, TIpcArgs(aFinished));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, DUP1_RSBECLIENTSESSION_SUPPLYDATAL, "Leave: %d", result));
+		OstTraceFunctionExit0( DUP1_RSBECLIENTSESSION_SUPPLYDATAL_EXIT );
 		}
 	void RSBEClientSession::AllSnapshotsSuppliedL()
 	/**
 	This methods informs the data owner that all snapshots have been supplied.
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
-User::LeaveIfError(SendReceive(ESBEMsgAllSnapshotsSupplied));
+OstTraceFunctionEntry0( RSBECLIENTSESSION_ALLSNAPSHOTSSUPPLIEDL_ENTRY );
+TInt result = SendReceive(ESBEMsgAllSnapshotsSupplied);
+LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_ALLSNAPSHOTSSUPPLIEDL, "Leave: %d", result));
+		OstTraceFunctionExit0( RSBECLIENTSESSION_ALLSNAPSHOTSSUPPLIEDL_EXIT );
 		}
 	TUint RSBEClientSession::ExpectedDataSizeL(CSBGenericTransferType& aGenericTransferType)
 	/**
 	Get the expected total size of the data to be returned by the SBE for the purposes
 	@param aGenericTransferType Reference to the identifier of the data to be retrieved
 	@leave If a synchronous IPC call to the SBEngine returns an error code (i.e. if SBEngine leaves)
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_EXPECTEDDATASIZEL_ENTRY );
 TPckgBuf<TUint> sizePkg;
 		TPtrC8 genType(aGenericTransferType.Externalise());
-		User::LeaveIfError(SendReceive(ESBEMsgGetExpectedDataSize, TIpcArgs(&genType, &sizePkg)));
+		TInt result = SendReceive(ESBEMsgGetExpectedDataSize, TIpcArgs(&genType, &sizePkg));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_EXPECTEDDATASIZEL, "Leave: %d", result));
-		return sizePkg();
+		TUint size = sizePkg();
+		OstTraceFunctionExit0( RSBECLIENTSESSION_EXPECTEDDATASIZEL_EXIT );
+		return size;
 		}
 	void RSBEClientSession::AllSystemFilesRestored()
 	/**
 	Signal the Secure Backup Engine that registration files are to be parsed and Active data owners
 	are to be started
 	*/
 		{
+OstTraceFunctionEntry0( RSBECLIENTSESSION_ALLSYSTEMFILESRESTORED_ENTRY );
 SendReceive(ESBEMsgAllSystemFilesRestored);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_ALLSYSTEMFILESRESTORED_EXIT );
 		}
 	/**
 	Return the list of private data owners on the device that have backup registration files.
 	If a leave does occur, then aDataOwners
 			Any items present in this array will be lost
 	@param aStatus is TRequestStatus&
 	*/
 	void RSBEClientSession::ListOfDataOwnersL(RPointerArray<CDataOwnerInfo>& aDataOwners, TRequestStatus& aStatus)
 		{
+		OstTraceFunctionEntry0( DUP1_RSBECLIENTSESSION_LISTOFDATAOWNERSL_ENTRY );
 		if (iCallbackHandler == NULL)
 			{
 			iCallbackHandler = CSBECallbackHandler::NewL(*this);
 			}
 		if (iCallbackHandler->IsActive())
 			{
+		    OstTrace0(TRACE_ERROR, DUP1_RSBECLIENTSESSION_LISTOFDATAOWNERSL, "Leave: KErrInUse");
 			User::Leave(KErrInUse);
 			}
 		else
 			{
 			iDataOwnersArray = &aDataOwners;
 			SendReceive(ESBEMsgPrepDataOwnerInfo, iCallbackHandler->iStatus);
 			iCallbackHandler->StartL(aStatus, EListOfDataOwners);
 			}
+		OstTraceFunctionExit0( DUP1_RSBECLIENTSESSION_LISTOFDATAOWNERSL_EXIT );
 		}
 	/**
 	Get the list of public files to backup for a particular Data Owner on a particular drive
 	@param aStatus A reference to TRequestStatus
 	*/
 	void RSBEClientSession::PublicFileListL(TDriveNumber aDrive, CSBGenericDataType& aGenericDataType, RFileArray& aFiles, TRequestStatus& aStatus)
 		{
+		OstTraceFunctionEntry0( DUP1_RSBECLIENTSESSION_PUBLICFILELISTL_ENTRY );
 		if (iCallbackHandler == NULL)
 			{
 			iCallbackHandler = CSBECallbackHandler::NewL(*this);
 			}
 		if (iCallbackHandler->IsActive())
 			{
+		    OstTrace0(TRACE_ERROR, DUP1_RSBECLIENTSESSION_PUBLICFILELISTL, "Leave: KErrInUse");
 			User::Leave(KErrInUse);
 			}
 		else
 			{
 			iFileArray = &aFiles;
 			// request the public file list
 			SendReceive(ESBEMsgPrepPublicFiles, TIpcArgs(aDrive, &(aGenericDataType.Externalise())), iCallbackHandler->iStatus);
 			iCallbackHandler->StartL(aStatus,EPublicFileList);
 			}
+		OstTraceFunctionExit0( DUP1_RSBECLIENTSESSION_PUBLICFILELISTL_EXIT );
 		}
 	void RSBEClientSession::SetBURModeL(const TDriveList& aDriveList, TBURPartType aBURType,
 								  TBackupIncType aBackupIncType, TRequestStatus& aStatus)
 	/**
 	@param aBackupIncType Base/Incremental backup
 	@param aStatus A reference to TRequestStatus
 	*/
 		{
+		OstTraceFunctionEntry0( DUP1_RSBECLIENTSESSION_SETBURMODEL_ENTRY );
 		SendReceive(ESBEMsgSetBURMode, TIpcArgs(&aDriveList, aBURType, aBackupIncType), aStatus);
+		OstTraceFunctionExit0( DUP1_RSBECLIENTSESSION_SETBURMODEL_EXIT );
 		}
 	/**
 	This methods informs the data owner that all snapshots have been supplied.
 	@param aStatus A reference to TRequestStatus
 	*/
 	void RSBEClientSession::AllSnapshotsSuppliedL(TRequestStatus& aStatus)
 		{
+		OstTraceFunctionEntry0( DUP1_RSBECLIENTSESSION_ALLSNAPSHOTSSUPPLIEDL_ENTRY );
 		SendReceive(ESBEMsgAllSnapshotsSupplied, aStatus);
+		OstTraceFunctionExit0( DUP1_RSBECLIENTSESSION_ALLSNAPSHOTSSUPPLIEDL_EXIT );
 		}
 	/**
 	Signal the Secure Backup Engine that registration files are to be parsed and Active data owners
 	are to be started
 	@param aStatus A reference to TRequestStatus
 	*/
 	void RSBEClientSession::AllSystemFilesRestoredL(TRequestStatus& aStatus)
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_ALLSYSTEMFILESRESTOREDL_ENTRY );
 		SendReceive(ESBEMsgAllSystemFilesRestored, aStatus);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_ALLSYSTEMFILESRESTOREDL_EXIT );
 		}
 	/**
 	Method to perform and IPC call to populate list of data owners.
 	@InternalTechnology
 	*/
 	void RSBEClientSession::PopulateListOfDataOwnersL(TUint aBufferSize)
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_POPULATELISTOFDATAOWNERSL_ENTRY );
 		__ASSERT_DEBUG(iDataOwnersArray, Panic(KErrBadHandle));
 		iDataOwnersArray->ResetAndDestroy();
 		// Create a descriptor that's appropriate to hold the buffer to be returned
 		HBufC8* pReturnedBuf = HBufC8::NewL(aBufferSize);
 		CleanupStack::PushL(pReturnedBuf);
 		TPtr8 returnedBuf(pReturnedBuf->Des());
 		// Request that the server returns the previously packed array
 		TInt result = SendReceive(ESBEMsgGetDataOwnerInfo, TIpcArgs(&returnedBuf));
-		User::LeaveIfError(result);
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_POPULATELISTOFDATAOWNERSL, "Leave: %d", result));
 		TInt offset = 0;
 		for (TInt index = 0; index < result; index++)
 			{
 			offset += (*iDataOwnersArray)[index]->Size();
 			}
 		CleanupStack::PopAndDestroy(pReturnedBuf);
+		OstTraceFunctionExit0( RSBECLIENTSESSION_POPULATELISTOFDATAOWNERSL_EXIT );
 		}
 	/**
 	Method to perform and IPC call to populate list of public files.
 	@param aBufferSize Size of the buffer needed to be allocated for the IPC call
 	@InternalTechnology
 	*/
 	void RSBEClientSession::PopulatePublicFileListL(TUint aBufferSize)
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_POPULATEPUBLICFILELISTL_ENTRY );
 		__ASSERT_DEBUG(iFileArray, Panic(KErrBadHandle));
 		iFileArray->Reset();
 		// Create a descriptor big enough for the array to be externalised into
 		HBufC8* pFileArray = HBufC8::NewL(aBufferSize);
 		CleanupStack::PushL(pFileArray);
 		TPtr8 fileArray(pFileArray->Des());
-		User::LeaveIfError(SendReceive(ESBEMsgGetPublicFiles, TIpcArgs(&fileArray)));
+		TInt result = SendReceive(ESBEMsgGetPublicFiles, TIpcArgs(&fileArray));
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_POPULATEPUBLICFILELISTL, "Leave: %d", result));
 		RFileArray* pFiles = RFileArray::InternaliseL(fileArray);
 		CleanupStack::PopAndDestroy(pFileArray);
 		CleanupStack::PushL(pFiles);
 		CleanupClosePushL(*pFiles);
 			pFiles->Remove(0);					// We're running out of memory, hence be frugal
 			} // for x
 		CleanupStack::PopAndDestroy(pFiles); // CleanupClosePushL(*pFiles)
 		CleanupStack::PopAndDestroy(pFiles); // CleanupStack::PushL(pFiles)
+		OstTraceFunctionExit0( RSBECLIENTSESSION_POPULATEPUBLICFILELISTL_EXIT );
 		}
 	void RSBEClientSession::PublicFileListL(TDriveNumber aDrive, CSBGenericDataType& aGenericDataType,
 								RPointerArray<CSBEFileEntry>& aFileList, TBool& aFinished,
 								TInt aTotalListCursor, TInt aMaxResponseSize, TRequestStatus& aStatus)
 						method can be determined by querying the count of aFileList
 	@param aMaxResponseSize The maximum total size in bytes of externalised CSBEFileEntry objects that will be returned
 	@param aStatus The TRequestStatus that will be completed once the engine has fully processed this request
 	*/
 		{
+		OstTraceFunctionEntry0( DUP2_RSBECLIENTSESSION_PUBLICFILELISTL_ENTRY );
 		if (iCallbackHandler == NULL)
 			{
 			iCallbackHandler = CSBECallbackHandler::NewL(*this);
 			}
 		if (iCallbackHandler->IsActive())
 			{
+		    OstTrace0(TRACE_ERROR, DUP2_RSBECLIENTSESSION_PUBLICFILELISTL, "Leave: KErrInUse");
 			User::Leave(KErrInUse);
 			}
 		else
 			{
 			iFileList = &aFileList;
 			SendReceive(ESBEMsgPrepLargePublicFiles, TIpcArgs(static_cast<TInt>(aDrive),
 				&(aGenericDataType.Externalise()), aTotalListCursor, aMaxResponseSize),
 				iCallbackHandler->iStatus);
 			iCallbackHandler->StartL(aStatus,ELargePublicFileList);
 			}
+		OstTraceFunctionExit0( DUP2_RSBECLIENTSESSION_PUBLICFILELISTL_EXIT );
 		}
 	void RSBEClientSession::PopulateLargePublicFileListL(TInt aResult)
 	/**
 	Callback following the asynchronous completion of the request for the public file list
 	@param aResult The error code returned by the engine as a result of the initial request
 	*/
 		{
+		OstTraceFunctionEntry0( RSBECLIENTSESSION_POPULATELARGEPUBLICFILELISTL_ENTRY );
 		// Retrieve the return parameters (finished flag and entry count) from SBE
 		if (KErrNone == aResult)
 			{
 			TBool finishedFlag;
 			TInt numEntries;
 			TPckg<TBool> finishPkg(finishedFlag);
 			TPckg<TInt> numEntriesPkg(numEntries);
-			User::LeaveIfError(SendReceive(ESBEMsgGetLargePublicFiles, TIpcArgs(&finishPkg, &numEntriesPkg)));
+			TInt result = SendReceive(ESBEMsgGetLargePublicFiles, TIpcArgs(&finishPkg, &numEntriesPkg));
+			LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, RSBECLIENTSESSION_POPULATELARGEPUBLICFILELISTL, "Leave: %d", result));
 			*iFinished = finishPkg();
 			TInt numberOfReturnedEntries = numEntriesPkg();
 			iFileList->ResetAndDestroy();
 			}
 		else
 			{
 			*iFinished = EFalse;
 			}
+		OstTraceFunctionExit0( RSBECLIENTSESSION_POPULATELARGEPUBLICFILELISTL_EXIT );
 		}
 	//
 	// CSBECallbackHandler //
 	@param aClientSession reference to a ClientSession to call callbacks on
 	@return pointer to an instantiated RSBEClientSession object
 	*/
 	CSBECallbackHandler* CSBECallbackHandler::NewL(RSBEClientSession& aClientSession)
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_NEWL_ENTRY );
 		CSBECallbackHandler* self = new (ELeave) CSBECallbackHandler(aClientSession);
 		CleanupStack::PushL(self);
 		self->ConstructL();
 		CleanupStack::Pop(self);
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_NEWL_EXIT );
 		return self;
 		}
 	/** Symbian second phase constructor */
 	void CSBECallbackHandler::ConstructL()
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_CONSTRUCTL_ENTRY );
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_CONSTRUCTL_EXIT );
 		}
 	/** Class constructor. */
 	CSBECallbackHandler::CSBECallbackHandler(RSBEClientSession& aClientSession)
 		: CActive(EPriorityNormal), iClientSession(aClientSession)
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_CSBECALLBACKHANDLER_CONS_ENTRY );
 		CActiveScheduler::Add(this);
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_CSBECALLBACKHANDLER_CONS_EXIT );
 		}
 	/** Class destructor. */
 	CSBECallbackHandler::~CSBECallbackHandler()
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_CSBECALLBACKHANDLER_DES_ENTRY );
 		Cancel();
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_CSBECALLBACKHANDLER_DES_EXIT );
 		}
 	/** Starts Callback Handler
 	@param aStatus Reference to the Client's request Status
 	@param aState State in order to make a relevant callback
 	*/
 	void CSBECallbackHandler::StartL(TRequestStatus& aStatus, TState aState)
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_STARTL_ENTRY );
 		aStatus = KRequestPending;
 		iObserver = &aStatus;
 		iState = aState;
 		SetActive();
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_STARTL_EXIT );
 		}
 	/**
 	Cancels outsanding request
 	*/
 	void CSBECallbackHandler::CancelRequest()
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_CANCELREQUEST_ENTRY );
 		Cancel();
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_CANCELREQUEST_EXIT );
 		}
 	/**
 	CActive::RunL() implementation
 	*/
 	void CSBECallbackHandler::RunL()
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_RUNL_ENTRY );
 		TInt result = iStatus.Int();
 		if (result >= KErrNone)
 			{
 			switch (iState)
 				{
 				result = KErrNotSupported;
 				break;
 				} //switch
 			} // if
-		User::LeaveIfError(result);
+		LEAVEIFERROR(result, OstTrace1(TRACE_ERROR, CSBECALLBACKHANDLER_RUNL, "Leave: %d", result));
 		CompleteObserver(KErrNone);
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_RUNL_EXIT );
 		}
 	/**
 	CActive::DoCancel() implmenation
 	Completes observer's status with KErrCancel and sets the state to None
 	*/
 	void CSBECallbackHandler::DoCancel()
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_DOCANCEL_ENTRY );
 		iState = ENone;
 		// just to avoid repeating the code
 		CompleteObserver(KErrCancel);
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_DOCANCEL_EXIT );
 		}
 	/**
 	Method for completing Client's request status
 	@param aError Completion Error
 	*/
 	void CSBECallbackHandler::CompleteObserver(TInt aError)
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_COMPLETEOBSERVER_ENTRY );
 		if(iObserver)
 			{
 			User::RequestComplete(iObserver, aError);
 			iObserver = NULL;
 			}
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_COMPLETEOBSERVER_EXIT );
 		}
 	/**
 	If RunL() leaves a CompleteObserver() method called
 	@aError Error code
 	*/
 	TInt CSBECallbackHandler::RunError(TInt aError)
 		{
+		OstTraceFunctionEntry0( CSBECALLBACKHANDLER_RUNERROR_ENTRY );
 		CompleteObserver(aError);
+		OstTraceFunctionExit0( CSBECALLBACKHANDLER_RUNERROR_EXIT );
 		return KErrNone;
 		}
 	} // conn namespace

changeset 47	63cf70d3ecd8
parent 33	883e91c086aa