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

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 #include "cmtpdataprovidercontroller.h"
 #include "cmtpobjectmgr.h"
 #include "mtpframeworkconst.h"
 #include "cmtpframeworkconfig.h"
 #include "cmtpstoragemgr.h"
+#include "mtpdebug.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpdataprovidercontrollerTraces.h"
+#endif
 // Class constants.
 _LIT(KMTPDpResourceDirectory, "z:\\resource\\mtp\\");
 _LIT(KMTPDpDummyResourcefile, "z:\\resource\\mtp\\dummydp.rsc");
-// Class constants.
-__FLOG_STMT(_LIT8(KComponent,"DataProviderController");)
 static const TUint KOpaqueDataLength(64);
 /**
 CMTPDataProviderController panics
 /**
 Destructor.
 */
 CMTPDataProviderController::~CMTPDataProviderController()
 {
-__FLOG(_L8("~CMTPDataProviderController - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_CMTPDATAPROVIDERCONTROLLER_DES_ENTRY );
 Cancel();
 UnloadDataProviders();
 iDataProviderIds.Close();
 iEnumeratingDps.Close();
 iEnumeratingStorages.Close();
 iSingletons.Close();
 CloseRegistrySessionAndEntryL();
 delete iOpenSessionWaiter;
 delete iPendingRequestTimer;
-__FLOG(_L8("~CMTPDataProviderController - Exit"));
-__FLOG_CLOSE;
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_CMTPDATAPROVIDERCONTROLLER_DES_EXIT );
 }
 /**
 Loads the set of available data providers and initiates the data provider
 enumeration sequence.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 EXPORT_C void CMTPDataProviderController::LoadDataProvidersL()
 {
-__FLOG(_L8("LoadDataProvidersL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERSL_ENTRY );
 // Retrieve the ECOM data provider implementations list
 RImplInfoPtrArray   implementations;
 TCleanupItem        cleanup(ImplementationsCleanup, reinterpret_cast<TAny*>(&implementations));
 CleanupStack::PushL(cleanup);
 REComSession::ListImplementationsL(KMTPDataProviderPluginInterfaceUid, implementations);
 implementations.Sort(TLinearOrder<CImplementationInformation>(ImplementationsLinearOrderUid));
 // Retrieve the data provider registration resource file list.
 CDir* registrations;
-User::LeaveIfError(iSingletons.Fs().GetDir(KMTPDpResourceDirectory, KEntryAttNormal, ESortByName, registrations));
+LEAVEIFERROR(iSingletons.Fs().GetDir(KMTPDpResourceDirectory, KEntryAttNormal, ESortByName, registrations),
+OstTrace0( TRACE_ERROR, DUP5_CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERSL, "get MTP Dp resource directory error!" ));
 CleanupStack::PushL(registrations);
 CreateRegistrySessionAndEntryL();
 // Load the registered data providers.
 for (TInt i = 0; i < KCount; ++i)
 {
 TUint uid = 0;
 if(Uid((*registrations)[i].iName, uid) != KErrNone)
 	{
-	__FLOG_1(_L8("LoadDataProvidersL - Fail to get UID = %s"),&((*registrations)[i].iName) );
+	OstTraceExt1( TRACE_WARNING, CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERSL,
+	        "LoadDataProvidersL - Fail to get UID = %S", (*registrations)[i].iName);
 	continue;
 	}
 index = implementations.FindInOrder(TUid::Uid(uid), ImplementationsLinearOrderUid);
 if (KErrNotFound == index)
 	{
 for (index = 0; index < implementations.Count(); ++index)
 {
 TRAPD(err, LoadInstalledDataProvidersL(implementations[index]));
 if (KErrNone != err)
 {
-__FLOG_VA((_L8("Load installed data provider[0x%x] failed."),implementations[index]->ImplementationUid().iUid));
+OstTrace1(TRACE_ERROR, DUP1_CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERSL,
+"Load installed data provider[0x%x] failed.", implementations[index]->ImplementationUid().iUid);
 }
 }
 CleanupStack::PopAndDestroy(registrations);
 CleanupStack::PopAndDestroy(&implementations);
 // Verify that the framework data providers are loaded.
-User::LeaveIfError(DpId(KMTPImplementationUidDeviceDp));
+LEAVEIFERROR(DpId(KMTPImplementationUidDeviceDp),
-User::LeaveIfError(DpId(KMTPImplementationUidProxyDp));
+OstTrace0( TRACE_ERROR, DUP2_CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERSL, "Device Dp not loaded!" ));
-User::LeaveIfError(DpId(KMTPImplementationUidFileDp));
+LEAVEIFERROR(DpId(KMTPImplementationUidProxyDp),
+OstTrace0( TRACE_ERROR, DUP3_CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERSL, "Proxy Dp not loaded!" ));
+LEAVEIFERROR(DpId(KMTPImplementationUidFileDp),
+OstTrace0( TRACE_ERROR, DUP4_CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERSL, "file Dp not loaded!" ));
 	// Sort the data provider set on enumeration phase order.
 	iDataProviders.Sort(TLinearOrder<CMTPDataProvider>(CMTPDataProvider::LinearOrderEnumerationPhase));
 	// Add the DP IDs into DP ID array, except for device DP, File DP and proxy DP
 	for (TUint index=0; index < iDataProviders.Count(); index++)
 	  {
 // Start enumerating.
 iEnumeratingStorages.AppendL(KMTPStorageAll);
 iEnumerationState = EEnumerationStarting;
 Schedule();
-__FLOG(_L8("LoadDataProvidersL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERSL_EXIT );
 }
 /**
 Unloads all active data providers.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 EXPORT_C void CMTPDataProviderController::UnloadDataProviders()
 {
-__FLOG(_L8("UnloadDataProviders - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_UNLOADDATAPROVIDERS_ENTRY );
 TRAP_IGNORE(iSingletons.ObjectMgr().ObjectStore().CleanL());
 iDataProviders.ResetAndDestroy();
 iDataProviderIds.Reset();
-__FLOG(_L8("UnloadDataProviders - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_UNLOADDATAPROVIDERS_EXIT );
 }
 /**
 Issues the specified notification to all loaded data providers.
 @param aNotification The notification type identifier.
 NotifyDataProvidersL(KMTPDataProviderAll, aNotification, aParams);
 }
 EXPORT_C void CMTPDataProviderController::NotifyDataProvidersL(TUint aDPId, TMTPNotification aNotification, const TAny* aParams)
 {
-__FLOG(_L8("NotifyDataProvidersL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_NOTIFYDATAPROVIDERSL_ENTRY);
 // Schedule any long running operations.
 switch (aNotification)
 {
 case EMTPStorageAdded:
 {
 for(TInt i=1; i<iEnumeratingStorages.Count(); i++)
 {
 if(storageId==iEnumeratingStorages[i])
 {
 iEnumeratingStorages.Remove(i);
-__FLOG_VA((_L8("Unhandle memory card add event removed, storageId: %d"), storageId));
+OstTrace1(TRACE_ERROR, CMTPDATAPROVIDERCONTROLLER_NOTIFYDATAPROVIDERSL,
+"Unhandle memory card add event removed, storageId: %d", storageId);
 }
 }
 }
 break;
 case EMTPObjectAdded:
 dp->Plugin().ProcessNotificationL(aNotification, aParams);
 break;
 }
 }
 }
-__FLOG(_L8("NotifyDataProvidersL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_NOTIFYDATAPROVIDERSL_EXIT);
 }
 /**
 Provides the number of active data providers.
 @return the number of active data providers.
 Data provider enumeration state change notification callback.
 @param aDp The notifying data provider.
 */
 void CMTPDataProviderController::EnumerationStateChangedL(const CMTPDataProvider& aDp)
 {
-__FLOG(_L8("EnumerationStateChangedL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_ENUMERATIONSTATECHANGEDL_ENTRY);
-__FLOG_VA((_L8("Entry iEnumerationState: 0x%x DpId: %d"), iEnumerationState, aDp.DataProviderId()));
+OstTraceDefExt2(OST_TRACE_CATEGORY_PRODUCTION, TRACE_IMPORTANT, CMTPDATAPROVIDERCONTROLLER_ENUMERATIONSTATECHANGEDL,
+"iEnumerationState: 0x%x DpId: %d", iEnumerationState, aDp.DataProviderId());
 switch (iEnumerationState)
 {
 case EEnumeratingFrameworkStorages:
 	switch (aDp.ImplementationUid().iUid)
 {
 case EEnumeratingDataProviderObjects:
 case EEnumeratingSubDirFiles:
 if(KMTPImplementationUidFileDp == aDp.ImplementationUid().iUid && NeedEnumeratingPhase2())
 {
-__FLOG(_L8("File DP first level enum complete"));
+OstTrace0(TRACE_NORMAL, DUP1_CMTPDATAPROVIDERCONTROLLER_ENUMERATIONSTATECHANGEDL,
+"File DP first level enum complete");
 Cancel();
 //clean the root level snapshot
 TRAP_IGNORE(iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL(ETrue));
 default:
 __DEBUG_ONLY(User::Invariant());
 break;
 }
-__FLOG_VA((_L8("Exit iEnumerationState: 0x%x, DpId: %d, UID=0x%x"), iEnumerationState,  aDp.DataProviderId(), aDp.ImplementationUid().iUid));
+OstTraceExt3(TRACE_NORMAL, DUP2_CMTPDATAPROVIDERCONTROLLER_ENUMERATIONSTATECHANGEDL,
-__FLOG(_L8("EnumerationStateChangedL - Exit"));
+"iEnumerationState: 0x%x, DpId: %d, UID=0x%x", iEnumerationState, aDp.DataProviderId(), (TUint)aDp.ImplementationUid().iUid);
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_ENUMERATIONSTATECHANGEDL_EXIT);
 }
 void CMTPDataProviderController::DoCancel()
 {
-__FLOG(_L8("DoCancel - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_DOCANCEL_ENTRY);
-__FLOG(_L8("DoCancel - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_DOCANCEL_EXIT);
 }
 /*
 {
 const RArray<TUint>& logicalIds(storage.UintArray(CMTPStorageMetaData::EStorageLogicalIds));
 const TUint KCountLogicalIds(logicalIds.Count());
 for (TUint i(0); (i < KCountLogicalIds); i++)
 {
-__FLOG_VA((_L8("Establish snapshot for storage: 0x%x"), logicalIds[i]));
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDERCONTROLLER_ESTABLISHDBSNAPSHOTL,
+"Establish snapshot for storage: 0x%x", logicalIds[i]);
 iSingletons.ObjectMgr().ObjectStore().EstablishDBSnapshotL(logicalIds[i]);
 }
 }
 }
 }
 void CMTPDataProviderController::RunL()
 {
-__FLOG(_L8("RunL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_RUNL_ENTRY );
-__FLOG_VA((_L8("iEnumerationState: 0x%x iNextDpId: %d"), iEnumerationState, iNextDpId));
+OstTraceDef1(OST_TRACE_CATEGORY_PRODUCTION, TRACE_IMPORTANT, CMTPDATAPROVIDERCONTROLLER_RUNL,
+"iEnumerationState: 0x%x", iEnumerationState);
 switch (iEnumerationState)
 {
 case EEnumerationStarting:
 iEnumerationState   = EEnumeratingFrameworkStorages;
 iNextDpId           = iDpIdDeviceDp;
 const TUint KLoadedDps(iDataProviderIds.Count());
 while ((iEnumeratingDps.Count() < KMTPMaxEnumeratingDataProviders) && (iDpIdArrayIndex < KLoadedDps)
 && (iEnumerationPhase == DataProviderL(iDataProviderIds[iDpIdArrayIndex]).DataProviderConfig().UintValue(MMTPDataProviderConfig::EEnumerationPhase)))
 {
 currentDp = iDataProviderIds[iDpIdArrayIndex++];
-__FLOG_VA((_L8("Enumerating dpid %d"), currentDp));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDERCONTROLLER_RUNL,
+"Enumerating dpid %d", currentDp);
 iEnumeratingDps.InsertInOrderL(currentDp);
 EnumerateDataProviderObjectsL(currentDp);
 }
-__FLOG_VA((_L8("iDpIdArrayIndex = %d, KLoadedDps = %d"), iDpIdArrayIndex, KLoadedDps));
+OstTraceExt2(TRACE_NORMAL, DUP2_CMTPDATAPROVIDERCONTROLLER_RUNL,
+"iDpIdArrayIndex = %d, KLoadedDps = %d", iDpIdArrayIndex, KLoadedDps);
 }
 break;
 case EEnumeratingCleanDBSnapshot:
 {
 case EEnumeratingPhaseOneDone:
 default:
 __DEBUG_ONLY(User::Invariant());
 break;
 }
-__FLOG(_L8("RunL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_RUNL_EXIT );
 }
-#ifdef __FLOG_ACTIVE
 TInt CMTPDataProviderController::RunError(TInt aError)
-#else
+{
-TInt CMTPDataProviderController::RunError(TInt /*aError*/)
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_RUNERROR_ENTRY );
-#endif
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDERCONTROLLER_RUNERROR, "Error = %d", aError);
-{
-__FLOG(_L8("RunError - Entry"));
-__FLOG_VA((_L8("Error = %d"), aError));
 // If a RunL error happens, there's no point in trying to continue.
 switch (iEnumerationState)
 {
 case EEnumerationStarting:
 User::Invariant();
 break;
 }
 // This code is never reached
-__FLOG(_L8("RunError - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_RUNERROR_EXIT );
 return KErrNone;
 }
 /**
 Constructor.
 Second-phase constructor.
 @leave One of the system wide error codes if a processing failure occurs.
 */
 void CMTPDataProviderController::ConstructL()
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_CONSTRUCTL_ENTRY );
-__FLOG(_L8("ConstructL - Entry"));
 iSingletons.OpenL();
 	TInt tMTPMode;
 	TInt err = RProperty::Get(KUidSystemCategory, KUidMTPModeKeyValue, tMTPMode);
 	if(err != KErrNone)
 		{
 iOpenSessionWaiter = new(ELeave) CActiveSchedulerWait();
 iPendingRequestTimer = CMTPPendingReqestTimer::NewL(this);
-__FLOG(_L8("ConstructL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_CONSTRUCTL_EXIT );
 }
 /**
 Creates a data provider configurability parameter data instance on the cleanup
 stack.
 which is also placed on the cleanup stack. Ownership is transferred.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 CMTPDataProviderConfig* CMTPDataProviderController::CreateConfigLC(const TDesC& aResourceFilename)
 {
-__FLOG(_L8("CreateConfigLC - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_CREATECONFIGLC_ENTRY );
 // Open the configuration data resource file
 RResourceFile file;
 CleanupClosePushL(file);
 file.OpenL(iSingletons.Fs(), aResourceFilename);
 // Load the data provider configurability parameter data.
 CMTPDataProviderConfig* config(CMTPDataProviderConfig::NewL(reader, aResourceFilename));
 CleanupStack::PopAndDestroy(buffer);
 CleanupStack::PopAndDestroy(&file);
 CleanupStack::PushL(config);
-__FLOG(_L8("CreateConfigLC - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_CREATECONFIGLC_EXIT );
 return config;
 }
 /**
 Check the  necessity of objects enumeration as given the data provider
 @param dp CMTPDataProvider reference
 */
 TBool CMTPDataProviderController::IsObjectsEnumerationNeededL(CMTPDataProvider& dp)
 {
-__FLOG(_L8("CheckEnumerateDPObjectsL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_ISOBJECTSENUMERATIONNEEDEDL_ENTRY );
 	CMTPStorageMgr& storages = iSingletons.StorageMgr();
 	TUint32 aStorageId = iEnumeratingStorages[0];
 TBool doEnumeration = true;
 		if (!isFSBased)
 			{
 			  doEnumeration = false;
 			}
 	    }
-	__FLOG(_L8("CheckEnumerateDPObjectsL - Exit"));
+	OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_ISOBJECTSENUMERATIONNEEDEDL_EXIT );
 	return doEnumeration;
 }
 /**
 Requests that the given data provider enumerate its objects.
 @param aId data provider ID
 */
 void CMTPDataProviderController::EnumerateDataProviderObjectsL(TUint aId)
 {
-__FLOG(_L8("EnumerateDataProviderObjectsL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_ENUMERATEDATAPROVIDEROBJECTSL_ENTRY );
+OstTraceDef1(OST_TRACE_CATEGORY_PRODUCTION, TRACE_IMPORTANT, CMTPDATAPROVIDERCONTROLLER_ENUMERATEDATAPROVIDEROBJECTSL,
+"Data provider with DpId %d to enumerate its objects", aId );
 CMTPDataProvider& dp(DataProviderL(aId));
 if (IsObjectsEnumerationNeededL(dp))
 {
 TBool abnormaldown = ETrue;
 {
 //The DP does not need enumeration this time, so just change the state to go on.
 EnumerationStateChangedL(dp);
 }
-__FLOG(_L8("EnumerateDataProviderObjectsL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_ENUMERATEDATAPROVIDEROBJECTSL_EXIT );
 }
 /**
 Loads the dataprovider on ROM drives depending upon the mode and activates the specified ECOM data provider.
 @param aResourceFilename The data provider registration and configuration data
 @return ETrue if data provider is successfully loaded, EFalse otherwise.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 TBool CMTPDataProviderController::LoadROMDataProvidersL(const TDesC& aResourceFilename, const RImplInfoPtrArray& aImplementations)
 {
-__FLOG(_L8("LoadROMDataProvidersL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_LOADROMDATAPROVIDERSL_ENTRY );
 // Retrieve the implementation UID
 TUint uid(0);
-User::LeaveIfError(Uid(aResourceFilename, uid));
+LEAVEIFERROR(Uid(aResourceFilename, uid),
+OstTraceExt1( TRACE_ERROR, CMTPDATAPROVIDERCONTROLLER_LOADROMDATAPROVIDERSL, "can't get uid from resource file %S", aResourceFilename));
 TBool success(EFalse);
 // Check for a corresponding plug-in implementation.
 TInt index = aImplementations.FindInOrder(TUid::Uid(uid), ImplementationsLinearOrderUid);
 if (index >= 0)
 files.ResetAndDestroy();
 }
 success = LoadDataProviderL(filename);
 CleanupStack::PopAndDestroy(&filename);
 }
-__FLOG(_L8("LoadROMDataProvidersL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_LOADROMDATAPROVIDERSL_EXIT );
 return success;
 }
 /**
 Load all data providers installed on non-ROM drives depending upon the mode and activates
 implementation UID).
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPDataProviderController::LoadInstalledDataProvidersL(const CImplementationInformation* aImplementations)
 {
-__FLOG(_L8("LoadInstalledDataProvidersL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_LOADINSTALLEDDATAPROVIDERSL_ENTRY );
 TUint uid = aImplementations->ImplementationUid().iUid;
 TBool tFlag(EFalse);
 iNextDpId = iSingletons.ObjectMgr().DPIDL(uid, tFlag);
 if(!tFlag)
 {
 //Skip "0x".
 pkgIDstr = pkgIDstr.Mid(searchindex + 2);
 }
 if (0 == pkgIDstr.Length())
 {
+OstTrace0( TRACE_ERROR, CMTPDATAPROVIDERCONTROLLER_LOADINSTALLEDDATAPROVIDERSL, "pkgIdstr is empty!" );
 User::Leave(KErrArgument);
 }
 TUint aUid(0);
-User::LeaveIfError(Uid(pkgIDstr, aUid));
+LEAVEIFERROR(Uid(pkgIDstr, aUid),
+OstTraceExt1( TRACE_ERROR, DUP1_CMTPDATAPROVIDERCONTROLLER_LOADINSTALLEDDATAPROVIDERSL, "can't get uid from string %S",pkgIDstr ));
 iSingletons.ObjectMgr().InsertPkgIDObjectL(iNextDpId, aUid);
 TDriveName drive = aImplementations->Drive().Name();
 RBuf resourcefilename;
 CleanupClosePushL(resourcefilename);
 CleanupStack::PopAndDestroy(&rscfile);
 LoadDataProviderL(resourcefilename);
 CleanupStack::PopAndDestroy(&resourcefilename);
-__FLOG(_L8("LoadInstalledDataProvidersL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_LOADINSTALLEDDATAPROVIDERSL_EXIT );
 }
 /**
 Load data providers
 @param aImplementations The installed ECOM data provider implementations list (ordered by
 @return ETrue if data provider is successfully loaded, EFalse otherwise.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 TBool CMTPDataProviderController::LoadDataProviderL(const TDesC& aResourceFilename)
 {
-__FLOG(_L8("LoadDataProviderL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERL_ENTRY );
 // Load the configurability parameter data.
 CMTPDataProviderConfig* config(CreateConfigLC(aResourceFilename));
 TBool success(EFalse);
 TBool supported(ETrue);
 TUint aUid(0);
 if ( Uid(aResourceFilename,aUid) != KErrNone )
 	{
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERL_EXIT );
 return success;
 	}
 TUint uid(aUid);
 if ((uid != KMTPImplementationUidDeviceDp) && (uid != KMTPImplementationUidProxyDp) && (uid != KMTPImplementationUidFileDp))
 {
 else
 {
 // No data provider was created.
 CleanupStack::PopAndDestroy(config);
 }
-__FLOG(_L8("LoadDataProviderL - Exit"));
+OstTraceFunctionExit0( DUP1_CMTPDATAPROVIDERCONTROLLER_LOADDATAPROVIDERL_EXIT );
 return success;
 }
 /**
 Provides the implemetation UID associated with the specified data provider
 filename.
 @param aUid On completion, the implemetation UID.
 */
 TInt CMTPDataProviderController::Uid(const TDesC& aResourceFilename, TUint& aUid)
 {
-__FLOG(_L8("Uid - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_UID_ENTRY );
 // Extract the implemetation UID from the filename.
 TParsePtrC parser(aResourceFilename);
 TLex lex(parser.Name());
 TInt err = lex.Val(aUid, EHex);
-__FLOG(_L8("Uid - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_UID_EXIT );
 return err;
 }
 /**
 Schedules an enumeration iteration.
 */
 void CMTPDataProviderController::Schedule()
 {
-__FLOG(_L8("Schedule - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_SCHEDULE_ENTRY );
 if (!IsActive())
 {
 TRequestStatus* status(&iStatus);
 *status = KRequestPending;
 SetActive();
 User::RequestComplete(status, KErrNone);
 }
-__FLOG(_L8("Schedule - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_SCHEDULE_EXIT );
 }
 /**
 Get the mtpkey mode.
 */
 TMTPOperationalMode CMTPDataProviderController::Mode()
 if(iStubFound)
 {
 return;
 }
-	User::LeaveIfError(iSisSession.Connect());
+	LEAVEIFERROR(iSisSession.Connect(),
+	        OstTrace0( TRACE_ERROR, CMTPDATAPROVIDERCONTROLLER_CREATEREGISTRYSESSIONANDENTRYL, "can't connect to iSisSession " ));
 CleanupClosePushL(iSisSession);
 TInt err = KErrNone;
 TUint stubuid;
 iSingletons.FrameworkConfig().GetValueL(CMTPFrameworkConfig::EPackageStubUID , stubuid);
 	TRAP_IGNORE(err=iSisEntry.Open(iSisSession, TUid::Uid(stubuid) ));
 	iSisSession.Close();
 	}
 EXPORT_C void CMTPDataProviderController::SetNeedEnumeratingPhase2(TBool aNeed)
 	{
-	__FLOG(_L8("SetNeedEnumeratingPhase2 - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_SETNEEDENUMERATINGPHASE2_ENTRY );
-	__FLOG_VA((_L8("Need = %d"), aNeed));
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDERCONTROLLER_SETNEEDENUMERATINGPHASE2, "Need = %d", aNeed);
 	iNeedEnumeratingPhase2 = aNeed;
-	__FLOG(_L8("SetNeedEnumeratingPhase2 - Exit"));
+	OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_SETNEEDENUMERATINGPHASE2_EXIT );
 	}
 EXPORT_C TBool CMTPDataProviderController::NeedEnumeratingPhase2() const
 	{
 	return iNeedEnumeratingPhase2;
 	}
 EXPORT_C void CMTPDataProviderController::RegisterPendingRequestDP(TUint aDpUid, TUint aTimeOut)
 {
-__FLOG(_L8("CMTPDataProviderController::RegisterPendingRequestDP - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_REGISTERPENDINGREQUESTDP_ENTRY );
 __ASSERT_DEBUG((iPendingRequestDpUid == 0), User::Invariant());
 iPendingRequestDpUid = aDpUid;
 if (aTimeOut > 0)
 {
 iPendingRequestTimer->Start(aTimeOut);
 }
-__FLOG(_L8("CMTPDataProviderController::RegisterPendingRequestDP - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_REGISTERPENDINGREQUESTDP_EXIT );
 }
 EXPORT_C void CMTPDataProviderController::ExecutePendingRequestL()
 {
-__FLOG(_L8("CMTPDataProviderController::ExecutePendingRequestL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDERCONTROLLER_EXECUTEPENDINGREQUESTL_ENTRY );
 if (iPendingRequestDpUid == 0)
 {
 iPendingRequestTimer->Cancel();
+OstTraceFunctionExit0( CMTPDATAPROVIDERCONTROLLER_EXECUTEPENDINGREQUESTL_EXIT );
 return;
 }
 int i = 0;
 int count = iDataProviders.Count();
 iPendingRequestDpUid = 0;
 break;
 }
 }
 iPendingRequestTimer->Cancel();
-__FLOG(_L8("CMTPDataProviderController::ExecutePendingRequestL - Exit"));
+OstTraceFunctionExit0( DUP1_CMTPDATAPROVIDERCONTROLLER_EXECUTEPENDINGREQUESTL_EXIT );
 }
 EXPORT_C TUint CMTPDataProviderController::StorageEnumerateState(TUint aStorageId)
 {
 if (iEnumeratingStorages.Count() == 0)
 return self;
 }
 CMTPDataProviderController::CMTPPendingReqestTimer::~CMTPPendingReqestTimer()
 {
-__FLOG(_L8("~CMTPPendingReqestTimer - Entry"));
+OstTraceFunctionEntry0( CMTPPENDINGREQESTTIMER_CMTPPENDINGREQESTTIMER_ENTRY );
 Cancel();
-__FLOG(_L8("~CMTPPendingReqestTimer - Exit"));
+OstTraceFunctionExit0( CMTPPENDINGREQESTTIMER_CMTPPENDINGREQESTTIMER_EXIT );
-__FLOG_CLOSE;
 }
 void CMTPDataProviderController::CMTPPendingReqestTimer::Start(TUint aTimeOut)
 {
-__FLOG(_L8("CMTPPendingReqestTimer::Start - Entry"));
+OstTraceFunctionEntry0( CMTPPENDINGREQESTTIMER_START_ENTRY );
 if (aTimeOut > 0)
 {
 const TUint KMTPPendingRequestDelay = (1000000 * aTimeOut);
 After(KMTPPendingRequestDelay);
 }
-__FLOG(_L8("CMTPPendingReqestTimer::Start - Exit"));
+OstTraceFunctionExit0( CMTPPENDINGREQESTTIMER_START_EXIT );
 }
 void CMTPDataProviderController::CMTPPendingReqestTimer::RunL()
 {
-__FLOG(_L8("CMTPPendingReqestTimer::RunL - Entry"));
+OstTraceFunctionEntry0( CMTPPENDINGREQESTTIMER_RUNL_ENTRY );
 iDPController->ExecutePendingRequestL();
-__FLOG(_L8("CMTPPendingReqestTimer::RunL - Exit"));
+OstTraceFunctionExit0( CMTPPENDINGREQESTTIMER_RUNL_EXIT );
 }
 CMTPDataProviderController::CMTPPendingReqestTimer::CMTPPendingReqestTimer(CMTPDataProviderController* aDPController) :
 CTimer(EPriorityNormal)
 {
 iDPController = aDPController;
 }
 void CMTPDataProviderController::CMTPPendingReqestTimer::ConstructL()
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPPENDINGREQESTTIMER_CONSTRUCTL_ENTRY );
-__FLOG(_L8("CMTPPendingReqestTimer::ConstructL - Entry"));
 CTimer::ConstructL();
 CActiveScheduler::Add(this);
-__FLOG(_L8("CMTPPendingReqestTimer::ConstructL - Exit"));
+OstTraceFunctionExit0( CMTPPENDINGREQESTTIMER_CONSTRUCTL_EXIT );
 }

changeset 49	c20dd21d1eb4
parent 31	a26669f87b46
child 54	4dc88a4ac6f4
child 60	841f70763fbe