FCL/sf/mw/remoteconn: comparison mtpfws/mtpfw/dataproviders/dputility/src/cmtpsvccompoundprocessor.cpp

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 #include "mmtpsvcobjecthandler.h"
 #include "cmtpconnection.h"
 #include "cmtpconnectionmgr.h"
 #include "mtpsvcdpconst.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpsvccompoundprocessorTraces.h"
+#endif
 // Class constants.
-__FLOG_STMT(_LIT8(KComponent,"SvcCompound");)
 EXPORT_C MMTPRequestProcessor* CMTPSvcCompoundProcessor::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection, MMTPServiceDataProvider& aDataProvider)
 	{
 	CMTPSvcCompoundProcessor* self = new (ELeave) CMTPSvcCompoundProcessor(aFramework, aConnection, aDataProvider);
 	CleanupStack::PushL(self);
 	return self;
 	}
 EXPORT_C CMTPSvcCompoundProcessor::~CMTPSvcCompoundProcessor()
 	{
-	__FLOG(_L8("~CMTPSvcCompoundProcessor - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CMTPSVCCOMPOUNDPROCESSOR_DES_ENTRY );
 	delete iReceivedObjectMetaData;
 	delete iObjectInfo;
 	delete iObjectPropList;
-	__FLOG(_L8("~CMTPSvcCompoundProcessor - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CMTPSVCCOMPOUNDPROCESSOR_DES_EXIT );
-	__FLOG_CLOSE;
 	}
 CMTPSvcCompoundProcessor::CMTPSvcCompoundProcessor(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection, MMTPServiceDataProvider& aDataProvider) :
 	CMTPRequestProcessor(aFramework, aConnection, 0, NULL),
 	iDataProvider(aDataProvider), iState(EIdle), iIsCommited(EFalse), iIsRollBackHandlerObject(EFalse)
 	{
 	}
 void CMTPSvcCompoundProcessor::ConstructL()
 	{
-	__FLOG_OPEN(KMTPSubsystem, KComponent);
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CONSTRUCTL_ENTRY );
-	__FLOG(_L8("ConstructL - Entry"));
 	iExpectedSendObjectRequest.SetUint16(TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSendObject);
 	iReceivedObjectMetaData = CMTPObjectMetaData::NewL();
 	iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EDataProviderId, iFramework.DataProviderId());
-	__FLOG(_L8("ConstructL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CONSTRUCTL_EXIT );
 	}
 /**
 Override to match both the SendObjectInfo/SendObjectPropList/UpdateObjectPropList and SendObject requests
 @param aRequest    The request to match
 @param aConnection The connection from which the request comes
 @return ETrue if the processor can handle the request, otherwise EFalse
 */
 TBool CMTPSvcCompoundProcessor::Match(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const
 	{
-	__FLOG(_L8("Match - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_MATCH_ENTRY );
 	TBool result = EFalse;
 	TUint16 operationCode = aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode);
 	if ((&iConnection == &aConnection) &&
 		(operationCode == EMTPOpCodeSendObjectInfo ||
 		operationCode == EMTPOpCodeSendObject ||
 		operationCode == EMTPOpCodeUpdateObjectPropList ||
 		operationCode == EMTPOpCodeSendObjectPropList))
 		{
 		result = ETrue;
 		}
-	__FLOG(_L8("Match - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_MATCH_EXIT );
 	return result;
 	}
 TBool CMTPSvcCompoundProcessor::HasDataphase() const
 	{
 Verify the request
 @return EMTPRespCodeOK if request is verified, otherwise one of the error response codes
 */
 TMTPResponseCode CMTPSvcCompoundProcessor::CheckRequestL()
 	{
-	__FLOG(_L8("CheckRequestL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTL_ENTRY );
 	TMTPResponseCode responseCode = CMTPRequestProcessor::CheckRequestL();
 	if (EMTPRespCodeOK == responseCode)
 		{
 		responseCode = CheckSendingStateL();
 		if (EMTPRespCodeOK == responseCode)
 			{
 			responseCode = CheckRequestParametersL();
 			}
 		}
-	__FLOG_VA((_L8("CheckRequestL - Exit with code: 0x%04X"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTL, "Exit with code: 0x%04X", responseCode);
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTL_EXIT );
 	return responseCode;
 	}
 /**
 Verify if the SendObject request comes after SendObjectInfo/SendObjectPropList request
 @return EMTPRespCodeOK if SendObject request comes after a valid SendObjectInfo request, otherwise
 EMTPRespCodeNoValidObjectInfo
 */
 TMTPResponseCode CMTPSvcCompoundProcessor::CheckSendingStateL()
 	{
-	__FLOG(_L8("CheckSendingStateL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	iOperationCode = Request().Uint16(TMTPTypeRequest::ERequestOperationCode);
 	if (iOperationCode == EMTPOpCodeSendObject)
 		{
 		case EIdle:
 			// Received an orphan SendObject
 			if (iOperationCode == EMTPOpCodeSendObject)
 				{
 				responseCode = EMTPRespCodeNoValidObjectInfo;
-				__FLOG(_L8("EIdle: Received an orphan SendObject request"));
+				OstTrace0( TRACE_NORMAL, DUP1_CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL, "EIdle: Received an orphan SendObject request" );
 				}
 			break;
 		case EObjectInfoSucceed:
 			// If another SendObjectInfo or SendObjectPropList operation occurs before a SendObject
 			// operation, the new ObjectInfo or ObjectPropList shall replace the previously held one.
 				iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EDataProviderId, iFramework.DataProviderId());
 				iObjectHandler = NULL;
 				iState = EIdle;
 				// Reset commit state to false
 				iIsCommited = EFalse;
-				__FLOG(_L8("EObjectInfoSucceed: Receive send obj info request again, return to EIdle"));
+				OstTrace0( TRACE_NORMAL, DUP2_CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL,
+				        "EObjectInfoSucceed: Receive send obj info request again, return to EIdle" );
 				}
 			break;
 		default:
+		    OstTrace1( TRACE_ERROR, DUP3_CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL, "wrong iState %d", iState);
 			User::Leave(KErrGeneral);
 		}
-	__FLOG_VA((_L8("CheckSendingStateL - Exit with code: 0x%04X, state: %u"), responseCode, iState));
+	OstTraceExt2( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL, "Exit with code: 0x%04X, state: %u", (TUint32)responseCode, iState );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL_EXIT );
 	return responseCode;
 	}
 /**
 Validates the data type for a given property code.
 @return EMTPRespCodeOK if the parent handle matches the store id, or another MTP response code if not
 */
 TMTPResponseCode CMTPSvcCompoundProcessor::CheckRequestParametersL()
 	{
-	__FLOG(_L8("CheckRequestParametersL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	switch (iOperationCode)
 		{
 		case EMTPOpCodeSendObject:
 			{
-			__FLOG(_L8("Check SendObject request parameters"));
+			OstTrace0( TRACE_NORMAL, DUP1_CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL,
+			        "Check SendObject request parameters" );
 			// Check SendObject's session ID
 			if (iSessionId != iLastSessionID)
 				{
 				responseCode = EMTPRespCodeNoValidObjectInfo;
 				}
 			break;
 			}
 		case EMTPOpCodeSendObjectInfo:
 			{
-			__FLOG(_L8("Check SendObjectInfo request parameters"));
+			OstTrace0( TRACE_NORMAL, DUP2_CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL,
+			        "Check SendObjectInfo request parameters" );
 			responseCode = CheckStoreAndParent();
 			break;
 			}
 		case EMTPOpCodeSendObjectPropList:
 			{
-			__FLOG(_L8("Check SendObjectPropList request parameters"));
+			OstTrace0( TRACE_NORMAL, DUP3_CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL,
+			        "Check SendObjectPropList request parameters" );
 			responseCode = CheckStoreAndParent();
 			if (EMTPRespCodeOK == responseCode)
 				{
 				// SendObjectPropList need check format code and size in the request
 				TUint32 objectSizeHigh = Request().Uint32(TMTPTypeRequest::ERequestParameter4);
 			break;
 			}
 		case EMTPOpCodeUpdateObjectPropList:
 			{
-			__FLOG(_L8("Check UpdateObjectPropList request parameters"));
+			OstTrace0( TRACE_NORMAL, DUP4_CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL,
+			        "Check UpdateObjectPropList request parameters" );
 			TUint32 objectHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
 			if (objectHandle != KMTPHandleNone)
 				{
 				// Find the updating object information
 				MMTPObjectMgr& objects(iFramework.ObjectMgr());
 		default:
 			// Unexpected operation code
 			responseCode = EMTPRespCodeOperationNotSupported;
 			break;
 		}
-	__FLOG_VA((_L8("CheckRequestParametersL exit with code: 0x%x"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL, "exit with code: 0x%x", responseCode );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL_EXIT );
 	return responseCode;
 	}
 /**
 Validates the data type for a given property code.
 @return EMTPRespCodeOK if the parent handle matches the store id, or another MTP response code if not
 */
 TMTPResponseCode CMTPSvcCompoundProcessor::CheckStoreAndParent()
 	{
-	__FLOG(_L8("CheckStoreAndParent - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKSTOREANDPARENT_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	iStorageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
 	iParentHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter2);
 	// If the first parameter is unused, it should be set to 0x00000000, and the responder should decide
 			{
 			responseCode = EMTPRespCodeInvalidStorageID;
 			}
 		}
-	__FLOG_VA((_L8("CheckStoreAndParent - Exit with code: 0x%x"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_CHECKSTOREANDPARENT, "Exit with code: 0x%x", responseCode );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKSTOREANDPARENT_EXIT );
 	return responseCode;
 	}
 /**
 SendObjectInfo/SendObjectPropList/UpdateObjectPropList/SendObject request handler
 To maintain the state information between the two requests, the two requests are
 combined together in one request processor.
 */
 void CMTPSvcCompoundProcessor::ServiceL()
 	{
-	__FLOG(_L8("ServiceL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICEL_ENTRY );
 	switch (iState)
 		{
 		case EIdle:
 			ServiceObjectPropertiesL();
 			break;
 		case EObjectInfoSucceed:
 			ServiceSendObjectL();
 			break;
 		default:
-			__FLOG(_L8("Wrong state in ServiceL"));
+			OstTrace0( TRACE_WARNING, CMTPSVCCOMPOUNDPROCESSOR_SERVICEL, "Wrong state in ServiceL" );
 			break;
 		}
-	__FLOG(_L8("ServiceL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICEL_EXIT );
 	}
 void CMTPSvcCompoundProcessor::ServiceObjectPropertiesL()
 	{
-	__FLOG(_L8("ServiceObjectPropertiesL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICEOBJECTPROPERTIESL_ENTRY );
 	switch (iOperationCode)
 		{
 		case EMTPOpCodeSendObjectInfo:
 			ServiceSendObjectInfoL();
 			break;
 			ServiceSendObjectPropListL();
 			break;
 		default:
 			break;
 		}
-	__FLOG(_L8("ServiceObjectPropertiesL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICEOBJECTPROPERTIESL_EXIT );
 	}
 /**
 SendObject request handler
 */
 void CMTPSvcCompoundProcessor::ServiceSendObjectL()
 	{
-	__FLOG(_L8("ServiceSendObjectL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTL_ENTRY );
 	MMTPSvcObjectHandler* pHandler = iDataProvider.ObjectHandler(iFormatCode);
 	if (pHandler)
 		{
 		pHandler->GetBufferForSendObjectL(*iReceivedObjectMetaData, &iObjectContent);
 		}
 	else
 		{
+OstTrace1( TRACE_ERROR, CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTL,
+"can't get object handler for format code %d", iFormatCode);
 		User::Leave(KErrGeneral);
 		}
 	ReceiveDataL(*iObjectContent);
 	iState = EObjectSendProcessing;
-	__FLOG(_L8("ServiceSendObjectL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTL_EXIT );
 	}
 /**
 SendObjectInfo request handler
 */
 void CMTPSvcCompoundProcessor::ServiceSendObjectInfoL()
 	{
-	__FLOG(_L8("ServiceSendObjectInfoL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTINFOL_ENTRY );
 	delete iObjectInfo;
 	iObjectInfo = NULL;
 	iObjectInfo = CMTPTypeObjectInfo::NewL();
 	ReceiveDataL(*iObjectInfo);
 	iState = EObjectInfoProcessing;
-	__FLOG(_L8("ServiceSendObjectInfoL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTINFOL_EXIT );
 	}
 /**
 SendObjectPropList request handler
 */
 void CMTPSvcCompoundProcessor::ServiceSendObjectPropListL()
 	{
-	__FLOG(_L8("ServiceSendObjectPropListL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTPROPLISTL_ENTRY );
 	delete iObjectPropList;
 	iObjectPropList = NULL;
 	iObjectPropList = CMTPTypeObjectPropList::NewL();
 	ReceiveDataL(*iObjectPropList);
 	iState = EObjectInfoProcessing;
-	__FLOG(_L8("ServiceSendObjectPropListL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTPROPLISTL_EXIT );
 	}
 /**
 Override to handle the response phase of SendObjectInfo/SendObjectPropList and SendObject requests
 @return EFalse
 */
 TBool CMTPSvcCompoundProcessor::DoHandleResponsePhaseL()
 	{
-	__FLOG(_L8("DoHandleResponsePhaseL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEPHASEL_ENTRY );
 	TBool successful = !iCancelled;
 	switch (iState)
 		{
 		case EObjectInfoProcessing:
 			{
 			iState = (successful ? EObjectSendSucceed : EObjectSendFail);
 			break;
 			}
 		default:
 			// Wrong State value.
-			__FLOG_VA((_L8("DoHandleResponsePhaseL enter an abnormal state %d"), iState));
+			OstTrace1( TRACE_WARNING, CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEPHASEL,
-			break;
+			        "DoHandleResponsePhaseL enter an abnormal state %d", iState );
-		}
+			break;
-	__FLOG(_L8("DoHandleResponsePhaseL - Exit"));
+		}
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEPHASEL_EXIT );
 	return EFalse;
 	}
 /**
 Override to handle the completing phase of SendObjectInfo/SendObjectPropList and SendObject requests
 @return ETrue if succesfully received the object content, otherwise EFalse
 */
 TBool CMTPSvcCompoundProcessor::DoHandleCompletingPhaseL()
 	{
-	__FLOG(_L8("DoHandleCompletingPhaseL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLECOMPLETINGPHASEL_ENTRY );
 	TBool result = ETrue;
 	CMTPRequestProcessor::DoHandleCompletingPhaseL();
-	__FLOG_VA((_L8("DoHandleCompletingPhaseL - Progress State: %u"), iState));
+	OstTrace1( TRACE_WARNING, CMTPSVCCOMPOUNDPROCESSOR_DOHANDLECOMPLETINGPHASEL,
+	        "DoHandleCompletingPhaseL - Progress State: %u", iState );
 	switch (iState)
 		{
 		case EObjectInfoSucceed:
 			{
 			// Two cases will come here:
 				iLastTransactionID = iTransactionCode;
 				iLastSessionID = iSessionId;
 				iLastInfoOperationCode = iOperationCode;
 				}
 			result = EFalse;
-			__FLOG_VA((_L8("EObjectInfoSucceed: Save send info transaction id: %u, operation: 0x%x"), iLastTransactionID, iOperationCode));
+			OstTraceExt2( TRACE_NORMAL, DUP1_CMTPSVCCOMPOUNDPROCESSOR_DOHANDLECOMPLETINGPHASEL,
+			        "EObjectInfoSucceed: Save send info transaction id: %u, operation: 0x%x", iLastTransactionID, iOperationCode );
 			break;
 			}
 		case EObjectSendFail:
 			{
 			// When process SendObject fail, such as received size is wrong.
 			// 2. Framework error and call complete with error state.
 			// 3. SendObjInfo fail
 			// 4. First request is orphan SendObject, state is Idle
 			break;
 		}
-	__FLOG(_L8("DoHandleCompletingPhaseL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLECOMPLETINGPHASEL_EXIT );
 	return result;
 	}
 /**
 Handling the completing phase of SendObjectInfo request
 @return ETrue if the specified object can be saved on the specified location, otherwise, EFalse
 */
 TBool CMTPSvcCompoundProcessor::DoHandleResponseSendObjectInfoL()
 	{
-	__FLOG(_L8("DoHandleResponseSendObjectInfoL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTINFOL_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	TBool result(ETrue);
 	iFormatCode = iObjectInfo->Uint16L(CMTPTypeObjectInfo::EObjectFormat);
 	// Check format code and set object handler
 	responseCode = CheckFmtAndSetHandler(iFormatCode);
 		else
 			{
 			//if object size is zero, then directly store object without waiting for sendobject operation.
 			if (iObjectSize == 0)
 				{
-				__FLOG(_L8("CommitReservedObject because object size is 0 and register for SendObject"));
+				OstTrace0( TRACE_NORMAL, DUP1_CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTINFOL,
+				        "CommitReservedObject because object size is 0 and register for SendObject" );
 				// Commit new temp object to object mgr, if leave, CleanupStack will rollback new temp object.
 				TCleanupItem rollBackTempObject(RollBackObject, this);
 				CleanupStack::PushL(rollBackTempObject);
 				// Commit prop to obj mgr
 				iObjectHandler->CommitForNewObjectL(suid);
 				RegisterRequestAndSendResponseL(responseCode);
 				}
 			}
 		}
 	result = (responseCode == EMTPRespCodeOK) ? ETrue : EFalse;
-	__FLOG_VA((_L8("DoHandleResponseSendObjectInfoL exit with code: 0x%x"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTINFOL, "exit with code: 0x%x", responseCode);
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTINFOL_EXIT );
 	return result;
 	}
 /**
 Handling the completing phase of SendObjectPropList request
 @return ETrue if the specified object can be saved on the specified location, otherwise, EFalse
 */
 TBool CMTPSvcCompoundProcessor::DoHandleResponseSendObjectPropListL()
 	{
-	__FLOG(_L8("DoHandleResponseSendObjectPropListL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTPROPLISTL_ENTRY );
 	TBool result = ETrue;
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	TBuf<KMaxSUIDLength> suid;
 	TUint32 parameter = 0;
 	else
 		{
 		//if object size is zero, then directly store object without waiting for sendobject operation.
 		if (iObjectSize == 0)
 			{
-			__FLOG(_L8("CommitReservedObject because object size is 0 and register for SendObject"));
+			OstTrace0( TRACE_NORMAL, DUP1_CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTPROPLISTL,
+			        "CommitReservedObject because object size is 0 and register for SendObject" );
 			// Commit new temp object to object mgr, if leave, CleanupStack will rollback new temp object.
 			TCleanupItem rollBackTempObject(RollBackObject, this);
 			CleanupStack::PushL(rollBackTempObject);
 			// Commit prop to obj mgr
 			iObjectHandler->CommitForNewObjectL(suid);
 			RegisterRequestAndSendResponseL(responseCode);
 			}
 		}
 	result = (responseCode == EMTPRespCodeOK) ? ETrue : EFalse;
-	__FLOG_VA((_L8("DoHandleResponseSendObjectPropListL exit with code = 0x%x"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTPROPLISTL, "exit with code = 0x%x", responseCode );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTPROPLISTL_EXIT );
 	return result;
 	}
 /**
 Handling the completing phase of UpdateObjectPropList request
 @return ETrue if the specified object can be saved on the specified location, otherwise, EFalse
 */
 TBool CMTPSvcCompoundProcessor::DoHandleResponseUpdateObjectPropListL()
 	{
-	__FLOG(_L8("DoHandleResponseUpdateObjectPropListL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEUPDATEOBJECTPROPLISTL_ENTRY );
 	TBool result = ETrue;
 	TUint32 parameter = 0;
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	// Check object size property with format
 	responseCode = ExtractObjectSizeL();
 			iFramework.RouteRequestRegisterL(iExpectedSendObjectRequest, iConnection);
 			}
 		}
 	SendResponseL(responseCode, 1, &parameter);
 	result = (responseCode == EMTPRespCodeOK) ? ETrue: EFalse;
-	__FLOG_VA((_L8("DoHandleResponseUpdateObjectPropListL exit with code: 0x%x"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEUPDATEOBJECTPROPLISTL, "exit with code: 0x%x", responseCode );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEUPDATEOBJECTPROPLISTL_EXIT );
 	return result;
 	}
 /**
 Handling the completing phase of SendObject request
 @return ETrue if the object has been successfully saved on the device, otherwise, EFalse
 */
 TBool CMTPSvcCompoundProcessor::DoHandleResponseSendObjectL()
 	{
-	__FLOG(_L8("DoHandleResponseSendObjectL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTL_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	TBool result = ETrue;
 	if (iCancelled)
 		{
 	result = (responseCode == EMTPRespCodeOK || responseCode == EMTPRespCodeTransactionCancelled) ? ETrue : EFalse;
 	if (result)
 		{
 		iFramework.RouteRequestUnregisterL(iExpectedSendObjectRequest, iConnection);
 		}
-	__FLOG_VA((_L8("DoHandleResponseSendObjectL exit with code = 0x%x"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTL, "exit with code = 0x%x", responseCode );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSESENDOBJECTL_EXIT );
 	return result;
 	}
 TMTPResponseCode CMTPSvcCompoundProcessor::ExtractObjectSizeL()
 	{
-	__FLOG(_L8("ExtractObjectSizeL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_EXTRACTOBJECTSIZEL_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	TBool foundSizeProp  = EFalse;
 	const TUint KCount(iObjectPropList->NumberOfElements());
 	iObjectPropList->ResetCursor();
 	for (TUint i = 0; i < KCount; i++)
 			{
 			responseCode = EMTPRespCodeGeneralError;
 			}
 		}
-	__FLOG(_L8("ExtractObjectSizeL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_EXTRACTOBJECTSIZEL_EXIT );
 	return responseCode;
 	}
 /**
 Reserves space for and assigns an object handle to the received object, then
 sends a success response.
 */
 void CMTPSvcCompoundProcessor::ReserveObjectL()
 	{
-	__FLOG(_L8("ReserveObjectL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_RESERVEOBJECTL_ENTRY );
 	iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EStorageId, iStorageId);
 	iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EParentHandle, iParentHandle);
 	iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EFormatCode, iFormatCode);
 	iFramework.ObjectMgr().ReserveObjectHandleL(*iReceivedObjectMetaData, iObjectSize);
-	__FLOG_VA((_L8("ReserveObjectL Exit Storage:%u, ParentHandle:%u, FormatCode:%u, Size:%u "), iStorageId, iParentHandle, iFormatCode, iObjectSize));
+	OstTraceExt4( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_RESERVEOBJECTL, "Exit Storage:%u, ParentHandle:%u, FormatCode:%u, Size:%u", iStorageId, iParentHandle, iFormatCode, iObjectSize );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_RESERVEOBJECTL_EXIT );
 	}
 void CMTPSvcCompoundProcessor::RegisterRequestAndSendResponseL(TMTPResponseCode aResponseCode)
 	{
-	__FLOG(_L8("RegisterRequestAndSendResponseL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_REGISTERREQUESTANDSENDRESPONSEL_ENTRY );
 	// Register to framework for handle the next sendobj request
 	iExpectedSendObjectRequest.SetUint32(TMTPTypeRequest::ERequestSessionID, iSessionId);
 	iFramework.RouteRequestRegisterL(iExpectedSendObjectRequest, iConnection);
 	TUint32 parameters[3];
 	parameters[0] = iStorageId;
 	parameters[1] = iParentHandle;
 	// Responder’s reserved ObjectHandle for the incoming object
 	parameters[2] = iReceivedObjectMetaData->Uint(CMTPObjectMetaData::EHandle);
 	SendResponseL(aResponseCode, 3, parameters);
-	__FLOG(_L8("RegisterRequestAndSendResponseL - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_REGISTERREQUESTANDSENDRESPONSEL_EXIT );
 	}
 void CMTPSvcCompoundProcessor::RollBackObject(TAny* aObject)
 	{
 	reinterpret_cast<CMTPSvcCompoundProcessor*>(aObject)->RollBack();
 		}
 	}
 TMTPResponseCode CMTPSvcCompoundProcessor::CheckFmtAndSetHandler(TUint32 aFormatCode)
 	{
-	__FLOG(_L8("CheckFmtAndSetHandler - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKFMTANDSETHANDLER_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	iObjectHandler = iDataProvider.ObjectHandler(aFormatCode);
 	if (!iObjectHandler)
 		{
 		responseCode = EMTPRespCodeInvalidObjectFormatCode;
 		}
-	__FLOG(_L8("CheckFmtAndSetHandler - Exit"));
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKFMTANDSETHANDLER_EXIT );
 	return responseCode;
 	}
 TMTPResponseCode CMTPSvcCompoundProcessor::SendObjectPropListL(const CMTPTypeObjectPropList& aObjectPropList, TUint32& aParentHandle,
 														TUint32& aParameter, TDes& aSuid, TUint64 aObjectSize)
 	{
-	__FLOG(_L8("SendObjectPropListL - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SENDOBJECTPROPLISTL_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	aParameter = 0;
 	responseCode = iObjectHandler->SendObjectPropListL(aObjectSize, aObjectPropList, aParentHandle, aSuid);
 	// If handler cache an entry in SendObjectPropList, then it should never return error code. Processor will
 		if (EMTPRespCodeOK != responseCode)
 			{
 			iObjectHandler->RollBack();
 			}
 		}
-	__FLOG_VA((_L8("SendObjectPropListL - Exit with responseCode = 0x%04X"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_SENDOBJECTPROPLISTL, "Exit with responseCode = 0x%04X", responseCode );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SENDOBJECTPROPLISTL_EXIT );
 	return responseCode;
 	}
 // All object handlers current don't support partial update, so once update one parameter failed,
 // all updated will be reverted.
 TMTPResponseCode CMTPSvcCompoundProcessor::UpdateObjectPropListL(CMTPObjectMetaData& aObjectMetaData,
 														const CMTPTypeObjectPropList& aObjectPropList,
 														TUint32& /*aParameter*/)
 	{
-	__FLOG(_L8("UpdateObjectPropList - Entry"));
+	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_UPDATEOBJECTPROPLISTL_ENTRY );
 	TMTPResponseCode responseCode = EMTPRespCodeOK;
 	const TUint count = aObjectPropList.NumberOfElements();
 	aObjectPropList.ResetCursor();
 	for (TUint i = 0; i < count; i++)
 		{
 			{
 			iObjectHandler->RollBack();
 			break;
 			}
 		}
-	__FLOG_VA((_L8("UpdateObjectPropListL - Exit with responseCode = 0x%04X"), responseCode));
+	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_UPDATEOBJECTPROPLISTL, "Exit with responseCode = 0x%04X", responseCode );
+	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_UPDATEOBJECTPROPLISTL_EXIT );
 	return responseCode;
 	}

changeset 49	c20dd21d1eb4
parent 0	d0791faffa3f