FCL/sf/mw/remoteconn: comparison mtpfws/mtpfw/src/cmtpobjectstore.cpp

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 #include "cmtpdpidstore.h"
 #include "cmtppkgidstore.h"
 #include "cmtpdeltadatamgr.h"
 #include <e32hashtab.h>
 #include "cmtpstoragemgr.h"
+#include "mtpdebug.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpobjectstoreTraces.h"
+#endif
 _LIT(KMTPDbDriveLocation, "c:");
 _LIT(KMTPBackSlash, "\\");
 _LIT(KMTPHandleObjectDbName, "MTPObjectStore.db");
 _LIT(KMTPNoBackupFolderName, "nobackup");
 _LIT(KSQLSuidHash, "SuidIndex");
 _LIT(KSQLCreateSuidIndexText,"CREATE INDEX SuidIndex on HandleStore (SuidHash)");
 _LIT(KSQLParentHandle, "ParentHandleIndex");
 _LIT(KSQLCreateParentHandleText,"CREATE INDEX ParentHandleIndex on HandleStore (ParentHandle)");
 _LIT(KMTPFormat, "MTP");
-__FLOG_STMT(_LIT8(KComponent,"MTPObjectStore");)
 const TInt KMaxLimitCommitInEnumeration = 1024;
 const TInt KMaxLimitCommitAfterEnumeration = 256;
 const TInt KMaxLimitCompactInEnumeration = 2048;
 const TInt KMaxLimitCompactAfterEnumeration = 1024;
 const TInt KSnapshotGranularity = 128;
 CleanupStack::Pop(self);
 return self;
 }
+CMTPObjectStore::CSnapshotWorker::~CSnapshotWorker()
+{
+Cancel();
+}
 void CMTPObjectStore::CSnapshotWorker::RunL()
 {
 iObjectStore->CleanDBSnapshotL(iOnlyRoot);
 }
 	iBatched_SuidHashID.Close();
 	CloseDb();
 	iSingletons.Close();
 	iNonPersistentDPList.Close();
 	iEnumeratingCacheObjList.ResetAndDestroy();
-	__FLOG_CLOSE;
 	}
 /**
 Provides a reference to the object meta data store database.
 @return The object information store database.
 void CMTPObjectStore::MarkNonPersistentObjectsL(TUint aDataProviderId, TUint32)
 	{
 	TInt result = iNonPersistentDPList.InsertInOrder(aDataProviderId);
 	if(result != KErrAlreadyExists)
 		{
-		User::LeaveIfError(result);
+		LEAVEIFERROR(result,
+		        OstTrace1( TRACE_ERROR, CMTPOBJECTSTORE_MARKNONPERSISTENTOBJECTSL, "insert DpId %d into iNonPersistentDPList error!", aDataProviderId ));
 		}
 	}
 void CMTPObjectStore::MarkDPLoadedL(TUint aDataProviderId, TBool aFlag)
 	{
-	__FLOG(_L8("MarkDPFlafFalseL - Entry"));
+OstTraceFunctionEntry0( CMTPOBJECTSTORE_MARKDPLOADEDL_ENTRY );
 	if (!aFlag)
 		{
 		_LIT(KSQLMarkfalgDPFalse, "UPDATE HandleStore SET DPFlag = %u WHERE DataProviderId = %u");
 		iSqlStatement.Format(KSQLMarkfalgDPFalse, aFlag, aDataProviderId);
-		User::LeaveIfError(iDatabase.Execute(iSqlStatement));
+		LEAVEIFERROR(iDatabase.Execute(iSqlStatement),
-		}
+		        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_MARKDPLOADEDL, "UPDATE HandleStore SET DPFlag error!" ));
-	__FLOG(_L8("MarkNonPersistentObjectsL - Exit"));
+		}
+	OstTraceFunctionExit0( CMTPOBJECTSTORE_MARKDPLOADEDL_EXIT );
 	}
 TBool CMTPObjectStore::FilterObject(const RDbTable& aCurrRow,const TUint32 aStorageID,const TUint32 aFormatCode,const TUint32 aDpID) const
 {
 return  ( ((KMTPStorageAll==aStorageID) ||(aCurrRow.ColUint32(EObjectStoreStorageId)== aStorageID))
 	TFileName suid;
 	suid.CopyLC(aObject.DesC(CMTPObjectMetaData::ESuid));
 	TUint32 handle = HandleL(suid);
 	if (handle != KMTPHandleNone)
 	    {
-	    __FLOG(_L8("CommitReserverd leave for duplicate suid."));
+	    OstTrace0(TRACE_ERROR, CMTPOBJECTSTORE_COMMITRESERVEDOBJECTHANDLEL,
+	            "CommitReserverd leave for duplicate suid.");
 	    User::Leave(KErrAlreadyExists);
 	    }
 	TUint32 suidHash = DefaultHash::Des16(suid);
 	//After the PutL called the cursor's position is not well defined.
 	reinterpret_cast<RDbTable*> (aTable)->Cancel();
 	}
 void CMTPObjectStore::InsertObjectL(CMTPObjectMetaData& aObject)
 	{
-	__FLOG(_L8("InsertObjectL - Entry"));
+OstTraceFunctionEntry0( CMTPOBJECTSTORE_INSERTOBJECTL_ENTRY );
 	iCachedHandle = 0;
 	iCachedSuidHash = 0;
 	TBool needToInsert = EFalse;
 	TBool needUpdateOwner = EFalse;
 	TUint dpId(aObject.Uint(CMTPObjectMetaData::EDataProviderId));
 	if ((aObject.DesC(CMTPObjectMetaData::ESuid)).Length() > KMaxFileName)
 	{
 	// The length of object uid should not excceeds KMaxFileName
+	OstTrace0( TRACE_ERROR, DUP4_CMTPOBJECTSTORE_INSERTOBJECTL, "The length of object uid excceeds KMaxFileName" );
 	User::Leave( KErrBadName );
 	}
 	TFileName suid;
 	suid.CopyLC(aObject.DesC(CMTPObjectMetaData::ESuid));
 					needUpdateOwner = ETrue;
 					}
 				delete iEnumeratingCacheObjList[found];
 				iEnumeratingCacheObjList.Remove(found);
 				}
-			__FLOG_VA(_L8("Found in Snapshot"));
+			OstTrace0(TRACE_NORMAL, CMTPOBJECTSTORE_INSERTOBJECTL, "Found in Snapshot");
 			}
 		else
 			{//This is a totally new object. insert it after check the db to prevent user wrong operation
 			handle = HandleL(aObject.DesC(CMTPObjectMetaData::ESuid));
 			if (handle == KMTPHandleNone)
 						needUpdateOwner = ETrue;
 						}
 					}
 				CleanupStack::PopAndDestroy(object);
 				}
-			__FLOG_VA(_L8("Not Found in Snapshot"));
+			OstTrace0(TRACE_NORMAL, DUP1_CMTPOBJECTSTORE_INSERTOBJECTL, "Not Found in Snapshot");
 			}
-		__FLOG_VA((_L8("InsertObjectL Under enmueration, needUpdateOwner %d needToInsert %d"), needUpdateOwner, needToInsert));
+		OstTraceExt2(TRACE_NORMAL, DUP2_CMTPOBJECTSTORE_INSERTOBJECTL,
+		        "InsertObjectL Under enmueration, needUpdateOwner %d needToInsert %d", needUpdateOwner, needToInsert);
 		}
 	else
 		{
 		handle = HandleL(aObject.DesC(CMTPObjectMetaData::ESuid));
 		if (handle != KMTPHandleNone)
 			{
 				//Leaves if id already exists in suid map table
+OstTrace1( TRACE_ERROR, DUP5_CMTPOBJECTSTORE_INSERTOBJECTL, "id %d already exists in suid map table", handle );
 			User::Leave(KErrAlreadyExists);
 			}
 		// dp is not enumerating, do a plain insert
 		needToInsert = ETrue;
-		__FLOG_VA((_L8("InsertObjectL After enmueration, needUpdateOwner %d needToInsert %d"), needUpdateOwner, needToInsert));
+OstTraceExt2(TRACE_NORMAL, DUP3_CMTPOBJECTSTORE_INSERTOBJECTL,
+"InsertObjectL After enmueration, needUpdateOwner %d needToInsert %d", needUpdateOwner, needToInsert);
 		}
 	if (needToInsert)//needToInsert and needUpdateOwner can't be true at same time
 		{
 		TUint32 parentHandle(aObject.Uint(CMTPObjectMetaData::EParentHandle));
 			{
 			iMtpDeltaDataMgr->UpdateDeltaDataTableL(id, CMtpDeltaDataMgr::EAdded);
 			}
 		}
-	__FLOG(_L8("InsertObjectL - Exit"));
+	OstTraceFunctionExit0( CMTPOBJECTSTORE_INSERTOBJECTL_EXIT );
 	}
 void CMTPObjectStore::IncTranOpsNumL()
 	{
 	iTransactionOps++;
 	if (iTransactionOps % iMaxCommitLimit == 0)
 		{
 		CommitTransactionL();
 		if (iTransactionOps % iMaxCompactLimit == 0)
 			{
-			User::LeaveIfError(iDatabase.Compact());
+			LEAVEIFERROR(iDatabase.Compact(),
+			        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_INCTRANOPSNUML, "database compact error!" ));
 			}
 		BeginTransactionL();
 		}
 	}
 void CMTPObjectStore::BeginTransactionL()
 	{
 	if (!iDatabase.InTransaction())
 		{
-		User::LeaveIfError(iDatabase.Begin());
+		LEAVEIFERROR(iDatabase.Begin(),
+		        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_BEGINTRANSACTIONL, "database begin error!" ));
 		}
 	}
 void CMTPObjectStore::CommitTransactionL()
 	{
-	__FLOG(_L8("CommitTransactionL Entry"));
+	OstTraceFunctionEntry0( CMTPOBJECTSTORE_COMMITTRANSACTIONL_ENTRY );
 	if (iDatabase.InTransaction())
 		{
-		User::LeaveIfError(iDatabase.Commit());
+		LEAVEIFERROR(iDatabase.Commit(),
-		}
+		        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_COMMITTRANSACTIONL, "database commit error!" ));
-	__FLOG(_L8("CommitTransactionL Exit"));
+		}
+	OstTraceFunctionExit0( CMTPOBJECTSTORE_COMMITTRANSACTIONL_EXIT );
 	}
 void CMTPObjectStore::InsertObjectsL(RPointerArray<CMTPObjectMetaData>& aObjects)
 	{
 	TInt count = aObjects.Count();
 		{
 		//To avoid this modification will not generate duplicate SUID
 		TUint32 handle2 = HandleL(suid);
 		if (handle2 != KMTPHandleNone && handle2 != handle)
 		    {
-		    __FLOG(_L8("ModifyObjectL leave for duplicate suid."));
+		    OstTrace0(TRACE_ERROR, CMTPOBJECTSTORE_MODIFYOBJECTL, "ModifyObjectL leave for duplicate suid.");
 		    User::Leave(KErrAlreadyExists);
 		    }
 		//After the PutL called the cursor's position is not well defined.
 		iCachedHandle = 0;
 				}
 			}
 		}
 	else
 		{
+OstTrace1( TRACE_ERROR, DUP1_CMTPOBJECTSTORE_MODIFYOBJECTL, "LocateByHandleL failed for handle %d", handle );
 		User::Leave(KErrNotFound);
 		}
 	}
 TBool CMTPObjectStore::ObjectL(const TMTPTypeUint32& aHandle, CMTPObjectMetaData& aBuf) const
 const TPtrC CMTPObjectStore::ObjectSuidL(TUint32 aHandle) const
 	{
 	//iBatched owns the memory of Suid ?
 	if (!LocateByHandleL(aHandle))
 		{
+OstTrace1( TRACE_ERROR, CMTPOBJECTSTORE_OBJECTSUIDL, "LocateByHandleL failed for handle %d", aHandle );
 		User::Leave(KErrNotFound);
 		}
 DbColReadStreamL(iBatched, EObjectStoreSUID, iSuidBuf);
 	return iSuidBuf;
 	}
 TMTPTypeUint128 CMTPObjectStore::PuidL(TUint32 aHandle)
 	{
 	if (!LocateByHandleL(aHandle))
 		{
+OstTrace1( TRACE_ERROR, CMTPOBJECTSTORE_PUIDL_TUINT32, "LocateByHandleL failed for handle %d", aHandle );
 		User::Leave(KErrNotFound);
 		}
 	TUint64 highHalfPOUID = static_cast<TUint64> (iBatched.ColInt64(EObjectStorePOUID));
 	// We actually use the first 64 bits to represent the PUID. this will represent 2^64=16 G xG objects, it is reasonable
 	//to assume the Phone, as a resource-constrained device, never will reach that number, therefore, we choose
 TMTPTypeUint128 CMTPObjectStore::PuidL(const TDesC& aSuid)
 	{
 	if (!LocateBySuidL(aSuid))
 		{
+OstTraceExt1( TRACE_ERROR, CMTPOBJECTSTORE_PUIDL_TDESC, "LocateByHandleL failed for suid %S", aSuid );
 		User::Leave(KErrNotFound);
 		}
 	TUint64 highHalfPOUID = static_cast<TUint64> (iBatched_SuidHashID.ColInt64(EObjectStorePOUID));
 	// We actually use the first 64 bits to represent the PUID. this will represent 2^64=16 G xG objects, it is reasonable
 	//to assume the Phone, as a resource-constrained device, never will reach that number, therefore, we choose
 	return result;
 	}
 void CMTPObjectStore::RemoveObjectL(const TMTPTypeUint32& aHandle)
 {
-__FLOG_VA((_L8("RemoveObjectL Entry Handle = 0x%x"), aHandle.Value()));
+OstTraceFunctionEntry0( CMTPOBJECTSTORE_REMOVEOBJECTL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPOBJECTSTORE_REMOVEOBJECTL,
+"Handle = 0x%x", aHandle.Value());
 if (LocateByHandleL(aHandle.Value()))
 {
 if (iSingletons.DpController().EnumerateState() != CMTPDataProviderController::EEnumeratedFulllyCompleted &&
 IsMediaFormat(iBatched.ColUint16(EObjectStoreFormatCode)))
 {
 }
 iCachedSuidHash = 0;
 iCachedHandle = 0;
 iReferenceMgr->RemoveReferencesL(aHandle.Value());
 iBatched.DeleteL();
-__FLOG(_L8("RemoveObjectL From iBacthed"));
+OstTrace0(TRACE_NORMAL, DUP1_CMTPOBJECTSTORE_REMOVEOBJECTL, "RemoveObjectL From iBacthed");
 IncTranOpsNumL();
 }
-__FLOG(_L8("RemoveObjectL Exit"));
+OstTraceFunctionExit0( CMTPOBJECTSTORE_REMOVEOBJECTL_EXIT );
 }
 void CMTPObjectStore::RemoveObjectL(const TDesC& aSuid)
 	{
 	if(LocateBySuidL(aSuid))
 /**
 Clean unloaded data provider contents from object store
 */
 void CMTPObjectStore::CleanL()
 	{
-	__FLOG(_L8("CleanL - Entry"));
+	OstTraceFunctionEntry0( CMTPOBJECTSTORE_CLEANL_ENTRY );
 	RemoveUndefinedObjectsL();
 	Swi::RSisRegistrySession sisSession;
-	User::LeaveIfError(sisSession.Connect());
+	LEAVEIFERROR(sisSession.Connect(),
+	        OstTrace0( TRACE_ERROR, DUP1_CMTPOBJECTSTORE_CLEANL, "can't connect to sisSession!" ));
 	CleanupClosePushL(sisSession);
 	const RArray<TUint>& loadedDPIDs = iPkgIDStore->DPIDL();
 	RArray<TUint> unInstalledDpIDs;
 	CleanupClosePushL(unInstalledDpIDs);
 		TUid pkgUid = TUid::Uid(iPkgIDStore->PKGIDL(idx));
 		if (!sisSession.IsInstalledL(pkgUid))
 			{
 			//DP is uninstalled, remove DP related data from database.
 			TUint thisID = loadedDPIDs[idx];
-			__FLOG_1(_L("Data provider[%d] is removed from device!"),thisID);
+			OstTrace1(TRACE_NORMAL, CMTPOBJECTSTORE_CLEANL, "Data provider[%d] is removed from device!", thisID);
 			unInstalledDpIDs.AppendL(thisID);
 			}
 		}
 	for (TUint index = 0; index < unInstalledDpIDs.Count(); ++index)
 		{
 		RemoveObjectsL(unInstalledDpIDs[index]);
 		iPkgIDStore->RemoveL(unInstalledDpIDs[index]);
 		}
 	CleanupStack::PopAndDestroy(&unInstalledDpIDs);
 	CleanupStack::PopAndDestroy(&sisSession);
-	__FLOG(_L8("CleanL - Exit"));
+	OstTraceFunctionExit0( CMTPOBJECTSTORE_CLEANL_EXIT );
 	}
 TUint CMTPObjectStore::ObjectOwnerId(const TMTPTypeUint32& aHandle) const
 {
 if (!LocateByHandleL(aHandle.Value()))
 /**
 Second phase constructor.
 */
 void CMTPObjectStore::ConstructL()
 	{
-	__FLOG_OPEN(KMTPSubsystem, KComponent);
 	iMaxCommitLimit = KMaxLimitCommitInEnumeration;
 	iMaxCompactLimit = KMaxLimitCompactInEnumeration;
 	iSingletons.OpenL();
 	InitializeDbL();
 	iCompactor = CDbCompactor::NewL(&iDatabase);
 	iMtpDeltaDataMgr = CMtpDeltaDataMgr::NewL(iDatabase);
 	iReferenceMgr = CMTPReferenceMgr::NewL(*this);
 	iDPIDStore = CMTPDPIDStore::NewL(iDatabase);
 	iPkgIDStore = CMTPPkgIDStore::NewL(iDatabase);
-	User::LeaveIfError(iBatched.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable));
+	LEAVEIFERROR(iBatched.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable),
-	User::LeaveIfError(iBatched.SetIndex(KSQLHandleId));
+	        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_CONSTRUCTL, "iBatched open error!" ));
-	User::LeaveIfError(iBatched_SuidHashID.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable));
+	LEAVEIFERROR(iBatched.SetIndex(KSQLHandleId),
-	User::LeaveIfError(iBatched_SuidHashID.SetIndex(KSQLSuidHash));
+	        OstTrace0( TRACE_ERROR, DUP1_CMTPOBJECTSTORE_CONSTRUCTL, "set index for iBatched error!" ));
+	LEAVEIFERROR(iBatched_SuidHashID.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable),
+	        OstTrace0( TRACE_ERROR, DUP2_CMTPOBJECTSTORE_CONSTRUCTL, "iBatched_SuidHashID open error!" ));
+	LEAVEIFERROR(iBatched_SuidHashID.SetIndex(KSQLSuidHash),
+	        OstTrace0( TRACE_ERROR, DUP3_CMTPOBJECTSTORE_CONSTRUCTL, "set index for iBatched_SuidHashID error!"));
 	iHandleAllocator = CMTPHandleAllocator::NewL(*this);
 	iSentinal = CEnumertingCacheItem::NewL(0, 0, 0, 0, 0, 0);
 	BeginTransactionL();
 	}
 */
 void CMTPObjectStore::CreateDbL(const TDesC& aFileName)
 	{
 	BaflUtils::EnsurePathExistsL(iSingletons.Fs(), aFileName);
-	User::LeaveIfError(iDatabase.Replace(iSingletons.Fs(), aFileName, KMTPFormat));
+	LEAVEIFERROR(iDatabase.Replace(iSingletons.Fs(), aFileName, KMTPFormat),
+	        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_CREATEDBL, " a new non-secure database create error!" ));
 	// Create table and index
 	CreateHandleTableL();
 	CreateHandleIndexL();
 	iUpdateDeltaDataTable = ETrue;
 	}
 */
 void CMTPObjectStore::CreateHandleTableL()
 	{
 	if (!DBUtility::IsTableExistsL(iDatabase, KSQLHandleTableName))
 		{
-		User::LeaveIfError(iDatabase.Execute(KSQLCreateHandleTableText));
+		LEAVEIFERROR(iDatabase.Execute(KSQLCreateHandleTableText),
+		        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_CREATEHANDLETABLEL, "TABLE HandleStore create failed!" ));
 		}
 	}
 /**
 Create three index on the table: 1. Handle, 2. SuidHash, 3. ParentHandle
 	{
 	if (DBUtility::IsTableExistsL(iDatabase, KSQLHandleTableName))
 		{
 		if (!DBUtility::IsIndexExistsL(iDatabase, KSQLHandleTableName, KSQLHandleId))
 			{
-			User::LeaveIfError(iDatabase.Execute(KSQLCreateHandleIndexText));
+			LEAVEIFERROR(iDatabase.Execute(KSQLCreateHandleIndexText),
+			        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_CREATEHANDLEINDEXL, "INDEX HandleIndex on HandleStore create failed!" ));
 			}
 		if (!DBUtility::IsIndexExistsL(iDatabase, KSQLHandleTableName, KSQLSuidHash))
 			{
-			User::LeaveIfError(iDatabase.Execute(KSQLCreateSuidIndexText));
+			LEAVEIFERROR(iDatabase.Execute(KSQLCreateSuidIndexText),
+			        OstTrace0( TRACE_ERROR, DUP1_CMTPOBJECTSTORE_CREATEHANDLEINDEXL, "INDEX SuidIndex on HandleStore create failed!" ));
 			}
 		if (!DBUtility::IsIndexExistsL(iDatabase, KSQLHandleTableName, KSQLParentHandle))
 			{
-			User::LeaveIfError(iDatabase.Execute(KSQLCreateParentHandleText));
+			LEAVEIFERROR(iDatabase.Execute(KSQLCreateParentHandleText),
+			        OstTrace0( TRACE_ERROR, DUP2_CMTPOBJECTSTORE_CREATEHANDLEINDEXL, "INDEX ParentHandleIndex on HandleStore create failed!" ));
 			}
 		}
 	else
 		{
+OstTrace0( TRACE_ERROR, DUP3_CMTPOBJECTSTORE_CREATEHANDLEINDEXL, "HandleStore table doesn't exist" );
 		User::Leave(KErrNotFound);
 		}
 	}
 /**
 	}
 TBool CMTPObjectStore::LocateByHandleL(const TUint aHandle, const TBool aReadTable /*default = ETrue*/) const
 	{
-	__FLOG_VA((_L8("LocateByHandleL - Entry aHandle 0x%x"), aHandle));
+OstTraceFunctionEntry1( CMTPOBJECTSTORE_LOCATEBYHANDLEL_ENTRY, this );
+	OstTrace1(TRACE_NORMAL, CMTPOBJECTSTORE_LOCATEBYHANDLEL, "aHandle 0x%x", aHandle);
 	TBool result = EFalse;
 	if(IsInvalidHandle(aHandle))
 		{
-		__FLOG_VA((_L8("LocateByHandleL - Exit result 0x%x"), result));
+		OstTraceFunctionExitExt( CMTPOBJECTSTORE_LOCATEBYHANDLEL_EXIT, this, result );
 		return result;
 		}
 	if (iCachedHandle == aHandle)
 		{
-		__FLOG(_L8("CacheHit"));
+		OstTrace0(TRACE_NORMAL, DUP1_CMTPOBJECTSTORE_LOCATEBYHANDLEL, "CacheHit");
 		result = ETrue;
 		}
 	else
 		{
 		if (iBatched.SeekL(aHandle))
 		}
 	if (result && aReadTable)
 		{
 		iBatched.GetL();
 		}
-	__FLOG_VA((_L8("LocateByHandleL - Exit result 0x%x"), result));
+	OstTraceFunctionExitExt( DUP1_CMTPOBJECTSTORE_LOCATEBYHANDLEL_EXIT, this, result );
 	return result;
 	}
 TBool CMTPObjectStore::LocateBySuidL(const TDesC& aSuid) const
 	{
 //Currently, i only do this for File DP since it is non-persistent, later, if we take the proposal that
 //1. FileDP is the last DP to be enumerated.
 //2. FileDP will san the whole file system, and will try to enumerate all of the objects(might on behalf of another DP) if the objects is still not
 // in the object store after all other DP finish its enumeration.
 //3. Then notify the related DP about the newly added objects by notification API;
-__FLOG(_L8("EstablishDBSnapshotL - Entry"));
+OstTraceFunctionEntry0( CMTPOBJECTSTORE_ESTABLISHDBSNAPSHOTL_ENTRY );
 RDbTable temp;
 CleanupClosePushL(temp);
-User::LeaveIfError(temp.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable));
+LEAVEIFERROR(temp.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable),
+OstTrace0( TRACE_ERROR, DUP1_CMTPOBJECTSTORE_ESTABLISHDBSNAPSHOTL, "HandleStore table open failed!" ));
 if(!iCacheExist)
 {
 TInt32 count = temp.CountL(RDbRowSet::EQuick);
 iEnumeratingCacheObjList.ReserveL(count);
 }
 result = iEnumeratingCacheObjList.InsertInOrder(item, TLinearOrder<CEnumertingCacheItem>(CEnumertingCacheItem::Compare));
 }
 if(result != KErrAlreadyExists)
 {
-User::LeaveIfError(result);
+LEAVEIFERROR(result,
+OstTrace1( TRACE_ERROR, DUP2_CMTPOBJECTSTORE_ESTABLISHDBSNAPSHOTL, "insert into iEnumeratingCacheObjList failed, error code %d", result));
 CleanupStack::Pop(item);
 }
 else
 {
 CleanupStack::PopAndDestroy(item);
 temp.NextL();
 }
 CleanupStack::PopAndDestroy(&temp);
 iCacheExist = ETrue;
-__FLOG_VA((_L8("EstablishDBSnapshotL - Exit build %d items"), iEnumeratingCacheObjList.Count()));
+OstTrace1(TRACE_NORMAL, CMTPOBJECTSTORE_ESTABLISHDBSNAPSHOTL,
+"EstablishDBSnapshotL - Exit build %d items", iEnumeratingCacheObjList.Count());
+OstTraceFunctionExit0( CMTPOBJECTSTORE_ESTABLISHDBSNAPSHOTL_EXIT );
 }
 /*
 * All Objects enumeration complete
 */
 void CMTPObjectStore::ObjectsEnumComplete()
 iEnumeratingCacheObjList.ResetAndDestroy();
 iUpdateDeltaDataTable = ETrue;
 iMaxCommitLimit = KMaxLimitCommitAfterEnumeration;
 iMaxCompactLimit = KMaxLimitCompactAfterEnumeration;
 CommitTransactionL();
-User::LeaveIfError(iDatabase.Compact());
+LEAVEIFERROR(iDatabase.Compact(),
+OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_OBJECTSENUMCOMPLETE, "database compact failed!" ));
 BeginTransactionL();
 }
 void CMTPObjectStore::CleanDBSnapshotL(TBool aOnlyRoot/* = EFalse*/)
 //For those items left in the iEnumeratingCacheObjList, remove the object entry if the DPID of the handle is not persistent. and populate the
 //roundtrip table if needed.
 //and then close the iEnumeratingCacheObjList to release the memory.
 //_LIT(KInsert, "CMTPObjectStore::CleanDBSnapshot");
 //volatile TTimer t(KInsert);
-__FLOG(_L8("CleanDBSnapshotL Entry"));
+OstTraceFunctionEntry0( CMTPOBJECTSTORE_CLEANDBSNAPSHOTL_ENTRY );
 if (iSnapshotWorker == NULL)
 {
 iSnapshotCleanPos = iEnumeratingCacheObjList.Count() - 1;
 iSnapshotWorker = CSnapshotWorker::NewL(this, aOnlyRoot);
 }
 ||(!aOnlyRoot)) //everything
 {
 TInt rc = iNonPersistentDPList.FindInOrder(iEnumeratingCacheObjList[iSnapshotCleanPos]->iDpID);
 if (rc != KErrNotFound)
 {//This is a non persistent DP.
-__FLOG_VA((_L8("Remove Object 0x%x"), iEnumeratingCacheObjList[iSnapshotCleanPos]->iObjHandleId));
+OstTrace1(TRACE_NORMAL, CMTPOBJECTSTORE_CLEANDBSNAPSHOTL,
+"Remove Object 0x%x", iEnumeratingCacheObjList[iSnapshotCleanPos]->iObjHandleId);
 RemoveObjectL(iEnumeratingCacheObjList[iSnapshotCleanPos]->iObjHandleId);
 }
 }
 }
 iSnapshotCleanPos = 0;
 delete iSnapshotWorker;
 iSnapshotWorker = NULL;
 }
-__FLOG(_L8("CleanDBSnapshotL Exit"));
+OstTraceFunctionExit0( CMTPOBJECTSTORE_CLEANDBSNAPSHOTL_EXIT );
 }
 void CMTPObjectStore::RemoveUndefinedObjectsL()
 {
-__FLOG(_L8("CompactDBSnapshotL Entry"));
+OstTraceFunctionEntry0( CMTPOBJECTSTORE_REMOVEUNDEFINEDOBJECTSL_ENTRY );
 if (iCleanUndefined)
 {
+OstTraceFunctionExit0( CMTPOBJECTSTORE_REMOVEUNDEFINEDOBJECTSL_EXIT );
 return;
 }
 TInt32 count = 0;
 RDbTable temp;
 CleanupClosePushL(temp);
-User::LeaveIfError(temp.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable));
+LEAVEIFERROR(temp.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable),
+OstTrace0( TRACE_ERROR, DUP1_CMTPOBJECTSTORE_REMOVEUNDEFINEDOBJECTSL, "HandleStore Table open error!" ));
 count = temp.CountL(RDbRowSet::EQuick);
-__FLOG_VA((_L8("Count before deletion %d "), count));
+OstTrace1(TRACE_NORMAL, CMTPOBJECTSTORE_REMOVEUNDEFINEDOBJECTSL,
+"Count before deletion %d ", count);
 CleanupStack::PopAndDestroy(&temp);
 if (count > KMaxLimitSnapshotSize)
 {
 // Delete all object with undefined format
 _LIT(KSQLDeleteObjectText, "DELETE FROM HandleStore WHERE FormatCode = %u");
 iSqlStatement.Format(KSQLDeleteObjectText, EMTPFormatCodeUndefined);
-User::LeaveIfError(iDatabase.Execute(iSqlStatement));
+LEAVEIFERROR(iDatabase.Execute(iSqlStatement),
+OstTrace0( TRACE_ERROR, DUP2_CMTPOBJECTSTORE_REMOVEUNDEFINEDOBJECTSL, "DELETE FROM HandleStore failed!"));
 }
 iCleanUndefined = ETrue;
-__FLOG(_L8("CompactDBSnapshotL Exit"));
+OstTraceFunctionExit0( DUP1_CMTPOBJECTSTORE_REMOVEUNDEFINEDOBJECTSL_EXIT );
 }
 CMTPObjectStore::CEnumertingCacheItem::CEnumertingCacheItem(TUint32 aSuidHash, TUint32 aHandle, TUint32 aParent, TUint32 aFormat, TUint64 aId, TUint8 aDpID)
 	{

changeset 49	c20dd21d1eb4
parent 31	a26669f87b46
child 51	64200268cac2