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

equal deleted inserted replaced

-:a5deb6b96675
+:63cf70d3ecd8
 @file
 */
 #include "sbedataowner.h"
 #include "sbebufferhandler.h"
 #include "sbpackagedatatransfer.h"
-#include "sblog.h"
 #include <babackup.h>
 #include <swi/backuprestore.h>
 #include <swi/sisregistryentry.h>
 #include <swi/sisregistrypackage.h>
 #include "sbeparserdefs.h"
+#include "OstTraceDefinitions.h"
+#include "sbtrace.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "sbpackagedatatransferTraces.h"
+#endif
 namespace conn
 	{
 	_LIT(KSys, "?:\\sys\\*");
 	_LIT(KResource, "?:\\resource\\*");
 	@param aPid Package Id
 	@return a CPackageDataTransfer object
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_NEWL_ENTRY );
 		CPackageDataTransfer* self = CPackageDataTransfer::NewLC(aPid, aDOM);
 		CleanupStack::Pop(self);
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_NEWL_EXIT );
 		return self;
 		}
 	CPackageDataTransfer* CPackageDataTransfer::NewLC(TUid aPid, CDataOwnerManager* aDOM)
 	/** Standard Symbian Constructor
 	@param aPid Package Id
 	@return a CPackageDataTransfer object
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_NEWLC_ENTRY );
 		CPackageDataTransfer *self = new(ELeave) CPackageDataTransfer(aPid, aDOM);
 		CleanupStack::PushL(self);
 		self->ConstructL();
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_NEWLC_EXIT );
 		return self;
 		}
 	CPackageDataTransfer::CPackageDataTransfer(TUid aPid, CDataOwnerManager* aDOM) :
 	/** Standard C++ Constructor
 	*/
 		iBufferSnapshotReader(NULL),
 		iBufferFileWriter(NULL), iBufferSnapshotWriter(NULL),
 		iPackageID(aPid), iSnapshot(NULL), iMetaData(NULL), ipDataOwnerManager(aDOM), iRestored(EFalse)
 	  	{
+	  	OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_CPACKAGEDATATRANSFER_CONS_ENTRY );
 	  	// needed for intiliazion
 	  	iDriveList.SetLength(KMaxDrives);
 	  	iDriveList.FillZ();
 	  	// needed for hashes in registry on drive C (i.e. MMC card app's hash)
 	  	iDriveList[EDriveC] = ETrue;
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_CPACKAGEDATATRANSFER_CONS_EXIT );
 		}
 	void CPackageDataTransfer::ConstructL()
 	/** Standard Symbian second phase constructor
 	*/
 		{
-		User::LeaveIfError(iSWIRestore.Connect());
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_CONSTRUCTL_ENTRY );
-		User::LeaveIfError(iSWIBackup.Connect());
+		TInt err = iSWIRestore.Connect();
-		User::LeaveIfError(iFs.Connect());
+		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_CONSTRUCTL, "error = %d", err));
-		User::LeaveIfError(iFs.ShareProtected());
+		err = iSWIBackup.Connect();
+		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP1_CPACKAGEDATATRANSFER_CONSTRUCTL, "error = %d", err));
+		err = iFs.Connect();
+		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_CONSTRUCTL, "error = %d", err));
+		err = iFs.ShareProtected();
+		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP3_CPACKAGEDATATRANSFER_CONSTRUCTL, "error = %d", err));
 		iRegistrationFile = HBufC::NewL(0);
 		iFileName = HBufC::NewL(KMaxFileName);
 		iTempFileName = HBufC::NewL(KMaxFileName);
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_CONSTRUCTL_EXIT );
 		}
 	CPackageDataTransfer::~CPackageDataTransfer()
 	/** Standard C++ Destructor
 	*/
 	  	{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_CPACKAGEDATATRANSFER_DES_ENTRY );
 		iSWIRestore.Close();
 		iSWIBackup.Close();
 		iFileHandle.Close();
 		iFiles.ResetAndDestroy();
 		iPublicSelections.ResetAndDestroy();
 		delete iSnapshot;
 		delete iMetaData;
 		delete iFileName;
 		delete iTempFileName;
 		iFs.Close();
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_CPACKAGEDATATRANSFER_DES_EXIT );
 		}
 	void CPackageDataTransfer::WriteData(TAny* aItem, TPtr8& aBuffer,
 										 TInt aSize)
 	@param aItem Item to write
 	@param aBuffer Buffer to write aItem to
 	@param aSize Size of the aItem
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_WRITEDATA_ENTRY );
 		TUint8 *pos = reinterpret_cast<TUint8*>(aItem);
 		for (TInt i = 0; i < aSize; ++i)
 			{
 			aBuffer.Append(pos[i]);
 			}
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_WRITEDATA_EXIT );
 		}
 	TUid CPackageDataTransfer::PackageId() const
 	/** Returns the package Id
 	@param apSnapshot (OPTIONAL)A file will only be included if the file is not
 					  in the snapshot is newer than the file in the snapshot
 	@param aFileNames on return the list of files
 	*/
 		{
-		__LOG("CPackageDataTransfer::BuildPackageFileListL() - START");
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_BUILDPACKAGEFILELIST_ENTRY );
 		// Establish a connection to the registry and read the list of
 		// filenames into array.
 		//
 		iDriveList.SetLength(KMaxDrives);
 		iDriveList.FillZ();
 		// also set EDriveC to True for hashesh of the registry
 		iDriveList[EDriveC] = ETrue;
 		TUint count = iFiles.Count();
-		__LOG1("CPackageDataTransfer::BuildPackageFileListL() - No of files: %d", count);
+		OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_BUILDPACKAGEFILELIST, "No of files: %d", count);
 		while (count > 0)
 			{
 			count--;
 			TBool remove = EFalse;
 			TFileName fileName (*iFiles[count]);
 					}
 				}
 			} // for
-		#ifdef SBE_LOGGING_ENABLED
+const TUint fNameCount = iFiles.Count();
-			const TUint fNameCount = iFiles.Count();
+if  (fNameCount)
-	        if  (fNameCount)
+{
-	            {
+for(TUint k=0; k<fNameCount; k++)
-	            for(TUint k=0; k<fNameCount; k++)
+{
-	                {
+const TDesC& file = *iFiles[k];
-	                const TDesC& file = *iFiles[k];
+OstTraceExt2(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_BUILDPACKAGEFILELIST, "Files Added - file entry[%03d] %S", static_cast<TInt32>(k), file);
-	                __LOG2("CPackageDataTransfer::BuildPackageFileListL() - Files Added - file entry[%03d] %S", k, &file);
+}
-	                }
+}
-	            }
-		#endif
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_BUILDPACKAGEFILELIST_EXIT );
-		__LOG("CPackageDataTransfer::BuildPackageFileListL() - END");
 		}
 	void CPackageDataTransfer::GetExpectedDataSizeL(TPackageDataType aTransferType, TDriveNumber aDriveNumber, TUint& aSize)
 	/** Get the expected data size of a request for data
 	@param aTransferType the type of data to check the size of
 	@param aDriveNumber the drive to check
 	@param aSize on return the size of the data
 	*/
 		{
-		__LOG("CPackageDataTransfer::GetExpectedDataSizeL - Begin getmetadata");
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL_ENTRY );
+		OstTrace0(TRACE_NORMAL, CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "Begin getmetadata");
 		if (iMetaData == NULL)
 			{
 			TRAPD(err, iMetaData = iSWIBackup.GetMetaDataL(iPackageID, iFiles));
 			if(KErrNotSupported == err)
 			    {//Non-Removable package, nothing to backup
 			    aSize = 0;
-			    __LOG("CPackageDataTransfer::GetExpectedDataSizeL - GetMetaDataL - KErrNotSupported");
+			    OstTrace0(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "GetMetaDataL - KErrNotSupported");
+			    OstTraceFunctionExit0( CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL_EXIT );
 			    return;
 			    }
 			else if(KErrNone != err)
 			    {
-			    __LOG1("CPackageDataTransfer::GetExpectedDataSizeL - GetMetaDataL leave with %d", err);
+			    OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "GetMetaDataL leave with %d", err);
 			    User::Leave(err);
 			    }
 			iMetaDataSize = iMetaData->Size();
 			BuildPackageFileList();
 			}
-		__LOG("CPackageDataTransfer::GetExpectedDataSizeL - End getmetadata");
+		OstTrace0(TRACE_NORMAL, DUP3_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "End getmetadata");
 		if (!IsDataOnDrive(aDriveNumber))
 			{
 			// no data on drive
 			aSize = 0;
+			OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL_EXIT );
 			return;
 			}
 		aSize = iMetaData->Size();
 		TUint count = iFiles.Count();
 		switch (aTransferType)
 			{
 			case ESystemSnapshotData:
 				{
-				__LOG1("CPackageDataTransfer::GetExpectedDataSizeL() - START - ESystemSnapshotData - aDriveNumber: %c", aDriveNumber + 'A');
+				OstTraceExt1(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "ESystemSnapshotData - aDriveNumber: %c", aDriveNumber + 'A');
 				// Find all files
 				aSize = (count * sizeof(TSnapshot));
-				__LOG1("CPackageDataTransfer::GetExpectedDataSizeL() - passive snapshot count: %d", count);
+				OstTrace1(TRACE_NORMAL, DUP5_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "passive snapshot count: %d", count);
 				for (TUint x = 0; x < count; x++)
 					{
 					const TDesC& fileName = *iFiles[x];
 	const TInt fileSize = fileName.Length();;
-	__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - passive snapshot file: %S, size: %d", &fileName, fileSize);
+	OstTraceExt2(TRACE_NORMAL, DUP6_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "passive snapshot file: %S, size: %d", fileName, fileSize);
 					aSize += fileSize;
 					} // for x
 				break;
 				}
 			case ESystemData:
 				{
-				__LOG1("CPackageDataTransfer::GetExpectedDataSizeL() - START - ESystemData - aDriveNumber: %c", aDriveNumber + 'A');
+				OstTraceExt1(TRACE_NORMAL, DUP7_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "ESystemData - aDriveNumber: %c", aDriveNumber + 'A');
 				aSize += sizeof(TInt);
 				TEntry entry;
-				__LOG1("CPackageDataTransfer::GetExpectedDataSizeL() - passive file count: %d", count);
+				OstTrace1(TRACE_NORMAL, DUP8_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "passive file count: %d", count);
 				for (TUint x = 0; x < count; x++)
 					{
 					const TDesC& fileName = *iFiles[x];
 					TInt err = iFs.Entry(fileName, entry);
 					TUint fileSize = entry.iSize;
-					__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - passive file: %S, size: %d", &fileName, fileSize);
+					OstTraceExt2(TRACE_NORMAL, DUP9_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "passive file: %S, size: %d", fileName, static_cast<TInt32>(fileSize));
 					switch(err)
 						{
 					case KErrNone:
 						aSize += fileSize;
 						break;
 					case KErrNotFound:
 					case KErrPathNotFound:
 					case KErrBadName:
-						__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - error getting passive file: %S, error: %d", &fileName, err);
+					    OstTraceExt2(TRACE_NORMAL, DUP10_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "error getting passive file: %S, error: %d", fileName, err);
 						break;
 					default:
+					    OstTrace1(TRACE_ERROR, DUP13_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "Leave: %d", err);
 						User::Leave(err);
 						}
 					}
 				break;
 				}
 			default:
 				{
-				__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - No case for TransferType: %d, data owner 0x%08x", aTransferType, iPackageID.iUid);
+				OstTraceExt2(TRACE_ERROR, DUP11_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "No case for TransferType: %d, data owner 0x%08x", static_cast<TInt32>(aTransferType), iPackageID.iUid);
 				User::Leave(KErrNotSupported);
 				}
 			} // switch
-		__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - END - size is: %d, data owner 0x%08x", aSize, iPackageID.iUid);
+		OstTraceExt2(TRACE_NORMAL, DUP12_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "size is: %d, data owner 0x%08x", static_cast<TInt32>(aSize), iPackageID.iUid);
+		OstTraceFunctionExit0( DUP2_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL_EXIT );
 		}
 	void CPackageDataTransfer::RequestDataL(TDriveNumber aDriveNumber,
 	    									TPackageDataType aTransferType,
 	    									TPtr8& aBuffer,
 		@param aLastSection has all the data been supplied. If all data is not
 			   supplied a further calls to the function will return the extra
 			   data.
 		*/
 		{
-		__LOG6("CPackageDataTransfer::RequestDataL() - START - aDrive: %c, aTransferType: %d, iSecureId: 0x%08x, iState.iState: %d, iState.iTransferType: %d, aBuffer.Length(): %d", aDriveNumber + 'A', aTransferType, iPackageID.iUid, iState.iState, iState.iTransferType, aBuffer.Length());
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_REQUESTDATAL_ENTRY );
-//__LOGDATA("CPackageDataTransfer::RequestDataL() - %S", aBuffer.Ptr(), aBuffer.Length() );
+		OstTraceExt3(TRACE_NORMAL, CPACKAGEDATATRANSFER_REQUESTDATAL, "aDrive: %c, aTransferType: %d, iSecureId: 0x%08x", static_cast<TInt8>(aDriveNumber + 'A'), static_cast<TInt32>(aTransferType), static_cast<TUint32>(iPackageID.iUid));
+		OstTraceExt3(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_REQUESTDATAL, "iState.iState: %d, iState.iTransferType: %d, aBuffer.Length(): %d", static_cast<TInt32>(iState.iState), static_cast<TInt32>(iState.iTransferType), static_cast<TInt32>(aBuffer.Length()));
 		TInt err = KErrNone;
 		if (iMetaData == NULL)
 			{
 if(KErrNotSupported == err)
 {//Non-Removable package, nothing to backup
 iState.iState = ENone;
 aLastSection = ETrue;
 Cleanup();
+OstTraceFunctionExit0( CPACKAGEDATATRANSFER_REQUESTDATAL_EXIT );
 return;
 }
 else if(KErrNone != err)
 {
 iState.iState = ENone;
 aLastSection = ETrue;
 Cleanup();
+OstTrace1(TRACE_ERROR, DUP3_CPACKAGEDATATRANSFER_REQUESTDATAL, "Leave: %d", err);
 User::Leave(err);
 }
 			iMetaDataSize = iMetaData->Size();
 			BuildPackageFileList();
 		// Check our state
 		if (!((iState.iState == ENone) || (iState.iState == EBuffer) ||
 		     ((iState.iState == ERequest) && (iState.iDriveNumber == aDriveNumber) &&
 		      (iState.iTransferType == aTransferType))))
 			{
-		    __LOG("CPackageDataTransfer::RequestDataL() - bad state => ERROR => KErrNotReady");
+		    OstTrace0(TRACE_ERROR, DUP1_CPACKAGEDATATRANSFER_REQUESTDATAL, "bad state => ERROR => KErrNotReady");
 			User::Leave(KErrNotReady);
 			}
 		// Set the state?
 		if (iState.iState == ENone)
 		if (err != KErrNone)
 			{
 			iState.iState = ENone;
 			Cleanup();
-			__LOG1("CPackageDataTransfer::RequestDataL() - Left with error: %d", err);
+			OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_REQUESTDATAL, "Leave with error: %d", err);
 			User::Leave(err);
 			} // if
-		__LOG("CPackageDataTransfer::RequestDataL() - END");
+		OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_REQUESTDATAL_EXIT );
 		}
 	void CPackageDataTransfer::ReadData(TAny* aDestinationAddress, const TDesC8& aBuffer, TInt aSize)
 	/** Read data from the given buffer
 	@param aItem the item to fill
 	@param aBuffer the buffer to read the data from
 	@param aSize the size of the item to fill
 	*/
 		{
+OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_READDATA_ENTRY );
 TUint8* pos = reinterpret_cast<TUint8*>(aDestinationAddress);
 		for (TInt i = 0; i < aSize; ++i)
 			{
 			pos[i] = aBuffer[i];
 			}
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_READDATA_EXIT );
 		}
 	void CPackageDataTransfer::SupplyFileDataL( const TDesC8& aBuffer, TBool aLastSection)
 	/** Restores files from the buffer to the package.
 	@param aBuffer the buffer to read data from
 	@param aLastSection has all data been supplied
 	*/
 		{
-		__LOG1("CPackageDataTransfer::SupplyFileDataL() - START - aLastSection: %d", aLastSection);
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_SUPPLYFILEDATAL_ENTRY );
+		OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "aLastSection: %d", aLastSection);
 		TUint8* current = const_cast<TUint8*>(aBuffer.Ptr());
 		const TUint8* end = current + aBuffer.Size();
 		while (current < end)
 			{
 			if (!iFixedHeaderRead)
 				{
 				if (ReadFromBufferF(iFixedHeader, current, end) == EFalse)
 					{
-					__LOG("CPackageDataTransfer::SupplyFileDataL() - ReadFromBufferF() returned False so breaking!");
+				    OstTrace0(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "ReadFromBufferF() returned False so breaking!");
 					break;
 					} // if
-				__LOG1("CPackageDataTransfer::SupplyFileDataL() - fixed header - iFileNameLength:  %d", iFixedHeader.iFileNameLength);
+				OstTrace1(TRACE_NORMAL, DUP2_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "fixed header - iFileNameLength:  %d", iFixedHeader.iFileNameLength);
-__LOG1("CPackageDataTransfer::SupplyFileDataL() - fixed header - iFileSize:        %d", iFixedHeader.iFileSize);
+				OstTrace1(TRACE_NORMAL, DUP3_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "fixed header - iFileSize:        %d", iFixedHeader.iFileSize);
-__LOG1("CPackageDataTransfer::SupplyFileDataL() - fixed header - iAttributes:      %d", iFixedHeader.iAttributes);
+				OstTrace1(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "fixed header - iAttributes:      %d", iFixedHeader.iAttributes);
 if ((iFixedHeader.iFileNameLength > KMaxFileName) || (!iFixedHeader.iFileNameLength))
 					{
-					__LOG1("CBufferFileReader::SupplyFileDataL() - Leaving - iFileNameLength: %d more then MaxLength", iFixedHeader.iFileNameLength);
+OstTrace1(TRACE_ERROR, DUP5_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "Leave with KErrOverflow - iFileNameLength: %d more then MaxLength", iFixedHeader.iFileNameLength);
 					User::Leave(KErrOverflow);
 					}
 				iFixedHeaderRead = ETrue;
 				} //if
 				TPtr8 ptr(reinterpret_cast<TUint8*>(const_cast<TUint16*>(iFileName->Des().Ptr())), iBytesRead,iFixedHeader.iFileNameLength * KCharWidthInBytes);
 				if (ReadFromBufferV(ptr, iFixedHeader.iFileNameLength * KCharWidthInBytes, current, end) == EFalse)
 					{
 					iBytesRead = ptr.Size();
-					__LOG1("CPackageDataTransfer::SupplyFileDataL() - ReadFromBufferV() returned False - Filename bytes read: %d", iBytesRead);
+					OstTrace1(TRACE_NORMAL, DUP6_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "ReadFromBufferV() returned False - Filename bytes read: %d", iBytesRead);
 					break;
 					} // if
 				if (iFixedHeader.iFileNameLength > KMaxFileName)
 					{
-					__LOG("CBufferFileReader::SupplyFileDataL() - Leave with KErrOverflow");
+				    OstTrace0(TRACE_ERROR, DUP7_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "Leave with KErrOverflow");
 					User::Leave(KErrOverflow);
 					}
 				iFileName->Des().SetLength(iFixedHeader.iFileNameLength);
 				iFileNameRead = ETrue;
-				__LOG1("CPackageDataTransfer::SupplyFileDataL() - FileName: %S", iFileName);
+				OstTraceExt1(TRACE_NORMAL, DUP8_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "FileName: %S", *iFileName);
 				}
 				if (!iFileOpen)
 					{
 					TFileName tempPath;
 						iTempFileName = tempFile.AllocL();
 						}
 					if (tempErr != KErrNone)
 						{
-						__LOG2("CPackageDataTransfer::SupplyFileDataL() - Left creating temp file in: %S , with %d", &tempPath, tempErr);
+					    OstTraceExt2(TRACE_ERROR, DUP9_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "Leave while creating temp file in: %S , with %d", tempPath, tempErr);
 						User::Leave(tempErr);
 						}
 					iFileOpen = ETrue;
 					}
 			// Write to the file
+			TInt err;
 			TInt filesize;
 			iFileHandle.Size(filesize);
 			if ((end - current) >= (iFixedHeader.iFileSize - filesize))
 				{
 				TPtr8 ptr(current, iFixedHeader.iFileSize - filesize, iFixedHeader.iFileSize - filesize);
-				User::LeaveIfError(iFileHandle.Write(ptr));
+				err = iFileHandle.Write(ptr);
+				LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP13_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "error = %d", err));
 				// Write the attributes & modified time
-				User::LeaveIfError(iFileHandle.Set(iFixedHeader.iModified, iFixedHeader.iAttributes, KEntryAttNormal));
+				err = iFileHandle.Set(iFixedHeader.iModified, iFixedHeader.iAttributes, KEntryAttNormal);
+				LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP14_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "error = %d", err));
 				TInt err = KErrNone;
 				if (((*iFileName).FindC(KPrimaryBackupRegistrationFile) >= 0) ||
 					((*iFileName).MatchC(KSys) >= 0) ||
 					((*iFileName).MatchC(KResource) >= 0) ||
 					((*iFileName).MatchC(KImport) >= 0) )
 					{
-					__LOG("CPackageDataTransfer::SupplyFileDataL() - about to call RestoreFileL()");
+				    OstTrace0(TRACE_NORMAL, DUP10_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "about to call RestoreFileL()");
 					TRAP(err, iSWIRestore.RestoreFileL(iFileHandle, *iFileName));
-					__LOG1("CPackageDataTransfer::SupplyFileDataL() - RestoreFileL() - err :%d", err);
+					OstTrace1(TRACE_NORMAL, DUP11_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "RestoreFileL() - err :%d", err);
 					}
 				else if ((*iFileName).MatchC(KPrivateMatch) >= 0)
 					{
-					User::LeaveIfError(iFs.MkDirAll((*iFileName)));
+				    err = iFs.MkDirAll((*iFileName));
-					User::LeaveIfError(iFileHandle.Rename((*iFileName)));
+					LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP15_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "error = %d", err));
+					err = iFileHandle.Rename((*iFileName));
+					LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP16_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "error = %d", err));
 					}
 				// Finished reset state
 				iFileHandle.Close();
 				}
 			else
 				{
 				TInt fsize = end - current;
 				TPtr8 ptr(current, fsize, fsize);
-				User::LeaveIfError(iFileHandle.Write(ptr));
+				err = iFileHandle.Write(ptr);
+				LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP17_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "error = %d", err));
 				break;
 				}
 			} // while
 		if (aLastSection && iFileOpen)
 			{
+		    OstTrace0(TRACE_ERROR, DUP12_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "Leave with KErrUnderflow");
 			User::Leave(KErrUnderflow);
 			} // if
-		__LOG("CPackageDataTransfer::SupplyFileDataL() - END");
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_SUPPLYFILEDATAL_EXIT );
 		} // SupplyFileDataL
 	void CPackageDataTransfer::SupplyDataL(TDriveNumber aDriveNumber,
 									   TPackageDataType aTransferType,
 									   TDesC8& aBuffer,
 		@param aTransferType the type of data you require
 		@param aBuffer the buffer to write the data
 		@param aLastSection is this the last section
 		*/
 		{
-		__LOG5("CPackageDataTransfer::SupplyDataL() - START - aDrive: %c, aTransferType: %d, iSecureId: 0x%08x, iState.iState: %d, iState.iTransferType: %d", aDriveNumber + 'A', aTransferType, iPackageID.iUid, iState.iState, iState.iTransferType);
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_SUPPLYDATAL_ENTRY );
+		OstTraceExt5(TRACE_NORMAL, CPACKAGEDATATRANSFER_SUPPLYDATAL, "aDrive: %c, aTransferType: %d, iSecureId: 0x%08x, iState.iState: %d, iState.iTransferType: %d", aDriveNumber + 'A', aTransferType, iPackageID.iUid, iState.iState, iState.iTransferType);
 		if (!iRestored)
 			{
 			TInt err = KErrNone;
 			if (!((iState.iState == ENone) ||
 			     ((iState.iState == ESupply || iState.iState == EBuffer) && (iState.iDriveNumber == aDriveNumber) &&
 			      (iState.iTransferType == aTransferType))))
 				{
-				__LOG("CPackageDataTransfer::SupplyDataL() - bad state => ERROR => KErrNotReady");
+			    OstTrace0(TRACE_ERROR, DUP1_CPACKAGEDATATRANSFER_SUPPLYDATAL, "bad state => ERROR => KErrNotReady");
 				User::Leave(KErrNotReady);
 				}
 			// Set the state?
 			if (iState.iState == ENone)
 				iState.iState = ENone;
 				if (err != KErrAlreadyExists)
 					{
 					Cleanup();
 					iSWIRestore.Close();
-					User::LeaveIfError(iSWIRestore.Connect());
+					TInt err1 = iSWIRestore.Connect();
-					}
+					LEAVEIFERROR(err1, OstTrace1(TRACE_ERROR, DUP3_CPACKAGEDATATRANSFER_SUPPLYDATAL, "error = %d", err1));
-				__LOG1("CPackageDataTransfer::SupplyDataL() - Left with error: %d", err);
+					}
+				OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_SUPPLYDATAL, "Left with error: %d", err);
 				User::Leave(err);
 				} //else
 			}
-		__LOG("CPackageDataTransfer::SupplyDataL() - END");
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_SUPPLYDATAL_EXIT );
 		}
 void CPackageDataTransfer::DoSupplyDataL(TDriveNumber /*aDriveNumber*/, const TDesC8& aBuffer, TBool aLastSection)
 	/** Handles the actual supply of package data
 	@param aDriveNumber not used.
 	@param aBuffer the data that was supplied
 	@param aLastSection was this the last section of data
 	*/
 	{
-	__LOG3("CPackageDataTransfer::DoSupplyDataL() - START - aBuffer length: %d, aLastSection: %d, iState: %d", aBuffer.Length(), aLastSection, iState.iState);
+	OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_DOSUPPLYDATAL_ENTRY );
-//__LOGDATA("CPackageDataTransfer::DoSupplyDataL() -       %S", aBuffer.Ptr(), Min( aBuffer.Length(), 1024 ));
+	OstTraceExt3(TRACE_NORMAL, CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "aBuffer length: %d, aLastSection: %d, iState: %d", aBuffer.Length(), aLastSection, iState.iState);
 		TInt currentPos = 0;
 const TInt sourceBufferLength = aBuffer.Length();
 if  ( iState.iState != ESupply )
 {
 		    if (iState.iState == ENone )
 			    {
-			    __LOG("CPackageDataTransfer::DoSupplyDataL() - iState == ENone - set up for initial meta data read...");
+		        OstTrace0(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "iState == ENone - set up for initial meta data read...");
 // Retrieve metadata and file list from the buffer
 			    ReadData(&iMetaDataSize, aBuffer, sizeof(TInt));
-			    __LOG1("CPackageDataTransfer::DoSupplyDataL() - meta data size: %d", iMetaDataSize);
+			    OstTrace1(TRACE_NORMAL, DUP2_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "meta data size: %d", iMetaDataSize);
 			    currentPos += sizeof(TInt);
 			    if (iMetaDataSize >= (KMaxTInt/2) || iMetaDataSize < 0)
 				    {
-				    __LOG("CPackageDataTransfer::DoSupplyDataL() - size read is too big");
+			        OstTrace0(TRACE_ERROR, DUP3_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "size read is too big");
 				    User::Leave(KErrCorrupt);
 				    }
-			    __LOG1("CPackageDataTransfer::DoSupplyDataL() - creating meta data buffer of length: %d bytes", iMetaDataSize);
+			    OstTrace1(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "creating meta data buffer of length: %d bytes", iMetaDataSize);
 			    HBufC8* metaDataBuffer = HBufC8::NewL(iMetaDataSize);
 delete iMetaData;
 			    iMetaData = metaDataBuffer;
 TPtr8 data(iMetaData->Des());
 if (iMetaDataSize > sourceBufferLength )
 				    {
-				    __LOG("CPackageDataTransfer::DoSupplyDataL() - not enough source data to obtain entire meta data in one pass...");
+OstTrace0(TRACE_NORMAL, DUP5_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "not enough source data to obtain entire meta data in one pass...");
 if (aLastSection)
 					    {
-					    __LOG("CPackageDataTransfer::DoSupplyDataL() - Underflow1");
+OstTrace0(TRACE_ERROR, DUP6_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "Underflow1");
 					    User::Leave(KErrUnderflow);
 					    }
 else
 {
 data.Append(aBuffer.Mid(currentPos));
 				        iState.iState = EBuffer;
-				        __LOG2("CPackageDataTransfer::DoSupplyDataL() - got %d bytes of meta data (%d bytes remaining) => changing state to EBuffer", data.Length(), iMetaDataSize - data.Length() );
+				        OstTraceExt2(TRACE_NORMAL, DUP7_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "got %d bytes of meta data (%d bytes remaining) => changing state to EBuffer", data.Length(), iMetaDataSize - data.Length() );
 }
 				    }
 			    else
 				    {
-				    __LOG("CPackageDataTransfer::DoSupplyDataL() - able to read entire meta data buffer in a single pass... ");
+			        OstTrace0(TRACE_NORMAL, DUP8_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "able to read entire meta data buffer in a single pass... ");
 				    data.Append(aBuffer.Mid(currentPos, iMetaDataSize));
 				    currentPos += iMetaDataSize;
 				    }
 			    }
 		    else if (iState.iState == EBuffer)
 			    {
-			    __LOG1("CPackageDataTransfer::DoSupplyDataL() - iState == EBuffer, iMetaData length: %d", iMetaData->Length());
+		        OstTrace1(TRACE_NORMAL, DUP9_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "iState == EBuffer, iMetaData length: %d", iMetaData->Length());
 			    TPtr8 ptr( iMetaData->Des() );
 			    const TInt leftToRead = iMetaDataSize - ptr.Length();
-__LOG1("CPackageDataTransfer::DoSupplyDataL() - meta data buffer left to read: %d", leftToRead);
+			    OstTrace1(TRACE_NORMAL, DUP10_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "meta data buffer left to read: %d", leftToRead);
 if (sourceBufferLength < leftToRead)
 				    {
-				    __LOG("CPackageDataTransfer::DoSupplyDataL() - not enough source data to obtain remaining required meta data in this pass...");
+OstTrace0(TRACE_NORMAL, DUP11_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "not enough source data to obtain remaining required meta data in this pass...");
 if (aLastSection)
 					    {
-					    __LOG("CPackageDataTransfer::DoSupplyDataL() - Underflow2");
+OstTrace0(TRACE_ERROR, DUP12_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "Underflow2");
 					    User::Leave(KErrUnderflow);
 					    }
 				    ptr.Append(aBuffer);
-				    __LOG1("CPackageDataTransfer::DoSupplyDataL() - meta data buffered again: %d", ptr.Length());
+				    OstTrace1(TRACE_NORMAL, DUP13_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "meta data buffered again: %d", ptr.Length());
 				    iState.iState = EBuffer;
+				    OstTraceFunctionExit0( CPACKAGEDATATRANSFER_DOSUPPLYDATAL_EXIT );
 				    return;
 				    }
 			    else
 				    {
-				    __LOG("CPackageDataTransfer::DoSupplyDataL() - able to complete meta data read in this pass...");
+			        OstTrace0(TRACE_NORMAL, DUP14_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "able to complete meta data read in this pass...");
 ptr.Append( aBuffer.Left(leftToRead) );
-__LOG1("CPackageDataTransfer::DoSupplyDataL() - meta data finished buffering, meta data size is now: %d", ptr.Length());
+OstTrace1(TRACE_NORMAL, DUP15_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "meta data finished buffering, meta data size is now: %d", ptr.Length());
 				    currentPos += leftToRead;
 				    }
 			    }
 const TBool metaDataComplete = ( iMetaData->Length() == iMetaDataSize );
-	    __LOG4("CPackageDataTransfer::DoSupplyDataL() - meta data complete?: %d ( %d bytes remaining out of total: %d with current length of: %d)", metaDataComplete, iMetaDataSize - iMetaData->Length(), iMetaDataSize, iMetaData->Length() );
+OstTraceExt4(TRACE_NORMAL, DUP16_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "meta data complete?: %d ( %d bytes remaining out of total: %d with current length of: %d)", metaDataComplete, iMetaDataSize - iMetaData->Length(), iMetaDataSize, iMetaData->Length() );
 if  ( metaDataComplete )
 {
-	        __LOG("CPackageDataTransfer::DoSupplyDataL() - Asking SWI to start a package...");
+OstTrace0(TRACE_NORMAL, DUP17_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "Asking SWI to start a package...");
 		        iState.iState = ESupply;
 		        iSWIRestore.StartPackageL(iPackageID, *iMetaData);
-		        __LOG("CPackageDataTransfer::DoSupplyDataL() - SWI StartPackageL() completed OK");
+		        OstTrace0(TRACE_NORMAL, DUP18_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "SWI StartPackageL() completed OK");
 }
 }
 if  ( iState.iState == ESupply )
 {
-			__LOG1("CPackageDataTransfer::DoSupplyDataL() - iState == ESupply, currentPos: %d", currentPos);
+OstTrace1(TRACE_NORMAL, DUP19_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "iState == ESupply, currentPos: %d", currentPos);
 // Now restore each file and commit the changes
 const TPtrC8 ptr( aBuffer.Mid( currentPos ) );
-//__LOGDATA("CPackageDataTransfer::DoSupplyDataL() - for supplyFileData   %S", ptr.Ptr(), Min( ptr.Length(), 1024 ));
 		    SupplyFileDataL(ptr, aLastSection);
-		    __LOG("CPackageDataTransfer::DoSupplyDataL() - SupplyFileDataL() completed OK");
+		    OstTrace0(TRACE_NORMAL, DUP20_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "SupplyFileDataL() completed OK");
 		    if (aLastSection)
 			    {
-			    __LOG("CPackageDataTransfer::DoSupplyDataL() - aLastSection - asking SWI to commit package...");
+		        OstTrace0(TRACE_NORMAL, DUP21_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "aLastSection - asking SWI to commit package...");
 			    // now we can finalise the restore
 			    iSWIRestore.CommitPackageL();
-			    __LOG("CPackageDataTransfer::DoSupplyDataL() - Package commited OK");
+			    OstTrace0(TRACE_NORMAL, DUP22_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "Package commited OK");
 			    iRestored = ETrue;
 			    iState.iState = ENone;
 			    Cleanup();
 			    iSWIRestore.Close();
-			    User::LeaveIfError(iSWIRestore.Connect());
+			    TInt err = iSWIRestore.Connect();
+			    LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP23_CPACKAGEDATATRANSFER_DOSUPPLYDATAL, "error = %d", err));
 			    }
 }
-		__LOG("CPackageDataTransfer::DoSupplyDataL() - END");
+	OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_DOSUPPLYDATAL_EXIT );
 	} // SupplyDataL
 	void CPackageDataTransfer::SupplySnapshotL(TDriveNumber aDriveNumber, const TDesC8& aBuffer, TBool aLastSection)
 	/** Handles the actual supply of snapshot data
 	@param aDriveNumber the drive the snapshot is for
 	@param aBuffer the data that was supplied
 	@param aLastSection was this the last section of data
 	*/
 		{
-		__LOG("CPackageDataTransfer::SupplySnapshotL() - START");
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_SUPPLYSNAPSHOTL_ENTRY );
 		TInt err = KErrNone;
 		if (iBufferSnapshotReader == NULL)
 			{
 			CSnapshotHolder* snapshot = CSnapshotHolder::NewL();
 			delete iSnapshot;
 		if ((err != KErrNone) || aLastSection)
 			{
 			delete iBufferSnapshotReader;
 			iBufferSnapshotReader = NULL;
-			User::LeaveIfError(err);
+			LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_SUPPLYSNAPSHOTL, "error = %d", err));
 			} // if
-		__LOG("CPackageDataTransfer::SupplySnapshotL() - END");
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_SUPPLYSNAPSHOTL_EXIT );
 		}
 void CPackageDataTransfer::DoRequestDataL(TDriveNumber aDriveNumber, TPtr8& aBuffer, TBool& aLastSection)
 	/** Handles the actual request for package data
 	@param aLastSection has all the data been supplied. If all data is not
 		   supplied a further calls to the function will return the extra
 		   data.
 	*/
 	{
-	__LOG3("CPackageDataTransfer::DoRequestDataL() - START - iState: %d, iMetaData length: %d, iMetaDataSize: %d", iState.iState, iMetaData->Length(), iMetaDataSize);
+	OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_DOREQUESTDATAL_ENTRY );
+	OstTraceExt3(TRACE_NORMAL, CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState: %d, iMetaData length: %d, iMetaDataSize: %d", iState.iState, iMetaData->Length(), iMetaDataSize);
 if (iState.iState == ENone || iState.iState == EBuffer)
 			{
 			if (!IsDataOnDrive(aDriveNumber))
 				{
 				aLastSection = ETrue;
-	        __LOG("CPackageDataTransfer::DoRequestDataL() - END - no data on drive");
+				OstTrace0(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "no data on drive");
-//__LOGDATA("CPackageDataTransfer::DoRequestDataL() -       %S", aBuffer.Ptr(), aBuffer.Length());
+				OstTraceFunctionExit0( CPACKAGEDATATRANSFER_DOREQUESTDATAL_EXIT );
 				return;
 				}
 // Now write the meta data to the buffer.
 			const TInt KSizeOfTInt = sizeof(TInt);
 			const TInt availableBuffer = aBuffer.MaxSize() - aBuffer.Size();
-			__LOG1("CPackageDataTransfer::DoRequestDataL() - available Buffer %d", availableBuffer);
+			OstTrace1(TRACE_NORMAL, DUP2_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "available Buffer %d", availableBuffer);
 			if (iState.iState == ENone)
 				{
 				if ((availableBuffer - KSizeOfTInt) >= iMetaDataSize)
 					{
-					__LOG("CPackageDataTransfer::DoRequestDataL() - iState = ENone - can write entire meta data in single pass...");
+				    OstTrace0(TRACE_NORMAL, DUP3_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState = ENone - can write entire meta data in single pass...");
 WriteData(&iMetaDataSize, aBuffer, KSizeOfTInt);
 					aBuffer.Append(*iMetaData);
-__LOG1("CPackageDataTransfer::DoRequestDataL() - iState = ENone - Written Meta Data, size %d", iMetaDataSize);
+					OstTrace1(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState = ENone - Written Meta Data, size %d", iMetaDataSize);
 					}
 				else if (availableBuffer - KSizeOfTInt > 0)
 					{
 				    // can we write metasize and something else?
-					__LOG("CPackageDataTransfer::DoRequestDataL() - iState = ENone - have room for some meta data (not all)...");
+				    OstTrace0(TRACE_NORMAL, DUP5_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState = ENone - have room for some meta data (not all)...");
 WriteData(&iMetaDataSize, aBuffer, KSizeOfTInt);
 // Write as much meta data as we can (allowing for buffer size) in this pass.
 const TInt amountOfMetaDataToWrite = availableBuffer - KSizeOfTInt;
 // need to get rid of KSizeOfTInt
 					iMetaDataLeft = iMetaDataSize - amountOfMetaDataToWrite;
 					aLastSection = EFalse;
 iState.iState = EBuffer;
-__LOG2("CPackageDataTransfer::DoRequestDataL() - END - iState = ENone - Written MetaData %d, left %d", amountOfMetaDataToWrite, iMetaDataLeft);
+OstTraceExt2(TRACE_NORMAL, DUP6_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState = ENone - Written MetaData %d, left %d", amountOfMetaDataToWrite, iMetaDataLeft);
+					OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_DOREQUESTDATAL_EXIT );
 					return;
 					}
 				else
 					{
-					__LOG("CPackageDataTransfer::DoRequestDataL() - END - iState = ENone - not enough space to write MetaData, Return for more");
+				    OstTrace0(TRACE_NORMAL, DUP7_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState = ENone - not enough space to write MetaData, Return for more");
+					OstTraceFunctionExit0( DUP2_CPACKAGEDATATRANSFER_DOREQUESTDATAL_EXIT );
 					return;
 					}
 				}// if
 			else if (iState.iState == EBuffer)
 				{
 				if (availableBuffer - iMetaDataLeft >= 0)
 					{
 const TInt readPosition = iMetaDataSize - iMetaDataLeft;
-					__LOG2("CPackageDataTransfer::DoRequestDataL() - iState = EBuffer - enough space for remaining meta data in this pass, size %d, readPos: %d", iMetaDataLeft, readPosition);
+OstTraceExt2(TRACE_NORMAL, DUP8_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState = EBuffer - enough space for remaining meta data in this pass, size %d, readPos: %d", iMetaDataLeft, readPosition);
 					aBuffer.Append(iMetaData->Mid(readPosition));
 					}
 				else
 					{
 				    // continute buffer
 					const TInt readPosition = iMetaDataSize - iMetaDataLeft;
-__LOG2("CPackageDataTransfer::DoRequestDataL() - iState = EBuffer - Still buffering Meta Data, Left to write %d, readPos: %d", iMetaDataLeft, readPosition);
+					OstTraceExt2(TRACE_NORMAL, DUP9_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState = EBuffer - Still buffering Meta Data, Left to write %d, readPos: %d", iMetaDataLeft, readPosition);
 					aBuffer.Append(iMetaData->Mid(readPosition, availableBuffer));
 					iMetaDataLeft -= availableBuffer;
 					aLastSection = EFalse;
-__LOG1("CPackageDataTransfer::DoRequestDataL() - iState = EBuffer - END - Still buffering Meta Data, Left to write %d", iMetaDataLeft);
+					OstTrace1(TRACE_NORMAL, DUP10_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState = EBuffer - END - Still buffering Meta Data, Left to write %d", iMetaDataLeft);
+					OstTraceFunctionExit0( DUP3_CPACKAGEDATATRANSFER_DOREQUESTDATAL_EXIT );
 					return;
 					}
 				}
 			TUint count = iFiles.Count();
-			__LOG1("CPackageDataTransfer::DoRequestDataL() - No of fileNames: %d", count);
+			OstTrace1(TRACE_NORMAL, DUP11_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "No of fileNames: %d", count);
 			if (count == 0)
 				{
 				aLastSection = ETrue;
-	        __LOG("CPackageDataTransfer::DoRequestDataL() - END - no files");
+				OstTrace0(TRACE_NORMAL, DUP12_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "no files");
+				OstTraceFunctionExit0( DUP4_CPACKAGEDATATRANSFER_DOREQUESTDATAL_EXIT );
 				return;
 				}
 			CDesCArray* files = new (ELeave) CDesCArrayFlat(KDesCArrayGranularity);
 			CleanupStack::PushL(files);
 				{
 				files->AppendL(*iFiles[i]);
 				}
-			__LOG("CPackageDataTransfer::DoRequestDataL() - starting buffer file writer...");
+			OstTrace0(TRACE_NORMAL, DUP13_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "starting buffer file writer...");
 			CBufferFileWriter* bufferFileWriter = CBufferFileWriter::NewL(iFs, files);
 			delete iBufferFileWriter;
 			iBufferFileWriter = bufferFileWriter;
 			iBufferFileWriter->StartL(aBuffer, aLastSection);
 			iState.iState = ERequest;
-			__LOG("CPackageDataTransfer::DoRequestDataL() - iState is now ERequest");
+			OstTrace0(TRACE_NORMAL, DUP14_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "iState is now ERequest");
 			if (aLastSection)
 				{
 				delete iBufferFileWriter;
 				iBufferFileWriter = NULL;
 CleanupStack::Pop(files);
 			}
 		else if (iBufferFileWriter != NULL)
 			{
-			__LOG("CPackageDataTransfer::DoRequestDataL() - continuing buffer file writer from last time...");
+		    OstTrace0(TRACE_NORMAL, DUP15_CPACKAGEDATATRANSFER_DOREQUESTDATAL, "continuing buffer file writer from last time...");
 			iBufferFileWriter->ContinueL(aBuffer, aLastSection);
 			if (aLastSection)
 				{
 				delete iBufferFileWriter;
 				iBufferFileWriter = NULL;
 				iState.iState = ENone;
 				}
 			}
-//__LOGDATA("CPackageDataTransfer::DoRequestDataL() -       %S", aBuffer.Ptr(), aBuffer.Length());
+	OstTraceFunctionExit0( DUP5_CPACKAGEDATATRANSFER_DOREQUESTDATAL_EXIT );
-		__LOG("CPackageDataTransfer::DoRequestDataL() - END");
 	} // RequestDataL
 	void CPackageDataTransfer::RequestSnapshotL(TDriveNumber aDriveNumber, TPtr8& aBuffer, TBool& aLastSection)
 	/** Handles the request for snapshot data
 	@param aLastSection has all the data been supplied. If all data is not
 		   supplied a further calls to the function will return the extra
 		   data.
 	*/
 		{
-		__LOG("CPackageDataTransfer::RequestSnapshotL() - START");
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_REQUESTSNAPSHOTL_ENTRY );
 		if (iBufferSnapshotWriter == NULL)
 			{
 			if (!IsDataOnDrive(aDriveNumber))
 				{
 				aLastSection = ETrue;
+				OstTraceFunctionExit0( CPACKAGEDATATRANSFER_REQUESTSNAPSHOTL_EXIT );
 				return;
 				}
 			TUint count = iFiles.Count();
-			__LOG1("CPackageDataTransfer::RequestSnapshotL() - No of fileNames: %d", count);
+			OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_REQUESTSNAPSHOTL, "No of fileNames: %d", count);
 			if (count > 0)
 				{
 				RSnapshots* snapshots = new(ELeave) RSnapshots();
 				TCleanupItem cleanup(CleanupRPointerArray, snapshots);
 				CleanupStack::PushL(cleanup);
 		if (aLastSection)
 			{
 			delete iBufferSnapshotWriter;
 			iBufferSnapshotWriter = NULL;
 			}
-		__LOG("CPackageDataTransfer::RequestSnapshotL() - END");
+		OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_REQUESTSNAPSHOTL_EXIT );
 		}
 	/** Cleanup of the internal data
 	*/
 	void CPackageDataTransfer::Cleanup()
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_CLEANUP_ENTRY );
 		delete iBufferFileWriter;
 		iBufferFileWriter = NULL;
 		delete iBufferSnapshotReader;
 		iBufferSnapshotReader = NULL;
 		delete iBufferSnapshotWriter;
 		iBufferSnapshotWriter = NULL;
 		delete iSnapshot;
 		iSnapshot = NULL;
 		delete iMetaData;
 		iMetaData = NULL;
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_CLEANUP_EXIT );
 		}
 	/**
 	Checks if there is any data on the specified drive
 	@param aDrive the drive to check on
 	@return ETrue if there is any data
 	*/
 	TBool CPackageDataTransfer::IsDataOnDrive(TDriveNumber aDrive)
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_ISDATAONDRIVE_ENTRY );
 		if (!iDriveList[aDrive])
 			{
+			OstTraceFunctionExit0( CPACKAGEDATATRANSFER_ISDATAONDRIVE_EXIT );
 			return EFalse;
 			}
 		else
 			{
+			OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_ISDATAONDRIVE_EXIT );
 			return ETrue;
 			}
 		}
 	@pre CPackageDataTransfer::ParseFilesL() must have been called
 	@return the common settings of the data owner
 	@leave KErrNotReady if CPackageDataTransfer::ParseFilesL() not called
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_COMMONSETTINGSL_ENTRY );
 		TCommonBURSettings settings = ENoOptions;
-		__LOG1("CPackageDataTransfer::CommonSettingsL() - System Supported: %d", iSystemInformation.iSupported);
+		OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_COMMONSETTINGSL, "System Supported: %d", iSystemInformation.iSupported);
 		if (iSystemInformation.iSupported)
 			{
 			settings |= EHasSystemFiles;
 			}
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_COMMONSETTINGSL_EXIT );
 		return settings;
 		}
 	TPassiveBURSettings CPackageDataTransfer::PassiveSettingsL()
 	/** Get the passive settings of the data owner
 	@pre CPackageDataTransfer::ParseFilesL() must have been called
 	@return the passive settings of the data owner
 	@leave KErrNotReady if CPackageDataTransfer::ParseFilesL() not called
 	*/
 		{
-		__LOG1("CPackageDataTransfer::CommonSettingsL() - Public Supported: %d", iPublicInformation.iSupported);
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_PASSIVESETTINGSL_ENTRY );
+		OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_PASSIVESETTINGSL, "Public Supported: %d", iPublicInformation.iSupported);
 		TPassiveBURSettings settings = ENoPassiveOptions;
 		if (iPublicInformation.iSupported)
 			{
 			settings |= EHasPublicFiles;
 			} // if
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_PASSIVESETTINGSL_EXIT );
 		return settings;
 		}
 	TActiveBURSettings CPackageDataTransfer::ActiveSettingsL()
 	/** Get the active settings of the data owner
 	/** Set the registration file for the package
 	@param aFileName path including filename of the registration file
 	*/
 	void CPackageDataTransfer::SetRegistrationFileL(const TDesC& aFileName)
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_SETREGISTRATIONFILEL_ENTRY );
 		delete iRegistrationFile;
 		iRegistrationFile = aFileName.AllocL();
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_SETREGISTRATIONFILEL_EXIT );
 		}
 	/** Parses the package registration file
 	@pre CPackageDataTransfer::SetRegistrationFile() must have been called
 	*/
 	void CPackageDataTransfer::ParseL()
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_PARSEL_ENTRY );
 		if ((*iRegistrationFile).FindF(KPrimaryBackupRegistrationFile) == KErrNotFound)
 			{
+		    OstTrace0(TRACE_ERROR, CPACKAGEDATATRANSFER_PARSEL, "Leave: KErrNotReady");
 			User::Leave(KErrNotReady);
 			}
 		ipDataOwnerManager->ParserProxy().ParseL(*iRegistrationFile, *this);
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_PARSEL_EXIT );
 		}
 	void CPackageDataTransfer::GetRawPublicFileListL(TDriveNumber aDriveNumber,
 										   RRestoreFileFilterArray& aRestoreFileFilter)
 	@param aDriveNumber the drive to return the list for
 	@param aRestoreFileFilter on return the file filter
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_GETRAWPUBLICFILELISTL_ENTRY );
 		// Convert drive number to letter
 		TChar drive;
-		User::LeaveIfError(iFs.DriveToChar(aDriveNumber, drive));
+		TInt err = iFs.DriveToChar(aDriveNumber, drive);
+		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_GETRAWPUBLICFILELISTL, "error = %d", err));
 		const TInt count = iPublicSelections.Count();
 		for (TInt x = 0; x < count; x++)
 			{
 			CSelection* selection = iPublicSelections[x];
 			if (add)
 				{
 				aRestoreFileFilter.AppendL(TRestoreFileFilter(include, filename));
 				} // if
 			} // for x
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_GETRAWPUBLICFILELISTL_EXIT );
 		}
 	void CPackageDataTransfer::GetPublicFileListL(TDriveNumber aDriveNumber, RFileArray& aFiles)
 	/** Gets the public file list
 	Gets the public file list for the given drive
 	@param aDriveNumber the drive to retrieve the public files for
 	@param aFiles on return a list of public files
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_GETPUBLICFILELISTL_ENTRY );
 		_LIT(KDrive, "?:");
 		_LIT(KDriveAndSlash, "?:\\");
 		_LIT( KExclamationAsDrive, "!"); // Used to generic drives for public data as in .SIS file package
 		// Split selections into include and exclude
 		RArray<TPtrC> exclude;
 		CleanupClosePushL(exclude);
 		TInt count = iPublicSelections.Count();
-__LOG("CPackageDataTransfer::GetPublicFileListL() - file selection listing...:");
+		OstTrace0(TRACE_NORMAL, CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "file selection listing...:");
 		for (TInt x = 0; x < count; x++)
 			{
 const TDesC& selectionName = iPublicSelections[x]->SelectionName();
-__LOG3("CPackageDataTransfer::GetPublicFileListL() - selection[%03d]: %S, type: %d", x, &selectionName, iPublicSelections[x]->SelectionType());
+OstTraceExt3(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "selection[%03d]: %S, type: %d", x, selectionName, iPublicSelections[x]->SelectionType());
 			if (iPublicSelections[x]->SelectionType() == EInclude)
 				{
 				include.AppendL(selectionName);
 				} // if
 			else
 				} // else
 			} // for x
 		// Loop through all includes
 		count = include.Count();
-__LOG("CPackageDataTransfer::GetPublicFileListL() - include listing...:");
+		OstTrace0(TRACE_NORMAL, DUP2_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "include listing...:");
 		for (TInt x = 0; x < count; x++)
 			{
 			TFileName fileName;
 			TChar drive;
-			User::LeaveIfError(iFs.DriveToChar(aDriveNumber, drive));
+			TInt err = iFs.DriveToChar(aDriveNumber, drive);
+			LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP13_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "error = %d", err));
 const TPtrC includeEntry( include[x] );
-__LOG2("CPackageDataTransfer::GetPublicFileListL() - entry[%03d] is: %S", x, &includeEntry);
+OstTraceExt2(TRACE_NORMAL, DUP3_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "entry[%03d] is: %S", x, includeEntry);
 // See if the drive is specified
 			if (include[x][0] == KBackSlash()[0])
 				{
 				// Add the drive
 					fileName.Copy(includeEntry);
 					} // else
 				} // else
-__LOG2("CPackageDataTransfer::GetPublicFileListL() - entry[%03d] filename is therefore: %S", x, &fileName);
+			OstTraceExt2(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "entry[%03d] filename is therefore: %S", x, fileName);
 			if (fileName.Length() > 0)
 				{
 				// Check to see if fileName is just a drive(we cant get an entry)
 				TBool isDrive = EFalse;
 				if ((fileName.MatchF(KDrive) != KErrNotFound) ||
 				    (fileName.MatchF(KDriveAndSlash) != KErrNotFound))
 					{
 					isDrive = ETrue;
-__LOG("CPackageDataTransfer::GetPublicFileListL() - filename is a drive");
+					OstTrace0(TRACE_NORMAL, DUP5_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "filename is a drive");
 					} // if
 				TEntry entry;
 				TBool isEntry = EFalse;
 				if (!isDrive)
 					{
 					TInt err = iFs.Entry(fileName, entry);
-__LOG1("CPackageDataTransfer::GetPublicFileListL() - get entry error: %d", err);
+					OstTrace1(TRACE_NORMAL, DUP6_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "get entry error: %d", err);
 					entry.iName = fileName;
 					switch (err)
 						{
 					case KErrNone:
 						isEntry = ETrue;
 					case KErrNotFound:
 					case KErrPathNotFound:
 					case KErrBadName:
 						break;
 					default:
+					    OstTrace1(TRACE_ERROR, DUP12_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "Leave: %d", err);
 						User::Leave(err);
 						} // switch
 					} // if
 				if (isDrive || (isEntry && entry.IsDir()))
 					{
-__LOG("CPackageDataTransfer::GetPublicFileListL() - parsing directory...");
+				    OstTrace0(TRACE_NORMAL, DUP7_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "parsing directory...");
 					ParseDirL(fileName, exclude, aFiles);
-				#ifdef SBE_LOGGING_ENABLED
 					const TInt fNameCount = aFiles.Count();
 if  (fNameCount)
 {
 for(TInt k=0; k<fNameCount; k++)
 {
 const TDesC& fileName = aFiles[k].iName;
-__LOG2("CPackageDataTransfer::GetPublicFileListL() - directory entry[%03d] %S", k, &fileName);
+OstTraceExt2(TRACE_NORMAL, DUP8_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "directory entry[%03d] %S", k, fileName);
 }
 }
-__LOG("CPackageDataTransfer::GetPublicFileListL() - end of parsing directory");
+OstTrace0(TRACE_NORMAL, DUP9_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "end of parsing directory");
-				#endif
 					} // if
 				else
 					{
 					if (isEntry)
 						{
 const TBool isExcluded = IsExcluded(ETrue, fileName, exclude);
 						if (!isExcluded)
 							{
-						    __LOG1("CPackageDataTransfer::GetPublicFileListL() - adding fully verified file: %S", &fileName);
+						    OstTraceExt1(TRACE_NORMAL, DUP10_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "adding fully verified file: %S", fileName);
 							// Add to list of files
 							aFiles.AppendL(entry);
 							} // if
 else
 {
-__LOG("CPackageDataTransfer::GetPublicFileListL() - file is excluded!");
+OstTrace0(TRACE_NORMAL, DUP11_CPACKAGEDATATRANSFER_GETPUBLICFILELISTL, "file is excluded!");
 }
 						} // if
 					} // else
 				} // if
 			} // for x
 		CleanupStack::PopAndDestroy(&exclude);
 		CleanupStack::PopAndDestroy(&include);
-__LOG("CPackageDataTransfer::GetPublicFileListL() - END");
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_GETPUBLICFILELISTL_EXIT );
 		}
 	void CPackageDataTransfer::ParseDirL(const TDesC& aDirName, const RArray<TPtrC>& aExclude, RFileArray& apFileEntries)
 	/** Parses a directory for files.
 	@param aDirName the directory to search
 	@param aExclude a list of directories or files to exclude
 	@param apFileEntries Array of file entries to populate
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_PARSEDIRL_ENTRY );
 		CDir* pFiles = NULL;
 		// This function requires a / on the end otherwise it does not work!
 		TFileName path = aDirName;
 		if (path[path.Length() - 1] != KBackSlash()[0])
 		TInt err = iFs.GetDir(path, KEntryAttMatchMask, ESortNone, pFiles);
 		CleanupStack::PushL(pFiles); // Add to cleanup stack
 		if ((err != KErrNone) && (err != KErrNotFound)) // Do we need to leave?
 			{
+		    OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_PARSEDIRL, "Leave: %d", err);
 			User::Leave(err);
 			} // if
 		TUint count = pFiles->Count();
 		while(count--)
 				} // if
 			} // for x
 		// Cleanup
 		CleanupStack::PopAndDestroy(pFiles);
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_PARSEDIRL_EXIT );
 		}
 	void CPackageDataTransfer::GetDriveListL(TDriveList& aDriveList)
 	/** Get the drive list for the data owner
 	@pre CDataOwner::ParseFilesL() must have been called
 	@return the active settings of the data owner
 	@leave KErrNotReady if CDataOwner::ParseFilesL() not called
 	*/
 		{
-__LOG1("CPackageDataTransfer::GetDriveListL() - Begin - SID: 0x%08x", iPackageID.iUid);
+OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_GETDRIVELISTL_ENTRY );
+OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_GETDRIVELISTL, "SID: 0x%08x", iPackageID.iUid);
 		// We now no longer return the Z drive, it has been decided that the Z drive will always be the
 		// ROM. Backing up and restoring the ROM drive should not be possible, as what is the point
 		// build package files
 			if( err )
 				{
 				iMetaData = NULL;
 				iMetaDataSize = 0;
+				OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_GETDRIVELISTL, "Leave: %d", err);
 				User::Leave( err );
 				}
 			else
 				{
 				iMetaDataSize = iMetaData->Size();
 				}
 			}
 		aDriveList = iDriveList;
-		__LOG1("CPackageDataTransfer::GetDriveListL() - end - SID: 0x%08x", iPackageID.iUid);
+		OstTrace1(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_GETDRIVELISTL, "SID: 0x%08x", iPackageID.iUid);
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_GETDRIVELISTL_EXIT );
 		}
 	TBool CPackageDataTransfer::IsExcluded(const TBool aIsPublic, const TDesC& aFileName, const RArray<TPtrC>& aExclude)
 	/** Checks to see if a given file is excluded
 	@param aFileName file to check
 	@param aExclude list of excluded files
 	@return ETrue if excluded otherwise EFalse
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_ISEXCLUDED_ENTRY );
 		_LIT(KPrivateMatch, "?:\\private\\*");
 		_LIT(KSystem, "?:\\system\\*");
 		_LIT(KResource, "?:\\resource\\*");
 		_LIT(KOther, "*\\..\\*");
 		TBool ret = EFalse;
 					ret = (aFileName.CompareF(aExclude[x]) == 0);
 					} // else
 				} // for x
 			} // if
-__LOG2("CDataOwner::IsExcluded() - END - returns excluded: %d for file: %S", ret, &aFileName);
+		OstTraceExt2(TRACE_NORMAL, CPACKAGEDATATRANSFER_ISEXCLUDED, "returns excluded: %d for file: %S", ret, aFileName);
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_ISEXCLUDED_EXIT );
 		return ret;
 		}
 		/**
 	Method will be used for Sort on RPointerArray
 	@see RArray::Sort()
 	*/
 	TInt CPackageDataTransfer::Compare(const CPackageDataTransfer& aFirst, const CPackageDataTransfer& aSecond)
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_COMPARE_ENTRY );
 		if (aFirst.PackageId().iUid < aSecond.PackageId().iUid)
 			{
+			OstTraceFunctionExit0( CPACKAGEDATATRANSFER_COMPARE_EXIT );
 			return -1;
 			}
 		else if (aFirst.PackageId().iUid > aSecond.PackageId().iUid)
 			{
+			OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_COMPARE_EXIT );
 			return 1;
 			}
 		else
 			{
+			OstTraceFunctionExit0( DUP2_CPACKAGEDATATRANSFER_COMPARE_EXIT );
 			return 0;
 			}
 		}
 	/**
 	void CPackageDataTransfer::OnStartDocumentL(const RDocumentParameters& /*aDocParam*/, TInt aErrorCode)
 	/** MContentHandler::OnStartDocumentL()
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_ONSTARTDOCUMENTL_ENTRY );
 		if (aErrorCode != KErrNone)
 			{
-			__LOG1("CPackageDataTransfer::OnStartDocumentL() - error = %d", aErrorCode);
+		    OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_ONSTARTDOCUMENTL, "error = %d", aErrorCode);
 			User::Leave(aErrorCode);
 			}
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_ONSTARTDOCUMENTL_EXIT );
 		}
 	void CPackageDataTransfer::OnEndDocumentL(TInt aErrorCode)
 	/** MContentHandler::OnEndDocumentL()
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_ONENDDOCUMENTL_ENTRY );
 		// just to satisfy UREL compiler
 		(void) aErrorCode;
-		__LOG1("CPackageDataTransfer::OnEndDocumentL() - error = %d", aErrorCode);
+		OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_ONENDDOCUMENTL, "error = %d", aErrorCode);
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_ONENDDOCUMENTL_EXIT );
 		}
 	void CPackageDataTransfer::OnStartElementL(const RTagInfo& aElement,
 									  const RAttributeArray& aAttributes,
 									  TInt aErrorCode)
 	/** MContentHandler::OnStartElementL()
 	@leave KErrUnknown an unknown element
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_ONSTARTELEMENTL_ENTRY );
 		if (aErrorCode != KErrNone)
 			{
-			__LOG1("CPackageDataTransfer::OnStartElementL() - error = %d", aErrorCode);
+		    OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_ONSTARTELEMENTL, "error = %d", aErrorCode);
 			User::Leave(aErrorCode);
 			}
+		TInt err;
 		TPtrC8 localName = aElement.LocalName().DesC();
 		if (localName == KIncludeFile)
 			{
 			HandlePathL(EInclude, aAttributes, EFalse);
 			}
 			{
 			HandleBackupRegistrationL(aAttributes);
 			}
 		else if (!localName.CompareF(KPublicBackup))
 			{
-			User::LeaveIfError(HandlePublicBackup(aAttributes));
+		    err = HandlePublicBackup(aAttributes);
+			LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_ONSTARTELEMENTL, "error = %d", err));
 			}
 		else if (!localName.CompareF(KSystemBackup))
 			{
-			User::LeaveIfError(HandleSystemBackup(aAttributes));
+		    err = HandleSystemBackup(aAttributes);
+			LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP3_CPACKAGEDATATRANSFER_ONSTARTELEMENTL, "error = %d", err));
 			}
 		else
 			{
-			__LOG1("CPackageDataTransfer::OnStartElementL() - Unknown element while parsing 0x%08x", iPackageID.iUid);
+		    OstTrace1(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_ONSTARTELEMENTL, "Unknown element while parsing 0x%08x", iPackageID.iUid);
 			}
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_ONSTARTELEMENTL_EXIT );
 		}
 	void CPackageDataTransfer::OnEndElementL(const RTagInfo& aElement, TInt aErrorCode)
 	/** MContentHandler::OnEndElementL()
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_ONENDELEMENTL_ENTRY );
 		if (aErrorCode != KErrNone)
 			{
-			__LOG1("CPackageDataTransfer::OnEndElementL() - error = %d", aErrorCode);
+		    OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_ONENDELEMENTL, "error = %d", aErrorCode);
 			User::Leave(aErrorCode);
 			}
 		TPtrC8 localName = aElement.LocalName().DesC();
 		if (!localName.CompareF(KPublicBackup))
 			{
 			iCurrentElement = ENoElement;
 			} // if
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_ONENDELEMENTL_EXIT );
 		}
 	void CPackageDataTransfer::OnContentL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)
 	/** MContentHandler::OnContentL()
 	*/
 	/** MContentHandler::OnError()
 	@leave aErrorCode
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_ONERROR_ENTRY );
 		(void)aErrorCode;
-		__LOG1("CPackageDataTransfer::OnError() - error = %d", aErrorCode);
+		OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_ONERROR, "error = %d", aErrorCode);
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_ONERROR_EXIT );
 		}
 	TAny* CPackageDataTransfer::GetExtendedInterface(const TInt32 /*aUid*/)
 	/** MContentHandler::OnEndPrefixMappingL()
 	*/
 	@param aAttributes the attributes for the element
 	@return KErrNone no errors
 	@return KErrUnknown unknown version
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_HANDLEBACKUPREGISTRATIONL_ENTRY );
 		_LIT8(KVersion, "1.0");
 		if (aAttributes.Count() == 1)
 			{
 			// Check the version is correct.
 			if (aAttributes[0].Value().DesC() != KVersion()) // Only version we know about
 				{
-				__LOG1("CDataOwner::HandleBackupRegistrationL() - Unknown version at SID(0x%08x)", iPackageID.iUid);
+			    OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_HANDLEBACKUPREGISTRATIONL, "Unknown version at SID(0x%08x)", iPackageID.iUid);
 				User::Leave(KErrNotSupported);
 				} // else
 			} // if
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_HANDLEBACKUPREGISTRATIONL_EXIT );
 		}
 	TInt CPackageDataTransfer::HandlePublicBackup(const RAttributeArray& aAttributes)
 	/** Handles the "public_backup" element
 	@param aAttributes the attributes for the element
 	@return KErrNone
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_HANDLEPUBLICBACKUP_ENTRY );
 		iPublicInformation.iSupported = ETrue;
 		if (aAttributes.Count() > 0)
 			{
 const TBool deleteBeforeRestore = ( aAttributes[0].Value().DesC().CompareF(KYes) == 0 );
 			iPublicInformation.iDeleteBeforeRestore = deleteBeforeRestore;
-			__LOG2("CPackageDataTransfer::HandlePublicBackup(0x%08x) - iPublicInformation.iDeleteBeforeRestore: %d", iPackageID.iUid, deleteBeforeRestore);
+			OstTraceExt2(TRACE_NORMAL, CPACKAGEDATATRANSFER_HANDLEPUBLICBACKUP, "(0x%08x) - iPublicInformation.iDeleteBeforeRestore: %d", iPackageID.iUid, static_cast<TInt32>(deleteBeforeRestore));
 			} // if
 		iCurrentElement = EPublic;
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_HANDLEPUBLICBACKUP_EXIT );
 		return KErrNone;
 		}
 	TInt CPackageDataTransfer::HandleSystemBackup(const RAttributeArray& /*aAttributes*/)
 	/** Handles the "system_backup" element
 	@param aAttributes the attributes for the element
 	@return KErrNone
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_HANDLESYSTEMBACKUP_ENTRY );
 		iSystemInformation.iSupported = ETrue;
-		__LOG2("CPackageDataTransfer::HandlePublicBackup(0x%08x) - iSystemInformation.iSupported: %d", iPackageID.iUid, iSystemInformation.iSupported);
+		OstTraceExt2(TRACE_NORMAL, CPACKAGEDATATRANSFER_HANDLESYSTEMBACKUP, "(0x%08x) - iSystemInformation.iSupported: %d", iPackageID.iUid, static_cast<TInt32>(iSystemInformation.iSupported));
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_HANDLESYSTEMBACKUP_EXIT );
 		return KErrNone;
 		}
 	void CPackageDataTransfer::HandlePathL(const TSelectionType aType,
 	@param aType The selection type
 	@param aAttributes The attributes for the element
 	@param aDir The element was found in an <include_dir/> element?
 	*/
 		{
+		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_HANDLEPATHL_ENTRY );
 		// Check we dont have a NULL string
 		if (aAttributes[0].Value().DesC().Length() > 0)
 			{
 			switch (iCurrentElement)
 				{
 							if (selectionName[1] == ':')
 								{
 								CSelection* selection = CSelection::NewLC(aType, selectionName);
 								iPublicSelections.AppendL(selection);
 								CleanupStack::Pop(selection);
-								__LOG3("CPackageDataTransfer::HandlePathL(0x%08x) - Added selection: %S [type: %d]", iPackageID.iUid, &selectionName, aType);
+								OstTraceExt3(TRACE_NORMAL, CPACKAGEDATATRANSFER_HANDLEPATHL, "(0x%08x) - Added selection: %S [type: %d]", iPackageID.iUid, selectionName, static_cast<TInt32>(aType));
 								} //if
 							}// if
 						else
 							{
-							__LOG3("CPackageDataTransfer::HandlePathL(0x%08x) - Wrong format: %S [type: %d]", iPackageID.iUid, &selectionName, aType);
+						    OstTraceExt3(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_HANDLEPATHL, "(0x%08x) - Wrong format: %S [type: %d]", iPackageID.iUid, selectionName, static_cast<TInt32>(aType));
 							}
 						} // if
 					else
 						{
-						__LOG1("CPackageDataTransfer::HandlePathL(0x%08x) - EPublic - Could not convert filename", iPackageID.iUid);
+					    OstTrace1(TRACE_NORMAL, DUP2_CPACKAGEDATATRANSFER_HANDLEPATHL, "(0x%08x) - EPublic - Could not convert filename", iPackageID.iUid);
 						} // else
 					break;
 					};
 			default:
 					{
-					__LOG1("CPackageDataTransfer::HandlePathL(0x%08x) - Private data is Not Supported", iPackageID.iUid);
+					OstTrace1(TRACE_NORMAL, DUP3_CPACKAGEDATATRANSFER_HANDLEPATHL, "(0x%08x) - Private data is Not Supported", iPackageID.iUid);
 					}
 				break;
 				} // switch
 			} // if
 		else
 			{
-			__LOG1("CPackageDataTransfer::HandlePathL(0x%08x) - Path attribute error", iPackageID.iUid);
+		    OstTrace1(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_HANDLEPATHL, "(0x%08x) - Path attribute error", iPackageID.iUid);
 			} // else
+		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_HANDLEPATHL_EXIT );
 		}
 //					//
 // MContentHandler //
 //

changeset 47	63cf70d3ecd8
parent 20	6e82ae192c3a