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

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 #include "cmtpparserrouter.h"
 #include "cmtpsession.h"
 #include "cmtpstoragemgr.h"
 #include "tmtptypeobjecthandle.h"
 #include "cmtpservicemgr.h"
+#include "mtpdebug.h"
-// Class constants.
+#include "OstTraceDefinitions.h"
-__FLOG_STMT(_LIT8(KComponent,"ParserRouter");)
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpparserrouterTraces.h"
+#endif
 /**
 Provides the byte size of the specified array.
 */
 #define _ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
 /**
 Destructor
 */
 CMTPParserRouter::~CMTPParserRouter()
 {
-__FLOG(_L8("~CMTPParserRouter, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_CMTPPARSERROUTER_DES_ENTRY );
 iMaps.ResetAndDestroy();
 iSingletons.Close();
-__FLOG(_L8("~CMTPParserRouter, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_CMTPPARSERROUTER_DES_EXIT );
-__FLOG_CLOSE;
 }
 /**
 Configures the parser/router. This processing primarily involves retrieving
 each data provider's set of supported category codes and using them to build
 up the operation parameter lookup routing sub-type tables.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 EXPORT_C void CMTPParserRouter::ConfigureL()
 {
-__FLOG(_L8("ConfigureL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_CONFIGUREL_ENTRY );
 const TUint KMapIds[] =
 {
 ESubTypeDevicePropCode,
 ESubTypeObjectPropCode,
 ESubTypeOperationCode,
 CleanupStack::PopAndDestroy(&p3Codes);
 CleanupStack::PopAndDestroy(&p2Codes);
 CleanupStack::PopAndDestroy(&p1Codes);
 }
-__FLOG_STMT(FLOGMapsL());
+#ifdef OST_TRACE_COMPILER_IN_USE
-__FLOG(_L8("ConfigureL, Exit"));
+OSTMapsL();
+#endif
+OstTraceFunctionExit0( CMTPPARSERROUTER_CONFIGUREL_EXIT );
 }
 /**
 Indicates if the specified MTP operation code is supported by any of the set
 of loaded data providers.
 @param aOperation The MTP operation code.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 EXPORT_C TBool CMTPParserRouter::OperationSupportedL(TUint16 aOperation) const
 {
-__FLOG(_L8("OperationSupported, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_OPERATIONSUPPORTEDL_ENTRY );
 RArray<TUint> from;
 RArray<TUint> to;
 CleanupClosePushL(from);
 CleanupClosePushL(to);
 iMaps[Index(ESubTypeOperationCode)]->GetToL(from, to);
 TBool ret(to.Count() > 0);
 CleanupStack::PopAndDestroy(&to);
 CleanupStack::PopAndDestroy(&from);
-__FLOG(_L8("OperationSupported, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_OPERATIONSUPPORTEDL_EXIT );
 return (ret);
 }
 /**
 Parses the operation dataset supplied in the specified routing parameters
 operation.
 @leave One of the system wide error codes if a processing failure occurs,
 */
 EXPORT_C void CMTPParserRouter::ParseOperationRequestL(TRoutingParameters& aParams) const
 {
-__FLOG(_L8("ParseOperationRequestL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_PARSEOPERATIONREQUESTL_ENTRY );
 const TUint16 KOpCode(aParams.Request().Uint16(TMTPTypeRequest::ERequestOperationCode));
-__FLOG_VA((_L8("Operation Code = 0x%04X"), KOpCode));
+OstTrace1(TRACE_NORMAL, CMTPPARSERROUTER_PARSEOPERATIONREQUESTL, "Operation Code = 0x%04X", KOpCode);
 switch (KOpCode)
 {
 case EMTPOpCodeGetStorageInfo:
 ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);
 break;
 case EMTPOpCodeSkip:
 case EMTPOpCodeGetServiceIDs:
 default:
 break;
 }
-__FLOG(_L8("ParseOperationRequestL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_PARSEOPERATIONREQUESTL_EXIT );
 }
 /**
 Routes an MTP operation using the specified routing parameters. By default
 only operation parameter routing is performed.
 operation should be dispatched.
 @leave One of the system wide error codes if a processing failure occurs,
 */
 EXPORT_C void CMTPParserRouter::RouteOperationRequestL(const TRoutingParameters& aParams, RArray<TUint>& aTargets) const
 {
-__FLOG(_L8("RouteOperationRequestL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTEOPERATIONREQUESTL_ENTRY );
 aTargets.Reset();
 // By default ETypeOperationParameter routing is always enabled.
 if (!(aParams.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeOperationParameter))
 {
 }
 }
 CleanupStack::PopAndDestroy(&params);
 CleanupStack::PopAndDestroy(&validation);
 CleanupStack::PopAndDestroy(&routing);
-__FLOG(_L8("RouteOperationRequestL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTEOPERATIONREQUESTL_EXIT );
 }
 /**
 Indicates if a routing request with the specified MTP operation code is
 registered on the specified session.
 registered on the session, otherwise EFalse.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 EXPORT_C TBool CMTPParserRouter::RouteRequestRegisteredL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const
 {
-__FLOG(_L8("RouteRequestRegistered, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTEREQUESTREGISTEREDL_ENTRY );
 TBool ret(EFalse);
 const TUint32 KSessionId(aRequest.Uint32(TMTPTypeRequest::ERequestSessionID));
 if ((KSessionId != KMTPSessionAll) && (aConnection.SessionWithMTPIdExists(KSessionId)))
 {
 CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(KSessionId)));
 ret = session.RouteRequestRegistered(aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode));
 }
-__FLOG(_L8("RouteRequestRegistered, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTEREQUESTREGISTEREDL_EXIT );
 return ret;
 }
 /**
 Routes and dispatches the specified MTP event dataset. The only valid event
 @param aConnection The MTP connection on which the event was received.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPParserRouter::ProcessEventL(const TMTPTypeEvent& aEvent, CMTPConnection& aConnection) const
 {
-__FLOG(_L8("ProcessEventL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_PROCESSEVENTL_ENTRY );
 if ((aEvent.Uint16(TMTPTypeEvent::EEventCode) == EMTPEventCodeCancelTransaction) &&
 (aConnection.SessionWithMTPIdExists(aEvent.Uint32(TMTPTypeEvent::EEventSessionID))))
 {
 CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(aEvent.Uint32(TMTPTypeEvent::EEventSessionID))));
 if (session.TransactionPhase() != EIdlePhase)
 {
 iSingletons.DpController().DataProviderL(RoutingTargetL(session.ActiveRequestL(), aConnection)).ExecuteEventL(aEvent, aConnection);
 }
 }
-__FLOG(_L8("ProcessEventL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_PROCESSEVENTL_EXIT );
 }
 /**
 Routes and dispatches the specified MTP operation (request) dataset.
 @param aRequest The MTP operation (request) dataset.
 @param aConnection The MTP connection on which the event was received.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPParserRouter::ProcessRequestL(const TMTPTypeRequest& aRequest, CMTPConnection& aConnection) const
 {
-__FLOG(_L8("ProcessRequestL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_PROCESSREQUESTL_ENTRY );
 iSingletons.DpController().DataProviderL(RoutingTargetL(aRequest, aConnection)).ExecuteRequestL(aRequest, aConnection);
-__FLOG(_L8("ProcessRequestL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_PROCESSREQUESTL_EXIT );
 }
 /**
 Registers the calling data provider to receive one or more occurrences of
 the specified request dataset that are received on the specified connection.
 @leave One of the system wide error codes, if a processing failure occurs.
 @see MMTPDataProviderFramework::RouteRequestRegisterL
 */
 void CMTPParserRouter::RouteRequestRegisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection, TInt aId)
 {
-__FLOG(_L8("RouteRequestRegisterL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTEREQUESTREGISTERL_ENTRY );
 const TUint32 KSessionId(aRequest.Uint32(TMTPTypeRequest::ERequestSessionID));
 if (KSessionId == KMTPSessionAll)
 {
 // Register the request on all sessions.
 const TUint KNumSessions(aConnection.SessionCount());
 else
 {
 CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(KSessionId)));
 session.RouteRequestRegisterL(aRequest, aId);
 }
-__FLOG(_L8("RouteRequestRegisterL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTEREQUESTREGISTERL_EXIT );
 }
 /**
 Cancels a pending RouteRequestRegisterL registration.
 @param aRequest The registered operation request dataset.
 occurs.
 @see MMTPDataProviderFramework::RouteRequestUnregisterL
 */
 void CMTPParserRouter::RouteRequestUnregisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
 {
-__FLOG(_L8("RouteRequestUnregisterL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTEREQUESTUNREGISTERL_ENTRY );
 CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(aRequest.Uint32(TMTPTypeRequest::ERequestSessionID))));
 session.RouteRequestUnregister(aRequest);
-__FLOG(_L8("RouteRequestUnregisterL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTEREQUESTUNREGISTERL_EXIT );
 }
 /**
 Constructor.
 @param aFrom The map source parameter.
 }
 else
 {
 iToBranches.ResetAndDestroy();
 }
-__FLOG_CLOSE;
 }
 /**
 Provides the map source parameter.
 @return The map source parameter.
 {
 const TUint KFrom(Param(aFrom));
 if (Params(iSubType) == ESubTypeParams1)
 {
 // Node.
-__FLOG_STMT(FLOGMapEntryL(aFrom, aTo));
+#ifdef OST_TRACE_COMPILER_IN_USE
+OSTMapEntryL(aFrom, aTo);
+#endif
 const TUint KSubType(CMTPParserRouter::SubType(Index(iSubType), Flags(iSubType), (ParamsCount(iSubType) - 1)));
 const TMap KNode(KFrom, aTo, KSubType);
 NodeInsertL(KNode);
 }
 else
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::CMap::GetToL(const RArray<TUint>& aFrom, RArray<TUint>& aTo) const
 {
-__FLOG(_L8("CMap::GetToL - entry"));
+OstTraceFunctionEntry0( CMAP_GETTOL_ENTRY );
 const TUint KFrom(Param(aFrom));
 if (KFrom == KMTPNotSpecified32)
 {
 // Null (zero) parameter acts as a wildcard.
 SelectTargetAllL(aFrom, aTo);
 }
 else
 {
 // Select 0 .. 1 matching targets.
 SelectTargetSingleL(aFrom, aTo);
 }
-	__FLOG(_L8("CMap::GetToL - Exit"));
+OstTraceFunctionExit0( CMAP_GETTOL_EXIT );
 }
 /**
 Provides the map subtype code.
 @return The map subtype code.
 TUint CMTPParserRouter::CMap::SubType() const
 {
 return iSubType;
 }
-#ifdef __FLOG_ACTIVE
+#ifdef OST_TRACE_COMPILER_IN_USE
 /**
 Logs the map table entries (source and target) which match the specified source
 parameters.
 @param aFrom The map source parameters.
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
-void CMTPParserRouter::CMap::FLOGMapL(RArray<TUint>& aFrom) const
+void CMTPParserRouter::CMap::OSTMapL(RArray<TUint>& aFrom) const
 {
 if (Params(iSubType) == ESubTypeParams1)
 {
 // Node.
 const TUint KCount(iToNodes.Count());
 for (TUint i(0); (i < KCount); i++)
 {
 aFrom[ParamIdx(aFrom)] = iToNodes[i].iFrom;
-FLOGMapEntryL(aFrom, iToNodes[i].iTo);
+OSTMapEntryL(aFrom, iToNodes[i].iTo);
 }
 }
 else
 {
 // Branch.
 const TUint KCount(iToBranches.Count());
 for (TUint i(0); (i < KCount); i++)
 {
 const CMap& KBranch(*iToBranches[i]);
 aFrom[ParamIdx(aFrom)] = KBranch.iFrom;
-KBranch.FLOGMapL(aFrom);
+KBranch.OSTMapL(aFrom);
 }
 }
 }
 /**
 @param aFrom The map source parameters.
 @param aTo The map target parameter.
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
-void CMTPParserRouter::CMap::FLOGMapEntryL(const RArray<TUint>& aFrom, TUint aTo) const
+void CMTPParserRouter::CMap::OSTMapEntryL(const RArray<TUint>& aFrom, TUint aTo) const
 {
 __ASSERT_DEBUG((aFrom.Count() >= ParamsCount(iSubType)), User::Invariant());
 RBuf log;
 log.CleanupClosePushL();
 const TUint KParamsCount(aFrom.Count());
 log.AppendNumFixedWidthUC(aFrom[i], EHex, KWidthFrom);
 log.Append(_L(" "));
 }
 log.Append(_L("-> 0x"));
 log.AppendNumFixedWidthUC(aTo, EHex, KWidthTo);
-__FLOG(log);
+OstTraceExt1(TRACE_NORMAL, CMTPPARSERROUTER_CMAP_OSTMAPENTRYL, "%S", log);
 CleanupStack::PopAndDestroy(&log);
 }
 #endif
 /**
 /**
 Second-phase constructor.
 */
 void CMTPParserRouter::CMap::ConstructL()
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
 }
 /**
 Locates the map branch table index of the first map table entry matching the
 specified source parameter, using a binary search algorithm.
 {
 Panic(EMTPPanicRoutingConflict);
 }
 else
 {
-User::LeaveIfError(err);
+LEAVEIFERROR(err,
+OstTrace1( TRACE_ERROR, CMAP_NODEINSERTL, "Inserts the specified map node into the map node table failed, error code %d", err ));
 }
 }
 const TInt KIdx(NodeFind(aMap));
 __ASSERT_DEBUG((KIdx != KErrNotFound), User::Invariant());
 return KIdx;
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::CMap::SelectTargetMatchingL(const RArray<TUint>& aFrom, RArray<TUint>& aTo) const
 {
-__FLOG(_L8("CMap::SelectTargetMatchingL - entry"));
+OstTraceFunctionEntry0( CMAP_SELECTTARGETMATCHINGL_ENTRY );
 const TUint KFrom(Param(aFrom));
 TInt idx(KErrNotFound);
 if (Params(iSubType) == ESubTypeParams1)
 {
 idx = iToNodes.SpecificFindInOrder(TMap(KFrom), ((iSubType & ESubTypeFlagOrderDescending) ? NodeOrderFromDescending : NodeOrderFromAscending), EArrayFindMode_First);
 const TUint KCount(iToBranches.Count());
 while ((idx < KCount) && (iToBranches[idx]->From() == KFrom))
 {
 iToBranches[idx++]->GetToL(aFrom, aTo);
 }
 }
-	__FLOG(_L8("CMap::SelectTargetMatchingL - exit"));
+OstTraceFunctionExit0( CMAP_SELECTTARGETMATCHINGL_EXIT );
 }
 /**
 Selects the first map target which matches the specified source parameters.
 @param aFrom The map source parameter set.
 /**
 Second-phase constructor.
 */
 void CMTPParserRouter::ConstructL()
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPPARSERROUTER_CONSTRUCTL_ENTRY );
-__FLOG(_L8("ConstructL, Entry"));
 iSingletons.OpenL();
-__FLOG(_L8("ConstructL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_CONSTRUCTL_EXIT );
 }
 /**
 Provides the set of @see TMTPSupportCategory codes which comprise each of the
 lookup parameters for the specified routing sub-type (routing map).
 occurs.
 */
 void CMTPParserRouter::SelectTargetL(TUint aTarget, RArray<TUint>& aTargets)
 {
-__FLOG_STATIC(KMTPSubsystem, KComponent, _L8("SelectTargetL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_SELECTTARGETL_ENTRY );
 TInt idx(aTargets.Find(aTarget));
 if (idx != KErrNotFound)
 {
 aTargets.Remove(idx);
 }
 aTargets.AppendL(aTarget);
-__FLOG_STATIC(KMTPSubsystem, KComponent, _L8("SelectTargetL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_SELECTTARGETL_EXIT );
 }
 /**
 Configures (loads) the specified one lookup parameter routing sub-type map. The
 map is constructed by interrogating each data provider in turn and building a
 const TUint KCount(iSingletons.DpController().Count());
 for (TUint d(0); (d < KCount); d++)
 {
 CMTPDataProvider& dp(iSingletons.DpController().DataProviderByIndexL(d));
-__FLOG(_L8(""));
+OstTrace0(TRACE_NORMAL, CMTPPARSERROUTER_CONFIGURE1PARAMETERMAPL,"");
-__FLOG_VA((_L8("Creating DP %02d Table 0x%08X Entries"), dp.DataProviderId(), aSubType));
+OstTraceExt2(TRACE_NORMAL, DUP1_CMTPPARSERROUTER_CONFIGURE1PARAMETERMAPL,
-__FLOG(_L8("---------------------------------------"));
+"Creating DP %d Table 0x%X Entries", dp.DataProviderId(), aSubType);
+OstTrace0(TRACE_NORMAL, DUP2_CMTPPARSERROUTER_CONFIGURE1PARAMETERMAPL,"----------------");
 RArray<TUint> p1s;
 CleanupClosePushL(p1s);
 GetConfigParametersL(dp, aP1Codes, p1s);
 const TUint KCountP1s(p1s.Count());
 const TUint KP1(p1s[p1]);
 from[EParam1] = KP1;
 map.InsertL(from, dp.DataProviderId());
 }
 CleanupStack::PopAndDestroy(&p1s);
-__FLOG(_L8(""));
+OstTrace0(TRACE_NORMAL, DUP3_CMTPPARSERROUTER_CONFIGURE1PARAMETERMAPL,"");
 }
 CleanupStack::PopAndDestroy(&from);
 }
 /**
 const TUint KCountDps(iSingletons.DpController().Count());
 for (TUint d(0); (d < KCountDps); d++)
 {
 CMTPDataProvider& dp(iSingletons.DpController().DataProviderByIndexL(d));
-__FLOG(_L8(""));
+OstTrace0(TRACE_NORMAL, CMTPPARSERROUTER_CONFIGURE2PARAMETERMAPL,"");
-__FLOG_VA((_L8("Creating DP %02d Table 0x%08X Entries"), dp.DataProviderId(), aSubType));
+OstTraceExt2(TRACE_NORMAL, DUP1_CMTPPARSERROUTER_CONFIGURE2PARAMETERMAPL,
-__FLOG(_L8("---------------------------------------"));
+"Creating DP %d Table 0x%X Entries", dp.DataProviderId(), aSubType);
+OstTrace0(TRACE_NORMAL, DUP2_CMTPPARSERROUTER_CONFIGURE2PARAMETERMAPL,"----------------");
 RArray<TUint> p1s;
 CleanupClosePushL(p1s);
 GetConfigParametersL(dp, aP1Codes, p1s);
 const TUint KCountP1s(p1s.Count());
 }
 CleanupStack::PopAndDestroy(&p2s);
 }
 }
 CleanupStack::PopAndDestroy(&p1s);
-__FLOG(_L8(""));
+OstTrace0(TRACE_NORMAL, DUP3_CMTPPARSERROUTER_CONFIGURE2PARAMETERMAPL,"");
 }
 CleanupStack::PopAndDestroy(&from);
 }
 /**
 const TUint KCount(iSingletons.DpController().Count());
 for (TUint d(0); (d < KCount); d++)
 {
 CMTPDataProvider& dp(iSingletons.DpController().DataProviderByIndexL(d));
-__FLOG(_L8(""));
+OstTrace0(TRACE_NORMAL, CMTPPARSERROUTER_CONFIGURE3PARAMETERMAPL,"");
-__FLOG_VA((_L8("Creating DP %02d Table 0x%08X Entries"), dp.DataProviderId(), aSubType));
+OstTraceExt2(TRACE_NORMAL, DUP1_CMTPPARSERROUTER_CONFIGURE3PARAMETERMAPL,
-__FLOG(_L8("---------------------------------------"));
+"Creating DP %d Table 0x%X Entries", dp.DataProviderId(), aSubType);
+OstTrace0(TRACE_NORMAL, DUP2_CMTPPARSERROUTER_CONFIGURE3PARAMETERMAPL,"----------------");
 RArray<TUint> p1s;
 CleanupClosePushL(p1s);
 GetConfigParametersL(dp, aP1Codes, p1s);
 const TUint KCountP1s(p1s.Count());
 CleanupStack::PopAndDestroy(&p2s);
 }
 CleanupStack::PopAndDestroy(&p3s);
 }
 CleanupStack::PopAndDestroy(&p1s);
-__FLOG(_L8(""));
+OstTrace0(TRACE_NORMAL, DUP3_CMTPPARSERROUTER_CONFIGURE3PARAMETERMAPL,"");
 }
 CleanupStack::PopAndDestroy(&from);
 }
 /**
 const TUint KCountParams(KParams.Count());
 for (TUint p(0); (p < KCountParams); p++)
 {
 if(( EServiceIDs == aCodes[c] )&&( iSingletons.ServiceMgr().IsSupportedService( KParams[p] )) )
 {
-__FLOG_1(_L8("GetConfigParametersL, abstract service id = %d"), KParams[p]);
+OstTrace1( TRACE_NORMAL, CMTPPARSERROUTER_GETCONFIGPARAMETERSL,
+"GetConfigParametersL, abstract service id = %d",KParams[p] );
 continue;
 }
 TInt err(aParams.InsertInOrder(KParams[p]));
 if ((err != KErrNone) && (err != KErrAlreadyExists))
 {
+OstTrace1( TRACE_ERROR, DUP1_CMTPPARSERROUTER_GETCONFIGPARAMETERSL, "insert into aParams error! error code %d", err );
 User::Leave(err);
 }
 }
 }
 }
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::GetRoutingSubTypesL(RArray<TRoutingParameters>& aParams, RArray<TUint>& aRoutingSubTypes, RArray<TUint>& aValidationSubTypes) const
 {
-__FLOG(_L8("GetRoutingSubTypesL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_GETROUTINGSUBTYPESL_ENTRY );
 __ASSERT_DEBUG((aParams.Count() > 0), User::Invariant());
 aRoutingSubTypes.Reset();
 aValidationSubTypes.Reset();
 TRoutingParameters& params1(aParams[0]);
 params1.SetParam(TRoutingParameters::EFlagRoutingTypes, (KRoutingTypes | ETypeFlagSingleTarget));
 }
 break;
 }
 }
-__FLOG(_L8("GetRoutingSubTypesL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_GETROUTINGSUBTYPESL_EXIT );
 }
 /**
 Provides the set of operation parameter routing and validation sub-types to be
 executed against each of the specified MTP DeleteObject operation routing
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::GetRoutingSubTypesDeleteRequestL(RArray<TRoutingParameters>& aParams, RArray<TUint>& aRoutingSubTypes, RArray<TUint>& aValidationSubTypes) const
 {
-__FLOG(_L8("GetRoutingSubTypesDeleteRequestL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_GETROUTINGSUBTYPESDELETEREQUESTL_ENTRY );
 TRoutingParameters& params1(aParams[0]);
 __ASSERT_DEBUG((params1.Request().Uint16(TMTPTypeRequest::ERequestOperationCode) == EMTPOpCodeDeleteObject), User::Invariant());
 const TUint KObjectHandle(params1.Param(TRoutingParameters::EParamObjectHandle));
 const TUint KObjectFormatCode(params1.Param(TRoutingParameters::EParamFormatCode));
 {
 SelectSubTypeRoutingL(ESubTypeStorageTypeOperationCode, aRoutingSubTypes, aValidationSubTypes, aParams);
 }
 SelectSubTypeRoutingL(ESubTypeOwnerObject, aRoutingSubTypes, aValidationSubTypes, aParams);
 }
-__FLOG(_L8("GetRoutingSubTypesDeleteRequestL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_GETROUTINGSUBTYPESDELETEREQUESTL_EXIT );
 }
 /**
 Provides the set of operation parameter routing and validation sub-types to be
 executed against each of the specified MTP CopyObject and MoveObject operation routing
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::GetRoutingSubTypesCopyMoveRequestL(RArray<TRoutingParameters>& aParams, RArray<TUint>& aRoutingSubTypes, RArray<TUint>& aValidationSubTypes) const
 	{
-	__FLOG(_L8("GetRoutingSubTypesCopyMoveRequestL, Entry"));
+	OstTraceFunctionEntry0( CMTPPARSERROUTER_GETROUTINGSUBTYPESCOPYMOVEREQUESTL_ENTRY );
 	const TUint KObjectFormatCode(aParams[0].Param(TRoutingParameters::EParamFormatCode));
 	if (KObjectFormatCode == EMTPFormatCodeAssociation)
 {
 SelectSubTypeRoutingL(ESubTypeStorageTypeOperationCode, aRoutingSubTypes, aValidationSubTypes, aParams);
 }
 else
 	{
 	SelectSubTypeRoutingL(ESubTypeOwnerObject, aRoutingSubTypes, aValidationSubTypes, aParams);
 	}
-	__FLOG(_L8("GetRoutingSubTypesCopyMoveRequestL, Exit"));
+	OstTraceFunctionExit0( CMTPPARSERROUTER_GETROUTINGSUBTYPESCOPYMOVEREQUESTL_EXIT );
 	}
 /**
 Provides the set of operation parameter routing and validation sub-types to be
 executed against each of the specified MTP GetObjectPropList operation routing
 parameter data.
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::GetRoutingSubTypesGetObjectPropListRequestL(RArray<TRoutingParameters>& aParams, RArray<TUint>& aRoutingSubTypes, RArray<TUint>& aValidationSubTypes) const
 {
-__FLOG(_L8("GetRoutingSubTypesGetObjectPropListRequestL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_GETROUTINGSUBTYPESGETOBJECTPROPLISTREQUESTL_ENTRY );
 TRoutingParameters& params1(aParams[0]);
 __ASSERT_DEBUG((params1.Request().Uint16(TMTPTypeRequest::ERequestOperationCode) == EMTPOpCodeGetObjectPropList), User::Invariant());
 if (params1.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeOperationParameter)
 {
 const TUint KObjectHandle(params1.Param(TRoutingParameters::EParamObjectHandle));
 {
 SelectSubTypeRoutingL(ESubTypeOperationCode, aRoutingSubTypes, aValidationSubTypes, aParams);
 }
 }
-__FLOG(_L8("GetRoutingSubTypesGetObjectPropListRequestL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_GETROUTINGSUBTYPESGETOBJECTPROPLISTREQUESTL_EXIT );
 }
 /**
 Provides the set of operation parameter routing and validation sub-types to be
 executed against each of the specified MTP SendObjectPropList operation routing
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::GetRoutingSubTypesSendObjectPropListRequestL(RArray<TRoutingParameters>& aParams, RArray<TUint>& aRoutingSubTypes, RArray<TUint>& aValidationSubTypes) const
 {
-__FLOG(_L8("GetRoutingSubTypesSendObjectPropListRequestL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_GETROUTINGSUBTYPESSENDOBJECTPROPLISTREQUESTL_ENTRY );
 TRoutingParameters& params1(aParams[0]);
 __ASSERT_DEBUG((params1.Request().Uint16(TMTPTypeRequest::ERequestOperationCode) == EMTPOpCodeSendObjectPropList), User::Invariant());
 const TUint KRoutingTypes(params1.Param(TRoutingParameters::EFlagRoutingTypes));
 if ((KRoutingTypes & ETypeFramework) &&
 (params1.Param(TRoutingParameters::EParamFormatCode) == EMTPFormatCodeAssociation))
 }
 else if (KRoutingTypes & ETypeOperationParameter)
 {
 SelectSubTypeRoutingL(ESubTypeFormatCodeFormatSubcodeStorageType, aRoutingSubTypes, aValidationSubTypes, aParams);
 }
-__FLOG(_L8("GetRoutingSubTypesSendObjectPropListRequestL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_GETROUTINGSUBTYPESSENDOBJECTPROPLISTREQUESTL_EXIT );
 }
 void CMTPParserRouter::GetRoutingSubTypesDeleteObjectPropListL(RArray<TRoutingParameters>& aParams, RArray<TUint>& aRoutingSubTypes, RArray<TUint>& aValidationSubTypes) const
 {
-__FLOG(_L8("GetRoutingSubTypesDeleteObjectPropListL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_GETROUTINGSUBTYPESDELETEOBJECTPROPLISTL_ENTRY );
 TRoutingParameters& params1(aParams[0]);
 __ASSERT_DEBUG((params1.Request().Uint16(TMTPTypeRequest::ERequestOperationCode) == EMTPOpCodeDeleteObjectPropList), User::Invariant());
 const TUint KObjectHandle(params1.Param(TRoutingParameters::EParamObjectHandle));
 else
 {
 SelectSubTypeRoutingL(ESubTypeOwnerObject, aRoutingSubTypes, aValidationSubTypes, aParams);
 }
-__FLOG(_L8("GetRoutingSubTypesDeleteObjectPropListL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_GETROUTINGSUBTYPESDELETEOBJECTPROPLISTL_EXIT );
 }
 void CMTPParserRouter::GetRoutingSubTypesGetFormatCapabilitiesL(RArray<TRoutingParameters>& aParams, RArray<TUint>& aRoutingSubTypes, RArray<TUint>& aValidationSubTypes) const
 {
-__FLOG(_L8("GetRoutingSubTypesGetFormatCapabilities, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_GETROUTINGSUBTYPESGETFORMATCAPABILITIESL_ENTRY );
 TRoutingParameters& params1(aParams[0]);
 __ASSERT_DEBUG((params1.Request().Uint16(TMTPTypeRequest::ERequestOperationCode) == EMTPOpCodeGetFormatCapabilities), User::Invariant());
 if( params1.Param(TRoutingParameters::EParamFormatCode) == KMTPFormatsAll)
 else if ( params1.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeOperationParameter)
 {
 SelectSubTypeRoutingL(ESubTypeFormatCodeOperationCode, aRoutingSubTypes, aValidationSubTypes, aParams);
 }
-__FLOG(_L8("GetRoutingSubTypesGetFormatCapabilities, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_GETROUTINGSUBTYPESGETFORMATCAPABILITIESL_EXIT );
 }
 /**
 Parses the specified MTP operation request dataset to extract the specified
 parameter value together with any applicable meta-data. The parameter value
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::ParseOperationRequestParameterL(TMTPTypeRequest::TElements aParam, TRoutingParameters::TParameterType aType, TRoutingParameters& aParams) const
 {
-__FLOG(_L8("ParseOperationRequestParameterL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_PARSEOPERATIONREQUESTPARAMETERL_ENTRY );
 const TUint32 KParam(aParams.Request().Uint32(aParam));
-__FLOG_VA((_L8("Parameter %d = 0x%08X"), (aParam - TMTPTypeRequest::ERequestParameter1 + 1), KParam));
+OstTraceExt2(TRACE_NORMAL, CMTPPARSERROUTER_PARSEOPERATIONREQUESTPARAMETERL,
+"Parameter %d = 0x%X", (aParam - TMTPTypeRequest::ERequestParameter1 + 1), (int)KParam);
 // Parse out the parameter value if a non-null value is present.
 if (KParam != KMTPNotSpecified32)
 {
 aParams.SetParam(aType, KParam);
 break;
 default:
 break;
 }
-__FLOG(_L8("ParseOperationRequestParameterL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_PARSEOPERATIONREQUESTPARAMETERL_EXIT );
 }
 /**
 Resolves set of zero or more routing targets using the specified lookup
 parameter based routing sub-type.
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::RouteOperationRequestNParametersL(TUint aRoutingSubType, const TRoutingParameters& aParams, RArray<TUint>& aTargets) const
 {
-__FLOG(_L8("RouteOperationRequestNParametersL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTEOPERATIONREQUESTNPARAMETERSL_ENTRY );
-__FLOG_VA((_L8("Routing Sub-type = 0x%08X"), aRoutingSubType));
+OstTrace1(TRACE_NORMAL, CMTPPARSERROUTER_ROUTEOPERATIONREQUESTNPARAMETERSL,
+"Routing Sub-type = 0x%X", aRoutingSubType);
 // Build the set of map source parameter values.
 RArray<TUint> from;
 CleanupClosePushL(from);
 switch (aRoutingSubType)
 }
 // Resolve the map target parameter set.
 iMaps[Index(aRoutingSubType)]->GetToL(from, aTargets);
 CleanupStack::PopAndDestroy(&from);
-__FLOG(_L8("RouteOperationRequestNParametersL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTEOPERATIONREQUESTNPARAMETERSL_EXIT );
 }
 /**
 Resolves set of zero or more routing targets using the specified parameterless
 routing sub-type.
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::RouteOperationRequest0ParametersL(TUint aRoutingSubType, const TRoutingParameters& aParams, RArray<TUint>& aTargets) const
 {
-__FLOG(_L8("RouteOperationRequest0ParametersL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTEOPERATIONREQUEST0PARAMETERSL_ENTRY );
-__FLOG_VA((_L8("Routing Sub-type = 0x%08X"), aRoutingSubType));
+OstTrace1(TRACE_NORMAL, CMTPPARSERROUTER_ROUTEOPERATIONREQUEST0PARAMETERSL,
+"Routing Sub-type = 0x%X", aRoutingSubType);
 TInt id(KErrNotFound);
 switch (aRoutingSubType)
 {
 case ESubTypeDpDevice:
 id = iSingletons.DpController().DeviceDpId();
 if (id != KErrNotFound && iSingletons.DpController().IsDataProviderLoaded(id))
 {
 SelectTargetL(id, aTargets);
 }
-__FLOG(_L8("RouteOperationRequest0ParametersL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTEOPERATIONREQUEST0PARAMETERSL_EXIT );
 }
 /**
 Provides a single suitable routing target for the specified request. A target
 is selected such that:
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 TUint CMTPParserRouter::RoutingTargetL(const TMTPTypeRequest& aRequest, CMTPConnection& aConnection) const
 {
-__FLOG(_L8("RoutingTargetL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTINGTARGETL_ENTRY );
 // Parse the operation request dataset.
 TRoutingParameters params(aRequest, static_cast<MMTPConnection&>(aConnection));
 ParseOperationRequestL(params);
 ValidateOperationRequestParametersL(params);
 else
 {
 target = targets[0];
 }
 CleanupStack::PopAndDestroy(&targets);
-__FLOG(_L8("RoutingTargetL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTINGTARGETL_EXIT );
 return target;
 }
 /**
 Selects the specified routing sub-type together with any applicable validation
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::SelectSubTypeRoutingL(TRoutingSubType aSubType, RArray<TUint>& aRoutingSubTypes, RArray<TUint>& aValidationSubTypes, RArray<TRoutingParameters>& aParams) const
 {
-__FLOG(_L8("SelectSubTypeRoutingL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_SELECTSUBTYPEROUTINGL_ENTRY );
 __ASSERT_DEBUG((aRoutingSubTypes.Find(aSubType) == KErrNotFound), User::Invariant());
 aRoutingSubTypes.AppendL(aSubType);
 switch (aSubType)
 {
 case ESubTypeDevicePropCode:
 case ESubTypeRequestRegistration:
 default:
 break;
 }
-__FLOG(_L8("SelectSubTypeRoutingL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_SELECTSUBTYPEROUTINGL_EXIT );
 }
 /**
 Selects the specified validation sub-type.
 @param aSubType The selected validation sub-type.
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
 void CMTPParserRouter::SelectSubTypeValidationL(TRoutingSubType aSubType, RArray<TUint>& aValidationSubTypes) const
 {
-__FLOG(_L8("SelectSubTypeValidationL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_SELECTSUBTYPEVALIDATIONL_ENTRY );
 TInt err(aValidationSubTypes.InsertInOrder(aSubType));
 if ((err != KErrNone) &&
 (err != KErrAlreadyExists))
 {
+OstTrace1( TRACE_ERROR, CMTPPARSERROUTER_SELECTSUBTYPEVALIDATIONL, "insert into validation sub-type array failed! error code %d", err);
 User::Leave(err);
 }
-__FLOG(_L8("SelectSubTypeValidationL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_SELECTSUBTYPEVALIDATIONL_EXIT );
 }
 /**
 Validates the specified set of routing targets.
 @param aParams The operation routing parameter data.
 @param aTargets The set of data provider targets to be validated. Invalid
 targets are removed from this set.
 */
 void CMTPParserRouter::ValidateTargetsL(const TRoutingParameters& aParams, const RArray<TUint>& aValidationSubTypes, RArray<TUint>& aTargets) const
 {
-__FLOG(_L8("ValidateTargetsL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_VALIDATETARGETSL_ENTRY );
 const TUint KValidationsCount(aValidationSubTypes.Count());
 for (TUint v(0); (v < KValidationsCount); v++)
 {
 RArray<TUint> valid;
 CleanupClosePushL(valid);
 aTargets.Remove(target);
 }
 }
 CleanupStack::PopAndDestroy(&valid);
 }
-__FLOG(_L8("ValidateTargetsL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_VALIDATETARGETSL_EXIT );
 }
 void CMTPParserRouter::ValidateOperationRequestParametersL(TRoutingParameters& aParams) const
 	{
-__FLOG(_L8("ValidateOperationRequestParametersL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_VALIDATEOPERATIONREQUESTPARAMETERSL_ENTRY );
 if(aParams.Param(TRoutingParameters::EFlagInvalid))
 	{
-		__FLOG(_L8("ValidateOperationRequestParametersL, Invalid is true,Exit"));
+		OstTraceFunctionExit0( CMTPPARSERROUTER_VALIDATEOPERATIONREQUESTPARAMETERSL_EXIT );
 		return;
 	}
 const TUint16 KOpCode(aParams.Request().Uint16(TMTPTypeRequest::ERequestOperationCode));
-	__FLOG_VA((_L8("Operation Code = 0x%04X"), KOpCode));
+	OstTrace1(TRACE_NORMAL, CMTPPARSERROUTER_VALIDATEOPERATIONREQUESTPARAMETERSL,
+	        "Operation Code = 0x%X", KOpCode);
 	switch (KOpCode)
 	   {
 		case EMTPOpCodeSetObjectPropValue:
 		case EMTPOpCodeSetObjectProtection:
 		case EMTPOpCodeDeleteObject:
 	    	}
 	    	break;
 		default:
 			break;
 	   }
-__FLOG(_L8("ValidateOperationRequestParametersL, Exit"));
+	OstTraceFunctionExit0( DUP1_CMTPPARSERROUTER_VALIDATEOPERATIONREQUESTPARAMETERSL_EXIT );
 	}
 /**
 Provides the routing sub-type modifier flags of the specified routing sub-type.
 @param aSubType The routing sub-type identifier.
 TUint CMTPParserRouter::SubType(TUint aIndex, TUint aFlags, TUint aParamsCount)
 {
 return ((aParamsCount << 24) | aFlags | aIndex);
 }
-#ifdef __FLOG_ACTIVE
+#ifdef OST_TRACE_COMPILER_IN_USE
 /**
 Logs the map table entries of all map tables.
 @leave One of the system wide error codes, if a general processing error
 occurs.
 */
-void CMTPParserRouter::FLOGMapsL() const
+void CMTPParserRouter::OSTMapsL() const
 {
-__FLOG(_L8("FLOGMapsL, Entry"));
+OstTraceFunctionEntry0( CMTPPARSERROUTER_OSTMAPSL_ENTRY );
 const TUint KCount(iMaps.Count());
 for (TUint i(0); (i < KCount); i++)
 {
 const CMap& KMap (*iMaps[i]);
-__FLOG(_L8(""));
+OstTrace0(TRACE_NORMAL, CMTPPARSERROUTER_OSTMAPSL,"");
-__FLOG_VA((_L8("Table 0x%08X"), KMap.SubType()));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPPARSERROUTER_OSTMAPSL,"Table 0x%08X", KMap.SubType());
-__FLOG(_L8("----------------"));
+OstTrace0(TRACE_NORMAL, DUP2_CMTPPARSERROUTER_OSTMAPSL,"----------------");
 RArray<TUint> from;
 CleanupClosePushL(from);
 KMap.InitParamsL(from);
-KMap.FLOGMapL(from);
+KMap.OSTMapL(from);
 CleanupStack::PopAndDestroy(&from);
-__FLOG(_L8(""));
+OstTrace0(TRACE_NORMAL, DUP3_CMTPPARSERROUTER_OSTMAPSL,"");
 }
-__FLOG(_L8("FLOGMapsL, Exit"));
+OstTraceFunctionExit0( CMTPPARSERROUTER_OSTMAPSL_EXIT );
 }
 #endif

changeset 49	c20dd21d1eb4
parent 20	6e82ae192c3a